#include "audio.h"

#if AUDIO_BACKEND == AUDIO_BACKEND_AO

#include "../c-flod/backends/aowriter.h"

#define BACKEND_STRUCT AoWriter

#define BACKEND_INIT AoWriter_init

#define BACKEND_CLOSE AoWriter_close

#define BACKEND_WRITE AoWriter_write

#elif AUDIO_BACKEND == AUDIO_BACKEND_SDL

#include "../c-flod/backends/sdlwriter.h"

#define BACKEND_STRUCT SdlWriter

#define BACKEND_INIT SdlWriter_init

#define BACKEND_CLOSE SdlWriter_close

#define BACKEND_WRITE SdlWriter_write

#endif

#if AUDIO_BACKEND == AUDIO_BACKEND_NONE

void audio_init(void) {}

int audio_open_music_resource(const unsigned char* data, size_t data_size, int track) { return 0; }

int audio_open_music(const char* filename, int track) { return 0; }

void audio_play_wave_resource(const WAVE_HEADER_COMPLETE* wave) {}

int audio_process(void) { return -1; }

#else

#include "../c-flod/backends/wave_format.h"

#include "../c-flod/neoart/flod/core/CorePlayer.h"

#include "../c-flod/neoart/flod/whittaker/DWPlayer.h"

#include "../c-flod/flashlib/ByteArray.h"

#include "../c-flod/neoart/flod/core/Amiga.h"

#include <assert.h>

#include <pthread.h>

#include <errno.h>

#include "../lib/include/timelib.h"

#pragma RcB2 LINK "-lpthread"

enum thread_status {

};

struct AudioPlayer {

};

static struct AudioPlayer playa;

#define mlock() pthread_mutex_lock(&playa.music_mutex)

#define munlock() pthread_mutex_unlock(&playa.music_mutex)

#define slock() pthread_mutex_lock(&playa.sound_mutex)

#define sunlock() pthread_mutex_unlock(&playa.sound_mutex)

static int handle_overflow(int *sample) {

if(*sample > 32767) {

*sample = 32767;

return 1;

} else if (*sample < -32768) {

*sample = -32768;

return -1;

}

return 0;

}

#define MUSIC_FINISHED() (!playa.empty_track_active && CoreMixer_get_complete(&playa.hardware.core))

#define GEN_MUSIC() do{ \

if(!playa.empty_track_active) playa.hardware.core.accurate(&playa.hardware.core); \

else { assert(sizeof(playa.wave_buffer) >= 1024*3); \

memset(playa.wave_buffer, 0, 1024*3); playa.out_wave.pos = 1024*3;} \

} while (0)

#define MUSIC_AVAIL() (playa.out_wave.pos)

#define GET_MUSIC_WORD() (playa.empty_track_active ? 0 : ByteArray_readShort(out))

#define MUSIC_REWIND_WORD() do { if(!playa.empty_track_active) ByteArray_set_position_rel(out, -2); } while (0)

static void *thread_func(void* data) {

(void) data;

while(1) {

mlock();

if(playa.thread_music_status == TS_STOPPING) {

playa.thread_music_status = TS_WAITING;

munlock();

msleep(1);

continue;

} else if(playa.thread_music_status == TS_DONE || playa.thread_music_status == TS_WAITING) {

munlock();

msleep(4);

continue;

}

munlock();

if(MUSIC_FINISHED()) {

mlock();

playa.thread_music_status = TS_DONE;

munlock();

continue;

}

GEN_MUSIC();

if(MUSIC_AVAIL()) {

//dprintf(2, "writing %zu bytes...\n", (size_t) playa.out_wave.pos);

slock();

if(playa.play_waveslot != -1) {

struct ByteArray* mine = &playa.wave_streams[playa.play_waveslot];

if(!mine->bytesAvailable(mine)) {

playa.play_waveslot = -1;

goto mixin_done;

}

struct ByteArray* out = &playa.out_wave;

off_t savepos = out->pos;

size_t avail = mine->bytesAvailable(mine);

size_t upsample_factor = 44100 / playa.wavhdr.wave_hdr.samplerate;

size_t processed_m = 0, processed_w = 0;

size_t readbytes = playa.wavhdr.wave_hdr.bitwidth == 8 ? 1 : 2;

int chan[2] = { 0, 0 };

int next[2];

ByteArray_set_position(out, 0);

while(processed_m < (size_t)savepos && processed_w < avail) {

size_t c, u;

for(c = 0; c < 2; c++) {

if(c < playa.wavhdr.wave_hdr.channels) {

if(readbytes == 1) next[c] = ((uint8_t) ByteArray_readByte(mine) - 128) * 256;

else next[c] = ByteArray_readShort(mine);

handle_overflow(&next[c]);

} else

next[c] = next[c - 1];

processed_w += readbytes;

}

for(u = 0; u < upsample_factor; u++) {

for(c = 0; c < 2; c++) {

int interpolated = u == 0 ? chan[c] :

chan[c] + ((next[c]-chan[c]) * ((float)u/(float)upsample_factor));

interpolated = (float) interpolated * 0.3; // decrease volume to avoid overflow

int music = GET_MUSIC_WORD();

int sample = music + interpolated;

if(handle_overflow(&sample)) dprintf(2, "overflow\n");

MUSIC_REWIND_WORD();

ByteArray_writeShort(out, sample);

processed_m += 2;

}

}

for (c=0; c<2; c++) chan[c] = next[c];

}

ByteArray_set_position(out, savepos);

}

mixin_done:

sunlock();

BACKEND_WRITE(&playa.writer.ao, playa.wave_buffer, playa.out_wave.pos);

//dprintf(2, "done\n");

playa.out_wave.pos = 0;

}

}

return 0;

}

