SDL  2.0
SDL_audio.c File Reference
#include "../SDL_internal.h"
#include "SDL.h"
#include "SDL_audio.h"
#include "SDL_audio_c.h"
#include "SDL_sysaudio.h"
#include "../thread/SDL_systhread.h"
+ Include dependency graph for SDL_audio.c:

Go to the source code of this file.

Macros

#define _THIS   SDL_AudioDevice *_this
 
#define FILL_STUB(x)
 
#define CHECK_FMT_STRING(x)   if (SDL_strcmp(string, #x) == 0) return AUDIO_##x
 
#define NUM_FORMATS   10
 

Functions

static SDL_AudioDeviceget_audio_device (SDL_AudioDeviceID id)
 
static void SDL_AudioDetectDevices_Default (void)
 
static void SDL_AudioThreadInit_Default (_THIS)
 
static void SDL_AudioThreadDeinit_Default (_THIS)
 
static void SDL_AudioWaitDevice_Default (_THIS)
 
static void SDL_AudioPlayDevice_Default (_THIS)
 
static int SDL_AudioGetPendingBytes_Default (_THIS)
 
static Uint8SDL_AudioGetDeviceBuf_Default (_THIS)
 
static int SDL_AudioCaptureFromDevice_Default (_THIS, void *buffer, int buflen)
 
static void SDL_AudioFlushCapture_Default (_THIS)
 
static void SDL_AudioPrepareToClose_Default (_THIS)
 
static void SDL_AudioCloseDevice_Default (_THIS)
 
static void SDL_AudioDeinitialize_Default (void)
 
static void SDL_AudioFreeDeviceHandle_Default (void *handle)
 
static int SDL_AudioOpenDevice_Default (_THIS, void *handle, const char *devname, int iscapture)
 
static SDL_INLINE SDL_bool is_in_audio_device_thread (SDL_AudioDevice *device)
 
static void SDL_AudioLockDevice_Default (SDL_AudioDevice *device)
 
static void SDL_AudioUnlockDevice_Default (SDL_AudioDevice *device)
 
static void SDL_AudioLockOrUnlockDeviceWithNoMixerLock (SDL_AudioDevice *device)
 
static void finish_audio_entry_points_init (void)
 
static int add_audio_device (const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
 
static SDL_INLINE int add_capture_device (const char *name, void *handle)
 
static SDL_INLINE int add_output_device (const char *name, void *handle)
 
static void free_device_list (SDL_AudioDeviceItem **devices, int *devCount)
 
void SDL_AddAudioDevice (const int iscapture, const char *name, void *handle)
 
void SDL_OpenedAudioDeviceDisconnected (SDL_AudioDevice *device)
 
static void mark_device_removed (void *handle, SDL_AudioDeviceItem *devices, SDL_bool *removedFlag)
 
void SDL_RemoveAudioDevice (const int iscapture, void *handle)
 
static void SDL_BufferQueueDrainCallback (void *userdata, Uint8 *stream, int len)
 
static void SDL_BufferQueueFillCallback (void *userdata, Uint8 *stream, int len)
 
int SDL_QueueAudio (SDL_AudioDeviceID devid, const void *data, Uint32 len)
 
Uint32 SDL_DequeueAudio (SDL_AudioDeviceID devid, void *data, Uint32 len)
 
Uint32 SDL_GetQueuedAudioSize (SDL_AudioDeviceID devid)
 
void SDL_ClearQueuedAudio (SDL_AudioDeviceID devid)
 
static int SDL_RunAudio (void *devicep)
 
static int SDL_CaptureAudio (void *devicep)
 
static SDL_AudioFormat SDL_ParseAudioFormat (const char *string)
 
int SDL_GetNumAudioDrivers (void)
 
const char * SDL_GetAudioDriver (int index)
 
int SDL_AudioInit (const char *driver_name)
 
const char * SDL_GetCurrentAudioDriver ()
 
static void clean_out_device_list (SDL_AudioDeviceItem **devices, int *devCount, SDL_bool *removedFlag)
 
int SDL_GetNumAudioDevices (int iscapture)
 
const char * SDL_GetAudioDeviceName (int index, int iscapture)
 
static void close_audio_device (SDL_AudioDevice *device)
 
static int prepare_audiospec (const SDL_AudioSpec *orig, SDL_AudioSpec *prepared)
 
static SDL_AudioDeviceID open_audio_device (const char *devname, int iscapture, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, int allowed_changes, int min_id)
 
int SDL_OpenAudio (SDL_AudioSpec *desired, SDL_AudioSpec *obtained)
 
SDL_AudioDeviceID SDL_OpenAudioDevice (const char *device, int iscapture, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, int allowed_changes)
 
SDL_AudioStatus SDL_GetAudioDeviceStatus (SDL_AudioDeviceID devid)
 
SDL_AudioStatus SDL_GetAudioStatus (void)
 
void SDL_PauseAudioDevice (SDL_AudioDeviceID devid, int pause_on)
 
void SDL_PauseAudio (int pause_on)
 
void SDL_LockAudioDevice (SDL_AudioDeviceID devid)
 
void SDL_LockAudio (void)
 
void SDL_UnlockAudioDevice (SDL_AudioDeviceID devid)
 
void SDL_UnlockAudio (void)
 
void SDL_CloseAudioDevice (SDL_AudioDeviceID devid)
 
void SDL_CloseAudio (void)
 
void SDL_AudioQuit (void)
 
SDL_AudioFormat SDL_FirstAudioFormat (SDL_AudioFormat format)
 
SDL_AudioFormat SDL_NextAudioFormat (void)
 
void SDL_CalculateAudioSpec (SDL_AudioSpec *spec)
 
void SDL_MixAudio (Uint8 *dst, const Uint8 *src, Uint32 len, int volume)
 

Variables

static SDL_AudioDriver current_audio
 
static SDL_AudioDeviceopen_devices [16]
 
static const AudioBootStrap *const bootstrap []
 
static int format_idx
 
static int format_idx_sub
 
static SDL_AudioFormat format_list [NUM_FORMATS][NUM_FORMATS]
 

Macro Definition Documentation

◆ _THIS

#define _THIS   SDL_AudioDevice *_this

Definition at line 31 of file SDL_audio.c.

◆ CHECK_FMT_STRING

#define CHECK_FMT_STRING (   x)    if (SDL_strcmp(string, #x) == 0) return AUDIO_##x

Referenced by SDL_ParseAudioFormat().

◆ FILL_STUB

#define FILL_STUB (   x)
Value:
if (current_audio.impl.x == NULL) { \
current_audio.impl.x = SDL_Audio##x##_Default; \
}
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
#define NULL
Definition: begin_code.h:164
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115

Referenced by finish_audio_entry_points_init().

◆ NUM_FORMATS

#define NUM_FORMATS   10

Definition at line 1550 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

Function Documentation

◆ add_audio_device()

static int add_audio_device ( const char *  name,
void handle,
SDL_AudioDeviceItem **  devices,
int *  devCount 
)
static

Definition at line 375 of file SDL_audio.c.

References SDL_AudioDriver::detectionLock, SDL_AudioDeviceItem::handle, SDL_AudioDeviceItem::name, SDL_AudioDeviceItem::next, NULL, retval, SDL_assert, SDL_INLINE, SDL_LockMutex, SDL_malloc, SDL_strlcpy, SDL_strlen, and SDL_UnlockMutex.

Referenced by add_capture_device(), and add_output_device().

376 {
377  int retval = -1;
378  const size_t size = sizeof (SDL_AudioDeviceItem) + SDL_strlen(name) + 1;
380  if (item == NULL) {
381  return -1;
382  }
383 
384  SDL_assert(handle != NULL); /* we reserve NULL, audio backends can't use it. */
385 
386  item->handle = handle;
387  SDL_strlcpy(item->name, name, size - sizeof (SDL_AudioDeviceItem));
388 
390  item->next = *devices;
391  *devices = item;
392  retval = (*devCount)++;
394 
395  return retval;
396 }
#define SDL_strlcpy
#define SDL_LockMutex
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:100
char name[SDL_VARIABLE_LENGTH_ARRAY]
Definition: SDL_sysaudio.h:101
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
GLuint const GLchar * name
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:118
SDL_bool retval
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
GLsizeiptr size
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
#define SDL_strlen
#define SDL_UnlockMutex
#define SDL_malloc
EGLDeviceEXT * devices
Definition: eglext.h:621

◆ add_capture_device()

static SDL_INLINE int add_capture_device ( const char *  name,
void handle 
)
static

Definition at line 399 of file SDL_audio.c.

References add_audio_device(), SDL_AudioDriverImpl::HasCaptureSupport, SDL_AudioDriver::impl, SDL_AudioDriver::inputDeviceCount, SDL_AudioDriver::inputDevices, SDL_assert, and SDL_INLINE.

Referenced by SDL_AddAudioDevice().

400 {
403 }
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
GLuint const GLchar * name
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
static int add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:375
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:124

◆ add_output_device()

static SDL_INLINE int add_output_device ( const char *  name,
void handle 
)
static

Definition at line 406 of file SDL_audio.c.

References add_audio_device(), SDL_AudioDriver::outputDeviceCount, and SDL_AudioDriver::outputDevices.

Referenced by SDL_AddAudioDevice().

407 {
409 }
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
GLuint const GLchar * name
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
static int add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:375
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:123

◆ clean_out_device_list()

static void clean_out_device_list ( SDL_AudioDeviceItem **  devices,
int *  devCount,
SDL_bool removedFlag 
)
static

Definition at line 950 of file SDL_audio.c.

References SDL_AudioDeviceItem::handle, SDL_AudioDeviceItem::next, NULL, SDL_FALSE, and SDL_free().

Referenced by SDL_GetNumAudioDevices().

951 {
952  SDL_AudioDeviceItem *item = *devices;
953  SDL_AudioDeviceItem *prev = NULL;
954  int total = 0;
955 
956  while (item) {
957  SDL_AudioDeviceItem *next = item->next;
958  if (item->handle != NULL) {
959  total++;
960  prev = item;
961  } else {
962  if (prev) {
963  prev->next = next;
964  } else {
965  *devices = next;
966  }
967  SDL_free(item);
968  }
969  item = next;
970  }
971 
972  *devCount = total;
973  *removedFlag = SDL_FALSE;
974 }
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:100
void SDL_free(void *mem)
#define NULL
Definition: begin_code.h:164
EGLDeviceEXT * devices
Definition: eglext.h:621

◆ close_audio_device()

static void close_audio_device ( SDL_AudioDevice device)
static

Definition at line 1044 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue, SDL_AudioDriverImpl::CloseDevice, SDL_AudioDevice::enabled, SDL_AudioDevice::hidden, SDL_AudioDevice::id, SDL_AudioDriver::impl, SDL_AudioDevice::mixer_lock, NULL, SDL_assert, SDL_AtomicSet, SDL_DestroyMutex, SDL_free(), SDL_FreeAudioStream(), SDL_FreeDataQueue(), SDL_WaitThread, SDL_AudioDevice::shutdown, SDL_AudioDevice::stream, SDL_AudioDevice::thread, and SDL_AudioDevice::work_buffer.

Referenced by open_audio_device(), SDL_AudioQuit(), and SDL_CloseAudioDevice().

1045 {
1046  if (!device) {
1047  return;
1048  }
1049 
1050  if (device->id > 0) {
1051  SDL_AudioDevice *opendev = open_devices[device->id - 1];
1052  SDL_assert((opendev == device) || (opendev == NULL));
1053  if (opendev == device) {
1054  open_devices[device->id - 1] = NULL;
1055  }
1056  }
1057 
1058  SDL_AtomicSet(&device->shutdown, 1);
1059  SDL_AtomicSet(&device->enabled, 0);
1060  if (device->thread != NULL) {
1061  SDL_WaitThread(device->thread, NULL);
1062  }
1063  if (device->mixer_lock != NULL) {
1064  SDL_DestroyMutex(device->mixer_lock);
1065  }
1066 
1067  SDL_free(device->work_buffer);
1068  SDL_FreeAudioStream(device->stream);
1069 
1070  if (device->hidden != NULL) {
1071  current_audio.impl.CloseDevice(device);
1072  }
1073 
1075 
1076  SDL_free(device);
1077 }
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
struct SDL_PrivateAudioData * hidden
Definition: SDL_sysaudio.h:168
SDL_AudioDeviceID id
Definition: SDL_sysaudio.h:133
void SDL_FreeAudioStream(SDL_AudioStream *stream)
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:157
SDL_atomic_t enabled
Definition: SDL_sysaudio.h:146
SDL_atomic_t shutdown
Definition: SDL_sysaudio.h:145
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void SDL_free(void *mem)
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164
void(* CloseDevice)(_THIS)
Definition: SDL_sysaudio.h:78
#define SDL_DestroyMutex
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
#define SDL_AtomicSet
SDL_Thread * thread
Definition: SDL_sysaudio.h:160
void SDL_FreeDataQueue(SDL_DataQueue *queue)
Definition: SDL_dataqueue.c:88
SDL_AudioStream * stream
Definition: SDL_sysaudio.h:142
Uint8 * work_buffer
Definition: SDL_sysaudio.h:151
#define SDL_WaitThread

◆ finish_audio_entry_points_init()

static void finish_audio_entry_points_init ( void  )
static

Definition at line 332 of file SDL_audio.c.

References FILL_STUB, SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, NULL, SDL_AudioLockOrUnlockDeviceWithNoMixerLock(), SDL_AudioDriverImpl::SkipMixerLock, and SDL_AudioDriverImpl::UnlockDevice.

Referenced by SDL_AudioInit().

333 {
334  /*
335  * Fill in stub functions for unused driver entry points. This lets us
336  * blindly call them without having to check for validity first.
337  */
338 
342  }
345  }
346  }
347 
348 #define FILL_STUB(x) \
349  if (current_audio.impl.x == NULL) { \
350  current_audio.impl.x = SDL_Audio##x##_Default; \
351  }
352  FILL_STUB(DetectDevices);
353  FILL_STUB(OpenDevice);
354  FILL_STUB(ThreadInit);
355  FILL_STUB(ThreadDeinit);
356  FILL_STUB(WaitDevice);
357  FILL_STUB(PlayDevice);
358  FILL_STUB(GetPendingBytes);
359  FILL_STUB(GetDeviceBuf);
360  FILL_STUB(CaptureFromDevice);
361  FILL_STUB(FlushCapture);
362  FILL_STUB(PrepareToClose);
363  FILL_STUB(CloseDevice);
364  FILL_STUB(LockDevice);
365  FILL_STUB(UnlockDevice);
366  FILL_STUB(FreeDeviceHandle);
367  FILL_STUB(Deinitialize);
368 #undef FILL_STUB
369 }
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
#define FILL_STUB(x)
static void SDL_AudioLockOrUnlockDeviceWithNoMixerLock(SDL_AudioDevice *device)
Definition: SDL_audio.c:327
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
#define NULL
Definition: begin_code.h:164
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115

