/***
gx_audio_Start
This function restarts the audio engine
This is called when coming back from Main Menu
***/
void gx_audio_Start(void)
{
/* shutdown background music */
PauseOgg(1);
StopOgg();
/* shutdown menu audio processing */
ASND_Pause(1);
ASND_End();
AUDIO_StopDMA();
AUDIO_RegisterDMACallback(NULL);
DSP_Halt();
/* DMA Interrupt callback */
AUDIO_RegisterDMACallback(ai_callback);
/* emulation is synchronized with audio hardware by default */
audioSync = AUDIO_WAIT;
/* reset emulation audio processing */
memset(soundbuffer, 0, sizeof(soundbuffer));
audioWait = 0;
bufferSize = 0;
bufferIndex = 0;
}
static int init(int rate, int channels, int format, int flags)
{
AUDIO_StopDMA();
if(rate>32000) quality = AI_SAMPLERATE_48KHZ;
else quality = AI_SAMPLERATE_32KHZ;
ao_data.samplerate = (quality==AI_SAMPLERATE_48KHZ) ? 48000 : 32000;
ao_data.channels = clamp(channels, 2, 6);
ao_data.format = AF_FORMAT_S16_NE;
ao_data.bps = ao_data.channels * ao_data.samplerate * sizeof(s16);
request_mult = (float)ao_data.channels / HW_CHANNELS;
request_size = BUFFER_SIZE * request_mult;
ao_data.buffersize = request_size * BUFFER_COUNT;
ao_data.outburst = request_size;
for (int counter = 0; counter < BUFFER_COUNT; counter++)
{
memset(buffers[counter], 0, BUFFER_SIZE);
DCFlushRange(buffers[counter], BUFFER_SIZE);
}
memset(silence, 0, BUFFER_SIZE);
DCFlushRange(silence, BUFFER_SIZE);
buffer_fill = 0;
buffer_play = 0;
buffered = 0;
playing = false;
AUDIO_SetDSPSampleRate(quality);
AUDIO_RegisterDMACallback(switch_buffers);
return CONTROL_TRUE;
}
static void *gx_audio_init(const char *device, unsigned rate, unsigned latency)
{
gx_audio_t *wa = (gx_audio_t*)memalign(32, sizeof(*wa));
if (!wa)
return NULL;
gx_audio_data = wa;
memset(wa, 0, sizeof(*wa));
AUDIO_Init(NULL);
AUDIO_RegisterDMACallback(dma_callback);
if (rate < 33000)
{
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_32KHZ);
g_settings.audio.out_rate = 32000;
}
else
{
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
g_settings.audio.out_rate = 48000;
}
LWP_InitQueue(&wa->cond);
wa->dma_write = BLOCKS - 1;
DCFlushRange(wa->data, sizeof(wa->data));
AUDIO_InitDMA((uint32_t)wa->data[wa->dma_next], CHUNK_SIZE);
AUDIO_StartDMA();
return wa;
}
int
sound_lowlevel_init( const char *device, int *freqptr, int *stereoptr )
{
switch(*freqptr) {
case 32000:
samplerate = AI_SAMPLERATE_32KHZ;
break;
case 48000:
samplerate = AI_SAMPLERATE_48KHZ;
break;
default:
printf("Sample rate %d not supported on Wii\n", *freqptr);
return 1;
}
sfifo_init( &sound_fifo, BUFSIZE );
*stereoptr = 1;
AUDIO_Init( NULL );
AUDIO_SetDSPSampleRate( samplerate );
#ifndef DISPLAY_AUDIO
AUDIO_RegisterDMACallback( sound_dmacallback );
memset( dmabuf, 0, BUFSIZE );
AUDIO_InitDMA( (u32)dmabuf, BUFSIZE );
DCFlushRange( dmabuf, dmalen );
AUDIO_StartDMA();
#endif
return 0;
}
static void uninit(int immed)
{
reset();
AUDIO_RegisterDMACallback(NULL);
while(AUDIO_GetDMABytesLeft() > 0)
usleep(100);
AUDIO_StopDMA();
}
static void reset(void)
{
AUDIO_RegisterDMACallback(NULL);
while(AUDIO_GetDMABytesLeft() > 0)
usleep(100);
playing = false;
buffer_fill = 0;
buffer_play = 0;
buffered = 0;
for (int counter = 0; counter < BUFFER_COUNT; counter++)
{
memset(buffers[counter], 0, BUFFER_SIZE);
DCFlushRange(buffers[counter], BUFFER_SIZE);
}
AUDIO_RegisterDMACallback(switch_buffers);
}
void reinit_audio()
{
AUDIO_RegisterDMACallback(switch_buffers);
/*
if(!playing)
{
switch_buffers();
AUDIO_StartDMA();
}
*/
}
static void wii_audio_free(void *data)
{
AUDIO_StopDMA();
AUDIO_RegisterDMACallback(NULL);
if (g_audio && g_audio->cond)
{
LWP_CloseQueue(g_audio->cond);
g_audio->cond = 0;
}
if (data)
free(data);
g_audio = NULL;
}
/***
gx_audio_Start
This function restart the audio engine
This is called when coming back from Main Menu
***/
void gx_audio_Start(void)
{
/* shutdown background music */
PauseOgg(1);
StopOgg();
/* shutdown menu audio processing */
ASND_Pause(1);
AUDIO_StopDMA();
AUDIO_RegisterDMACallback(NULL);
DSP_Halt();
/* when not using 60hz mode, frame emulation is synchronized with Audio Interface DMA */
if (gc_pal | vdp_pal)
{
AUDIO_RegisterDMACallback(ai_callback);
}
/* reset emulation audio processing */
memset(soundbuffer, 0, 2 * 3840);
audioStarted = 0;
mixbuffer = 0;
}
EXPORT void CALL RomOpen()
{
#ifdef THREADED_AUDIO
// Create our semaphores and start/resume the audio thread; reset the buffer index
LWP_SemInit(&buffer_full, 0, NUM_BUFFERS);
LWP_SemInit(&buffer_empty, NUM_BUFFERS, NUM_BUFFERS);
LWP_SemInit(&audio_free, 0, 1);
LWP_SemInit(&first_audio, 0, 1);
thread_running = 0;
LWP_CreateThread(&audio_thread, (void*)play_buffer, NULL, audio_stack, AUDIO_STACK_SIZE, AUDIO_PRIORITY);
AUDIO_RegisterDMACallback(done_playing);
thread_buffer = which_buffer = 0;
audio_paused = 1;
#endif
}
void OSystem_Wii::deinitSfx() {
if (_mixer)
_mixer->setReady(false);
AUDIO_StopDMA();
AUDIO_RegisterDMACallback(NULL);
if (sfx_thread_running) {
sfx_thread_quit = true;
LWP_ThreadBroadcast(sfx_queue);
LWP_JoinThread(sfx_thread, NULL);
LWP_CloseQueue(sfx_queue);
free(sfx_stack);
sfx_thread_running = false;
for (u32 i = 0; i < SFX_BUFFERS; ++i)
free(sound_buffer[i]);
}
}
int SNDWiiInit()
{
AUDIO_Init(NULL);
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
soundpos = 0;
soundlen = 44100 / 60; // 60 for NTSC or 50 for PAL. Initially assume it's going to be NTSC.
soundtruelen = 48000 / 60;
truesoundoffset = stereodata16[0];
memset(stereodata16, 0, SOUNDBUFSIZE);
issoundmuted = 0;
AUDIO_RegisterDMACallback(StartDMA);
AUDIO_InitDMA((u32)stereodata16[soundpos], soundlen * 4);
DCFlushRange((void *)stereodata16[soundpos], soundlen * 4);
AUDIO_StartDMA();
return 0;
}
void OSystem_Wii::initSfx() {
_mixer = new Audio::MixerImpl(this, 48000);
sfx_thread_running = false;
sfx_thread_quit = false;
sfx_stack = (u8 *) memalign(32, SFX_THREAD_STACKSIZE);
if (sfx_stack) {
memset(sfx_stack, 0, SFX_THREAD_STACKSIZE);
LWP_InitQueue(&sfx_queue);
s32 res = LWP_CreateThread(&sfx_thread, sfx_thread_func, _mixer, sfx_stack,
SFX_THREAD_STACKSIZE, SFX_THREAD_PRIO);
if (res) {
printf("ERROR creating sfx thread: %d\n", res);
LWP_CloseQueue(sfx_queue);
return;
}
sfx_thread_running = true;
}
for (u32 i = 0; i < SFX_BUFFERS; ++i) {
sound_buffer[i] = (u8 *) memalign(32, SFX_THREAD_FRAG_SIZE);
memset(sound_buffer[i], 0, SFX_THREAD_FRAG_SIZE);
DCFlushRange(sound_buffer[i], SFX_THREAD_FRAG_SIZE);
}
_mixer->setReady(true);
sb_hw = 0;
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
AUDIO_RegisterDMACallback(audio_switch_buffers);
AUDIO_InitDMA((u32) sound_buffer[sb_hw], SFX_THREAD_FRAG_SIZE);
AUDIO_StartDMA();
}
static void *gx_audio_init(const char *device, unsigned rate, unsigned latency)
{
if (g_audio)
return g_audio;
AUDIO_Init(NULL);
AUDIO_RegisterDMACallback(dma_callback);
if (rate < 33000)
{
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_32KHZ);
g_settings.audio.out_rate = 32000;
}
else
{
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
g_settings.audio.out_rate = 48000;
}
if (!g_audio)
{
g_audio = memalign(32, sizeof(*g_audio));
memset(g_audio, 0, sizeof(*g_audio));
LWP_InitQueue(&g_audio->cond);
}
else
{
memset(g_audio->data, 0, sizeof(g_audio->data));
g_audio->dma_busy = g_audio->dma_next = 0;
g_audio->write_ptr = 0;
g_audio->nonblock = false;
}
g_audio->dma_write = BLOCKS - 1;
DCFlushRange(g_audio->data, sizeof(g_audio->data));
AUDIO_InitDMA((u32)g_audio->data[g_audio->dma_next], CHUNK_SIZE);
AUDIO_StartDMA();
return g_audio;
}
qboolean SNDDMA_Init(void)
{
// Set up Quake's audio.
shm = &sn;
shm->channels = 2;
shm->samplebits = 16;
shm->speed = 32000;
shm->soundalive = TRUE;
shm->splitbuffer = FALSE;
shm->samples = samples_per_mix_buffer * shm->channels;
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = (unsigned char*)(&mix_buffer[0]);
// Initialise the audio system.
AUDIO_Init(0);
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_32KHZ);
AUDIO_RegisterDMACallback(play_more_audio);
// Start the first chunk of audio playing.
play_more_audio();
return TRUE;
}
void SNDDMA_Shutdown(void)
{
// Stop streaming.
AUDIO_RegisterDMACallback(0);
AUDIO_StopDMA();
}
static int
wii_audio_start(audio_mode_t *am, audio_fifo_t *af)
{
audio_buf_t *ab;
int tbuf = 0, i;
uint32_t level;
int64_t pts;
media_pipe_t *mp;
prop_sub_t *s_vol;
s_vol =
prop_subscribe(PROP_SUB_DIRECT_UPDATE,
PROP_TAG_CALLBACK_FLOAT, set_mastervol, NULL,
PROP_TAG_ROOT, prop_mastervol,
NULL);
LWP_InitQueue(&audio_queue);
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
AUDIO_RegisterDMACallback(switch_buffers);
AUDIO_StartDMA();
while(1) {
level = IRQ_Disable();
while(tbuf == cur_buffer)
LWP_ThreadSleep(audio_queue);
tbuf = cur_buffer;
IRQ_Restore(level);
ab = af_deq(af, 0);
if(am != audio_mode_current) {
/* We're not the selected audio output anymore, return. */
if(ab != NULL)
ab_free(ab);
break;
}
if(ab != NULL) {
const int16_t *src = (const int16_t *)ab->ab_data;
int16_t *dst = (int16_t *)buffer[!tbuf];
for(i = 0; i < ADMA_BUFFER_SIZE / 2; i++)
*dst++ = (*src++ * audio_vol) >> 16;
/* PTS is the time of the first frame of this audio packet */
if((pts = ab->ab_pts) != AV_NOPTS_VALUE && ab->ab_mp != NULL) {
#if 0
/* Convert the frame delay into micro seconds */
d = (fr * 1000 / aam->aam_sample_rate) * 1000;
/* Subtract it from our timestamp, this will yield
the PTS for the sample currently played */
pts -= d;
/* Offset with user configure delay */
#endif
pts += am->am_audio_delay * 1000;
mp = ab->ab_mp;
hts_mutex_lock(&mp->mp_clock_mutex);
mp->mp_audio_clock = pts;
mp->mp_audio_clock_realtime = showtime_get_ts();
mp->mp_audio_clock_epoch = ab->ab_epoch;
hts_mutex_unlock(&mp->mp_clock_mutex);
}
ab_free(ab);
} else {
memset(buffer[!tbuf], 0, ADMA_BUFFER_SIZE);
}
DCFlushRange(buffer[!tbuf], ADMA_BUFFER_SIZE);
}
