/*
 * standalone sound mixer based on rxi's cmixer.
 */
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <thread.h>
#include "mixer.h"

static Mixer mixer;


static int wav_init(AudioSourceInfo*, void*, int, int);
static int mp3_init(AudioSourceInfo*, int);

static int
min(int a, int b)
{
	return a < b? a: b;
}

static int
max(int a, int b)
{
	return a > b? a: b;
}

static int
clamp(int n, int min, int max)
{
	return n < min? min: n > max? max: n;
}

static double
fclamp(double n, double min, double max)
{
	return n < min? min: n > max? max: n;
}

static int
float2fixed(double n)
{
	return n*FIXED_UNIT;
}

static int
fixedlerp(int a, int b, int t)
{
	return a + ((b - a)*t >> FIXED_BITS);
}

//static void
//fprintsource(int fd, AudioSource *src)
//{
//	fprint(fd, "src 0x%p:\n"
//		"udata\t0x%p\n"
//		"samplerate\t%d\n"
//		"length\t%d\n"
//		"end\t%d\n"
//		"state\t%d\n"
//		"position\t%lld\n"
//		"gain l/r\t%d/%d\n"
//		"rate\t%d\n"
//		"nextfill\t%d\n"
//		"loop\t%d\n"
//		"rewind\t%d\n"
//		"active\t%d\n"
//		"gain\t%g\n"
//		"pan\t%g\n",
//		src, src->udata, src->samplerate, src->length, src->end, src->state, src->position,
//		src->lgain, src->rgain, src->rate, src->nextfill, src->loop, src->rewind,
//		src->active, src->gain, src->pan);
//
//}

void
audio_init(int samplerate)
{
	mixer.samplerate = samplerate;
	mixer.sources = nil;
	mixer.gain = FIXED_UNIT;
}

void
audio_set_master_gain(double gain)
{
	mixer.gain = float2fixed(gain);
}

static void
rewind_source(AudioSource *src)
{
	AudioEvent e;

	e.type = AUDIO_EVENT_REWIND;
	e.udata = src->udata;
	src->handler(&e);
	src->position = 0;
	src->rewind = 0;
	src->end = src->length;
	src->nextfill = 0;
}

static void
fill_source_buffer(AudioSource *src, int offset, int length)
{
	AudioEvent e;

	e.type = AUDIO_EVENT_SAMPLES;
	e.udata = src->udata;
	e.buffer = src->buffer + offset;
	e.length = length;
	src->handler(&e);
}

static void
process_source(AudioSource *src, int len)
{
	int i, n, a, b, p;
	int frame, count;
	s32int *dst;

	dst = mixer.buffer;

	/* Do rewind if flag is set */
	if(src->rewind)
		rewind_source(src);

	/* Process audio */
	while(len > 0){
		/* Get current position frame */
		frame = src->position >> FIXED_BITS;

		/* Fill buffer if required */
		if(frame + 3 >= src->nextfill){
			fill_source_buffer(src, 2*src->nextfill & MIXBUFMASK, MIXBUFSIZE/2);
			src->nextfill += MIXBUFSIZE/4;
		}

		/* Handle reaching the end of the playthrough */
		if(frame >= src->end){
			/*
			 * As streams continously fill the raw buffer in a loop we simply
			 * increment the end idx by one length and continue reading from it for
			 * another play-through
			 */
			src->end = frame + src->length;
			/* Set state and stop processing if we're not set to loop */
			if(!src->loop){
				src->state = AUDIO_STATE_STOPPED;
				break;
			}
		}

		/* Work out how many frames we should process in the loop */
		n = min(src->nextfill - 2, src->end) - frame;
		count = (n << FIXED_BITS) / src->rate;
		count = max(count, 1);
		count = min(count, len/2);
		len -= count * 2;

		/* Add audio to master buffer */
		if(src->rate == FIXED_UNIT){
			/* Add audio to buffer -- basic */
			n = 2*frame;
			for(i = 0; i < count; i++){
				dst[0] += (src->buffer[n&MIXBUFMASK] * src->lgain) >> FIXED_BITS;
				dst[1] += (src->buffer[(n+1)&MIXBUFMASK] * src->rgain) >> FIXED_BITS;
				n += 2;
				dst += 2;
			}
			src->position += count * FIXED_UNIT;
		}else{
			/* Add audio to buffer -- interpolated */
			for(i = 0; i < count; i++){
				n = (src->position >> FIXED_BITS) * 2;
				p = src->position & FIXED_MASK;

				a = src->buffer[n & MIXBUFMASK];
				b = src->buffer[(n+2) & MIXBUFMASK];
				dst[0] += fixedlerp(a, b, p)*src->lgain >> FIXED_BITS;
				n++;
				a = src->buffer[n & MIXBUFMASK];
				b = src->buffer[(n+2) & MIXBUFMASK];
				dst[1] += fixedlerp(a, b, p)*src->rgain >> FIXED_BITS;

				src->position += src->rate;
				dst += 2;
			}
		}
	}
}