◆ free_device_list()

static void free_device_list ( SDL_AudioDeviceItem **  devices,
int *  devCount 
)
static

Definition at line 412 of file SDL_audio.c.

References SDL_AudioDriverImpl::FreeDeviceHandle, SDL_AudioDeviceItem::handle, SDL_AudioDriver::impl, SDL_AudioDeviceItem::next, NULL, and SDL_free().

Referenced by SDL_AudioQuit().

413 {
414  SDL_AudioDeviceItem *item, *next;
415  for (item = *devices; item != NULL; item = next) {
416  next = item->next;
417  if (item->handle != NULL) {
419  }
420  SDL_free(item);
421  }
422  *devices = NULL;
423  *devCount = 0;
424 }
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:100
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void SDL_free(void *mem)
#define NULL
Definition: begin_code.h:164
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
void(* FreeDeviceHandle)(void *handle)
Definition: SDL_sysaudio.h:81

◆ get_audio_device()

static SDL_AudioDevice* get_audio_device ( SDL_AudioDeviceID  id)
static

Definition at line 200 of file SDL_audio.c.

References NULL, SDL_arraysize, and SDL_SetError.

Referenced by SDL_ClearQueuedAudio(), SDL_CloseAudioDevice(), SDL_DequeueAudio(), SDL_GetAudioDeviceStatus(), SDL_GetQueuedAudioSize(), SDL_LockAudioDevice(), SDL_MixAudio(), SDL_OpenedAudioDeviceDisconnected(), SDL_PauseAudioDevice(), SDL_QueueAudio(), and SDL_UnlockAudioDevice().

201 {
202  id--;
203  if ((id >= SDL_arraysize(open_devices)) || (open_devices[id] == NULL)) {
204  SDL_SetError("Invalid audio device ID");
205  return NULL;
206  }
207 
208  return open_devices[id];
209 }
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
GLuint id
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93

◆ is_in_audio_device_thread()

static SDL_INLINE SDL_bool is_in_audio_device_thread ( SDL_AudioDevice device)
static

Definition at line 297 of file SDL_audio.c.

References SDL_FALSE, SDL_ThreadID, SDL_TRUE, SDL_AudioDevice::thread, and SDL_AudioDevice::threadid.

Referenced by SDL_AudioLockDevice_Default(), and SDL_AudioUnlockDevice_Default().

298 {
299  /* The device thread locks the same mutex, but not through the public API.
300  This check is in case the application, in the audio callback,
301  tries to lock the thread that we've already locked from the
302  device thread...just in case we only have non-recursive mutexes. */
303  if (device->thread && (SDL_ThreadID() == device->threadid)) {
304  return SDL_TRUE;
305  }
306 
307  return SDL_FALSE;
308 }
#define SDL_ThreadID
SDL_threadID threadid
Definition: SDL_sysaudio.h:161
SDL_Thread * thread
Definition: SDL_sysaudio.h:160

◆ mark_device_removed()

static void mark_device_removed ( void handle,
SDL_AudioDeviceItem devices,
SDL_bool removedFlag 
)
static

Definition at line 472 of file SDL_audio.c.

References SDL_AudioDeviceItem::handle, SDL_AudioDeviceItem::next, NULL, SDL_assert, and SDL_TRUE.

Referenced by SDL_RemoveAudioDevice().

473 {
474  SDL_AudioDeviceItem *item;
475  SDL_assert(handle != NULL);
476  for (item = devices; item != NULL; item = item->next) {
477  if (item->handle == handle) {
478  item->handle = NULL;
479  *removedFlag = SDL_TRUE;
480  return;
481  }
482  }
483 }
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:100
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164

◆ open_audio_device()

static SDL_AudioDeviceID open_audio_device ( const char *  devname,
int  iscapture,
const SDL_AudioSpec desired,
SDL_AudioSpec obtained,
int  allowed_changes,
int  min_id 
)
static

Definition at line 1143 of file SDL_audio.c.

References SDL_AudioDriverImpl::AllowsArbitraryDeviceNames, SDL_AudioDevice::buffer_queue, SDL_AudioSpec::callback, SDL_AudioDevice::callbackspec, SDL_AudioSpec::channels, close_audio_device(), DEFAULT_INPUT_DEVNAME, DEFAULT_OUTPUT_DEVNAME, SDL_AudioDriver::detectionLock, device, SDL_AudioDevice::enabled, SDL_AudioSpec::format, SDL_AudioSpec::freq, SDL_AudioDeviceItem::handle, SDL_AudioDevice::handle, SDL_AudioDriverImpl::HasCaptureSupport, SDL_AudioDevice::hidden, i, SDL_AudioDevice::id, SDL_AudioDriver::impl, SDL_AudioDriver::inputDevices, SDL_AudioDevice::iscapture, SDL_AudioDevice::mixer_lock, SDL_AudioDeviceItem::name, SDL_AudioDeviceItem::next, NULL, SDL_AudioDriverImpl::OnlyHasDefaultCaptureDevice, SDL_AudioDriverImpl::OnlyHasDefaultOutputDevice, SDL_AudioDriverImpl::OpenDevice, SDL_AudioDriver::outputDevices, SDL_AudioDevice::paused, prepare_audiospec(), SDL_AudioDriverImpl::ProvidesOwnCallbackThread, SDL_AudioSpec::samples, SDL_arraysize, SDL_assert, SDL_AtomicSet, SDL_AUDIO_ALLOW_CHANNELS_CHANGE, SDL_AUDIO_ALLOW_FORMAT_CHANGE, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE, SDL_AUDIOBUFFERQUEUE_PACKETLEN, SDL_BufferQueueDrainCallback(), SDL_BufferQueueFillCallback(), SDL_CalculateAudioSpec(), SDL_calloc(), SDL_CaptureAudio(), SDL_CreateMutex, SDL_CreateThreadInternal(), SDL_FALSE, SDL_getenv, SDL_INIT_AUDIO, SDL_LockMutex, SDL_malloc, SDL_NewAudioStream(), SDL_NewDataQueue(), SDL_OutOfMemory, SDL_RunAudio(), SDL_SetError, SDL_snprintf, SDL_strcmp, SDL_TRUE, SDL_UnlockMutex, SDL_WasInit, SDL_AudioDevice::shutdown, SDL_AudioSpec::size, SDL_AudioDriverImpl::SkipMixerLock, SDL_AudioDevice::spec, SDL_AudioDevice::stream, SDL_AudioDevice::thread, SDL_AudioSpec::userdata, SDL_AudioDevice::work_buffer, and SDL_AudioDevice::work_buffer_len.

Referenced by SDL_OpenAudio(), and SDL_OpenAudioDevice().

