ref: b221c56a6bb90de4631f4b2eb999db8dad05a006
parent: 9c377e4f25344a908f18f5154ac9143ffb9577e6
author: rodri <rgl@antares-labs.eu>
date: Sat Sep 30 20:06:50 EDT 2023
add a mixer and some background sfx. also postponed the connection establishment until the subsystem initialization is complete. there's no point in taking a seat you're going to leave milliseconds after a local resource failure.
binary files /dev/null b/assets/sfx/bg0.mp3 differ
binary files /dev/null b/assets/sfx/bg1.mp3 differ
binary files /dev/null b/assets/sfx/bg2.mp3 differ
binary files /dev/null b/assets/sfx/defeat.mp3 differ
--- a/bts.c
+++ b/bts.c
@@ -1,5 +1,6 @@
#include <u.h>
#include <libc.h>
+#include <bio.h>
#include <thread.h>
#include <draw.h>
#include <mouse.h>
@@ -8,6 +9,7 @@
#include <geometry.h>
#include "dat.h"
#include "fns.h"
+#include "mixer.h"
enum {PCBlack,
@@ -137,6 +139,7 @@
Image *pal[NCOLORS];
Image *screenb;
Image *tiletab[NTILES];
+AudioSource *playlist[NSOUNDS];
Board alienboard;
Board localboard;
Ship armada[NSHIPS];
@@ -538,6 +541,26 @@
}
}
+void
+initsound(void)
+{+ audio_init(44100);
+ audio_set_master_gain(0.5);
+
+ playlist[SBG0] = audio_new_source_from_mp3file("assets/sfx/bg0.mp3");+ if(playlist[SBG0] == nil)
+ sysfatal("audio_new_source_from_mp3file: %r");+ playlist[SBG1] = audio_new_source_from_mp3file("assets/sfx/bg1.mp3");+ if(playlist[SBG1] == nil)
+ sysfatal("audio_new_source_from_mp3file: %r");+ playlist[SBG2] = audio_new_source_from_mp3file("assets/sfx/bg2.mp3");+ if(playlist[SBG2] == nil)
+ sysfatal("audio_new_source_from_mp3file: %r");+
+ audio_play(playlist[SBG0]);
+ audio_set_loop(playlist[SBG0], 1);
+}
+
int
confirmdone(Mousectl *mc)
{@@ -917,6 +940,24 @@
}
void
+soundproc(void *)
+{+ Biobuf *aout;
+ uchar adata[512];
+
+ threadsetname("soundproc");+
+ aout = Bopen("/dev/audio", OWRITE);+ if(aout == nil)
+ sysfatal("Bopen: %r");+
+ for(;;){+ audio_process((void*)adata, sizeof(adata)/2);
+ Bwrite(aout, adata, sizeof adata);
+ }
+}
+
+void
netrecvthread(void *arg)
{Ioproc *io;
@@ -988,16 +1029,6 @@
if(argc != 1)
usage();
- addr = netmkaddr(argv[0], "tcp", "3047");
- if(debug)
- fprint(2, "connecting to %s\n", addr);
-
- fd = dial(addr, nil, nil, nil);
- if(fd < 0)
- sysfatal("dial: %r");- else if(debug)
- fprint(2, "line established\n");
-
snprint(winspec, sizeof winspec, "-dx %d -dy %d", SCRW, SCRH);
if(newwindow(winspec) < 0)
sysfatal("newwindow: %r");@@ -1033,6 +1064,18 @@
game.state = Waiting0;
/* TODO add sfx */
+ initsound();
+ proccreate(soundproc, nil, mainstacksize);
+
+ addr = netmkaddr(argv[0], "tcp", "3047");
+ if(debug)
+ fprint(2, "connecting to %s\n", addr);
+
+ fd = dial(addr, nil, nil, nil);
+ if(fd < 0)
+ sysfatal("dial: %r");+ else if(debug)
+ fprint(2, "line established\n");
drawchan = chancreate(sizeof(void*), 1);
ingress = chancreate(sizeof(char*), 1);
--- a/dat.h
+++ b/dat.h
@@ -37,6 +37,11 @@
Borderwidth+MAPH*TH+Borderwidth+
Boardmargin,
+ SBG0 = 0,
+ SBG1,
+ SBG2,
+ NSOUNDS,
+
KB = 1024,
BY2MAP = (TBITS*MAPW*MAPH+7)/8,
};
--- /dev/null
+++ b/mixer.c
@@ -1,0 +1,762 @@
+/*
+ * 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;
+}
--- /dev/null
+++ b/mixer.h
@@ -1,0 +1,123 @@
+/*
+ * standalone sound mixer based on rxi's cmixer.
+ */
+enum {+ FIXED_BITS = 12,
+ FIXED_UNIT = 1<<FIXED_BITS,
+ FIXED_MASK = FIXED_UNIT-1,
+
+ MIXBUFSIZE = 512,
+ MIXBUFMASK = MIXBUFSIZE-1,
+
+ AUDIO_STATE_STOPPED = 0,
+ AUDIO_STATE_PLAYING,
+ AUDIO_STATE_PAUSED,
+
+ AUDIO_EVENT_DESTROY = 0,
+ AUDIO_EVENT_SAMPLES,
+ AUDIO_EVENT_REWIND
+};
+
+typedef struct Wav Wav;
+typedef struct WavStream WavStream;
+typedef struct Pcm Pcm;
+typedef struct AudioEvent AudioEvent;
+typedef struct AudioSourceInfo AudioSourceInfo;
+typedef struct AudioSource AudioSource;
+typedef struct Mixer Mixer;
+
+struct Wav
+{+ void *data;
+ int bitdepth;
+ int samplerate;
+ int channels;
+ int length;
+};
+
+struct WavStream
+{+ Wav wav;
+ void *data;
+ int idx;
+};
+
+struct Pcm
+{+ void *data;
+ int len;
+ int off;
+ int depth;
+ int chans;
+ int rate;
+};
+
+struct AudioEvent
+{+ int type;
+ void *udata;
+ char *msg;
+ s16int *buffer;
+ int length;
+};
+
+struct AudioSourceInfo
+{+ void *udata;
+ int samplerate;
+ int length;
+
+ void (*handler)(AudioEvent *e); /* Event handler */
+};
+
+struct AudioSource
+{+ AudioSource *next; /* Next source in list */
+ s16int buffer[MIXBUFSIZE]; /* Internal buffer with raw stereo PCM */
+ void *udata; /* Stream's udata (from AudioSourceInfo) */
+ int samplerate; /* Stream's native samplerate */
+ int length; /* Stream's length in samples */
+ int end; /* End index for the current play-through */
+ int state; /* Current state (playing|paused|stopped) */
+ s64int position; /* Current playhead position (fixed point) */
+ int lgain, rgain; /* Left and right gain (fixed point) */
+ int rate; /* Playback rate (fixed point) */
+ int nextfill; /* Next frame idx where the buffer needs to be filled */
+ int loop; /* Whether the source will loop when `end` is reached */
+ int rewind; /* Whether the source will rewind before playing */
+ int active; /* Whether the source is part of `sources` list */
+ double gain; /* Gain set by `audio_set_gain()` */
+ double pan; /* Pan set by `audio_set_pan()` */
+
+ void (*handler)(AudioEvent *e); /* Event handler */
+};
+
+struct Mixer
+{+ char *lasterror; /* Last error message */
+ AudioSource *sources; /* Linked list of active (playing) sources */
+ s32int buffer[MIXBUFSIZE]; /* Internal master buffer */
+ int samplerate; /* Master samplerate */
+ int gain; /* Master gain (fixed point) */
+};
+
+
+void audio_init(int);
+void audio_set_master_gain(double);
+void audio_process(s16int*, int);
+
+AudioSource *audio_new_source(AudioSourceInfo*);
+AudioSource *audio_new_source_from_file(char*);
+AudioSource *audio_new_source_from_mp3file(char*);
+AudioSource *audio_new_source_from_mem(void*, int);
+void audio_destroy_source(AudioSource*);
+double audio_get_length(AudioSource*);
+double audio_get_position(AudioSource*);
+int audio_get_state(AudioSource*);
+void audio_set_gain(AudioSource*, double);
+void audio_set_pan(AudioSource*, double);
+void audio_set_pitch(AudioSource*, double);
+void audio_set_loop(AudioSource*, int);
+void audio_play(AudioSource*);
+void audio_pause(AudioSource*);
+void audio_stop(AudioSource*);
--- a/mkfile
+++ b/mkfile
@@ -11,10 +11,12 @@
parse.$O\
util.$O\
menulist.$O\
+ mixer.$O\
HFILES=\
dat.h\
fns.h\
+ mixer.h\
</sys/src/cmd/mkmany