void
audio_process(s16int *dst, int len)
{
	int i, x;
	AudioSource **s;

	/* Process in chunks of MIXBUFSIZE if `len` is larger than MIXBUFSIZE */
	while(len > MIXBUFSIZE){
		audio_process(dst, MIXBUFSIZE);
		dst += MIXBUFSIZE;
		len -= MIXBUFSIZE;
	}

	/* Zeroset internal buffer */
	memset(mixer.buffer, 0, len * sizeof(mixer.buffer[0]));

	/* Process active sources */
	s = &mixer.sources;
	while(*s){
		process_source(*s, len);
		/* Remove source from list if it is no longer playing */
		if((*s)->state != AUDIO_STATE_PLAYING){
			(*s)->active = 0;
			*s = (*s)->next;
		}else
			s = &(*s)->next;
	}

	/* Copy internal buffer to destination and clip */
	for(i = 0; i < len; i++){
		x = (mixer.buffer[i] * mixer.gain) >> FIXED_BITS;
		dst[i] = clamp(x, -32768, 32767);
	}
}

AudioSource *
audio_new_source(AudioSourceInfo *info)
{
	AudioSource *src;

	src = malloc(sizeof *src);
	if(src == nil){
		werrstr("allocation failed");
		return nil;
	}

	memset(src, 0, sizeof *src);
	src->handler = info->handler;
	src->length = info->length;
	src->samplerate = info->samplerate;
	src->udata = info->udata;
	audio_set_gain(src, 1);
	audio_set_pan(src, 0);
	audio_set_pitch(src, 1);
	audio_set_loop(src, 0);
	audio_stop(src);
	return src;
}

static int
check_header(void *data, int size, char *str, int offset)
{
	int len;

	len = strlen(str);
	return size >= offset + len &&
		memcmp((char*)data + offset, str, len) == 0;
}

static AudioSource *
new_source_from_mem(void *data, int size, int ownsdata)
{
	AudioSourceInfo info;

	if(check_header(data, size, "WAVE", 8)){
		if(wav_init(&info, data, size, ownsdata) < 0)
			return nil;
		return audio_new_source(&info);
	}

	werrstr("unknown format or invalid data");
	return nil;
}

static void *
load_file(char *filename, int *size)
{
	Biobuf *fp;
	void *data;
	int n;

	fp = Bopen(filename, OREAD);
	if(fp == nil)
		return nil;

	Bseek(fp, 0, 2);
	*size = Boffset(fp);
	Bseek(fp, 0, 0);

	data = malloc(*size);
	if(data == nil){
		Bterm(fp);
		return nil;
	}
	n = Bread(fp, data, *size);
	Bterm(fp);
	if(n != *size){
		free(data);
		return nil;
	}

	return data;
}

AudioSource *
audio_new_source_from_file(char *filename)
{
	int size;
	AudioSource *src;
	void *data;

	/* Load file into memory */
	data = load_file(filename, &size);
	if(data == nil){
		werrstr("could not load file");
		return nil;
	}

	/* Try to load and return */
	src = new_source_from_mem(data, size, 1);
	if(src == nil){
		free(data);
		return nil;
	}

	return src;
}

AudioSource *
audio_new_source_from_mp3file(char *path)
{
	AudioSourceInfo info;
	uchar buf[3];
	int fd;

	fd = open(path, OREAD);
	if(fd < 0)
		return nil;

	memset(buf, 0, sizeof buf);
	readn(fd, buf, sizeof buf);
	seek(fd, 0, 0);
	if(memcmp(buf, "ID3", 3) != 0 && (buf[0] != 0xFF || buf[1] != 0xFB)){
		werrstr("bad mp3 file");
		close(fd);
		return nil;
	}

	if(mp3_init(&info, fd) < 0){
		close(fd);
		return nil;
	}
	close(fd);

	return audio_new_source(&info);
}

AudioSource *
audio_new_source_from_mem(void *data, int size)
{
	return new_source_from_mem(data, size, 0);
}

void
audio_destroy_source(AudioSource *src)
{
	AudioSource **s;
	AudioEvent e;

	if(src->active){
		s = &mixer.sources;
		while(*s) /* TODO potential spinlock. no bueno */
			if(*s == src){
				*s = src->next;
				break;
			}
	}

	e.type = AUDIO_EVENT_DESTROY;
	e.udata = src->udata;
	src->handler(&e);
	free(src);
}