1146 {
1147  const SDL_bool is_internal_thread = (desired->callback == NULL);
1148  SDL_AudioDeviceID id = 0;
1149  SDL_AudioSpec _obtained;
1151  SDL_bool build_stream;
1152  void *handle = NULL;
1153  int i = 0;
1154 
1155  if (!SDL_WasInit(SDL_INIT_AUDIO)) {
1156  SDL_SetError("Audio subsystem is not initialized");
1157  return 0;
1158  }
1159 
1160  if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
1161  SDL_SetError("No capture support");
1162  return 0;
1163  }
1164 
1165  /* !!! FIXME: there is a race condition here if two devices open from two threads at once. */
1166  /* Find an available device ID... */
1167  for (id = min_id - 1; id < SDL_arraysize(open_devices); id++) {
1168  if (open_devices[id] == NULL) {
1169  break;
1170  }
1171  }
1172 
1173  if (id == SDL_arraysize(open_devices)) {
1174  SDL_SetError("Too many open audio devices");
1175  return 0;
1176  }
1177 
1178  if (!obtained) {
1179  obtained = &_obtained;
1180  }
1181  if (!prepare_audiospec(desired, obtained)) {
1182  return 0;
1183  }
1184 
1185  /* If app doesn't care about a specific device, let the user override. */
1186  if (devname == NULL) {
1187  devname = SDL_getenv("SDL_AUDIO_DEVICE_NAME");
1188  }
1189 
1190  /*
1191  * Catch device names at the high level for the simple case...
1192  * This lets us have a basic "device enumeration" for systems that
1193  * don't have multiple devices, but makes sure the device name is
1194  * always NULL when it hits the low level.
1195  *
1196  * Also make sure that the simple case prevents multiple simultaneous
1197  * opens of the default system device.
1198  */
1199 
1200  if ((iscapture) && (current_audio.impl.OnlyHasDefaultCaptureDevice)) {
1201  if ((devname) && (SDL_strcmp(devname, DEFAULT_INPUT_DEVNAME) != 0)) {
1202  SDL_SetError("No such device");
1203  return 0;
1204  }
1205  devname = NULL;
1206 
1207  for (i = 0; i < SDL_arraysize(open_devices); i++) {
1208  if ((open_devices[i]) && (open_devices[i]->iscapture)) {
1209  SDL_SetError("Audio device already open");
1210  return 0;
1211  }
1212  }
1213  } else if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
1214  if ((devname) && (SDL_strcmp(devname, DEFAULT_OUTPUT_DEVNAME) != 0)) {
1215  SDL_SetError("No such device");
1216  return 0;
1217  }
1218  devname = NULL;
1219 
1220  for (i = 0; i < SDL_arraysize(open_devices); i++) {
1221  if ((open_devices[i]) && (!open_devices[i]->iscapture)) {
1222  SDL_SetError("Audio device already open");
1223  return 0;
1224  }
1225  }
1226  } else if (devname != NULL) {
1227  /* if the app specifies an exact string, we can pass the backend
1228  an actual device handle thingey, which saves them the effort of
1229  figuring out what device this was (such as, reenumerating
1230  everything again to find the matching human-readable name).
1231  It might still need to open a device based on the string for,
1232  say, a network audio server, but this optimizes some cases. */
1233  SDL_AudioDeviceItem *item;
1235  for (item = iscapture ? current_audio.inputDevices : current_audio.outputDevices; item; item = item->next) {
1236  if ((item->handle != NULL) && (SDL_strcmp(item->name, devname) == 0)) {
1237  handle = item->handle;
1238  break;
1239  }
1240  }
1242  }
1243 
1245  /* has to be in our device list, or the default device. */
1246  if ((handle == NULL) && (devname != NULL)) {
1247  SDL_SetError("No such device.");
1248  return 0;
1249  }
1250  }
1251 
1252  device = (SDL_AudioDevice *) SDL_calloc(1, sizeof (SDL_AudioDevice));
1253  if (device == NULL) {
1254  SDL_OutOfMemory();
1255  return 0;
1256  }
1257  device->id = id + 1;
1258  device->spec = *obtained;
1259  device->iscapture = iscapture ? SDL_TRUE : SDL_FALSE;
1260  device->handle = handle;
1261 
1262  SDL_AtomicSet(&device->shutdown, 0); /* just in case. */
1263  SDL_AtomicSet(&device->paused, 1);
1264  SDL_AtomicSet(&device->enabled, 1);
1265 
1266  /* Create a mutex for locking the sound buffers */
1268  device->mixer_lock = SDL_CreateMutex();
1269  if (device->mixer_lock == NULL) {
1270  close_audio_device(device);
1271  SDL_SetError("Couldn't create mixer lock");
1272  return 0;
1273  }
1274  }
1275 
1276  if (current_audio.impl.OpenDevice(device, handle, devname, iscapture) < 0) {
1277  close_audio_device(device);
1278  return 0;
1279  }
1280 
1281  /* if your target really doesn't need it, set it to 0x1 or something. */
1282  /* otherwise, close_audio_device() won't call impl.CloseDevice(). */
1283  SDL_assert(device->hidden != NULL);
1284 
1285  /* See if we need to do any conversion */
1286  build_stream = SDL_FALSE;
1287  if (obtained->freq != device->spec.freq) {
1288  if (allowed_changes & SDL_AUDIO_ALLOW_FREQUENCY_CHANGE) {
1289  obtained->freq = device->spec.freq;
1290  } else {
1291  build_stream = SDL_TRUE;
1292  }
1293  }
1294  if (obtained->format != device->spec.format) {
1295  if (allowed_changes & SDL_AUDIO_ALLOW_FORMAT_CHANGE) {
1296  obtained->format = device->spec.format;
1297  } else {
1298  build_stream = SDL_TRUE;
1299  }
1300  }
1301  if (obtained->channels != device->spec.channels) {
1302  if (allowed_changes & SDL_AUDIO_ALLOW_CHANNELS_CHANGE) {
1303  obtained->channels = device->spec.channels;
1304  } else {
1305  build_stream = SDL_TRUE;
1306  }
1307  }
1308 
1309  /* !!! FIXME in 2.1: add SDL_AUDIO_ALLOW_SAMPLES_CHANGE flag?
1310  As of 2.0.6, we will build a stream to buffer the difference between
1311  what the app wants to feed and the device wants to eat, so everyone
1312  gets their way. In prior releases, SDL would force the callback to
1313  feed at the rate the device requested, adjusted for resampling.
1314  */
1315  if (device->spec.samples != obtained->samples) {
1316  build_stream = SDL_TRUE;
1317  }
1318 
1319  SDL_CalculateAudioSpec(obtained); /* recalc after possible changes. */
1320 
1321  device->callbackspec = *obtained;
1322 
1323  if (build_stream) {
1324  if (iscapture) {
1325  device->stream = SDL_NewAudioStream(device->spec.format,
1326  device->spec.channels, device->spec.freq,
1327  obtained->format, obtained->channels, obtained->freq);
1328  } else {
1329  device->stream = SDL_NewAudioStream(obtained->format, obtained->channels,
1330  obtained->freq, device->spec.format,
1331  device->spec.channels, device->spec.freq);
1332  }
1333 
1334  if (!device->stream) {
1335  close_audio_device(device);
1336  return 0;
1337  }
1338  }
1339 
1340  if (device->spec.callback == NULL) { /* use buffer queueing? */
1341  /* pool a few packets to start. Enough for two callbacks. */
1343  if (!device->buffer_queue) {
1344  close_audio_device(device);
1345  SDL_SetError("Couldn't create audio buffer queue");
1346  return 0;
1347  }
1349  device->callbackspec.userdata = device;
1350  }
1351 
1352  /* Allocate a scratch audio buffer */
1353  device->work_buffer_len = build_stream ? device->callbackspec.size : 0;
1354  if (device->spec.size > device->work_buffer_len) {
1355  device->work_buffer_len = device->spec.size;
1356  }
1357  SDL_assert(device->work_buffer_len > 0);
1358 
1359  device->work_buffer = (Uint8 *) SDL_malloc(device->work_buffer_len);
1360  if (device->work_buffer == NULL) {
1361  close_audio_device(device);
1362  SDL_OutOfMemory();
1363  return 0;
1364  }
1365 
1366  open_devices[id] = device; /* add it to our list of open devices. */
1367 
1368  /* Start the audio thread if necessary */
1370  /* Start the audio thread */
1371  /* !!! FIXME: we don't force the audio thread stack size here if it calls into user code, but maybe we should? */
1372  /* buffer queueing callback only needs a few bytes, so make the stack tiny. */
1373  const size_t stacksize = is_internal_thread ? 64 * 1024 : 0;
1374  char threadname[64];
1375 
1376  SDL_snprintf(threadname, sizeof (threadname), "SDLAudio%c%d", (iscapture) ? 'C' : 'P', (int) device->id);
1377  device->thread = SDL_CreateThreadInternal(iscapture ? SDL_CaptureAudio : SDL_RunAudio, threadname, stacksize, device);
1378 
1379  if (device->thread == NULL) {
1380  close_audio_device(device);
1381  SDL_SetError("Couldn't create audio thread");
1382  return 0;
1383  }
1384  }
1385 
1386  return device->id;
1387 }
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
struct SDL_PrivateAudioData * hidden
Definition: SDL_sysaudio.h:168
SDL_AudioStream * SDL_NewAudioStream(const SDL_AudioFormat src_format, const Uint8 src_channels, const int src_rate, const SDL_AudioFormat dst_format, const Uint8 dst_channels, const int dst_rate)
SDL_AudioDeviceID id
Definition: SDL_sysaudio.h:133
#define SDL_AUDIO_ALLOW_FREQUENCY_CHANGE
Definition: SDL_audio.h:140
#define SDL_LockMutex
GLuint id
static int SDL_CaptureAudio(void *devicep)
Definition: SDL_audio.c:733
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:157
SDL_atomic_t enabled
Definition: SDL_sysaudio.h:146
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:100
SDL_atomic_t paused
Definition: SDL_sysaudio.h:147
#define SDL_CreateMutex
SDL_atomic_t shutdown
Definition: SDL_sysaudio.h:145
SDL_DataQueue * SDL_NewDataQueue(const size_t _packetlen, const size_t initialslack)
Definition: SDL_dataqueue.c:58
Uint16 samples
Definition: SDL_audio.h:174
static int SDL_RunAudio(void *devicep)
Definition: SDL_audio.c:640
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:136
char name[SDL_VARIABLE_LENGTH_ARRAY]
Definition: SDL_sysaudio.h:101
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
Uint32 work_buffer_len
Definition: SDL_sysaudio.h:154
#define SDL_AUDIO_ALLOW_CHANNELS_CHANGE
Definition: SDL_audio.h:142
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:118
static SDL_AudioDeviceID device
Definition: loopwave.c:37
SDL_Thread * SDL_CreateThreadInternal(int(*fn)(void *), const char *name, const size_t stacksize, void *data)
Definition: SDL_thread.c:427
void * SDL_calloc(size_t nmemb, size_t size)
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
Uint8 channels
Definition: SDL_audio.h:172
uint8_t Uint8
Definition: SDL_stdinc.h:157
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
static int prepare_audiospec(const SDL_AudioSpec *orig, SDL_AudioSpec *prepared)
Definition: SDL_audio.c:1086
void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
Definition: SDL_audio.c:1598
SDL_AudioCallback callback
Definition: SDL_audio.h:177
static void SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:517
#define SDL_getenv
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:123
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
Uint32 size
Definition: SDL_audio.h:176
#define SDL_assert(condition)
Definition: SDL_assert.h:169
int(* OpenDevice)(_THIS, void *handle, const char *devname, int iscapture)
Definition: SDL_sysaudio.h:68
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_bool
Definition: SDL_stdinc.h:139
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164
static void SDL_BufferQueueFillCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:538
#define SDL_SetError
#define SDL_INIT_AUDIO
Definition: SDL.h:77
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:320
SDL_AudioFormat format
Definition: SDL_audio.h:171
#define SDL_AtomicSet
void * userdata
Definition: SDL_audio.h:178
#define DEFAULT_OUTPUT_DEVNAME
Definition: SDL_sysaudio.h:32
#define SDL_AUDIO_ALLOW_FORMAT_CHANGE
Definition: SDL_audio.h:141
#define SDL_snprintf
#define DEFAULT_INPUT_DEVNAME
Definition: SDL_sysaudio.h:33
#define SDL_UnlockMutex
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
#define SDL_malloc
#define SDL_strcmp
SDL_Thread * thread
Definition: SDL_sysaudio.h:160
#define SDL_WasInit
SDL_AudioSpec callbackspec
Definition: SDL_sysaudio.h:139
#define SDL_AUDIOBUFFERQUEUE_PACKETLEN
Definition: SDL_sysaudio.h:63
SDL_AudioStream * stream
Definition: SDL_sysaudio.h:142
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:124
Uint8 * work_buffer
Definition: SDL_sysaudio.h:151
static void close_audio_device(SDL_AudioDevice *device)
Definition: SDL_audio.c:1044

◆ prepare_audiospec()

static int prepare_audiospec ( const SDL_AudioSpec orig,
SDL_AudioSpec prepared 
)
static

Definition at line 1086 of file SDL_audio.c.

References AUDIO_S16, SDL_AudioSpec::channels, SDL_AudioSpec::format, SDL_AudioSpec::freq, SDL_AudioSpec::samples, SDL_atoi, SDL_CalculateAudioSpec(), SDL_getenv, SDL_memcpy, SDL_ParseAudioFormat(), and SDL_SetError.

Referenced by open_audio_device().

1087 {
1088  SDL_memcpy(prepared, orig, sizeof(SDL_AudioSpec));
1089 
1090  if (orig->freq == 0) {
1091  const char *env = SDL_getenv("SDL_AUDIO_FREQUENCY");
1092  if ((!env) || ((prepared->freq = SDL_atoi(env)) == 0)) {
1093  prepared->freq = 22050; /* a reasonable default */
1094  }
1095  }
1096 
1097  if (orig->format == 0) {
1098  const char *env = SDL_getenv("SDL_AUDIO_FORMAT");
1099  if ((!env) || ((prepared->format = SDL_ParseAudioFormat(env)) == 0)) {
1100  prepared->format = AUDIO_S16; /* a reasonable default */
1101  }
1102  }
1103 
1104  switch (orig->channels) {
1105  case 0:{
1106  const char *env = SDL_getenv("SDL_AUDIO_CHANNELS");
1107  if ((!env) || ((prepared->channels = (Uint8) SDL_atoi(env)) == 0)) {
1108  prepared->channels = 2; /* a reasonable default */
1109  }
1110  break;
1111  }
1112  case 1: /* Mono */
1113  case 2: /* Stereo */
1114  case 4: /* surround */
1115  case 6: /* surround with center and lfe */
1116  break;
1117  default:
1118  SDL_SetError("Unsupported number of audio channels.");
1119  return 0;
1120  }
1121 
1122  if (orig->samples == 0) {
1123  const char *env = SDL_getenv("SDL_AUDIO_SAMPLES");
1124  if ((!env) || ((prepared->samples = (Uint16) SDL_atoi(env)) == 0)) {
1125  /* Pick a default of ~46 ms at desired frequency */
1126  /* !!! FIXME: remove this when the non-Po2 resampling is in. */
1127  const int samples = (prepared->freq / 1000) * 46;
1128  int power2 = 1;
1129  while (power2 < samples) {
1130  power2 *= 2;
1131  }
1132  prepared->samples = power2;
1133  }
1134  }
1135 
1136  /* Calculate the silence and size of the audio specification */
1137  SDL_CalculateAudioSpec(prepared);
1138 
1139  return 1;
1140 }
Uint16 samples
Definition: SDL_audio.h:174
#define SDL_memcpy
Uint8 channels
Definition: SDL_audio.h:172
uint8_t Uint8
Definition: SDL_stdinc.h:157
void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
Definition: SDL_audio.c:1598
#define SDL_atoi
#define SDL_getenv
#define SDL_SetError
SDL_AudioFormat format
Definition: SDL_audio.h:171
#define AUDIO_S16
Definition: SDL_audio.h:96
uint16_t Uint16
Definition: SDL_stdinc.h:169
static SDL_AudioFormat SDL_ParseAudioFormat(const char *string)
Definition: SDL_audio.c:837
GLsizei samples

◆ SDL_AddAudioDevice()

void SDL_AddAudioDevice ( const int  iscapture,
const char *  name,
void handle 
)

Definition at line 429 of file SDL_audio.c.

References add_capture_device(), add_output_device(), SDL_AUDIODEVICEADDED, SDL_ENABLE, SDL_GetEventState, SDL_PushEvent, and SDL_zero.

Referenced by SDL_AudioDetectDevices_Default().

