static void
test_multi_audio()
{
int keep_going = 1;
int i;
if (devcount > 64) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Too many devices (%d), clamping to 64...\n",
devcount);
devcount = 64;
}
spec.callback = play_through_once;
SDL_memset(cbd, '\0', sizeof(cbd));
SDL_Log("playing on all devices...\n");
for (i = 0; i < devcount; i++) {
const char *devname = SDL_GetAudioDeviceName(i, 0);
spec.userdata = &cbd[i];
cbd[i].dev = SDL_OpenAudioDevice(devname, 0, &spec, NULL, 0);
if (cbd[i].dev == 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Open device %d failed: %s\n", i, SDL_GetError());
}
}
for (i = 0; i < devcount; i++) {
if (cbd[i].dev) {
SDL_PauseAudioDevice(cbd[i].dev, 0);
}
}
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop(loop, 0, 1);
#else
while (keep_going) {
keep_going = 0;
for (i = 0; i < devcount; i++) {
if ((cbd[i].dev) && (!cbd[i].done)) {
keep_going = 1;
}
}
SDL_Delay(100);
}
#endif
for (i = 0; i < devcount; i++) {
if (cbd[i].dev) {
SDL_PauseAudioDevice(cbd[i].dev, 1);
SDL_CloseAudioDevice(cbd[i].dev);
}
}
SDL_Log("All done!\n");
}
bool GBASDLInitAudio(struct GBASDLAudio* context, struct GBAThread* threadContext) {
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
GBALog(0, GBA_LOG_ERROR, "Could not initialize SDL sound system: %s", SDL_GetError());
return false;
}
context->desiredSpec.freq = 44100;
context->desiredSpec.format = AUDIO_S16SYS;
context->desiredSpec.channels = 2;
context->desiredSpec.samples = context->samples;
context->desiredSpec.callback = _GBASDLAudioCallback;
context->desiredSpec.userdata = context;
#if RESAMPLE_LIBRARY == RESAMPLE_NN
context->drift = 0.f;
#endif
#if SDL_VERSION_ATLEAST(2, 0, 0)
context->deviceId = SDL_OpenAudioDevice(0, 0, &context->desiredSpec, &context->obtainedSpec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE);
if (context->deviceId == 0) {
#else
if (SDL_OpenAudio(&context->desiredSpec, &context->obtainedSpec) < 0) {
#endif
GBALog(0, GBA_LOG_ERROR, "Could not open SDL sound system");
return false;
}
context->thread = threadContext;
context->samples = context->obtainedSpec.samples;
float ratio = GBAAudioCalculateRatio(0x8000, threadContext->fpsTarget, 44100);
threadContext->audioBuffers = context->samples / ratio;
if (context->samples > threadContext->audioBuffers) {
threadContext->audioBuffers = context->samples * 2;
}
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_PauseAudioDevice(context->deviceId, 0);
#else
SDL_PauseAudio(0);
#endif
return true;
}
void GBASDLDeinitAudio(struct GBASDLAudio* context) {
UNUSED(context);
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_PauseAudioDevice(context->deviceId, 1);
SDL_CloseAudioDevice(context->deviceId);
#else
SDL_PauseAudio(1);
SDL_CloseAudio();
#endif
SDL_QuitSubSystem(SDL_INIT_AUDIO);
}
/*
===========
S_Activate
Called when the main window gains or loses focus.
The window have been destroyed and recreated
between a deactivate and an activate.
===========
*/
void S_Activate (qboolean active)
{
if (snd_init)
{
if ( active )
{
SDL_PauseAudioDevice(audio_device, 0);
}
else
{
SDL_PauseAudioDevice(audio_device, 1);
}
}
}
bool mSDLInitAudio(struct mSDLAudio* context, struct mCoreThread* threadContext) {
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
mLOG(SDL_AUDIO, ERROR, "Could not initialize SDL sound system: %s", SDL_GetError());
return false;
}
context->desiredSpec.freq = context->sampleRate;
context->desiredSpec.format = AUDIO_S16SYS;
context->desiredSpec.channels = 2;
context->desiredSpec.samples = context->samples;
context->desiredSpec.callback = _mSDLAudioCallback;
context->desiredSpec.userdata = context;
#if SDL_VERSION_ATLEAST(2, 0, 0)
context->deviceId = SDL_OpenAudioDevice(0, 0, &context->desiredSpec, &context->obtainedSpec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE);
if (context->deviceId == 0) {
#else
if (SDL_OpenAudio(&context->desiredSpec, &context->obtainedSpec) < 0) {
#endif
mLOG(SDL_AUDIO, ERROR, "Could not open SDL sound system");
return false;
}
context->core = 0;
if (threadContext) {
context->core = threadContext->core;
context->sync = &threadContext->impl->sync;
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_PauseAudioDevice(context->deviceId, 0);
#else
SDL_PauseAudio(0);
#endif
}
return true;
}
void mSDLDeinitAudio(struct mSDLAudio* context) {
UNUSED(context);
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_PauseAudioDevice(context->deviceId, 1);
SDL_CloseAudioDevice(context->deviceId);
#else
SDL_PauseAudio(1);
SDL_CloseAudio();
#endif
SDL_QuitSubSystem(SDL_INIT_AUDIO);
}
static bool initAudio() {
if (audioDev) {
SDL_CloseAudioDevice(audioDev);
audioDev = 0;
}
if (audioEnabled) {
SDL_AudioSpec desired = {}, actual = {};
// We want 48 KHz stereo f32 to match opusfile output
desired.freq = 48000;
desired.channels = 2;
desired.format = AUDIO_F32;
desired.samples = 4096; // TODO: user-configurable buffer size?
desired.callback = audioCallback;
audioDev = SDL_OpenAudioDevice(NULL, 0, &desired, &actual, 0);
if (!audioDev) {
narf::console->println("Could not open default audio device: " + std::string(SDL_GetError()));
audioEnabled = false;
return false;
}
SDL_PauseAudioDevice(audioDev, 0);
narf::console->println("Audio initialized: " + std::to_string(actual.freq) + " Hz, " + std::to_string(actual.channels) + " channels");
}
return true;
}
void audio_pause() {
// Pause the SDL audio device
if (conf.audio_api == 0) { // SDL
SDL_PauseAudioDevice(dev, 1);
}
paused = true;
}
static void SDLAudioCallback(void * /*userdata*/, Uint8 *stream, int len)
{
if (playing_sample)
{
if (cursnd.sfxr)
{
uint l = len/2;
float *fbuf = new float[l];
memset(fbuf, 0, sizeof(float)*l);
SynthSample(l, fbuf, nullptr);
while (l--)
{
float f = fbuf[l];
if (f < -1.0) f = -1.0;
if (f > 1.0) f = 1.0;
((Sint16*)stream)[l] = (Sint16)(f * 32767);
}
delete[] fbuf;
}
else
{
size_t amount = min((size_t)len, cursnd.len - (cursndpos - cursnd.buf));
memcpy(stream, cursndpos, amount);
memset(stream + amount, 0, len - amount);
cursndpos += amount;
if (cursndpos == cursnd.buf + cursnd.len)
playing_sample = false;
}
}
else
{
memset(stream, 0, len);
SDL_PauseAudioDevice(audioid, 1);
}
}
void SoundSDL::resume()
{
if (!_initialized)
return;
SDL_PauseAudioDevice(_dev, 0);
}
void SoundSDL::pause()
{
if (!_initialized)
return;
SDL_PauseAudioDevice(_dev, 1);
}
void audio_unpause() {
// Unpause the SDL audio device
if (conf.audio_api == 0) { // SDL
SDL_PauseAudioDevice(dev, 0);
}
paused = false;
}
void SdlAudioSink::Stop()
{
if (this->state == Audio::State::STOPPED) return;
SDL_PauseAudioDevice(this->device, 1);
this->state = Audio::State::STOPPED;
}
void Mixer::Init(const char* device)
{
Close();
SDL_AudioSpec want, have;
SDL_zero(want);
want.freq = 44100;
want.format = AUDIO_S16SYS;
want.channels = 2;
want.samples = 1024;
want.callback = Callback;
want.userdata = this;
deviceid = SDL_OpenAudioDevice(device, 0, &want, &have, 0);
format.format = have.format;
format.channels = have.channels;
format.freq = have.freq;
const char* filename = get_file_path(PATH_ID_CSS1);
for (size_t i = 0; i < Util::CountOf(css1sources); i++) {
Source_Sample* source_sample = new Source_Sample;
if (source_sample->LoadCSS1(filename, i)) {
source_sample->Convert(format); // convert to audio output format, saves some cpu usage but requires a bit more memory, optional
css1sources[i] = source_sample;
} else {
css1sources[i] = &source_null;
delete source_sample;
}
}
effectbuffer = new uint8[(have.samples * format.BytesPerSample() * format.channels)];
SDL_PauseAudioDevice(deviceid, 0);
}
static void
iteration()
{
SDL_Event e;
SDL_AudioDeviceID dev;
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
done = 1;
} else if (e.type == SDL_AUDIODEVICEADDED) {
const char *name = SDL_GetAudioDeviceName(e.adevice.which, 0);
SDL_Log("New %s audio device: %s\n", e.adevice.iscapture ? "capture" : "output", name);
if (!e.adevice.iscapture) {
positions[posindex] = 0;
spec.userdata = &positions[posindex++];
spec.callback = fillerup;
dev = SDL_OpenAudioDevice(name, 0, &spec, NULL, 0);
if (!dev) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't open '%s': %s\n", name, SDL_GetError());
} else {
SDL_Log("Opened '%s' as %u\n", name, (unsigned int) dev);
SDL_PauseAudioDevice(dev, 0);
}
}
} else if (e.type == SDL_AUDIODEVICEREMOVED) {
dev = (SDL_AudioDeviceID) e.adevice.which;
SDL_Log("%s device %u removed.\n", e.adevice.iscapture ? "capture" : "output", (unsigned int) dev);
SDL_CloseAudioDevice(dev);
}
}
}
void SdlAudioSink::Start()
{
if (this->state != Audio::State::STOPPED) return;
SDL_PauseAudioDevice(this->device, 0);
this->state = Audio::State::PLAYING;
}
void Audio::pause_audio()
{
if (sound_enabled)
{
SDL_PauseAudioDevice(dev,1);
}
}
bool ZWVideoThread::stop(bool isWait)
{
if (mPlayerState == Stop)
{
return false;
}
mVideoState.quit = 1;
mPlayerState = Stop;
emit sig_StateChanged(Stop);
if (isWait)
{
while(!mVideoState.readThreadFinished || !mVideoState.videoThreadFinished)
{
SDL_Delay(10);
}
}
///关闭SDL音频播放设备
if (mVideoState.audioID != 0)
{
SDL_LockAudio();
SDL_PauseAudioDevice(mVideoState.audioID,1);
SDL_UnlockAudio();
mVideoState.audioID = 0;
}
return true;
}
SDL2Sink::SDL2Sink() : impl(std::make_unique<Impl>()) {
if (SDL_Init(SDL_INIT_AUDIO) < 0) {
LOG_CRITICAL(Audio_Sink, "SDL_Init(SDL_INIT_AUDIO) failed");
impl->audio_device_id = 0;
return;
}
SDL_AudioSpec desired_audiospec;
SDL_zero(desired_audiospec);
desired_audiospec.format = AUDIO_S16;
desired_audiospec.channels = 2;
desired_audiospec.freq = native_sample_rate;
desired_audiospec.samples = 1024;
desired_audiospec.userdata = impl.get();
desired_audiospec.callback = &Impl::Callback;
SDL_AudioSpec obtained_audiospec;
SDL_zero(obtained_audiospec);
impl->audio_device_id = SDL_OpenAudioDevice(nullptr, false, &desired_audiospec, &obtained_audiospec, 0);
if (impl->audio_device_id <= 0) {
LOG_CRITICAL(Audio_Sink, "SDL_OpenAudioDevice failed");
return;
}
impl->sample_rate = obtained_audiospec.freq;
// SDL2 audio devices start out paused, unpause it:
SDL_PauseAudioDevice(impl->audio_device_id, 0);
}
SDL2SoundCore::~SDL2SoundCore() {
// Pause and close the audio device (allowing
// loaded sounds to be freed)
if (device != 0) {
SDL_PauseAudioDevice(device, 1);
SDL_CloseAudioDevice(device);
}
}
void mSDLResumeAudio(struct mSDLAudio* context) {
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_PauseAudioDevice(context->deviceId, 0);
#else
UNUSED(context);
SDL_PauseAudio(0);
#endif
}
SdlAudioSink::~SdlAudioSink()
{
if (this->device == 0) return;
// Silence any currently playing audio.
SDL_PauseAudioDevice(this->device, SDL_TRUE);
SDL_CloseAudioDevice(this->device);
}
void Audio::resume_audio()
{
if (sound_enabled)
{
clear_buffers();
SDL_PauseAudioDevice(dev,0);
}
}
static int S_CaptureDriverInit (int sampleRate)
{
SDL_AudioDeviceID inputdevid = 0;
SDL_AudioSpec desired, obtained;
int ret = 0;
const char *requested_device = NULL;
if (SDL_WasInit (SDL_INIT_AUDIO) == 0)
ret = SDL_InitSubSystem (SDL_INIT_AUDIO);
if (ret == -1) {
Con_Printf ("Couldn't initialize SDL audio: %s\n", SDL_GetError ());
return false;
}
memset (&desired, 0, sizeof (desired));
desired.freq = sampleRate;
desired.samples = 64;
desired.format = AUDIO_S16LSB;
desired.channels = 1;
/* Make audiodevice list start from index 1 so that 0 can be system default */
if (s_inputdevice.integer > 0) {
requested_device = SDL_GetAudioDeviceName (s_inputdevice.integer - 1, 0);
}
if ((inputdevid = SDL_OpenAudioDevice (requested_device, 1, &desired, &obtained, 0)) <= 0) {
Com_Printf ("sound: couldn't open SDL audio: %s\n", SDL_GetError ());
if (requested_device != NULL) {
Com_Printf ("sound: retrying with default audio device\n");
if ((inputdevid = SDL_OpenAudioDevice (NULL, 1, &desired, &obtained, 0)) <= 0) {
Com_Printf ("sound: failure again, aborting...\n");
return 0;
}
Cvar_LatchedSet (&s_inputdevice, "0");
}
}
if (obtained.format != AUDIO_S16LSB) {
Com_Printf ("SDL audio format %d unsupported.\n", obtained.format);
SDL_CloseAudioDevice (inputdevid);
inputdevid = 0;
return 0;
}
if (obtained.channels != 1 && obtained.channels != 2) {
Com_Printf ("SDL audio channels %d unsupported.\n", obtained.channels);
SDL_CloseAudioDevice (inputdevid);
inputdevid = 0;
return 0;
}
Com_Printf ("Using SDL audio capture driver: %s @ %d Hz (samplerate %d)\n", SDL_GetCurrentAudioDriver (), obtained.freq, obtained.samples);
SDL_PauseAudioDevice (inputdevid, 0);
return inputdevid;
}
void SNDDMA_StopCapture(void)
{
#ifdef USE_SDL_AUDIO_CAPTURE
if (sdlCaptureDevice)
{
SDL_PauseAudioDevice(sdlCaptureDevice, 1);
}
#endif
}
void GBASDLPauseAudio(struct GBASDLAudio* context) {
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_PauseAudioDevice(context->deviceId, 1);
#else
UNUSED(context);
SDL_PauseAudio(1);
#endif
}
void StringSynth::Stop() {
SDL_PauseAudioDevice(device_ID, 1);
SDL_CloseAudioDevice(device_ID);
stopped = true;
paused = false;
time_elapsed = -1.0f;
distance_struck = 0.0f;
initial_offset = 0.0f;
}
int main(int argc, char** argv) {
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) != 0) {
SDL_Log("Unable to initialize SDL: %s", SDL_GetError());
return 1;
}
SDL_Window* win = SDL_CreateWindow("Bytebeat Visualizer", 0, 0, 800, 600, 0);
SDL_Renderer* ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED);
SDL_AudioSpec want, have;
SDL_AudioDeviceID dev;
SDL_zero(want); SDL_zero(have);
want.freq = 8000;
want.format = AUDIO_U8;
want.channels = 1;
want.samples = 4096;
want.callback = audio_callback;
// save the current time
want.userdata = malloc(sizeof(unsigned int));
memset(want.userdata, 0, sizeof(unsigned int));
// and save the pointer for further use
unsigned int* t = want.userdata;
dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0);
SDL_PauseAudioDevice(dev, 0);
int running = 1;
while (running) {
SDL_Event e;
while (SDL_PollEvent(&e)) {
switch (e.type) {
case SDL_QUIT:
running = 0;
break;
}
}
SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
SDL_RenderClear(ren);
SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
unsigned int i = (*t);
i -= 8000;
for (; i < *t; i++) {
int x = 0;
int sample_width = 1;
SDL_RenderDrawLine(ren, x, 0, x + sample_width, 200);
x++;
}
SDL_RenderPresent(ren);
}
SDL_CloseAudioDevice(dev);
SDL_DestroyRenderer(ren);
SDL_DestroyWindow(win);
SDL_Quit();
return 0;
}
void SNDDMA_StartCapture(void)
{
#ifdef USE_SDL_AUDIO_CAPTURE
if (sdlCaptureDevice)
{
SDL_ClearQueuedAudio(sdlCaptureDevice);
SDL_PauseAudioDevice(sdlCaptureDevice, 0);
}
#endif
}
/* attenuation in dB */
void osd_set_mastervolume(int _attenuation)
{
// clamp the attenuation to 0-32 range
if (_attenuation > 0) {
attenuation = 0;
} else if (_attenuation < -32) {
attenuation = -32;
} else {
attenuation = _attenuation;
}
if (Machine->sample_rate > 0) {
if (attenuation == -32) {
SDL_PauseAudioDevice(audio_device, 1);
SDL_ClearQueuedAudio(audio_device);
} else {
SDL_PauseAudioDevice(audio_device, 0);
}
}
}
void Audio::stop_audio()
{
if (sound_enabled)
{
sound_enabled = false;
SDL_PauseAudioDevice(dev,1);
SDL_CloseAudioDevice(dev);
delete[] dsp_buffer;
delete[] mix_buffer;
}
}
BOOL ffplayer::Pause(DWORD nPause)
{
if (m_bStepNext)
{
return false;
}
m_bPause = nPause;
if (m_devID > 0)
{
SDL_PauseAudioDevice(m_devID, m_bPause);
}
return true;
}