double
audio_get_length(AudioSource *src)
{
	return src->length / (double)src->samplerate;
}

double
audio_get_position(AudioSource *src)
{
	return ((src->position >> FIXED_BITS) % src->length) / (double)src->samplerate;
}

int
audio_get_state(AudioSource *src)
{
	return src->state;
}

static void
recalc_source_gains(AudioSource *src)
{
	double l, r;
	double pan;

	pan = src->pan;
	l = src->gain * (pan <= 0 ? 1 : 1.0 - pan);
	r = src->gain * (pan >= 0 ? 1 : 1.0 + pan);
	src->lgain = float2fixed(l);
	src->rgain = float2fixed(r);
}

void
audio_set_gain(AudioSource *src, double gain)
{
	src->gain = gain;
	recalc_source_gains(src);
}

void
audio_set_pan(AudioSource *src, double pan)
{
	src->pan = fclamp(pan, -1.0, 1.0);
	recalc_source_gains(src);
}

void
audio_set_pitch(AudioSource *src, double pitch)
{
	double rate;

	if(pitch > 0)
		rate = (double)src->samplerate / mixer.samplerate * pitch;
	else
		rate = 0.001;
	src->rate = float2fixed(rate);
}

void
audio_set_loop(AudioSource *src, int loop)
{
	src->loop = loop;
}

void
audio_play(AudioSource *src)
{
	src->state = AUDIO_STATE_PLAYING;
	if(!src->active){
		src->active = 1;
		src->next = mixer.sources;
		mixer.sources = src;
	}
}

void
audio_pause(AudioSource *src)
{
	src->state = AUDIO_STATE_PAUSED;
}

void
audio_stop(AudioSource *src)
{
	src->state = AUDIO_STATE_STOPPED;
	src->rewind = 1;
}

/*
 * Wav stream processing
 */

static char *
find_subchunk(char *data, int len, char *id, int *size)
{
	/* TODO : Error handling on malformed wav file */
	int idlen;
	char *p;

	idlen = strlen(id);
	p = data+12;
next:
	*size = *((u32int*)(p+4));
	if(memcmp(p, id, idlen) != 0){
		p += 8 + *size;
		if(p > data + len)
			return nil;
		goto next;
	}
	return p+8;
}

static int
read_wav(Wav *w, void *data, int len)
{
	uint format, channels, samplerate, bitdepth;
	int sz;
	char *p;

	p = data;
	memset(w, 0, sizeof(*w));

	/* Check header */
	if(memcmp(p, "RIFF", 4) != 0 || memcmp(p+8, "WAVE", 4) != 0){
		werrstr("bad wav header");
		return -1;
	}

	/* Find fmt subchunk */
	p = find_subchunk(data, len, "fmt", &sz);
	if(p == nil){
		werrstr("no fmt subchunk");
		return -1;
	}

	/* Load fmt info */
	format		= *((u16int*)(p));
	channels	= *((u16int*)(p+2));
	samplerate	= *((u32int*)(p+4));
	bitdepth	= *((u16int*)(p+14));

	if(format != 1){
		werrstr("unsupported format");
		return -1;
	}
	if(channels == 0 || samplerate == 0 || bitdepth == 0){
		werrstr("bad format");
		return -1;
	}
	if(channels > 2 || (bitdepth != 16 && bitdepth != 8)){
		werrstr("unsupported wav format");
		return -1;
	}

	/* Find data subchunk */
	p = find_subchunk(data, len, "data", &sz);
	if(p == nil){
		werrstr("no data subchunk");
		return -1;
	}

	/* Init struct */
	w->data = (void*)p;
	w->samplerate = samplerate;
	w->channels = channels;
	w->length = (sz / (bitdepth/8)) / channels;
	w->bitdepth = bitdepth;
	return 0;
}