430 {
431  const int device_index = iscapture ? add_capture_device(name, handle) : add_output_device(name, handle);
432  if (device_index != -1) {
433  /* Post the event, if desired */
436  SDL_zero(event);
437  event.adevice.type = SDL_AUDIODEVICEADDED;
438  event.adevice.which = device_index;
439  event.adevice.iscapture = iscapture;
440  SDL_PushEvent(&event);
441  }
442  }
443 }
static SDL_INLINE int add_output_device(const char *name, void *handle)
Definition: SDL_audio.c:406
#define SDL_ENABLE
Definition: SDL_events.h:722
GLuint const GLchar * name
#define SDL_GetEventState(type)
Definition: SDL_events.h:735
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
struct _cl_event * event
#define SDL_PushEvent
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
static SDL_INLINE int add_capture_device(const char *name, void *handle)
Definition: SDL_audio.c:399
General event structure.
Definition: SDL_events.h:525

◆ SDL_AudioCaptureFromDevice_Default()

static int SDL_AudioCaptureFromDevice_Default ( _THIS  ,
void buffer,
int  buflen 
)
static

Definition at line 259 of file SDL_audio.c.

260 {
261  return -1; /* just fail immediately. */
262 }

◆ SDL_AudioCloseDevice_Default()

static void SDL_AudioCloseDevice_Default ( _THIS  )
static

Definition at line 275 of file SDL_audio.c.

276 { /* no-op. */
277 }

◆ SDL_AudioDeinitialize_Default()

static void SDL_AudioDeinitialize_Default ( void  )
static

Definition at line 280 of file SDL_audio.c.

281 { /* no-op. */
282 }

◆ SDL_AudioDetectDevices_Default()

static void SDL_AudioDetectDevices_Default ( void  )
static

Definition at line 214 of file SDL_audio.c.

References DEFAULT_INPUT_DEVNAME, DEFAULT_OUTPUT_DEVNAME, SDL_AudioDriverImpl::HasCaptureSupport, SDL_AudioDriver::impl, SDL_AudioDriverImpl::OnlyHasDefaultCaptureDevice, SDL_AudioDriverImpl::OnlyHasDefaultOutputDevice, SDL_AddAudioDevice(), SDL_assert, SDL_FALSE, and SDL_TRUE.

215 {
216  /* you have to write your own implementation if these assertions fail. */
219 
220  SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, (void *) ((size_t) 0x1));
222  SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, (void *) ((size_t) 0x2));
223  }
224 }
GLuint GLfloat GLfloat GLfloat x1
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
GLfixed GLfixed x2
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
#define DEFAULT_OUTPUT_DEVNAME
Definition: SDL_sysaudio.h:32
#define DEFAULT_INPUT_DEVNAME
Definition: SDL_sysaudio.h:33
void SDL_AddAudioDevice(const int iscapture, const char *name, void *handle)
Definition: SDL_audio.c:429

◆ SDL_AudioFlushCapture_Default()

static void SDL_AudioFlushCapture_Default ( _THIS  )
static

Definition at line 265 of file SDL_audio.c.

266 { /* no-op. */
267 }

◆ SDL_AudioFreeDeviceHandle_Default()

static void SDL_AudioFreeDeviceHandle_Default ( void handle)
static

Definition at line 285 of file SDL_audio.c.

286 { /* no-op. */
287 }

◆ SDL_AudioGetDeviceBuf_Default()

static Uint8* SDL_AudioGetDeviceBuf_Default ( _THIS  )
static

Definition at line 253 of file SDL_audio.c.

References NULL.

254 {
255  return NULL;
256 }
#define NULL
Definition: begin_code.h:164

◆ SDL_AudioGetPendingBytes_Default()

static int SDL_AudioGetPendingBytes_Default ( _THIS  )
static

Definition at line 247 of file SDL_audio.c.

248 {
249  return 0;
250 }

◆ SDL_AudioInit()

int SDL_AudioInit ( const char *  driver_name)

Definition at line 878 of file SDL_audio.c.

References AudioBootStrap::demand_only, SDL_AudioDriver::desc, AudioBootStrap::desc, SDL_AudioDriverImpl::DetectDevices, SDL_AudioDriver::detectionLock, finish_audio_entry_points_init(), i, SDL_AudioDriver::impl, AudioBootStrap::init, SDL_AudioDriver::name, AudioBootStrap::name, NULL, SDL_AudioQuit(), SDL_CreateMutex, SDL_getenv, SDL_INIT_AUDIO, SDL_SetError, SDL_strlen, SDL_strncasecmp, SDL_WasInit, and SDL_zero.

879 {
880  int i = 0;
881  int initialized = 0;
882  int tried_to_init = 0;
883 
885  SDL_AudioQuit(); /* shutdown driver if already running. */
886  }
887 
890 
891  /* Select the proper audio driver */
892  if (driver_name == NULL) {
893  driver_name = SDL_getenv("SDL_AUDIODRIVER");
894  }
895 
896  for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
897  /* make sure we should even try this driver before doing so... */
898  const AudioBootStrap *backend = bootstrap[i];
899  if ((driver_name && (SDL_strncasecmp(backend->name, driver_name, SDL_strlen(driver_name)) != 0)) ||
900  (!driver_name && backend->demand_only)) {
901  continue;
902  }
903 
904  tried_to_init = 1;
906  current_audio.name = backend->name;
907  current_audio.desc = backend->desc;
908  initialized = backend->init(&current_audio.impl);
909  }
910 
911  if (!initialized) {
912  /* specific drivers will set the error message if they fail... */
913  if (!tried_to_init) {
914  if (driver_name) {
915  SDL_SetError("Audio target '%s' not available", driver_name);
916  } else {
917  SDL_SetError("No available audio device");
918  }
919  }
920 
922  return -1; /* No driver was available, so fail. */
923  }
924 
926 
928 
929  /* Make sure we have a list of devices available at startup. */
931 
932 #ifdef HAVE_LIBSAMPLERATE_H
933  LoadLibSampleRate();
934 #endif
935 
936  return 0;
937 }
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
const char * name
Definition: SDL_sysaudio.h:109
void(* DetectDevices)(void)
Definition: SDL_sysaudio.h:67
const char * name
Definition: SDL_sysaudio.h:176
#define SDL_CreateMutex
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
#define SDL_strncasecmp
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:118
const char * desc
Definition: SDL_sysaudio.h:113
void SDL_AudioQuit(void)
Definition: SDL_audio.c:1520
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
#define SDL_getenv
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
static const AudioBootStrap *const bootstrap[]
Definition: SDL_audio.c:37
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
#define SDL_INIT_AUDIO
Definition: SDL.h:77
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
#define SDL_strlen
int(* init)(SDL_AudioDriverImpl *impl)
Definition: SDL_sysaudio.h:178
const char * desc
Definition: SDL_sysaudio.h:177
#define SDL_WasInit
static void finish_audio_entry_points_init(void)
Definition: SDL_audio.c:332

◆ SDL_AudioLockDevice_Default()

static void SDL_AudioLockDevice_Default ( SDL_AudioDevice device)
static

Definition at line 311 of file SDL_audio.c.

References is_in_audio_device_thread(), SDL_AudioDevice::mixer_lock, and SDL_LockMutex.

312 {
313  if (!is_in_audio_device_thread(device)) {
314  SDL_LockMutex(device->mixer_lock);
315  }
316 }
#define SDL_LockMutex
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:157
static SDL_INLINE SDL_bool is_in_audio_device_thread(SDL_AudioDevice *device)
Definition: SDL_audio.c:297

◆ SDL_AudioLockOrUnlockDeviceWithNoMixerLock()

static void SDL_AudioLockOrUnlockDeviceWithNoMixerLock ( SDL_AudioDevice device)
static

Definition at line 327 of file SDL_audio.c.

Referenced by finish_audio_entry_points_init().

328 {
329 }

◆ SDL_AudioOpenDevice_Default()

static int SDL_AudioOpenDevice_Default ( _THIS  ,
void handle,
const char *  devname,
int  iscapture 
)
static

Definition at line 291 of file SDL_audio.c.

References SDL_INLINE, and SDL_Unsupported.

292 {
293  return SDL_Unsupported();
294 }
#define SDL_Unsupported()
Definition: SDL_error.h:53

◆ SDL_AudioPlayDevice_Default()

static void SDL_AudioPlayDevice_Default ( _THIS  )
static

Definition at line 242 of file SDL_audio.c.

243 { /* no-op. */
244 }

◆ SDL_AudioPrepareToClose_Default()

static void SDL_AudioPrepareToClose_Default ( _THIS  )
static

Definition at line 270 of file SDL_audio.c.

271 { /* no-op. */
272 }

◆ SDL_AudioQuit()

void SDL_AudioQuit ( void  )

Definition at line 1520 of file SDL_audio.c.

References close_audio_device(), SDL_AudioDriverImpl::Deinitialize, SDL_AudioDriver::detectionLock, free_device_list(), i, SDL_AudioDriver::impl, SDL_AudioDriver::inputDeviceCount, SDL_AudioDriver::inputDevices, SDL_AudioDriver::name, SDL_AudioDriver::outputDeviceCount, SDL_AudioDriver::outputDevices, SDL_arraysize, SDL_DestroyMutex, SDL_FreeResampleFilter(), and SDL_zero.

Referenced by SDL_AudioInit().

