/*** 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); }