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;
}
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;
}
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;
}
EXPORT void CALL
AiDacrateChanged( int SystemType )
{
// Taken from mupen_audio
freq = 32000; //default to 32khz incase we get a bad systemtype
switch (SystemType){
case SYSTEM_NTSC:
freq = 48681812 / (*AudioInfo.AI_DACRATE_REG + 1);
break;
case SYSTEM_PAL:
freq = 49656530 / (*AudioInfo.AI_DACRATE_REG + 1);
break;
case SYSTEM_MPAL:
freq = 48628316 / (*AudioInfo.AI_DACRATE_REG + 1);
break;
}
// Calculate the absolute differences from 32 and 48khz
int diff32 = freq - 32000;
int diff48 = freq - 48000;
diff32 = diff32 > 0 ? diff32 : -diff32;
diff48 = diff48 > 0 ? diff48 : -diff48;
// Choose the closest real frequency
real_freq = (diff32 < diff48) ? 32000 : 48000;
freq_ratio = (float)freq / real_freq;
if( real_freq == 32000 ){
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_32KHZ);
buffer_size = (SystemType != SYSTEM_PAL) ?
BUFFER_SIZE_32_60 : BUFFER_SIZE_32_50;
} else if( real_freq == 48000 ){
AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
buffer_size = (SystemType != SYSTEM_PAL) ?
BUFFER_SIZE_48_60 : BUFFER_SIZE_48_50;
}
#ifdef SHOW_DEBUG
sprintf(txtbuffer, "Initializing frequency: %d (resampling ratio %f)",
real_freq, freq_ratio);
DEBUG_print(txtbuffer,DBG_AUDIOINFO);
#endif
}
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;
}
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();
}
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;
}
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);
}