1521 {
1523 
1524  if (!current_audio.name) { /* not initialized?! */
1525  return;
1526  }
1527 
1528  for (i = 0; i < SDL_arraysize(open_devices); i++) {
1530  }
1531 
1534 
1535  /* Free the driver data */
1537 
1539 
1542 
1543 #ifdef HAVE_LIBSAMPLERATE_H
1544  UnloadLibSampleRate();
1545 #endif
1546 
1548 }
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
const char * name
Definition: SDL_sysaudio.h:109
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:118
void SDL_FreeResampleFilter(void)
Definition: SDL_audiocvt.c:459
void(* Deinitialize)(void)
Definition: SDL_sysaudio.h:82
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:123
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
static void free_device_list(SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:412
#define SDL_DestroyMutex
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:320
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:124
static void close_audio_device(SDL_AudioDevice *device)
Definition: SDL_audio.c:1044

◆ SDL_AudioThreadDeinit_Default()

static void SDL_AudioThreadDeinit_Default ( _THIS  )
static

Definition at line 232 of file SDL_audio.c.

233 { /* no-op. */
234 }

◆ SDL_AudioThreadInit_Default()

static void SDL_AudioThreadInit_Default ( _THIS  )
static

Definition at line 227 of file SDL_audio.c.

228 { /* no-op. */
229 }

◆ SDL_AudioUnlockDevice_Default()

static void SDL_AudioUnlockDevice_Default ( SDL_AudioDevice device)
static

Definition at line 319 of file SDL_audio.c.

References is_in_audio_device_thread(), SDL_AudioDevice::mixer_lock, and SDL_UnlockMutex.

320 {
321  if (!is_in_audio_device_thread(device)) {
322  SDL_UnlockMutex(device->mixer_lock);
323  }
324 }
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:157
#define SDL_UnlockMutex
static SDL_INLINE SDL_bool is_in_audio_device_thread(SDL_AudioDevice *device)
Definition: SDL_audio.c:297

◆ SDL_AudioWaitDevice_Default()

static void SDL_AudioWaitDevice_Default ( _THIS  )
static

Definition at line 237 of file SDL_audio.c.

238 { /* no-op. */
239 }

◆ SDL_BufferQueueDrainCallback()

static void SDL_BufferQueueDrainCallback ( void userdata,
Uint8 stream,
int  len 
)
static

Definition at line 517 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue, device, SDL_AudioDevice::iscapture, NULL, SDL_assert, SDL_CountDataQueue(), SDL_memset, SDL_ReadFromDataQueue(), SDLCALL, SDL_AudioSpec::silence, and SDL_AudioDevice::spec.

Referenced by open_audio_device(), SDL_GetQueuedAudioSize(), and SDL_QueueAudio().

518 {
519  /* this function always holds the mixer lock before being called. */
520  SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;
521  size_t dequeued;
522 
523  SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */
524  SDL_assert(!device->iscapture); /* this shouldn't ever happen, right?! */
525  SDL_assert(len >= 0); /* this shouldn't ever happen, right?! */
526 
527  dequeued = SDL_ReadFromDataQueue(device->buffer_queue, stream, len);
528  stream += dequeued;
529  len -= (int) dequeued;
530 
531  if (len > 0) { /* fill any remaining space in the stream with silence. */
533  SDL_memset(stream, device->spec.silence, len);
534  }
535 }
Uint8 silence
Definition: SDL_audio.h:173
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:136
GLenum GLsizei len
static SDL_AudioDeviceID device
Definition: loopwave.c:37
GLuint GLuint stream
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
size_t SDL_ReadFromDataQueue(SDL_DataQueue *queue, void *_buf, const size_t _len)
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164
size_t SDL_CountDataQueue(SDL_DataQueue *queue)
#define SDL_memset

◆ SDL_BufferQueueFillCallback()

static void SDL_BufferQueueFillCallback ( void userdata,
Uint8 stream,
int  len 
)
static

Definition at line 538 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue, device, SDL_AudioDevice::iscapture, NULL, SDL_assert, and SDL_WriteToDataQueue().

Referenced by open_audio_device(), SDL_DequeueAudio(), and SDL_GetQueuedAudioSize().

539 {
540  /* this function always holds the mixer lock before being called. */
541  SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;
542 
543  SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */
544  SDL_assert(device->iscapture); /* this shouldn't ever happen, right?! */
545  SDL_assert(len >= 0); /* this shouldn't ever happen, right?! */
546 
547  /* note that if this needs to allocate more space and run out of memory,
548  we have no choice but to quietly drop the data and hope it works out
549  later, but you probably have bigger problems in this case anyhow. */
551 }
int SDL_WriteToDataQueue(SDL_DataQueue *queue, const void *_data, const size_t _len)
GLenum GLsizei len
static SDL_AudioDeviceID device
Definition: loopwave.c:37
GLuint GLuint stream
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164

◆ SDL_CalculateAudioSpec()

void SDL_CalculateAudioSpec ( SDL_AudioSpec spec)

Definition at line 1598 of file SDL_audio.c.

References AUDIO_U8, SDL_AudioSpec::channels, SDL_AudioSpec::format, SDL_AudioSpec::samples, SDL_AUDIO_BITSIZE, SDL_AudioSpec::silence, and SDL_AudioSpec::size.

Referenced by open_audio_device(), and prepare_audiospec().

1599 {
1600  switch (spec->format) {
1601  case AUDIO_U8:
1602  spec->silence = 0x80;
1603  break;
1604  default:
1605  spec->silence = 0x00;
1606  break;
1607  }
1608  spec->size = SDL_AUDIO_BITSIZE(spec->format) / 8;
1609  spec->size *= spec->channels;
1610  spec->size *= spec->samples;
1611 }
Uint8 silence
Definition: SDL_audio.h:173
Uint16 samples
Definition: SDL_audio.h:174
#define AUDIO_U8
Definition: SDL_audio.h:89
Uint8 channels
Definition: SDL_audio.h:172
#define SDL_AUDIO_BITSIZE(x)
Definition: SDL_audio.h:75
Uint32 size
Definition: SDL_audio.h:176
SDL_AudioFormat format
Definition: SDL_audio.h:171

◆ SDL_CaptureAudio()

static int SDL_CaptureAudio ( void devicep)
static

Definition at line 733 of file SDL_audio.c.

References callback(), SDL_AudioSpec::callback, SDL_AudioDevice::callbackspec, SDL_AudioDriverImpl::CaptureFromDevice, device, SDL_AudioDevice::enabled, SDL_AudioDriverImpl::FlushCapture, SDL_AudioSpec::freq, SDL_AudioDriver::impl, SDL_AudioDevice::iscapture, SDL_AudioDevice::mixer_lock, NULL, SDL_AudioDevice::paused, SDL_AudioSpec::samples, SDL_assert, SDL_AtomicGet, SDL_AudioStreamAvailable(), SDL_AudioStreamClear(), SDL_AudioStreamGet(), SDL_AudioStreamPut(), SDL_Delay, SDL_LockMutex, SDL_memset, SDL_OpenedAudioDeviceDisconnected(), SDL_SetThreadPriority, SDL_THREAD_PRIORITY_HIGH, SDL_ThreadID, SDL_UnlockMutex, SDL_AudioDevice::shutdown, SDL_AudioSpec::silence, SDL_AudioSpec::size, SDL_AudioDevice::spec, SDL_AudioDevice::stream, SDL_AudioDriverImpl::ThreadDeinit, SDL_AudioDevice::threadid, SDL_AudioDriverImpl::ThreadInit, SDL_AudioSpec::userdata, and SDL_AudioDevice::work_buffer.

Referenced by open_audio_device().

734 {
735  SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
736  const int silence = (int) device->spec.silence;
737  const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
738  const int data_len = device->spec.size;
739  Uint8 *data;
740  void *udata = device->callbackspec.userdata;
742 
743  SDL_assert(device->iscapture);
744 
745  /* The audio mixing is always a high priority thread */
747 
748  /* Perform any thread setup */
749  device->threadid = SDL_ThreadID();
750  current_audio.impl.ThreadInit(device);
751 
752  /* Loop, filling the audio buffers */
753  while (!SDL_AtomicGet(&device->shutdown)) {
754  int still_need;
755  Uint8 *ptr;
756 
757  if (SDL_AtomicGet(&device->paused)) {
758  SDL_Delay(delay); /* just so we don't cook the CPU. */
759  if (device->stream) {
760  SDL_AudioStreamClear(device->stream);
761  }
762  current_audio.impl.FlushCapture(device); /* dump anything pending. */
763  continue;
764  }
765 
766  /* Fill the current buffer with sound */
767  still_need = data_len;
768 
769  /* Use the work_buffer to hold data read from the device. */
770  data = device->work_buffer;
771  SDL_assert(data != NULL);
772 
773  ptr = data;
774 
775  /* We still read from the device when "paused" to keep the state sane,
776  and block when there isn't data so this thread isn't eating CPU.
777  But we don't process it further or call the app's callback. */
778 
779  if (!SDL_AtomicGet(&device->enabled)) {
780  SDL_Delay(delay); /* try to keep callback firing at normal pace. */
781  } else {
782  while (still_need > 0) {
783  const int rc = current_audio.impl.CaptureFromDevice(device, ptr, still_need);
784  SDL_assert(rc <= still_need); /* device should not overflow buffer. :) */
785  if (rc > 0) {
786  still_need -= rc;
787  ptr += rc;
788  } else { /* uhoh, device failed for some reason! */
790  break;
791  }
792  }
793  }
794 
795  if (still_need > 0) {
796  /* Keep any data we already read, silence the rest. */
797  SDL_memset(ptr, silence, still_need);
798  }
799 
800  if (device->stream) {
801  /* if this fails...oh well. */
802  SDL_AudioStreamPut(device->stream, data, data_len);
803 
804  while (SDL_AudioStreamAvailable(device->stream) >= ((int) device->callbackspec.size)) {
805  const int got = SDL_AudioStreamGet(device->stream, device->work_buffer, device->callbackspec.size);
806  SDL_assert((got < 0) || (got == device->callbackspec.size));
807  if (got != device->callbackspec.size) {
808  SDL_memset(device->work_buffer, device->spec.silence, device->callbackspec.size);
809  }
810 
811  /* !!! FIXME: this should be LockDevice. */
812  SDL_LockMutex(device->mixer_lock);
813  if (!SDL_AtomicGet(&device->paused)) {
814  callback(udata, device->work_buffer, device->callbackspec.size);
815  }
816  SDL_UnlockMutex(device->mixer_lock);
817  }
818  } else { /* feeding user callback directly without streaming. */
819  /* !!! FIXME: this should be LockDevice. */
820  SDL_LockMutex(device->mixer_lock);
821  if (!SDL_AtomicGet(&device->paused)) {
822  callback(udata, data, device->callbackspec.size);
823  }
824  SDL_UnlockMutex(device->mixer_lock);
825  }
826  }
827 
829 
831 
832  return 0;
833 }
#define SDL_ThreadID
#define SDL_LockMutex
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:157
SDL_atomic_t enabled
Definition: SDL_sysaudio.h:146
Uint8 silence
Definition: SDL_audio.h:173
SDL_atomic_t paused
Definition: SDL_sysaudio.h:147
SDL_atomic_t shutdown
Definition: SDL_sysaudio.h:145
int SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, const Uint32 len)
void(* ThreadDeinit)(_THIS)
Definition: SDL_sysaudio.h:70
SDL_threadID threadid
Definition: SDL_sysaudio.h:161
Uint16 samples
Definition: SDL_audio.h:174
void SDL_OpenedAudioDeviceDisconnected(SDL_AudioDevice *device)
Definition: SDL_audio.c:446
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:136
uint32_t Uint32
Definition: SDL_stdinc.h:181
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
static SDL_AudioDeviceID device
Definition: loopwave.c:37
void(* ThreadInit)(_THIS)
Definition: SDL_sysaudio.h:69
void(* SDL_AudioCallback)(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.h:162
uint8_t Uint8
Definition: SDL_stdinc.h:157
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
int SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, const Uint32 len)
static Uint32 callback(Uint32 interval, void *param)
Definition: testtimer.c:34
SDL_AudioCallback callback
Definition: SDL_audio.h:177
#define SDL_Delay
Uint32 size
Definition: SDL_audio.h:176
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
int(* CaptureFromDevice)(_THIS, void *buffer, int buflen)
Definition: SDL_sysaudio.h:75
int SDL_AudioStreamAvailable(SDL_AudioStream *stream)
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
void(* FlushCapture)(_THIS)
Definition: SDL_sysaudio.h:76
#define SDL_AtomicGet
void * userdata
Definition: SDL_audio.h:178
void SDL_AudioStreamClear(SDL_AudioStream *stream)
#define SDL_UnlockMutex
SDL_AudioSpec callbackspec
Definition: SDL_sysaudio.h:139
SDL_AudioStream * stream
Definition: SDL_sysaudio.h:142
#define SDL_SetThreadPriority
Uint8 * work_buffer
Definition: SDL_sysaudio.h:151
#define SDL_memset

◆ SDL_ClearQueuedAudio()

void SDL_ClearQueuedAudio ( SDL_AudioDeviceID  dev)

Drop any queued audio data. For playback devices, this is any queued data still waiting to be submitted to the hardware. For capture devices, this is any data that was queued by the device that hasn't yet been dequeued by the application.

Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For playback devices, the hardware will start playing silence if more audio isn't queued. Unpaused capture devices will start filling the queue again as soon as they have more data available (which, depending on the state of the hardware and the thread, could be before this function call returns!).

This will not prevent playback of queued audio that's already been sent to the hardware, as we can not undo that, so expect there to be some fraction of a second of audio that might still be heard. This can be useful if you want to, say, drop any pending music during a level change in your game.

You may not queue audio on a device that is using an application-supplied callback; calling this function on such a device is always a no-op. You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use the audio callback, but not both.

You should not call SDL_LockAudio() on the device before clearing the queue; SDL handles locking internally for this function.

This function always succeeds and thus returns void.

Parameters
devThe device ID of which to clear the audio queue.
See also
SDL_QueueAudio
SDL_GetQueuedAudioSize

Definition at line 620 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue, device, get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, SDL_AUDIOBUFFERQUEUE_PACKETLEN, SDL_ClearDataQueue(), SDLCALL, and SDL_AudioDriverImpl::UnlockDevice.

621 {
623 
624  if (!device) {
625  return; /* nothing to do. */
626  }
627 
628  /* Blank out the device and release the mutex. Free it afterwards. */
629  current_audio.impl.LockDevice(device);
630 
631  /* Keep up to two packets in the pool to reduce future malloc pressure. */
633 
635 }
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
static SDL_AudioDeviceID device
Definition: loopwave.c:37
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164
void SDL_ClearDataQueue(SDL_DataQueue *queue, const size_t slack)
Definition: SDL_dataqueue.c:98
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
#define SDL_AUDIOBUFFERQUEUE_PACKETLEN
Definition: SDL_sysaudio.h:63
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_CloseAudio()

void SDL_CloseAudio ( void  )

This function shuts down audio processing and closes the audio device.

Definition at line 1514 of file SDL_audio.c.

References SDL_CloseAudioDevice().

1515 {
1517 }
void SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1508

◆ SDL_CloseAudioDevice()

void SDL_CloseAudioDevice ( SDL_AudioDeviceID  devid)

Definition at line 1508 of file SDL_audio.c.

References close_audio_device(), and get_audio_device().

Referenced by SDL_CloseAudio().

1509 {
1511 }
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200
static void close_audio_device(SDL_AudioDevice *device)
Definition: SDL_audio.c:1044

◆ SDL_DequeueAudio()

Uint32 SDL_DequeueAudio ( SDL_AudioDeviceID  dev,
void data,
Uint32  len 
)

Dequeue more audio on non-callback devices.

(If you are looking to queue audio for output on a non-callback playback device, you want SDL_QueueAudio() instead. This will always return 0 if you use it with playback devices.)

SDL offers two ways to retrieve audio from a capture device: you can either supply a callback that SDL triggers with some frequency as the device records more audio data, (push method), or you can supply no callback, and then SDL will expect you to retrieve data at regular intervals (pull method) with this function.