void audio_init(void) {

Amiga_ctor(&playa.hardware.amiga);

DWPlayer_ctor(&playa.player.dw, &playa.hardware.amiga);

BACKEND_INIT(&playa.writer.ao, 0);

ByteArray_ctor(&playa.music_stream);

ByteArray_ctor(&playa.wave_streams[0]);

ByteArray_ctor(&playa.wave_streams[1]);

ByteArray_ctor(&playa.out_wave);

playa.out_wave.endian = BAE_LITTLE;

ByteArray_open_mem(&playa.out_wave, playa.wave_buffer, sizeof(playa.wave_buffer));

playa.hardware.core.wave = &playa.out_wave;

playa.thread_music_status = TS_WAITING;

errno = pthread_mutex_init(&playa.music_mutex, 0);

if(errno) perror("1");

errno = pthread_mutex_init(&playa.sound_mutex, 0);

if(errno) perror("1.5");

errno = pthread_attr_init(&playa.attr);

if(errno) perror("2");

errno = pthread_attr_setstacksize(&playa.attr, 128*1024);

if(errno) perror("3");

errno = pthread_create(&playa.thread, &playa.attr, thread_func, 0);

if(errno) perror("4");

playa.free_waveslot = 0;

playa.play_waveslot = -1;

}

int audio_open_music_resource(const unsigned char* data, size_t data_size, int track) {

mlock();

if(playa.thread_music_status != TS_WAITING) {

playa.thread_music_status = TS_STOPPING;

munlock();

int done = 0;

do {

mlock();

if(playa.thread_music_status == TS_WAITING) done = 1;

munlock();

if(!done) msleep(1);

} while(!done);

mlock();

}

playa.empty_track_active = 0;

munlock();

if(track == -1) { /* "empty" track */

playa.empty_track_active = 1;

memset(playa.wave_buffer, 0, sizeof(playa.wave_buffer));

return 0;

}

ByteArray_open_mem(&playa.music_stream, (void*) data, data_size);

CorePlayer_load(&playa.player.core, &playa.music_stream);

assert(playa.player.core.version);

if(track > playa.player.core.lastSong) return -1;

playa.player.core.playSong = track;

playa.player.core.initialize(&playa.player.core);

return 0;

}

#if 0

//FIXME: does not close file handle

int audio_open_music(const char* filename, int track) {

mlock();

if(playa.thread_music_status != TS_WAITING) {

playa.thread_music_status = TS_STOPPING;

munlock();

int done = 0;

do {

mlock();

if(playa.thread_music_status == TS_WAITING) done = 1;

munlock();

if(!done) msleep(1);

} while(!done);

mlock();

}

munlock();

ByteArray_open_file(&playa.music_stream, filename);

CorePlayer_load(&playa.player.core, &playa.music_stream);

assert(playa.player.core.version);

playa.player.core.initialize(&playa.player.core);

if(track > playa.player.core.lastSong) return -1;

playa.player.core.playSong = track;

return 0;

}

#endif

void audio_play_wave_resource(const WAVE_HEADER_COMPLETE* wave) {

if(!wave) return;

slock();

if(playa.free_waveslot >= (int) ARRAY_SIZE(playa.wave_streams)) {

playa.free_waveslot = 0;

}

struct ByteArray *mine = &playa.wave_streams[playa.free_waveslot];

if(!ByteArray_open_mem(mine, waveheader_get_data(wave), waveheader_get_datasize(wave))) {

abort();

}

ByteArray_set_endian(mine, BAE_LITTLE);

playa.wavhdr = *wave;

playa.play_waveslot = playa.free_waveslot;

playa.free_waveslot++;

sunlock();

}

#if 0

static void close_all_but_playing_slot() {

size_t i;

for(i = 0; i < ARRAY_SIZE(playa.wave_streams); i++) {

/*if(i != playa.play_waveslot) */

ByteArray_close_file(&playa.wave_streams[i]);

}

}

void audio_play_wav(const char* filename) {

slock();

if(playa.free_waveslot >= (int) ARRAY_SIZE(playa.wave_streams)) {

playa.free_waveslot = 0;

close_all_but_playing_slot();

}

struct ByteArray *mine = &playa.wave_streams[playa.free_waveslot];

if(!ByteArray_open_file(mine, filename)) {

perror("open");

abort();

}

ByteArray_set_endian(mine, BAE_LITTLE);

/* assuming 16bit, 44khz stereo wav for the beginning. */

ByteArray_readMultiByte(mine, (void*) &playa.wavhdr, sizeof(WAVE_HEADER_COMPLETE));

//ByteArray_set_position(mine, sizeof(WAVE_HEADER_COMPLETE));

playa.play_waveslot = playa.free_waveslot;

playa.free_waveslot++;

sunlock();

}

#endif

// return -1: when track is finished, 0 if something was played, 1 if nothing was played.

int audio_process(void) {

mlock();

if(playa.thread_music_status == TS_DONE) {

munlock();

return -1;

} else if (playa.thread_music_status == TS_WAITING) {

playa.thread_music_status = TS_PLAYING;

}

munlock();

return 0;

}

#endif /* AUDIO_BACKEND != AUDIO_BACKEND_NONE */