static void
wav_handler(AudioEvent *e)
{
	int x, n;
	s16int *dst;
	WavStream *s;
	int len;

	s = e->udata;

	switch(e->type){
	case AUDIO_EVENT_DESTROY:
		free(s->data);
		free(s);
		break;
	case AUDIO_EVENT_SAMPLES:
		dst = e->buffer;
		len = e->length/2;
fill:
		n = min(len, s->wav.length - s->idx);
		len -= n;
		switch(s->wav.bitdepth){
		case 16:
			if(s->wav.channels == 1){
				while(n--){
					dst[0] = dst[1] = ((s16int*)s->wav.data)[s->idx];
					dst += 2;
					s->idx++;
				}
			}else if(s->wav.channels == 2){
				while(n--){
					x = s->idx * 2;
					dst[0] = ((s16int*)s->wav.data)[x];
					dst[1] = ((s16int*)s->wav.data)[x+1];
					dst += 2;
					s->idx++;
				}
			}
			break;
		case 8:
			if(s->wav.channels == 1){
				while(n--){
					dst[0] = dst[1] = (((uchar*)s->wav.data)[s->idx] - 128) << 8;
					dst += 2;
					s->idx++;
				}
			}else if(s->wav.channels == 2){
				while(n--){
					x = s->idx * 2;
					dst[0] = (((uchar*)s->wav.data)[x] - 128) << 8;
					dst[1] = (((uchar*)s->wav.data)[x+1] - 128) << 8;
					dst += 2;
					s->idx++;
				}
			}
			break;
		}
		/* Loop back and continue filling buffer if we didn't fill the buffer */
		if(len > 0){
			s->idx = 0;
			goto fill;
		}
		break;
	case AUDIO_EVENT_REWIND:
		s->idx = 0;
		break;
	}
}

static int
wav_init(AudioSourceInfo *info, void *data, int len, int ownsdata)
{
	WavStream *stream;

	stream = malloc(sizeof *stream);
	if(stream == nil){
		werrstr("allocation failed");
		return -1;
	}
	memset(stream, 0, sizeof *stream);

	if(read_wav(&stream->wav, data, len) < 0)
		return -1;

	if(ownsdata)
		stream->data = data;
	stream->idx = 0;

	info->udata = stream;
	info->handler = wav_handler;
	info->samplerate = stream->wav.samplerate;
	info->length = stream->wav.length;

	return 0;
}

static void
pcm_handler(AudioEvent *e)
{
	Pcm *pcm;
	s16int *dst;
	int len, i, n;

	pcm = e->udata;

	switch(e->type){
	case AUDIO_EVENT_DESTROY:
		free(pcm->data);
		free(pcm);
		break;
	case AUDIO_EVENT_SAMPLES:
		dst = e->buffer;
		len = e->length/2;
Fillbuf:
		n = min(len, pcm->len - pcm->off);
		len -= n;
		while(n--){
			i = pcm->off * 2;
			dst[0] = ((s16int*)pcm->data)[i];
			dst[1] = ((s16int*)pcm->data)[i+1];
			dst += 2;
			pcm->off++;
		}
		if(len > 0){
			pcm->off = 0;
			goto Fillbuf;
		}
		break;
	case AUDIO_EVENT_REWIND:
		pcm->off = 0;
		break;
	}
}

static void
mp3decproc(void *arg)
{
	int *pfd, fd;

	pfd = arg;
	fd = pfd[2];

	close(pfd[0]);
	dup(fd, 0);
	close(fd);
	dup(pfd[1], 1);
	close(pfd[1]);

	execl("/bin/audio/mp3dec", "mp3dec", nil);
	threadexitsall("execl: %r");
}

static int
mp3_init(AudioSourceInfo *info, int fd)
{
	Pcm *pcm;
	void *data;
	uchar buf[1024];
	int pfd[3], n, len;

	data = nil;
	len = 0;

	if(pipe(pfd) < 0){
		werrstr("pipe: %r");
		return -1;
	}
	pfd[2] = fd;

	procrfork(mp3decproc, pfd, mainstacksize, RFFDG|RFNAMEG|RFNOTEG);
	close(pfd[1]);
	while((n = read(pfd[0], buf, sizeof buf)) > 0){
		data = realloc(data, len+n);
		if(data == nil){
			werrstr("realloc: %r");
			return -1;
		}
		memmove((uchar*)data+len, buf, n);
		len += n;
	}
	close(pfd[0]);

	pcm = malloc(sizeof *pcm);
	if(pcm == nil){
		free(data);
		werrstr("malloc: %r");
		return -1;
	}
	pcm->depth = 16;
	pcm->chans = 2;
	pcm->rate = 44100;
	pcm->data = data;
	pcm->len = len/(pcm->depth/8)/pcm->chans;

	info->udata = pcm;
	info->handler = pcm_handler;
	info->samplerate = pcm->rate;
	info->length = pcm->len;

//	fprint(2, "pcm 0x%p:\ndata 0x%p\nlen %d\ndepth %d\nchans %d\nrate %d\n",
//		pcm, pcm->data, pcm->len, pcm->depth, pcm->chans, pcm->rate);
//	fprint(2, "info 0x%p:\nudata 0x%p\nhandler 0x%p\nsamplerate %d\nlength %d\n",
//		info, info->udata, info->handler, info->samplerate, info->length);

	return 0;
}