There are no limits on the amount of data you can queue, short of exhaustion of address space. Data from the device will keep queuing as necessary without further intervention from you. This means you will eventually run out of memory if you aren't routinely dequeueing data.

Capture devices will not queue data when paused; if you are expecting to not need captured audio for some length of time, use SDL_PauseAudioDevice() to stop the capture device from queueing more data. This can be useful during, say, level loading times. When unpaused, capture devices will start queueing data from that point, having flushed any capturable data available while paused.

This function is thread-safe, but dequeueing from the same device from two threads at once does not promise which thread will dequeued data first.

You may not dequeue audio from a device that is using an application-supplied callback; doing so returns an error. You have to use the audio callback, or dequeue audio with this function, but not both.

You should not call SDL_LockAudio() on the device before queueing; SDL handles locking internally for this function.

Parameters
devThe device ID from which we will dequeue audio.
dataA pointer into where audio data should be copied.
lenThe number of bytes (not samples!) to which (data) points.
Returns
number of bytes dequeued, which could be less than requested.
See also
SDL_GetQueuedAudioSize
SDL_ClearQueuedAudio

Definition at line 577 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue, SDL_AudioSpec::callback, SDL_AudioDevice::callbackspec, device, get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDevice::iscapture, SDL_AudioDriverImpl::LockDevice, SDL_BufferQueueFillCallback(), SDL_ReadFromDataQueue(), and SDL_AudioDriverImpl::UnlockDevice.

578 {
580  Uint32 rc;
581 
582  if ( (len == 0) || /* nothing to do? */
583  (!device) || /* called with bogus device id */
584  (!device->iscapture) || /* playback devices can't dequeue */
585  (device->callbackspec.callback != SDL_BufferQueueFillCallback) ) { /* not set for queueing */
586  return 0; /* just report zero bytes dequeued. */
587  }
588 
589  current_audio.impl.LockDevice(device);
592  return rc;
593 }
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
uint32_t Uint32
Definition: SDL_stdinc.h:181
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
GLenum GLsizei len
static SDL_AudioDeviceID device
Definition: loopwave.c:37
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
size_t SDL_ReadFromDataQueue(SDL_DataQueue *queue, void *_buf, const size_t _len)
SDL_AudioCallback callback
Definition: SDL_audio.h:177
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164
static void SDL_BufferQueueFillCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:538
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
SDL_AudioSpec callbackspec
Definition: SDL_sysaudio.h:139
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_FirstAudioFormat()

SDL_AudioFormat SDL_FirstAudioFormat ( SDL_AudioFormat  format)

Definition at line 1577 of file SDL_audio.c.

References format_idx, format_idx_sub, format_list, NUM_FORMATS, and SDL_NextAudioFormat().

1578 {
1579  for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
1580  if (format_list[format_idx][0] == format) {
1581  break;
1582  }
1583  }
1584  format_idx_sub = 0;
1585  return SDL_NextAudioFormat();
1586 }
static int format_idx_sub
Definition: SDL_audio.c:1552
static int format_idx
Definition: SDL_audio.c:1551
static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]
Definition: SDL_audio.c:1553
SDL_AudioFormat SDL_NextAudioFormat(void)
Definition: SDL_audio.c:1589
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
#define NUM_FORMATS
Definition: SDL_audio.c:1550

◆ SDL_GetAudioDeviceName()

const char* SDL_GetAudioDeviceName ( int  index,
int  iscapture 
)

Get the human-readable name of a specific audio device. Must be a value between 0 and (number of audio devices-1). Only valid after a successfully initializing the audio subsystem. The values returned by this function reflect the latest call to SDL_GetNumAudioDevices(); recall that function to redetect available hardware.

The string returned by this function is UTF-8 encoded, read-only, and managed internally. You are not to free it. If you need to keep the string for any length of time, you should make your own copy of it, as it will be invalid next time any of several other SDL functions is called.

Definition at line 1004 of file SDL_audio.c.

References SDL_AudioDriver::detectionLock, SDL_AudioDriverImpl::HasCaptureSupport, i, SDL_AudioDriver::impl, SDL_AudioDriver::inputDeviceCount, SDL_AudioDriver::inputDevices, SDL_AudioDeviceItem::next, NULL, SDL_AudioDriver::outputDeviceCount, SDL_AudioDriver::outputDevices, retval, SDL_assert, SDL_INIT_AUDIO, SDL_LockMutex, SDL_SetError, SDL_UnlockMutex, and SDL_WasInit.

1005 {
1006  const char *retval = NULL;
1007 
1008  if (!SDL_WasInit(SDL_INIT_AUDIO)) {
1009  SDL_SetError("Audio subsystem is not initialized");
1010  return NULL;
1011  }
1012 
1013  if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
1014  SDL_SetError("No capture support");
1015  return NULL;
1016  }
1017 
1018  if (index >= 0) {
1019  SDL_AudioDeviceItem *item;
1020  int i;
1021 
1025  if (index < i) {
1026  for (i--; i > index; i--, item = item->next) {
1027  SDL_assert(item != NULL);
1028  }
1029  SDL_assert(item != NULL);
1030  retval = item->name;
1031  }
1033  }
1034 
1035  if (retval == NULL) {
1036  SDL_SetError("No such device");
1037  }
1038 
1039  return retval;
1040 }
#define SDL_LockMutex
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:100
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:118
SDL_bool retval
GLuint index
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:123
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
#define SDL_INIT_AUDIO
Definition: SDL.h:77
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
#define SDL_UnlockMutex
#define SDL_WasInit
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:124

◆ SDL_GetAudioDeviceStatus()

SDL_AudioStatus SDL_GetAudioDeviceStatus ( SDL_AudioDeviceID  devid)

Definition at line 1436 of file SDL_audio.c.

References device, SDL_AudioDevice::enabled, get_audio_device(), SDL_AudioDevice::paused, SDL_AtomicGet, SDL_AUDIO_PAUSED, SDL_AUDIO_PLAYING, and SDL_AUDIO_STOPPED.

Referenced by SDL_GetAudioStatus().

1437 {
1440  if (device && SDL_AtomicGet(&device->enabled)) {
1441  if (SDL_AtomicGet(&device->paused)) {
1442  status = SDL_AUDIO_PAUSED;
1443  } else {
1444  status = SDL_AUDIO_PLAYING;
1445  }
1446  }
1447  return status;
1448 }
SDL_atomic_t enabled
Definition: SDL_sysaudio.h:146
SDL_atomic_t paused
Definition: SDL_sysaudio.h:147
SDL_AudioStatus
Definition: SDL_audio.h:385
static SDL_AudioDeviceID device
Definition: loopwave.c:37
#define SDL_AtomicGet
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_GetAudioDriver()

const char* SDL_GetAudioDriver ( int  index)

Definition at line 869 of file SDL_audio.c.

References AudioBootStrap::name, NULL, and SDL_GetNumAudioDrivers().

870 {
871  if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
872  return bootstrap[index]->name;
873  }
874  return NULL;
875 }
int SDL_GetNumAudioDrivers(void)
Definition: SDL_audio.c:863
const char * name
Definition: SDL_sysaudio.h:176
GLuint index
static const AudioBootStrap *const bootstrap[]
Definition: SDL_audio.c:37
#define NULL
Definition: begin_code.h:164

◆ SDL_GetAudioStatus()

SDL_AudioStatus SDL_GetAudioStatus ( void  )

Definition at line 1452 of file SDL_audio.c.

References SDL_GetAudioDeviceStatus().

1453 {
1454  return SDL_GetAudioDeviceStatus(1);
1455 }
SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1436

◆ SDL_GetCurrentAudioDriver()

const char* SDL_GetCurrentAudioDriver ( void  )

This function returns the name of the current audio driver, or NULL if no driver has been initialized.

Definition at line 943 of file SDL_audio.c.

References SDL_AudioDriver::name.

944 {
945  return current_audio.name;
946 }
const char * name
Definition: SDL_sysaudio.h:109
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33

◆ SDL_GetNumAudioDevices()

int SDL_GetNumAudioDevices ( int  iscapture)

Get the number of available devices exposed by the current driver. Only valid after a successfully initializing the audio subsystem. Returns -1 if an explicit list of devices can't be determined; this is not an error. For example, if SDL is set up to talk to a remote audio server, it can't list every one available on the Internet, but it will still allow a specific host to be specified to SDL_OpenAudioDevice().

In many common cases, when this function returns a value <= 0, it can still successfully open the default device (NULL for first argument of SDL_OpenAudioDevice()).

Definition at line 978 of file SDL_audio.c.

References SDL_AudioDriver::captureDevicesRemoved, clean_out_device_list(), SDL_AudioDriver::detectionLock, SDL_AudioDriver::inputDeviceCount, SDL_AudioDriver::inputDevices, SDL_AudioDriver::outputDeviceCount, SDL_AudioDriver::outputDevices, SDL_AudioDriver::outputDevicesRemoved, retval, SDL_FALSE, SDL_INIT_AUDIO, SDL_LockMutex, SDL_UnlockMutex, and SDL_WasInit.

979 {
980  int retval = 0;
981 
982  if (!SDL_WasInit(SDL_INIT_AUDIO)) {
983  return -1;
984  }
985 
987  if (iscapture && current_audio.captureDevicesRemoved) {
989  }
990 
991  if (!iscapture && current_audio.outputDevicesRemoved) {
994  }
995 
998 
999  return retval;
1000 }
#define SDL_LockMutex
SDL_bool captureDevicesRemoved
Definition: SDL_sysaudio.h:119
static void clean_out_device_list(SDL_AudioDeviceItem **devices, int *devCount, SDL_bool *removedFlag)
Definition: SDL_audio.c:950
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:118
SDL_bool retval
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:123
SDL_bool outputDevicesRemoved
Definition: SDL_sysaudio.h:120
#define SDL_INIT_AUDIO
Definition: SDL.h:77
#define SDL_UnlockMutex
#define SDL_WasInit
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:124

◆ SDL_GetNumAudioDrivers()

int SDL_GetNumAudioDrivers ( void  )

Definition at line 863 of file SDL_audio.c.

References SDL_arraysize.

Referenced by SDL_GetAudioDriver().

864 {
865  return SDL_arraysize(bootstrap) - 1;
866 }
static const AudioBootStrap *const bootstrap[]
Definition: SDL_audio.c:37
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93

◆ SDL_GetQueuedAudioSize()

Uint32 SDL_GetQueuedAudioSize ( SDL_AudioDeviceID  dev)

Get the number of bytes of still-queued audio.

For playback device:

This is the number of bytes that have been queued for playback with SDL_QueueAudio(), but have not yet been sent to the hardware. This number may shrink at any time, so this only informs of pending data.

Once we've sent it to the hardware, this function can not decide the exact byte boundary of what has been played. It's possible that we just gave the hardware several kilobytes right before you called this function, but it hasn't played any of it yet, or maybe half of it, etc.

For capture devices:

This is the number of bytes that have been captured by the device and are waiting for you to dequeue. This number may grow at any time, so this only informs of the lower-bound of available data.

You may not queue audio on a device that is using an application-supplied callback; calling this function on such a device always returns 0. You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use the audio callback, but not both.

You should not call SDL_LockAudio() on the device before querying; SDL handles locking internally for this function.

Parameters
devThe device ID of which we will query queued audio size.
Returns
Number of bytes (not samples!) of queued audio.
See also
SDL_QueueAudio
SDL_ClearQueuedAudio

Definition at line 596 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue, SDL_AudioSpec::callback, SDL_AudioDevice::callbackspec, device, get_audio_device(), SDL_AudioDriverImpl::GetPendingBytes, SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, retval, SDL_BufferQueueDrainCallback(), SDL_BufferQueueFillCallback(), SDL_CountDataQueue(), and SDL_AudioDriverImpl::UnlockDevice.

597 {
598  Uint32 retval = 0;
600 
601  if (!device) {
602  return 0;
603  }
604 
605  /* Nothing to do unless we're set up for queueing. */
607  current_audio.impl.LockDevice(device);
610  } else if (device->callbackspec.callback == SDL_BufferQueueFillCallback) {
611  current_audio.impl.LockDevice(device);
612  retval = (Uint32) SDL_CountDataQueue(device->buffer_queue);
614  }
615 
616  return retval;
617 }
uint32_t Uint32
Definition: SDL_stdinc.h:181
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
static SDL_AudioDeviceID device
Definition: loopwave.c:37
SDL_bool retval
SDL_AudioCallback callback
Definition: SDL_audio.h:177
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
static void SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:517
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164
static void SDL_BufferQueueFillCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:538
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
size_t SDL_CountDataQueue(SDL_DataQueue *queue)
int(* GetPendingBytes)(_THIS)
Definition: SDL_sysaudio.h:73
SDL_AudioSpec callbackspec
Definition: SDL_sysaudio.h:139
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_LockAudio()

void SDL_LockAudio ( void  )

Definition at line 1486 of file SDL_audio.c.

References SDL_LockAudioDevice().

1487 {
1489 }
void SDL_LockAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1476

◆ SDL_LockAudioDevice()

void SDL_LockAudioDevice ( SDL_AudioDeviceID  devid)

Definition at line 1476 of file SDL_audio.c.

References device, get_audio_device(), SDL_AudioDriver::impl, and SDL_AudioDriverImpl::LockDevice.

Referenced by SDL_LockAudio().

1477 {
1478  /* Obtain a lock on the mixing buffers */
1480  if (device) {
1481  current_audio.impl.LockDevice(device);
1482  }
1483 }
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
static SDL_AudioDeviceID device
Definition: loopwave.c:37
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_MixAudio()

void SDL_MixAudio ( Uint8 dst,
const Uint8 src,
Uint32  len,
int  volume 
)

This takes two audio buffers of the playing audio format and mixes them, performing addition, volume adjustment, and overflow clipping. The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME for full audio volume. Note this does not change hardware volume. This is provided for convenience – you can mix your own audio data.

Definition at line 1619 of file SDL_audio.c.

References SDL_AudioDevice::callbackspec, device, SDL_AudioSpec::format, get_audio_device(), NULL, and SDL_MixAudioFormat.

1620 {
1621  /* Mix the user-level audio format */
1623  if (device != NULL) {
1624  SDL_MixAudioFormat(dst, src, device->callbackspec.format, len, volume);
1625  }
1626 }
GLenum GLenum dst
#define SDL_MixAudioFormat
GLenum src
GLenum GLsizei len
static SDL_AudioDeviceID device
Definition: loopwave.c:37
#define NULL
Definition: begin_code.h:164
SDL_AudioFormat format
Definition: SDL_audio.h:171
SDL_AudioSpec callbackspec
Definition: SDL_sysaudio.h:139
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_NextAudioFormat()

SDL_AudioFormat SDL_NextAudioFormat ( void  )

Definition at line 1589 of file SDL_audio.c.

References format_idx, format_idx_sub, format_list, and NUM_FORMATS.

Referenced by SDL_FirstAudioFormat().

1590 {
1591  if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
1592  return 0;
1593  }
1595 }
static int format_idx_sub
Definition: SDL_audio.c:1552
static int format_idx
Definition: SDL_audio.c:1551
static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]
Definition: SDL_audio.c:1553
#define NUM_FORMATS
Definition: SDL_audio.c:1550

◆ SDL_OpenAudio()

int SDL_OpenAudio ( SDL_AudioSpec desired,
SDL_AudioSpec obtained 
)

This function opens the audio device with the desired parameters, and returns 0 if successful, placing the actual hardware parameters in the structure pointed to by obtained. If obtained is NULL, the audio data passed to the callback function will be guaranteed to be in the requested format, and will be automatically converted to the hardware audio format if necessary. This function returns -1 if it failed to open the audio device, or couldn't set up the audio thread.

When filling in the desired audio spec structure,

  • desired->freq should be the desired audio frequency in samples-per- second.
  • desired->format should be the desired audio format.
  • desired->samples is the desired size of the audio buffer, in samples. This number should be a power of two, and may be adjusted by the audio driver to a value more suitable for the hardware. Good values seem to range between 512 and 8096 inclusive, depending on the application and CPU speed. Smaller values yield faster response time, but can lead to underflow if the application is doing heavy processing and cannot fill the audio buffer in time. A stereo sample consists of both right and left channels in LR ordering. Note that the number of samples is directly related to time by the following formula:
    ms = (samples*1000)/freq
  • desired->size is the size in bytes of the audio buffer, and is calculated by SDL_OpenAudio().
  • desired->silence is the value used to set the buffer to silence, and is calculated by SDL_OpenAudio().
  • desired->callback should be set to a function that will be called when the audio device is ready for more data. It is passed a pointer to the audio buffer, and the length in bytes of the audio buffer. This function usually runs in a separate thread, and so you should protect data structures that it accesses by calling SDL_LockAudio() and SDL_UnlockAudio() in your code. Alternately, you may pass a NULL pointer here, and call SDL_QueueAudio() with some frequency, to queue more audio samples to be played (or for capture devices, call SDL_DequeueAudio() with some frequency, to obtain audio samples).
  • desired->userdata is passed as the first parameter to your callback function. If you passed a NULL callback, this value is ignored.

The audio device starts out playing silence when it's opened, and should be enabled for playing by calling SDL_PauseAudio(0) when you are ready for your audio callback function to be called. Since the audio driver may modify the requested size of the audio buffer, you should allocate any local mixing buffers after you open the audio device.

Definition at line 1391 of file SDL_audio.c.

References NULL, open_audio_device(), SDL_assert, SDL_AUDIO_ALLOW_ANY_CHANGE, SDL_INIT_AUDIO, SDL_InitSubSystem, SDL_SetError, SDL_WasInit, SDL_zero, SDL_AudioSpec::silence, and SDL_AudioSpec::size.

1392 {
1393  SDL_AudioDeviceID id = 0;
1394 
1395  /* Start up the audio driver, if necessary. This is legacy behaviour! */
1396  if (!SDL_WasInit(SDL_INIT_AUDIO)) {
1397  if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
1398  return -1;
1399  }
1400  }
1401 
1402  /* SDL_OpenAudio() is legacy and can only act on Device ID #1. */
1403  if (open_devices[0] != NULL) {
1404  SDL_SetError("Audio device is already opened");
1405  return -1;
1406  }
1407 
1408  if (obtained) {
1409  id = open_audio_device(NULL, 0, desired, obtained,
1411  } else {
1412  SDL_AudioSpec _obtained;
1413  SDL_zero(_obtained);
1414  id = open_audio_device(NULL, 0, desired, &_obtained, 0, 1);
1415  /* On successful open, copy calculated values into 'desired'. */
1416  if (id > 0) {
1417  desired->size = _obtained.size;
1418  desired->silence = _obtained.silence;
1419  }
1420  }
1421 
1422  SDL_assert((id == 0) || (id == 1));
1423  return (id == 0) ? -1 : 0;
1424 }
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
Uint8 silence
Definition: SDL_audio.h:173
#define SDL_InitSubSystem
#define SDL_AUDIO_ALLOW_ANY_CHANGE
Definition: SDL_audio.h:143
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
Uint32 size
Definition: SDL_audio.h:176
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
static SDL_AudioDeviceID open_audio_device(const char *devname, int iscapture, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, int allowed_changes, int min_id)
Definition: SDL_audio.c:1143
#define SDL_INIT_AUDIO
Definition: SDL.h:77
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:320
#define SDL_WasInit

◆ SDL_OpenAudioDevice()

SDL_AudioDeviceID SDL_OpenAudioDevice ( const char *  device,
int  iscapture,
const SDL_AudioSpec desired,
SDL_AudioSpec obtained,
int  allowed_changes 
)

Open a specific audio device. Passing in a device name of NULL requests the most reasonable default (and is equivalent to calling SDL_OpenAudio()).

The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but some drivers allow arbitrary and driver-specific strings, such as a hostname/IP address for a remote audio server, or a filename in the diskaudio driver.

Returns
0 on error, a valid device ID that is >= 2 on success.

SDL_OpenAudio(), unlike this function, always acts on device ID 1.

Definition at line 1427 of file SDL_audio.c.

References open_audio_device().

1430 {
1431  return open_audio_device(device, iscapture, desired, obtained,
1432  allowed_changes, 2);
1433 }
static SDL_AudioDeviceID device
Definition: loopwave.c:37
static SDL_AudioDeviceID open_audio_device(const char *devname, int iscapture, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, int allowed_changes, int min_id)
Definition: SDL_audio.c:1143

◆ SDL_OpenedAudioDeviceDisconnected()

void SDL_OpenedAudioDeviceDisconnected ( SDL_AudioDevice device)

Definition at line 446 of file SDL_audio.c.

References SDL_AudioDevice::enabled, get_audio_device(), SDL_AudioDevice::id, SDL_AudioDriver::impl, SDL_AudioDevice::iscapture, SDL_AudioDriverImpl::LockDevice, SDL_assert, SDL_AtomicGet, SDL_AtomicSet, SDL_AUDIODEVICEREMOVED, SDL_ENABLE, SDL_GetEventState, SDL_PushEvent, SDL_zero, and SDL_AudioDriverImpl::UnlockDevice.

Referenced by SDL_CaptureAudio(), and SDL_RemoveAudioDevice().

447 {
448  SDL_assert(get_audio_device(device->id) == device);
449 
450  if (!SDL_AtomicGet(&device->enabled)) {
451  return;
452  }
453 
454  /* Ends the audio callback and mark the device as STOPPED, but the
455  app still needs to close the device to free resources. */
456  current_audio.impl.LockDevice(device);
457  SDL_AtomicSet(&device->enabled, 0);
459 
460  /* Post the event, if desired */
463  SDL_zero(event);
464  event.adevice.type = SDL_AUDIODEVICEREMOVED;
465  event.adevice.which = device->id;
466  event.adevice.iscapture = device->iscapture ? 1 : 0;
467  SDL_PushEvent(&event);
468  }
469 }
SDL_AudioDeviceID id
Definition: SDL_sysaudio.h:133
SDL_atomic_t enabled
Definition: SDL_sysaudio.h:146
#define SDL_ENABLE
Definition: SDL_events.h:722
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
#define SDL_GetEventState(type)
Definition: SDL_events.h:735
struct _cl_event * event
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
#define SDL_PushEvent
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
#define SDL_AtomicSet
#define SDL_AtomicGet
General event structure.
Definition: SDL_events.h:525
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_ParseAudioFormat()

static SDL_AudioFormat SDL_ParseAudioFormat ( const char *  string)
static

Definition at line 837 of file SDL_audio.c.

References CHECK_FMT_STRING, and S32.

Referenced by prepare_audiospec().

838 {
839 #define CHECK_FMT_STRING(x) if (SDL_strcmp(string, #x) == 0) return AUDIO_##x
840  CHECK_FMT_STRING(U8);
841  CHECK_FMT_STRING(S8);
842  CHECK_FMT_STRING(U16LSB);
843  CHECK_FMT_STRING(S16LSB);
844  CHECK_FMT_STRING(U16MSB);
845  CHECK_FMT_STRING(S16MSB);
846  CHECK_FMT_STRING(U16SYS);
847  CHECK_FMT_STRING(S16SYS);
848  CHECK_FMT_STRING(U16);
849  CHECK_FMT_STRING(S16);
850  CHECK_FMT_STRING(S32LSB);
851  CHECK_FMT_STRING(S32MSB);
852  CHECK_FMT_STRING(S32SYS);
854  CHECK_FMT_STRING(F32LSB);
855  CHECK_FMT_STRING(F32MSB);
856  CHECK_FMT_STRING(F32SYS);
857  CHECK_FMT_STRING(F32);
858 #undef CHECK_FMT_STRING
859  return 0;
860 }
#define S32
#define CHECK_FMT_STRING(x)

◆ SDL_PauseAudio()

void SDL_PauseAudio ( int  pause_on)

Definition at line 1469 of file SDL_audio.c.

References SDL_PauseAudioDevice().

1470 {
1471  SDL_PauseAudioDevice(1, pause_on);
1472 }
void SDL_PauseAudioDevice(SDL_AudioDeviceID devid, int pause_on)
Definition: SDL_audio.c:1458

◆ SDL_PauseAudioDevice()

void SDL_PauseAudioDevice ( SDL_AudioDeviceID  devid,
int  pause_on 
)

Definition at line 1458 of file SDL_audio.c.

References device, get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, SDL_AudioDevice::paused, SDL_AtomicSet, and SDL_AudioDriverImpl::UnlockDevice.

Referenced by SDL_PauseAudio().

1459 {
1461  if (device) {
1462  current_audio.impl.LockDevice(device);
1463  SDL_AtomicSet(&device->paused, pause_on ? 1 : 0);
1465  }
1466 }
SDL_atomic_t paused
Definition: SDL_sysaudio.h:147
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
static SDL_AudioDeviceID device
Definition: loopwave.c:37
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
#define SDL_AtomicSet
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_QueueAudio()

int SDL_QueueAudio ( SDL_AudioDeviceID  dev,
const void data,
Uint32  len 
)

Queue more audio on non-callback devices.

(If you are looking to retrieve queued audio from a non-callback capture device, you want SDL_DequeueAudio() instead. This will return -1 to signify an error if you use it with capture devices.)

SDL offers two ways to feed audio to the device: you can either supply a callback that SDL triggers with some frequency to obtain more audio (pull method), or you can supply no callback, and then SDL will expect you to supply data at regular intervals (push method) with this function.

There are no limits on the amount of data you can queue, short of exhaustion of address space. Queued data will drain to the device as necessary without further intervention from you. If the device needs audio but there is not enough queued, it will play silence to make up the difference. This means you will have skips in your audio playback if you aren't routinely queueing sufficient data.

This function copies the supplied data, so you are safe to free it when the function returns. This function is thread-safe, but queueing to the same device from two threads at once does not promise which buffer will be queued first.

You may not queue audio on a device that is using an application-supplied callback; doing so returns an error. You have to use the audio callback or queue audio with this function, but not both.

You should not call SDL_LockAudio() on the device before queueing; SDL handles locking internally for this function.

Parameters
devThe device ID to which we will queue audio.
dataThe data to queue to the device for later playback.
lenThe number of bytes (not samples!) to which (data) points.
Returns
zero on success, -1 on error.
See also
SDL_GetQueuedAudioSize
SDL_ClearQueuedAudio

Definition at line 554 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue, SDL_AudioSpec::callback, SDL_AudioDevice::callbackspec, device, get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDevice::iscapture, SDL_AudioDriverImpl::LockDevice, SDL_BufferQueueDrainCallback(), SDL_SetError, SDL_WriteToDataQueue(), and SDL_AudioDriverImpl::UnlockDevice.

555 {
557  int rc = 0;
558 
559  if (!device) {
560  return -1; /* get_audio_device() will have set the error state */
561  } else if (device->iscapture) {
562  return SDL_SetError("This is a capture device, queueing not allowed");
563  } else if (device->callbackspec.callback != SDL_BufferQueueDrainCallback) {
564  return SDL_SetError("Audio device has a callback, queueing not allowed");
565  }
566 
567  if (len > 0) {
568  current_audio.impl.LockDevice(device);
569  rc = SDL_WriteToDataQueue(device->buffer_queue, data, len);
571  }
572 
573  return rc;
574 }
int SDL_WriteToDataQueue(SDL_DataQueue *queue, const void *_data, const size_t _len)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
GLenum GLsizei len
static SDL_AudioDeviceID device
Definition: loopwave.c:37
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
SDL_AudioCallback callback
Definition: SDL_audio.h:177
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:79
static void SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:517
SDL_DataQueue * buffer_queue
Definition: SDL_sysaudio.h:164
#define SDL_SetError
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
SDL_AudioSpec callbackspec
Definition: SDL_sysaudio.h:139
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

◆ SDL_RemoveAudioDevice()

void SDL_RemoveAudioDevice ( const int  iscapture,
void handle 
)

Definition at line 487 of file SDL_audio.c.

References SDL_AudioDriver::captureDevicesRemoved, SDL_AudioDriver::detectionLock, device, SDL_AudioDriverImpl::FreeDeviceHandle, SDL_AudioDevice::handle, SDL_AudioDriver::impl, SDL_AudioDriver::inputDevices, mark_device_removed(), NULL, SDL_AudioDriver::outputDevices, SDL_AudioDriver::outputDevicesRemoved, SDL_arraysize, SDL_LockMutex, SDL_OpenedAudioDeviceDisconnected(), SDL_UnlockMutex, and SDLCALL.

488 {
489  int device_index;
491 
493  if (iscapture) {
495  } else {
497  }
498  for (device_index = 0; device_index < SDL_arraysize(open_devices); device_index++)
499  {
500  device = open_devices[device_index];
501  if (device != NULL && device->handle == handle)
502  {
504  break;
505  }
506  }
508 
510 }
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
#define SDL_LockMutex
SDL_bool captureDevicesRemoved
Definition: SDL_sysaudio.h:119
static void mark_device_removed(void *handle, SDL_AudioDeviceItem *devices, SDL_bool *removedFlag)
Definition: SDL_audio.c:472
void SDL_OpenedAudioDeviceDisconnected(SDL_AudioDevice *device)
Definition: SDL_audio.c:446
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:118
static SDL_AudioDeviceID device
Definition: loopwave.c:37
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:123
#define NULL
Definition: begin_code.h:164
SDL_bool outputDevicesRemoved
Definition: SDL_sysaudio.h:120
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
void(* FreeDeviceHandle)(void *handle)
Definition: SDL_sysaudio.h:81
#define SDL_UnlockMutex
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:124

◆ SDL_RunAudio()

static int SDL_RunAudio ( void devicep)
static

Definition at line 640 of file SDL_audio.c.

References callback(), SDL_AudioSpec::callback, SDL_AudioDevice::callbackspec, device, SDL_AudioDevice::enabled, SDL_AudioSpec::freq, SDL_AudioDriverImpl::GetDeviceBuf, SDL_AudioDriver::impl, SDL_AudioDevice::iscapture, SDL_AudioDevice::mixer_lock, NULL, SDL_AudioDevice::paused, SDL_AudioDriverImpl::PlayDevice, SDL_AudioDriverImpl::PrepareToClose, SDL_AudioSpec::samples, SDL_assert, SDL_AtomicGet, SDL_AudioStreamAvailable(), SDL_AudioStreamGet(), SDL_AudioStreamPut(), SDL_Delay, SDL_LockMutex, SDL_memset, SDL_SetThreadPriority, SDL_THREAD_PRIORITY_HIGH, SDL_ThreadID, SDL_UnlockMutex, SDLCALL, SDL_AudioDevice::shutdown, SDL_AudioSpec::silence, SDL_AudioSpec::size, SDL_AudioDevice::spec, SDL_AudioDevice::stream, SDL_AudioDriverImpl::ThreadDeinit, SDL_AudioDevice::threadid, SDL_AudioDriverImpl::ThreadInit, SDL_AudioSpec::userdata, SDL_AudioDriverImpl::WaitDevice, and SDL_AudioDevice::work_buffer.

Referenced by open_audio_device().

641 {
642  SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
643  void *udata = device->callbackspec.userdata;
645  Uint8 *data;
646 
647  SDL_assert(!device->iscapture);
648 
649  /* The audio mixing is always a high priority thread */
651 
652  /* Perform any thread setup */
653  device->threadid = SDL_ThreadID();
654  current_audio.impl.ThreadInit(device);
655 
656  /* Loop, filling the audio buffers */
657  while (!SDL_AtomicGet(&device->shutdown)) {
658  const int data_len = device->callbackspec.size;
659 
660  /* Fill the current buffer with sound */
661  if (!device->stream && SDL_AtomicGet(&device->enabled)) {
662  SDL_assert(data_len == device->spec.size);
663  data = current_audio.impl.GetDeviceBuf(device);
664  } else {
665  /* if the device isn't enabled, we still write to the
666  work_buffer, so the app's callback will fire with
667  a regular frequency, in case they depend on that
668  for timing or progress. They can use hotplug
669  now to know if the device failed.
670  Streaming playback uses work_buffer, too. */
671  data = NULL;
672  }
673 
674  if (data == NULL) {
675  data = device->work_buffer;
676  }
677 
678  /* !!! FIXME: this should be LockDevice. */
679  SDL_LockMutex(device->mixer_lock);
680  if (SDL_AtomicGet(&device->paused)) {
681  SDL_memset(data, device->spec.silence, data_len);
682  } else {
683  callback(udata, data, data_len);
684  }
685  SDL_UnlockMutex(device->mixer_lock);
686 
687  if (device->stream) {
688  /* Stream available audio to device, converting/resampling. */
689  /* if this fails...oh well. We'll play silence here. */
690  SDL_AudioStreamPut(device->stream, data, data_len);
691 
692  while (SDL_AudioStreamAvailable(device->stream) >= ((int) device->spec.size)) {
693  int got;
694  data = SDL_AtomicGet(&device->enabled) ? current_audio.impl.GetDeviceBuf(device) : NULL;
695  got = SDL_AudioStreamGet(device->stream, data ? data : device->work_buffer, device->spec.size);
696  SDL_assert((got < 0) || (got == device->spec.size));
697 
698  if (data == NULL) { /* device is having issues... */
699  const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
700  SDL_Delay(delay); /* wait for as long as this buffer would have played. Maybe device recovers later? */
701  } else {
702  if (got != device->spec.size) {
703  SDL_memset(data, device->spec.silence, device->spec.size);
704  }
705  current_audio.impl.PlayDevice(device);
706  current_audio.impl.WaitDevice(device);
707  }
708  }
709  } else if (data == device->work_buffer) {
710  /* nothing to do; pause like we queued a buffer to play. */
711  const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
712  SDL_Delay(delay);
713  } else { /* writing directly to the device. */
714  /* queue this buffer and wait for it to finish playing. */
715  current_audio.impl.PlayDevice(device);
716  current_audio.impl.WaitDevice(device);
717  }
718  }
719 
721 
722  /* Wait for the audio to drain. */
723  SDL_Delay(((device->spec.samples * 1000) / device->spec.freq) * 2);
724 
726 
727  return 0;
728 }
#define SDL_ThreadID
#define SDL_LockMutex
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:157
SDL_atomic_t enabled
Definition: SDL_sysaudio.h:146
Uint8 silence
Definition: SDL_audio.h:173
SDL_atomic_t paused
Definition: SDL_sysaudio.h:147
SDL_atomic_t shutdown
Definition: SDL_sysaudio.h:145
int SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, const Uint32 len)
void(* ThreadDeinit)(_THIS)
Definition: SDL_sysaudio.h:70
SDL_threadID threadid
Definition: SDL_sysaudio.h:161
void(* PlayDevice)(_THIS)
Definition: SDL_sysaudio.h:72
Uint16 samples
Definition: SDL_audio.h:174
void(* WaitDevice)(_THIS)
Definition: SDL_sysaudio.h:71
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:136
uint32_t Uint32
Definition: SDL_stdinc.h:181
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
static SDL_AudioDeviceID device
Definition: loopwave.c:37
void(* ThreadInit)(_THIS)
Definition: SDL_sysaudio.h:69
void(* SDL_AudioCallback)(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.h:162
uint8_t Uint8
Definition: SDL_stdinc.h:157
void(* PrepareToClose)(_THIS)
Definition: SDL_sysaudio.h:77
SDL_bool iscapture
Definition: SDL_sysaudio.h:148
int SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, const Uint32 len)
static Uint32 callback(Uint32 interval, void *param)
Definition: testtimer.c:34
SDL_AudioCallback callback
Definition: SDL_audio.h:177
#define SDL_Delay
Uint32 size
Definition: SDL_audio.h:176
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
int SDL_AudioStreamAvailable(SDL_AudioStream *stream)
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
Uint8 *(* GetDeviceBuf)(_THIS)
Definition: SDL_sysaudio.h:74
#define SDL_AtomicGet
void * userdata
Definition: SDL_audio.h:178
#define SDL_UnlockMutex
SDL_AudioSpec callbackspec
Definition: SDL_sysaudio.h:139
SDL_AudioStream * stream
Definition: SDL_sysaudio.h:142
#define SDL_SetThreadPriority
Uint8 * work_buffer
Definition: SDL_sysaudio.h:151
#define SDL_memset

◆ SDL_UnlockAudio()

void SDL_UnlockAudio ( void  )

Definition at line 1502 of file SDL_audio.c.

References SDL_UnlockAudioDevice().

1503 {
1505 }
void SDL_UnlockAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1492

◆ SDL_UnlockAudioDevice()

void SDL_UnlockAudioDevice ( SDL_AudioDeviceID  devid)

Definition at line 1492 of file SDL_audio.c.

References device, get_audio_device(), SDL_AudioDriver::impl, and SDL_AudioDriverImpl::UnlockDevice.

Referenced by SDL_UnlockAudio().

1493 {
1494  /* Obtain a lock on the mixing buffers */
1496  if (device) {
1498  }
1499 }
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
static SDL_AudioDeviceID device
Definition: loopwave.c:37
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:115
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:200

Variable Documentation

◆ bootstrap

const AudioBootStrap* const bootstrap[]
static

Definition at line 37 of file SDL_audio.c.

◆ current_audio

SDL_AudioDriver current_audio
static

Definition at line 33 of file SDL_audio.c.

◆ format_idx

int format_idx
static

Definition at line 1551 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

◆ format_idx_sub

int format_idx_sub
static

Definition at line 1552 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

◆ format_list

SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]
static
Initial value:
= {
}
#define AUDIO_S32MSB
Definition: SDL_audio.h:104
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
#define AUDIO_F32MSB
Definition: SDL_audio.h:113
#define AUDIO_U8
Definition: SDL_audio.h:89
#define AUDIO_F32LSB
Definition: SDL_audio.h:112
#define AUDIO_S32LSB
Definition: SDL_audio.h:103
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
#define AUDIO_S8
Definition: SDL_audio.h:90
#define AUDIO_U16MSB
Definition: SDL_audio.h:93

Definition at line 1553 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

◆ open_devices

SDL_AudioDevice* open_devices[16]
static

Definition at line 34 of file SDL_audio.c.