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_AudioBeginLoopIteration_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

◆ FILL_STUB

#define FILL_STUB (   x)
Value:
if (current_audio.impl.x == NULL) { \
current_audio.impl.x = SDL_Audio##x##_Default; \
}

◆ NUM_FORMATS

#define NUM_FORMATS   10

Definition at line 1612 of file SDL_audio.c.

Function Documentation

◆ add_audio_device()

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

Definition at line 378 of file SDL_audio.c.

379 {
380  int retval = -1;
381  SDL_AudioDeviceItem *item;
382  const SDL_AudioDeviceItem *i;
383  int dupenum = 0;
384 
385  SDL_assert(handle != NULL); /* we reserve NULL, audio backends can't use it. */
386  SDL_assert(name != NULL);
387 
389  if (!item) {
390  return SDL_OutOfMemory();
391  }
392 
393  item->original_name = SDL_strdup(name);
394  if (!item->original_name) {
395  SDL_free(item);
396  return SDL_OutOfMemory();
397  }
398 
399  item->dupenum = 0;
400  item->name = item->original_name;
401  item->handle = handle;
402 
404 
405  for (i = *devices; i != NULL; i = i->next) {
406  if (SDL_strcmp(name, i->original_name) == 0) {
407  dupenum = i->dupenum + 1;
408  break; /* stop at the highest-numbered dupe. */
409  }
410  }
411 
412  if (dupenum) {
413  const size_t len = SDL_strlen(name) + 16;
414  char *replacement = (char *) SDL_malloc(len);
415  if (!replacement) {
417  SDL_free(item->original_name);
418  SDL_free(item);
419  SDL_OutOfMemory();
420  return -1;
421  }
422 
423  SDL_snprintf(replacement, len, "%s (%d)", name, dupenum + 1);
424  item->dupenum = dupenum;
425  item->name = replacement;
426  }
427 
428  item->next = *devices;
429  *devices = item;
430  retval = (*devCount)++; /* !!! FIXME: this should be an atomic increment */
431 
433 
434  return retval;
435 }

References current_audio, SDL_AudioDriver::detectionLock, SDL_AudioDeviceItem::dupenum, SDL_AudioDeviceItem::handle, i, SDL_AudioDeviceItem::name, SDL_AudioDeviceItem::next, NULL, SDL_AudioDeviceItem::original_name, retval, SDL_assert, SDL_free, SDL_LockMutex, SDL_malloc, SDL_OutOfMemory, SDL_snprintf, SDL_strcmp, SDL_strdup, SDL_strlen, and SDL_UnlockMutex.

Referenced by add_capture_device(), and add_output_device().

◆ add_capture_device()

◆ add_output_device()

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

◆ clean_out_device_list()

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

Definition at line 1004 of file SDL_audio.c.

1005 {
1006  SDL_AudioDeviceItem *item = *devices;
1007  SDL_AudioDeviceItem *prev = NULL;
1008  int total = 0;
1009 
1010  while (item) {
1011  SDL_AudioDeviceItem *next = item->next;
1012  if (item->handle != NULL) {
1013  total++;
1014  prev = item;
1015  } else {
1016  if (prev) {
1017  prev->next = next;
1018  } else {
1019  *devices = next;
1020  }
1021  /* these two pointers are the same if not a duplicate devname */
1022  if (item->name != item->original_name) {
1023  SDL_free(item->name);
1024  }
1025  SDL_free(item->original_name);
1026  SDL_free(item);
1027  }
1028  item = next;
1029  }
1030 
1031  *devCount = total;
1032  *removedFlag = SDL_FALSE;
1033 }

References SDL_AudioDeviceItem::handle, SDL_AudioDeviceItem::name, SDL_AudioDeviceItem::next, NULL, SDL_AudioDeviceItem::original_name, SDL_FALSE, and SDL_free.

Referenced by SDL_GetNumAudioDevices().

◆ close_audio_device()

static void close_audio_device ( SDL_AudioDevice device)
static

Definition at line 1102 of file SDL_audio.c.

1103 {
1104  if (!device) {
1105  return;
1106  }
1107 
1108  /* make sure the device is paused before we do anything else, so the
1109  audio callback definitely won't fire again. */
1111  SDL_AtomicSet(&device->paused, 1);
1112  SDL_AtomicSet(&device->shutdown, 1);
1113  SDL_AtomicSet(&device->enabled, 0);
1115 
1116  if (device->thread != NULL) {
1117  SDL_WaitThread(device->thread, NULL);
1118  }
1119  if (device->mixer_lock != NULL) {
1120  SDL_DestroyMutex(device->mixer_lock);
1121  }
1122 
1123  SDL_free(device->work_buffer);
1124  SDL_FreeAudioStream(device->stream);
1125 
1126  if (device->id > 0) {
1127  SDL_AudioDevice *opendev = open_devices[device->id - 1];
1128  SDL_assert((opendev == device) || (opendev == NULL));
1129  if (opendev == device) {
1130  open_devices[device->id - 1] = NULL;
1131  }
1132  }
1133 
1134  if (device->hidden != NULL) {
1136  }
1137 
1138  SDL_FreeDataQueue(device->buffer_queue);
1139 
1140  SDL_free(device);
1141 }

References SDL_AudioDriverImpl::CloseDevice, current_audio, device, SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, NULL, open_devices, SDL_assert, SDL_AtomicSet, SDL_DestroyMutex, SDL_free, SDL_FreeAudioStream, SDL_FreeDataQueue(), SDL_WaitThread, and SDL_AudioDriverImpl::UnlockDevice.

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

◆ finish_audio_entry_points_init()

static void finish_audio_entry_points_init ( void  )
static

Definition at line 334 of file SDL_audio.c.

335 {
336  /*
337  * Fill in stub functions for unused driver entry points. This lets us
338  * blindly call them without having to check for validity first.
339  */
340 
344  }
347  }
348  }
349 
350 #define FILL_STUB(x) \
351  if (current_audio.impl.x == NULL) { \
352  current_audio.impl.x = SDL_Audio##x##_Default; \
353  }
354  FILL_STUB(DetectDevices);
355  FILL_STUB(OpenDevice);
356  FILL_STUB(ThreadInit);
357  FILL_STUB(ThreadDeinit);
358  FILL_STUB(BeginLoopIteration);
359  FILL_STUB(WaitDevice);
360  FILL_STUB(PlayDevice);
361  FILL_STUB(GetPendingBytes);
362  FILL_STUB(GetDeviceBuf);
363  FILL_STUB(CaptureFromDevice);
364  FILL_STUB(FlushCapture);
365  FILL_STUB(PrepareToClose);
366  FILL_STUB(CloseDevice);
367  FILL_STUB(LockDevice);
368  FILL_STUB(UnlockDevice);
369  FILL_STUB(FreeDeviceHandle);
370  FILL_STUB(Deinitialize);
371 #undef FILL_STUB
372 }

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

Referenced by SDL_AudioInit().

◆ free_device_list()

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

Definition at line 451 of file SDL_audio.c.

452 {
453  SDL_AudioDeviceItem *item, *next;
454  for (item = *devices; item != NULL; item = next) {
455  next = item->next;
456  if (item->handle != NULL) {
458  }
459  /* these two pointers are the same if not a duplicate devname */
460  if (item->name != item->original_name) {
461  SDL_free(item->name);
462  }
463  SDL_free(item->original_name);
464  SDL_free(item);
465  }
466  *devices = NULL;
467  *devCount = 0;
468 }

References current_audio, SDL_AudioDriverImpl::FreeDeviceHandle, SDL_AudioDeviceItem::handle, SDL_AudioDriver::impl, SDL_AudioDeviceItem::name, SDL_AudioDeviceItem::next, NULL, SDL_AudioDeviceItem::original_name, and SDL_free.

Referenced by SDL_AudioQuit().

◆ get_audio_device()

static SDL_AudioDevice* get_audio_device ( SDL_AudioDeviceID  id)
static

◆ is_in_audio_device_thread()

static SDL_INLINE SDL_bool is_in_audio_device_thread ( SDL_AudioDevice device)
static

Definition at line 299 of file SDL_audio.c.

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

References device, SDL_FALSE, SDL_ThreadID, and SDL_TRUE.

Referenced by SDL_AudioLockDevice_Default(), and SDL_AudioUnlockDevice_Default().

◆ mark_device_removed()

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

Definition at line 520 of file SDL_audio.c.

521 {
522  SDL_AudioDeviceItem *item;
523  SDL_assert(handle != NULL);
524  for (item = devices; item != NULL; item = item->next) {
525  if (item->handle == handle) {
526  item->handle = NULL;
527  *removedFlag = SDL_TRUE;
528  return;
529  }
530  }
531 }

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

Referenced by SDL_RemoveAudioDevice().

◆ 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 1208 of file SDL_audio.c.

1211 {
1212  const SDL_bool is_internal_thread = (desired->callback == NULL);
1213  SDL_AudioDeviceID id = 0;
1214  SDL_AudioSpec _obtained;
1216  SDL_bool build_stream;
1217  void *handle = NULL;
1218  int i = 0;
1219 
1220  if (!SDL_WasInit(SDL_INIT_AUDIO)) {
1221  SDL_SetError("Audio subsystem is not initialized");
1222  return 0;
1223  }
1224 
1225  if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
1226  SDL_SetError("No capture support");
1227  return 0;
1228  }
1229 
1230  /* !!! FIXME: there is a race condition here if two devices open from two threads at once. */
1231  /* Find an available device ID... */
1232  for (id = min_id - 1; id < SDL_arraysize(open_devices); id++) {
1233  if (open_devices[id] == NULL) {
1234  break;
1235  }
1236  }
1237 
1238  if (id == SDL_arraysize(open_devices)) {
1239  SDL_SetError("Too many open audio devices");
1240  return 0;
1241  }
1242 
1243  if (!obtained) {
1244  obtained = &_obtained;
1245  }
1246  if (!prepare_audiospec(desired, obtained)) {
1247  return 0;
1248  }
1249 
1250  /* If app doesn't care about a specific device, let the user override. */
1251  if (devname == NULL) {
1252  devname = SDL_getenv("SDL_AUDIO_DEVICE_NAME");
1253  }
1254 
1255  /*
1256  * Catch device names at the high level for the simple case...
1257  * This lets us have a basic "device enumeration" for systems that
1258  * don't have multiple devices, but makes sure the device name is
1259  * always NULL when it hits the low level.
1260  *
1261  * Also make sure that the simple case prevents multiple simultaneous
1262  * opens of the default system device.
1263  */
1264 
1265  if ((iscapture) && (current_audio.impl.OnlyHasDefaultCaptureDevice)) {
1266  if ((devname) && (SDL_strcmp(devname, DEFAULT_INPUT_DEVNAME) != 0)) {
1267  SDL_SetError("No such device");
1268  return 0;
1269  }
1270  devname = NULL;
1271 
1272  for (i = 0; i < SDL_arraysize(open_devices); i++) {
1273  if ((open_devices[i]) && (open_devices[i]->iscapture)) {
1274  SDL_SetError("Audio device already open");
1275  return 0;
1276  }
1277  }
1278  } else if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
1279  if ((devname) && (SDL_strcmp(devname, DEFAULT_OUTPUT_DEVNAME) != 0)) {
1280  SDL_SetError("No such device");
1281  return 0;
1282  }
1283  devname = NULL;
1284 
1285  for (i = 0; i < SDL_arraysize(open_devices); i++) {
1286  if ((open_devices[i]) && (!open_devices[i]->iscapture)) {
1287  SDL_SetError("Audio device already open");
1288  return 0;
1289  }
1290  }
1291  } else if (devname != NULL) {
1292  /* if the app specifies an exact string, we can pass the backend
1293  an actual device handle thingey, which saves them the effort of
1294  figuring out what device this was (such as, reenumerating
1295  everything again to find the matching human-readable name).
1296  It might still need to open a device based on the string for,
1297  say, a network audio server, but this optimizes some cases. */
1298  SDL_AudioDeviceItem *item;
1300  for (item = iscapture ? current_audio.inputDevices : current_audio.outputDevices; item; item = item->next) {
1301  if ((item->handle != NULL) && (SDL_strcmp(item->name, devname) == 0)) {
1302  handle = item->handle;
1303  break;
1304  }
1305  }
1307  }
1308 
1310  /* has to be in our device list, or the default device. */
1311  if ((handle == NULL) && (devname != NULL)) {
1312  SDL_SetError("No such device.");
1313  return 0;
1314  }
1315  }
1316 
1317  device = (SDL_AudioDevice *) SDL_calloc(1, sizeof (SDL_AudioDevice));
1318  if (device == NULL) {
1319  SDL_OutOfMemory();
1320  return 0;
1321  }
1322  device->id = id + 1;
1323  device->spec = *obtained;
1324  device->iscapture = iscapture ? SDL_TRUE : SDL_FALSE;
1325  device->handle = handle;
1326 
1327  SDL_AtomicSet(&device->shutdown, 0); /* just in case. */
1328  SDL_AtomicSet(&device->paused, 1);
1329  SDL_AtomicSet(&device->enabled, 1);
1330 
1331  /* Create a mutex for locking the sound buffers */
1333  device->mixer_lock = SDL_CreateMutex();
1334  if (device->mixer_lock == NULL) {
1336  SDL_SetError("Couldn't create mixer lock");
1337  return 0;
1338  }
1339  }
1340 
1341  if (current_audio.impl.OpenDevice(device, handle, devname, iscapture) < 0) {
1343  return 0;
1344  }
1345 
1346  /* if your target really doesn't need it, set it to 0x1 or something. */
1347  /* otherwise, close_audio_device() won't call impl.CloseDevice(). */
1348  SDL_assert(device->hidden != NULL);
1349 
1350  /* See if we need to do any conversion */
1351  build_stream = SDL_FALSE;
1352  if (obtained->freq != device->spec.freq) {
1353  if (allowed_changes & SDL_AUDIO_ALLOW_FREQUENCY_CHANGE) {
1354  obtained->freq = device->spec.freq;
1355  } else {
1356  build_stream = SDL_TRUE;
1357  }
1358  }
1359  if (obtained->format != device->spec.format) {
1360  if (allowed_changes & SDL_AUDIO_ALLOW_FORMAT_CHANGE) {
1361  obtained->format = device->spec.format;
1362  } else {
1363  build_stream = SDL_TRUE;
1364  }
1365  }
1366  if (obtained->channels != device->spec.channels) {
1367  if (allowed_changes & SDL_AUDIO_ALLOW_CHANNELS_CHANGE) {
1368  obtained->channels = device->spec.channels;
1369  } else {
1370  build_stream = SDL_TRUE;
1371  }
1372  }
1373  if (device->spec.samples != obtained->samples) {
1374  if (allowed_changes & SDL_AUDIO_ALLOW_SAMPLES_CHANGE) {
1375  obtained->samples = device->spec.samples;
1376  } else {
1377  build_stream = SDL_TRUE;
1378  }
1379  }
1380 
1381  SDL_CalculateAudioSpec(obtained); /* recalc after possible changes. */
1382 
1383  device->callbackspec = *obtained;
1384 
1385  if (build_stream) {
1386  if (iscapture) {
1387  device->stream = SDL_NewAudioStream(device->spec.format,
1388  device->spec.channels, device->spec.freq,
1389  obtained->format, obtained->channels, obtained->freq);
1390  } else {
1391  device->stream = SDL_NewAudioStream(obtained->format, obtained->channels,
1392  obtained->freq, device->spec.format,
1393  device->spec.channels, device->spec.freq);
1394  }
1395 
1396  if (!device->stream) {
1398  return 0;
1399  }
1400  }
1401 
1402  if (device->spec.callback == NULL) { /* use buffer queueing? */
1403  /* pool a few packets to start. Enough for two callbacks. */
1404  device->buffer_queue = SDL_NewDataQueue(SDL_AUDIOBUFFERQUEUE_PACKETLEN, obtained->size * 2);
1405  if (!device->buffer_queue) {
1407  SDL_SetError("Couldn't create audio buffer queue");
1408  return 0;
1409  }
1410  device->callbackspec.callback = iscapture ? SDL_BufferQueueFillCallback : SDL_BufferQueueDrainCallback;
1411  device->callbackspec.userdata = device;
1412  }
1413 
1414  /* Allocate a scratch audio buffer */
1415  device->work_buffer_len = build_stream ? device->callbackspec.size : 0;
1416  if (device->spec.size > device->work_buffer_len) {
1417  device->work_buffer_len = device->spec.size;
1418  }
1419  SDL_assert(device->work_buffer_len > 0);
1420 
1421  device->work_buffer = (Uint8 *) SDL_malloc(device->work_buffer_len);
1422  if (device->work_buffer == NULL) {
1424  SDL_OutOfMemory();
1425  return 0;
1426  }
1427 
1428  open_devices[id] = device; /* add it to our list of open devices. */
1429 
1430  /* Start the audio thread if necessary */
1432  /* Start the audio thread */
1433  /* !!! FIXME: we don't force the audio thread stack size here if it calls into user code, but maybe we should? */
1434  /* buffer queueing callback only needs a few bytes, so make the stack tiny. */
1435  const size_t stacksize = is_internal_thread ? 64 * 1024 : 0;
1436  char threadname[64];
1437 
1438  SDL_snprintf(threadname, sizeof (threadname), "SDLAudio%c%d", (iscapture) ? 'C' : 'P', (int) device->id);
1439  device->thread = SDL_CreateThreadInternal(iscapture ? SDL_CaptureAudio : SDL_RunAudio, threadname, stacksize, device);
1440 
1441  if (device->thread == NULL) {
1443  SDL_SetError("Couldn't create audio thread");
1444  return 0;
1445  }
1446  }
1447 
1448  return device->id;
1449 }

References SDL_AudioDriverImpl::AllowsArbitraryDeviceNames, SDL_AudioSpec::callback, SDL_AudioSpec::channels, close_audio_device(), current_audio, DEFAULT_INPUT_DEVNAME, DEFAULT_OUTPUT_DEVNAME, SDL_AudioDriver::detectionLock, device, SDL_AudioSpec::format, SDL_AudioSpec::freq, SDL_AudioDeviceItem::handle, SDL_AudioDriverImpl::HasCaptureSupport, i, SDL_AudioDriver::impl, SDL_AudioDriver::inputDevices, SDL_AudioDevice::iscapture, SDL_AudioDeviceItem::name, SDL_AudioDeviceItem::next, NULL, SDL_AudioDriverImpl::OnlyHasDefaultCaptureDevice, SDL_AudioDriverImpl::OnlyHasDefaultOutputDevice, open_devices, SDL_AudioDriverImpl::OpenDevice, SDL_AudioDriver::outputDevices, 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_AUDIO_ALLOW_SAMPLES_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_AudioSpec::size, and SDL_AudioDriverImpl::SkipMixerLock.

Referenced by SDL_OpenAudio(), and SDL_OpenAudioDevice().

◆ prepare_audiospec()

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

Definition at line 1150 of file SDL_audio.c.

1151 {
1152  SDL_memcpy(prepared, orig, sizeof(SDL_AudioSpec));
1153 
1154  if (orig->freq == 0) {
1155  const char *env = SDL_getenv("SDL_AUDIO_FREQUENCY");
1156  if ((!env) || ((prepared->freq = SDL_atoi(env)) == 0)) {
1157  prepared->freq = 22050; /* a reasonable default */
1158  }
1159  }
1160 
1161  if (orig->format == 0) {
1162  const char *env = SDL_getenv("SDL_AUDIO_FORMAT");
1163  if ((!env) || ((prepared->format = SDL_ParseAudioFormat(env)) == 0)) {
1164  prepared->format = AUDIO_S16; /* a reasonable default */
1165  }
1166  }
1167 
1168  switch (orig->channels) {
1169  case 0:{
1170  const char *env = SDL_getenv("SDL_AUDIO_CHANNELS");
1171  if ((!env) || ((prepared->channels = (Uint8) SDL_atoi(env)) == 0)) {
1172  prepared->channels = 2; /* a reasonable default */
1173  }
1174  break;
1175  }
1176  case 1: /* Mono */
1177  case 2: /* Stereo */
1178  case 4: /* Quadrophonic */
1179  case 6: /* 5.1 surround */
1180  case 8: /* 7.1 surround */
1181  break;
1182  default:
1183  SDL_SetError("Unsupported number of audio channels.");
1184  return 0;
1185  }
1186 
1187  if (orig->samples == 0) {
1188  const char *env = SDL_getenv("SDL_AUDIO_SAMPLES");
1189  if ((!env) || ((prepared->samples = (Uint16) SDL_atoi(env)) == 0)) {
1190  /* Pick a default of ~46 ms at desired frequency */
1191  /* !!! FIXME: remove this when the non-Po2 resampling is in. */
1192  const int samples = (prepared->freq / 1000) * 46;
1193  int power2 = 1;
1194  while (power2 < samples) {
1195  power2 *= 2;
1196  }
1197  prepared->samples = power2;
1198  }
1199  }
1200 
1201  /* Calculate the silence and size of the audio specification */
1202  SDL_CalculateAudioSpec(prepared);
1203 
1204  return 1;
1205 }

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().

◆ SDL_AddAudioDevice()

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

Definition at line 473 of file SDL_audio.c.

474 {
475  const int device_index = iscapture ? add_capture_device(name, handle) : add_output_device(name, handle);
476  if (device_index != -1) {
477  /* Post the event, if desired */
480  SDL_zero(event);
481  event.adevice.type = SDL_AUDIODEVICEADDED;
482  event.adevice.which = device_index;
483  event.adevice.iscapture = iscapture;
485  }
486  }
487 }

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

Referenced by SDL_AudioDetectDevices_Default().

◆ SDL_AudioBeginLoopIteration_Default()

static void SDL_AudioBeginLoopIteration_Default ( _THIS  )
static

Definition at line 234 of file SDL_audio.c.

235 { /* no-op. */
236 }

◆ SDL_AudioCaptureFromDevice_Default()

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

Definition at line 261 of file SDL_audio.c.

262 {
263  return -1; /* just fail immediately. */
264 }

◆ SDL_AudioCloseDevice_Default()

static void SDL_AudioCloseDevice_Default ( _THIS  )
static

Definition at line 277 of file SDL_audio.c.

278 { /* no-op. */
279 }

◆ SDL_AudioDeinitialize_Default()

static void SDL_AudioDeinitialize_Default ( void  )
static

Definition at line 282 of file SDL_audio.c.

283 { /* no-op. */
284 }

◆ SDL_AudioDetectDevices_Default()

◆ SDL_AudioFlushCapture_Default()

static void SDL_AudioFlushCapture_Default ( _THIS  )
static

Definition at line 267 of file SDL_audio.c.

268 { /* no-op. */
269 }

◆ SDL_AudioFreeDeviceHandle_Default()

static void SDL_AudioFreeDeviceHandle_Default ( void handle)
static

Definition at line 287 of file SDL_audio.c.

288 { /* no-op. */
289 }

◆ SDL_AudioGetDeviceBuf_Default()

static Uint8* SDL_AudioGetDeviceBuf_Default ( _THIS  )
static

Definition at line 255 of file SDL_audio.c.

256 {
257  return NULL;
258 }

References NULL.

◆ SDL_AudioGetPendingBytes_Default()

static int SDL_AudioGetPendingBytes_Default ( _THIS  )
static

Definition at line 249 of file SDL_audio.c.

250 {
251  return 0;
252 }

◆ SDL_AudioInit()

int SDL_AudioInit ( const char *  driver_name)

Definition at line 932 of file SDL_audio.c.

933 {
934  int i = 0;
935  int initialized = 0;
936  int tried_to_init = 0;
937 
939  SDL_AudioQuit(); /* shutdown driver if already running. */
940  }
941 
944 
945  /* Select the proper audio driver */
946  if (driver_name == NULL) {
947  driver_name = SDL_getenv("SDL_AUDIODRIVER");
948  }
949 
950  for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
951  /* make sure we should even try this driver before doing so... */
952  const AudioBootStrap *backend = bootstrap[i];
953  if ((driver_name && (SDL_strncasecmp(backend->name, driver_name, SDL_strlen(driver_name)) != 0)) ||
954  (!driver_name && backend->demand_only)) {
955  continue;
956  }
957 
958  tried_to_init = 1;
960  current_audio.name = backend->name;
961  current_audio.desc = backend->desc;
962  initialized = backend->init(&current_audio.impl);
963  }
964 
965  if (!initialized) {
966  /* specific drivers will set the error message if they fail... */
967  if (!tried_to_init) {
968  if (driver_name) {
969  SDL_SetError("Audio target '%s' not available", driver_name);
970  } else {
971  SDL_SetError("No available audio device");
972  }
973  }
974 
976  return -1; /* No driver was available, so fail. */
977  }
978 
980 
982 
983  /* Make sure we have a list of devices available at startup. */
985 
986 #ifdef HAVE_LIBSAMPLERATE_H
987  LoadLibSampleRate();
988 #endif
989 
990  return 0;
991 }

References bootstrap, current_audio, 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, open_devices, SDL_AudioQuit(), SDL_CreateMutex, SDL_getenv, SDL_INIT_AUDIO, SDL_SetError, SDL_strlen, SDL_strncasecmp, SDL_WasInit, and SDL_zero.

◆ SDL_AudioLockDevice_Default()

static void SDL_AudioLockDevice_Default ( SDL_AudioDevice device)
static

Definition at line 313 of file SDL_audio.c.

314 {
316  SDL_LockMutex(device->mixer_lock);
317  }
318 }

References device, is_in_audio_device_thread(), and SDL_LockMutex.

◆ SDL_AudioLockOrUnlockDeviceWithNoMixerLock()

static void SDL_AudioLockOrUnlockDeviceWithNoMixerLock ( SDL_AudioDevice device)
static

Definition at line 329 of file SDL_audio.c.

330 {
331 }

Referenced by finish_audio_entry_points_init().

◆ SDL_AudioOpenDevice_Default()

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

Definition at line 293 of file SDL_audio.c.

294 {
295  return SDL_Unsupported();
296 }

References SDL_Unsupported.

◆ SDL_AudioPlayDevice_Default()

static void SDL_AudioPlayDevice_Default ( _THIS  )
static

Definition at line 244 of file SDL_audio.c.

245 { /* no-op. */
246 }

◆ SDL_AudioPrepareToClose_Default()

static void SDL_AudioPrepareToClose_Default ( _THIS  )
static

Definition at line 272 of file SDL_audio.c.

273 { /* no-op. */
274 }

◆ SDL_AudioQuit()

void SDL_AudioQuit ( void  )

◆ SDL_AudioThreadDeinit_Default()

static void SDL_AudioThreadDeinit_Default ( _THIS  )
static

Definition at line 229 of file SDL_audio.c.

230 { /* no-op. */
231 }

◆ SDL_AudioThreadInit_Default()

static void SDL_AudioThreadInit_Default ( _THIS  )
static

Definition at line 224 of file SDL_audio.c.

225 { /* no-op. */
226 }

◆ SDL_AudioUnlockDevice_Default()

static void SDL_AudioUnlockDevice_Default ( SDL_AudioDevice device)
static

Definition at line 321 of file SDL_audio.c.

322 {
324  SDL_UnlockMutex(device->mixer_lock);
325  }
326 }

References device, is_in_audio_device_thread(), and SDL_UnlockMutex.

◆ SDL_AudioWaitDevice_Default()

static void SDL_AudioWaitDevice_Default ( _THIS  )
static

Definition at line 239 of file SDL_audio.c.

240 { /* no-op. */
241 }

◆ SDL_BufferQueueDrainCallback()

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

Definition at line 565 of file SDL_audio.c.

566 {
567  /* this function always holds the mixer lock before being called. */
568  SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;
569  size_t dequeued;
570 
571  SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */
572  SDL_assert(!device->iscapture); /* this shouldn't ever happen, right?! */
573  SDL_assert(len >= 0); /* this shouldn't ever happen, right?! */
574 
575  dequeued = SDL_ReadFromDataQueue(device->buffer_queue, stream, len);
576  stream += dequeued;
577  len -= (int) dequeued;
578 
579  if (len > 0) { /* fill any remaining space in the stream with silence. */
580  SDL_assert(SDL_CountDataQueue(device->buffer_queue) == 0);
581  SDL_memset(stream, device->spec.silence, len);
582  }
583 }

References device, NULL, SDL_assert, SDL_CountDataQueue(), SDL_memset, and SDL_ReadFromDataQueue().

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

◆ SDL_BufferQueueFillCallback()

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

Definition at line 586 of file SDL_audio.c.

587 {
588  /* this function always holds the mixer lock before being called. */
589  SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;
590 
591  SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */
592  SDL_assert(device->iscapture); /* this shouldn't ever happen, right?! */
593  SDL_assert(len >= 0); /* this shouldn't ever happen, right?! */
594 
595  /* note that if this needs to allocate more space and run out of memory,
596  we have no choice but to quietly drop the data and hope it works out
597  later, but you probably have bigger problems in this case anyhow. */
598  SDL_WriteToDataQueue(device->buffer_queue, stream, len);
599 }

References device, NULL, SDL_assert, and SDL_WriteToDataQueue().

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

◆ SDL_CalculateAudioSpec()

void SDL_CalculateAudioSpec ( SDL_AudioSpec spec)

Definition at line 1660 of file SDL_audio.c.

1661 {
1662  switch (spec->format) {
1663  case AUDIO_U8:
1664  spec->silence = 0x80;
1665  break;
1666  default:
1667  spec->silence = 0x00;
1668  break;
1669  }
1671  spec->size *= spec->channels;
1672  spec->size *= spec->samples;
1673 }

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

Referenced by open_audio_device(), and prepare_audiospec().

◆ SDL_CaptureAudio()

static int SDL_CaptureAudio ( void devicep)
static

Definition at line 783 of file SDL_audio.c.

784 {
785  SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
786  const int silence = (int) device->spec.silence;
787  const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
788  const int data_len = device->spec.size;
789  Uint8 *data;
790  void *udata = device->callbackspec.userdata;
791  SDL_AudioCallback callback = device->callbackspec.callback;
792 
793  SDL_assert(device->iscapture);
794 
795  /* The audio mixing is always a high priority thread */
797 
798  /* Perform any thread setup */
799  device->threadid = SDL_ThreadID();
801 
802  /* Loop, filling the audio buffers */
803  while (!SDL_AtomicGet(&device->shutdown)) {
804  int still_need;
805  Uint8 *ptr;
806 
808 
809  if (SDL_AtomicGet(&device->paused)) {
810  SDL_Delay(delay); /* just so we don't cook the CPU. */
811  if (device->stream) {
812  SDL_AudioStreamClear(device->stream);
813  }
814  current_audio.impl.FlushCapture(device); /* dump anything pending. */
815  continue;
816  }
817 
818  /* Fill the current buffer with sound */
819  still_need = data_len;
820 
821  /* Use the work_buffer to hold data read from the device. */
822  data = device->work_buffer;
823  SDL_assert(data != NULL);
824 
825  ptr = data;
826 
827  /* We still read from the device when "paused" to keep the state sane,
828  and block when there isn't data so this thread isn't eating CPU.
829  But we don't process it further or call the app's callback. */
830 
831  if (!SDL_AtomicGet(&device->enabled)) {
832  SDL_Delay(delay); /* try to keep callback firing at normal pace. */
833  } else {
834  while (still_need > 0) {
835  const int rc = current_audio.impl.CaptureFromDevice(device, ptr, still_need);
836  SDL_assert(rc <= still_need); /* device should not overflow buffer. :) */
837  if (rc > 0) {
838  still_need -= rc;
839  ptr += rc;
840  } else { /* uhoh, device failed for some reason! */
842  break;
843  }
844  }
845  }
846 
847  if (still_need > 0) {
848  /* Keep any data we already read, silence the rest. */
849  SDL_memset(ptr, silence, still_need);
850  }
851 
852  if (device->stream) {
853  /* if this fails...oh well. */
854  SDL_AudioStreamPut(device->stream, data, data_len);
855 
856  while (SDL_AudioStreamAvailable(device->stream) >= ((int) device->callbackspec.size)) {
857  const int got = SDL_AudioStreamGet(device->stream, device->work_buffer, device->callbackspec.size);
858  SDL_assert((got < 0) || (got == device->callbackspec.size));
859  if (got != device->callbackspec.size) {
860  SDL_memset(device->work_buffer, device->spec.silence, device->callbackspec.size);
861  }
862 
863  /* !!! FIXME: this should be LockDevice. */
864  SDL_LockMutex(device->mixer_lock);
865  if (!SDL_AtomicGet(&device->paused)) {
866  callback(udata, device->work_buffer, device->callbackspec.size);
867  }
868  SDL_UnlockMutex(device->mixer_lock);
869  }
870  } else { /* feeding user callback directly without streaming. */
871  /* !!! FIXME: this should be LockDevice. */
872  SDL_LockMutex(device->mixer_lock);
873  if (!SDL_AtomicGet(&device->paused)) {
874  callback(udata, data, device->callbackspec.size);
875  }
876  SDL_UnlockMutex(device->mixer_lock);
877  }
878  }
879 
881 
883 
885 
886  return 0;
887 }

References SDL_AudioDriverImpl::BeginLoopIteration, callback(), SDL_AudioDriverImpl::CaptureFromDevice, current_audio, device, SDL_AudioDriverImpl::FlushCapture, SDL_AudioDriver::impl, NULL, SDL_AudioDriverImpl::PrepareToClose, 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_AudioDriverImpl::ThreadDeinit, and SDL_AudioDriverImpl::ThreadInit.

Referenced by open_audio_device().

◆ 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 668 of file SDL_audio.c.

669 {
671 
672  if (!device) {
673  return; /* nothing to do. */
674  }
675 
676  /* Blank out the device and release the mutex. Free it afterwards. */
678 
679  /* Keep up to two packets in the pool to reduce future malloc pressure. */
681 
683 }

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

◆ SDL_CloseAudio()

void SDL_CloseAudio ( void  )

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

Definition at line 1576 of file SDL_audio.c.

1577 {
1579 }

References SDL_CloseAudioDevice().

◆ SDL_CloseAudioDevice()

void SDL_CloseAudioDevice ( SDL_AudioDeviceID  devid)

Definition at line 1570 of file SDL_audio.c.

1571 {
1573 }

References close_audio_device(), and get_audio_device().

Referenced by SDL_CloseAudio().

◆ 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 625 of file SDL_audio.c.

626 {
628  Uint32 rc;
629 
630  if ( (len == 0) || /* nothing to do? */
631  (!device) || /* called with bogus device id */
632  (!device->iscapture) || /* playback devices can't dequeue */
633  (device->callbackspec.callback != SDL_BufferQueueFillCallback) ) { /* not set for queueing */
634  return 0; /* just report zero bytes dequeued. */
635  }
636 
638  rc = (Uint32) SDL_ReadFromDataQueue(device->buffer_queue, data, len);
640  return rc;
641 }

References current_audio, device, get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, SDL_BufferQueueFillCallback(), SDL_ReadFromDataQueue(), and SDL_AudioDriverImpl::UnlockDevice.

◆ SDL_FirstAudioFormat()

SDL_AudioFormat SDL_FirstAudioFormat ( SDL_AudioFormat  format)

Definition at line 1639 of file SDL_audio.c.

1640 {
1641  for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
1642  if (format_list[format_idx][0] == format) {
1643  break;
1644  }
1645  }
1646  format_idx_sub = 0;
1647  return SDL_NextAudioFormat();
1648 }

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

◆ 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 1062 of file SDL_audio.c.

1063 {
1064  const char *retval = NULL;
1065 
1066  if (!SDL_WasInit(SDL_INIT_AUDIO)) {
1067  SDL_SetError("Audio subsystem is not initialized");
1068  return NULL;
1069  }
1070 
1071  if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
1072  SDL_SetError("No capture support");
1073  return NULL;
1074  }
1075 
1076  if (index >= 0) {
1077  SDL_AudioDeviceItem *item;
1078  int i;
1079 
1083  if (index < i) {
1084  for (i--; i > index; i--, item = item->next) {
1085  SDL_assert(item != NULL);
1086  }
1087  SDL_assert(item != NULL);
1088  retval = item->name;
1089  }
1091  }
1092 
1093  if (retval == NULL) {
1094  SDL_SetError("No such device");
1095  }
1096 
1097  return retval;
1098 }

References current_audio, 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.

◆ SDL_GetAudioDeviceStatus()

SDL_AudioStatus SDL_GetAudioDeviceStatus ( SDL_AudioDeviceID  devid)

Definition at line 1498 of file SDL_audio.c.

1499 {
1502  if (device && SDL_AtomicGet(&device->enabled)) {
1503  if (SDL_AtomicGet(&device->paused)) {
1504  status = SDL_AUDIO_PAUSED;
1505  } else {
1506  status = SDL_AUDIO_PLAYING;
1507  }
1508  }
1509  return status;
1510 }

References device, get_audio_device(), SDL_AtomicGet, SDL_AUDIO_PAUSED, SDL_AUDIO_PLAYING, and SDL_AUDIO_STOPPED.

Referenced by SDL_GetAudioStatus().

◆ SDL_GetAudioDriver()

const char* SDL_GetAudioDriver ( int  index)

Definition at line 923 of file SDL_audio.c.

924 {
925  if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
926  return bootstrap[index]->name;
927  }
928  return NULL;
929 }

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

◆ SDL_GetAudioStatus()

SDL_AudioStatus SDL_GetAudioStatus ( void  )

Definition at line 1514 of file SDL_audio.c.

1515 {
1516  return SDL_GetAudioDeviceStatus(1);
1517 }

References SDL_GetAudioDeviceStatus().

◆ 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 997 of file SDL_audio.c.

998 {
999  return current_audio.name;
1000 }

References current_audio, and SDL_AudioDriver::name.

◆ 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 1037 of file SDL_audio.c.

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

◆ SDL_GetNumAudioDrivers()

int SDL_GetNumAudioDrivers ( void  )

Definition at line 917 of file SDL_audio.c.

918 {
919  return SDL_arraysize(bootstrap) - 1;
920 }

References bootstrap, and SDL_arraysize.

Referenced by SDL_GetAudioDriver().

◆ 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 644 of file SDL_audio.c.

645 {
646  Uint32 retval = 0;
648 
649  if (!device) {
650  return 0;
651  }
652 
653  /* Nothing to do unless we're set up for queueing. */
654  if (device->callbackspec.callback == SDL_BufferQueueDrainCallback) {
658  } else if (device->callbackspec.callback == SDL_BufferQueueFillCallback) {
660  retval = (Uint32) SDL_CountDataQueue(device->buffer_queue);
662  }
663 
664  return retval;
665 }

References current_audio, device, get_audio_device(), SDL_AudioDriverImpl::GetPendingBytes, SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, retval, SDL_BufferQueueDrainCallback(), SDL_BufferQueueFillCallback(), SDL_CountDataQueue(), and SDL_AudioDriverImpl::UnlockDevice.

◆ SDL_LockAudio()

void SDL_LockAudio ( void  )

Definition at line 1548 of file SDL_audio.c.

1549 {
1551 }

References SDL_LockAudioDevice().

◆ SDL_LockAudioDevice()

void SDL_LockAudioDevice ( SDL_AudioDeviceID  devid)

Definition at line 1538 of file SDL_audio.c.

1539 {
1540  /* Obtain a lock on the mixing buffers */
1542  if (device) {
1544  }
1545 }

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

Referenced by SDL_LockAudio().

◆ 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 1681 of file SDL_audio.c.

1682 {
1683  /* Mix the user-level audio format */
1685  if (device != NULL) {
1686  SDL_MixAudioFormat(dst, src, device->callbackspec.format, len, volume);
1687  }
1688 }

References device, get_audio_device(), NULL, and SDL_MixAudioFormat.

◆ SDL_NextAudioFormat()

SDL_AudioFormat SDL_NextAudioFormat ( void  )

Definition at line 1651 of file SDL_audio.c.

1652 {
1653  if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
1654  return 0;
1655  }
1657 }

References format_idx, format_idx_sub, format_list, and NUM_FORMATS.

Referenced by SDL_FirstAudioFormat().

◆ 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 1453 of file SDL_audio.c.

1454 {
1455  SDL_AudioDeviceID id = 0;
1456 
1457  /* Start up the audio driver, if necessary. This is legacy behaviour! */
1458  if (!SDL_WasInit(SDL_INIT_AUDIO)) {
1459  if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
1460  return -1;
1461  }
1462  }
1463 
1464  /* SDL_OpenAudio() is legacy and can only act on Device ID #1. */
1465  if (open_devices[0] != NULL) {
1466  SDL_SetError("Audio device is already opened");
1467  return -1;
1468  }
1469 
1470  if (obtained) {
1471  id = open_audio_device(NULL, 0, desired, obtained,
1473  } else {
1474  SDL_AudioSpec _obtained;
1475  SDL_zero(_obtained);
1476  id = open_audio_device(NULL, 0, desired, &_obtained, 0, 1);
1477  /* On successful open, copy calculated values into 'desired'. */
1478  if (id > 0) {
1479  desired->size = _obtained.size;
1480  desired->silence = _obtained.silence;
1481  }
1482  }
1483 
1484  SDL_assert((id == 0) || (id == 1));
1485  return (id == 0) ? -1 : 0;
1486 }

References NULL, open_audio_device(), open_devices, 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.

◆ 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 1489 of file SDL_audio.c.

1492 {
1493  return open_audio_device(device, iscapture, desired, obtained,
1494  allowed_changes, 2);
1495 }

References device, and open_audio_device().

◆ SDL_OpenedAudioDeviceDisconnected()

void SDL_OpenedAudioDeviceDisconnected ( SDL_AudioDevice device)

Definition at line 490 of file SDL_audio.c.

491 {
493 
494  if (!SDL_AtomicGet(&device->enabled)) {
495  return; /* don't report disconnects more than once. */
496  }
497 
498  if (SDL_AtomicGet(&device->shutdown)) {
499  return; /* don't report disconnect if we're trying to close device. */
500  }
501 
502  /* Ends the audio callback and mark the device as STOPPED, but the
503  app still needs to close the device to free resources. */
505  SDL_AtomicSet(&device->enabled, 0);
507 
508  /* Post the event, if desired */
511  SDL_zero(event);
512  event.adevice.type = SDL_AUDIODEVICEREMOVED;
513  event.adevice.which = device->id;
514  event.adevice.iscapture = device->iscapture ? 1 : 0;
516  }
517 }

References current_audio, device, get_audio_device(), SDL_AudioDriver::impl, 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().

◆ SDL_ParseAudioFormat()

static SDL_AudioFormat SDL_ParseAudioFormat ( const char *  string)
static

Definition at line 891 of file SDL_audio.c.

892 {
893 #define CHECK_FMT_STRING(x) if (SDL_strcmp(string, #x) == 0) return AUDIO_##x
894  CHECK_FMT_STRING(U8);
895  CHECK_FMT_STRING(S8);
896  CHECK_FMT_STRING(U16LSB);
897  CHECK_FMT_STRING(S16LSB);
898  CHECK_FMT_STRING(U16MSB);
899  CHECK_FMT_STRING(S16MSB);
900  CHECK_FMT_STRING(U16SYS);
901  CHECK_FMT_STRING(S16SYS);
902  CHECK_FMT_STRING(U16);
903  CHECK_FMT_STRING(S16);
904  CHECK_FMT_STRING(S32LSB);
905  CHECK_FMT_STRING(S32MSB);
906  CHECK_FMT_STRING(S32SYS);
908  CHECK_FMT_STRING(F32LSB);
909  CHECK_FMT_STRING(F32MSB);
910  CHECK_FMT_STRING(F32SYS);
911  CHECK_FMT_STRING(F32);
912 #undef CHECK_FMT_STRING
913  return 0;
914 }

References CHECK_FMT_STRING, and S32.

Referenced by prepare_audiospec().

◆ SDL_PauseAudio()

void SDL_PauseAudio ( int  pause_on)

Definition at line 1531 of file SDL_audio.c.

1532 {
1533  SDL_PauseAudioDevice(1, pause_on);
1534 }

References SDL_PauseAudioDevice().

◆ SDL_PauseAudioDevice()

void SDL_PauseAudioDevice ( SDL_AudioDeviceID  devid,
int  pause_on 
)

Definition at line 1520 of file SDL_audio.c.

1521 {
1523  if (device) {
1525  SDL_AtomicSet(&device->paused, pause_on ? 1 : 0);
1527  }
1528 }

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

Referenced by SDL_PauseAudio().

◆ 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
0 on success, or -1 on error.
See also
SDL_GetQueuedAudioSize
SDL_ClearQueuedAudio

Definition at line 602 of file SDL_audio.c.

603 {
605  int rc = 0;
606 
607  if (!device) {
608  return -1; /* get_audio_device() will have set the error state */
609  } else if (device->iscapture) {
610  return SDL_SetError("This is a capture device, queueing not allowed");
611  } else if (device->callbackspec.callback != SDL_BufferQueueDrainCallback) {
612  return SDL_SetError("Audio device has a callback, queueing not allowed");
613  }
614 
615  if (len > 0) {
617  rc = SDL_WriteToDataQueue(device->buffer_queue, data, len);
619  }
620 
621  return rc;
622 }

References current_audio, device, get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, SDL_BufferQueueDrainCallback(), SDL_SetError, SDL_WriteToDataQueue(), and SDL_AudioDriverImpl::UnlockDevice.

◆ SDL_RemoveAudioDevice()

◆ SDL_RunAudio()

static int SDL_RunAudio ( void devicep)
static

Definition at line 688 of file SDL_audio.c.

689 {
690  SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
691  void *udata = device->callbackspec.userdata;
692  SDL_AudioCallback callback = device->callbackspec.callback;
693  int data_len = 0;
694  Uint8 *data;
695 
696  SDL_assert(!device->iscapture);
697 
698  /* The audio mixing is always a high priority thread */
700 
701  /* Perform any thread setup */
702  device->threadid = SDL_ThreadID();
704 
705  /* Loop, filling the audio buffers */
706  while (!SDL_AtomicGet(&device->shutdown)) {
708  data_len = device->callbackspec.size;
709 
710  /* Fill the current buffer with sound */
711  if (!device->stream && SDL_AtomicGet(&device->enabled)) {
712  SDL_assert(data_len == device->spec.size);
714  } else {
715  /* if the device isn't enabled, we still write to the
716  work_buffer, so the app's callback will fire with
717  a regular frequency, in case they depend on that
718  for timing or progress. They can use hotplug
719  now to know if the device failed.
720  Streaming playback uses work_buffer, too. */
721  data = NULL;
722  }
723 
724  if (data == NULL) {
725  data = device->work_buffer;
726  }
727 
728  /* !!! FIXME: this should be LockDevice. */
729  SDL_LockMutex(device->mixer_lock);
730  if (SDL_AtomicGet(&device->paused)) {
731  SDL_memset(data, device->spec.silence, data_len);
732  } else {
733  callback(udata, data, data_len);
734  }
735  SDL_UnlockMutex(device->mixer_lock);
736 
737  if (device->stream) {
738  /* Stream available audio to device, converting/resampling. */
739  /* if this fails...oh well. We'll play silence here. */
740  SDL_AudioStreamPut(device->stream, data, data_len);
741 
742  while (SDL_AudioStreamAvailable(device->stream) >= ((int) device->spec.size)) {
743  int got;
745  got = SDL_AudioStreamGet(device->stream, data ? data : device->work_buffer, device->spec.size);
746  SDL_assert((got < 0) || (got == device->spec.size));
747 
748  if (data == NULL) { /* device is having issues... */
749  const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
750  SDL_Delay(delay); /* wait for as long as this buffer would have played. Maybe device recovers later? */
751  } else {
752  if (got != device->spec.size) {
753  SDL_memset(data, device->spec.silence, device->spec.size);
754  }
757  }
758  }
759  } else if (data == device->work_buffer) {
760  /* nothing to do; pause like we queued a buffer to play. */
761  const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
762  SDL_Delay(delay);
763  } else { /* writing directly to the device. */
764  /* queue this buffer and wait for it to finish playing. */
767  }
768  }
769 
771 
772  /* Wait for the audio to drain. */
773  SDL_Delay(((device->spec.samples * 1000) / device->spec.freq) * 2);
774 
776 
777  return 0;
778 }

References SDL_AudioDriverImpl::BeginLoopIteration, callback(), current_audio, device, SDL_AudioDriverImpl::GetDeviceBuf, SDL_AudioDriver::impl, NULL, SDL_AudioDriverImpl::PlayDevice, SDL_AudioDriverImpl::PrepareToClose, SDL_assert, SDL_AtomicGet, SDL_AudioStreamAvailable, SDL_AudioStreamGet, SDL_AudioStreamPut, SDL_Delay, SDL_LockMutex, SDL_memset, SDL_SetThreadPriority, SDL_THREAD_PRIORITY_TIME_CRITICAL, SDL_ThreadID, SDL_UnlockMutex, SDL_AudioDriverImpl::ThreadDeinit, SDL_AudioDriverImpl::ThreadInit, and SDL_AudioDriverImpl::WaitDevice.

Referenced by open_audio_device().

◆ SDL_UnlockAudio()

void SDL_UnlockAudio ( void  )

Definition at line 1564 of file SDL_audio.c.

1565 {
1567 }

References SDL_UnlockAudioDevice().

◆ SDL_UnlockAudioDevice()

void SDL_UnlockAudioDevice ( SDL_AudioDeviceID  devid)

Definition at line 1554 of file SDL_audio.c.

1555 {
1556  /* Obtain a lock on the mixing buffers */
1558  if (device) {
1560  }
1561 }

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

Referenced by SDL_UnlockAudio().

Variable Documentation

◆ bootstrap

const AudioBootStrap* const bootstrap[]
static

Definition at line 37 of file SDL_audio.c.

Referenced by SDL_AudioInit(), SDL_GetAudioDriver(), and SDL_GetNumAudioDrivers().

◆ current_audio

◆ format_idx

int format_idx
static

Definition at line 1613 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

◆ format_idx_sub

int format_idx_sub
static

Definition at line 1614 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

◆ format_list

SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]
static

◆ open_devices

finish_audio_entry_points_init
static void finish_audio_entry_points_init(void)
Definition: SDL_audio.c:334
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
format_idx
static int format_idx
Definition: SDL_audio.c:1613
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
SDL_NewDataQueue
SDL_DataQueue * SDL_NewDataQueue(const size_t _packetlen, const size_t initialslack)
Definition: SDL_dataqueue.c:58
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
SDL_SetThreadPriority
#define SDL_SetThreadPriority
Definition: SDL_dynapi_overrides.h:477
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:386
SDL_AudioSpec::channels
Uint8 channels
Definition: SDL_audio.h:182
SDL_AudioDriverImpl::HasCaptureSupport
int HasCaptureSupport
Definition: SDL_sysaudio.h:91
SDL_CountDataQueue
size_t SDL_CountDataQueue(SDL_DataQueue *queue)
Definition: SDL_dataqueue.c:294
SDL_AudioDriverImpl::UnlockDevice
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:81
format_idx_sub
static int format_idx_sub
Definition: SDL_audio.c:1614
SDL_AudioDriverImpl::ProvidesOwnCallbackThread
int ProvidesOwnCallbackThread
Definition: SDL_sysaudio.h:89
DEFAULT_OUTPUT_DEVNAME
#define DEFAULT_OUTPUT_DEVNAME
Definition: SDL_sysaudio.h:32
Uint16
uint16_t Uint16
Definition: SDL_stdinc.h:191
AUDIO_U16LSB
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
SDL_AUDIO_ALLOW_FREQUENCY_CHANGE
#define SDL_AUDIO_ALLOW_FREQUENCY_CHANGE
Definition: SDL_audio.h:140
clean_out_device_list
static void clean_out_device_list(SDL_AudioDeviceItem **devices, int *devCount, SDL_bool *removedFlag)
Definition: SDL_audio.c:1004
SDL_CaptureAudio
static int SDL_CaptureAudio(void *devicep)
Definition: SDL_audio.c:783
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:260
SDL_AudioDriverImpl::FlushCapture
void(* FlushCapture)(_THIS)
Definition: SDL_sysaudio.h:77
NULL
#define NULL
Definition: begin_code.h:164
SDL_AudioStreamAvailable
#define SDL_AudioStreamAvailable
Definition: SDL_dynapi_overrides.h:647
handle
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
add_output_device
static SDL_INLINE int add_output_device(const char *name, void *handle)
Definition: SDL_audio.c:445
AUDIO_S32MSB
#define AUDIO_S32MSB
Definition: SDL_audio.h:104
SDL_AudioSpec::samples
Uint16 samples
Definition: SDL_audio.h:184
SDL_GetNumAudioDrivers
int SDL_GetNumAudioDrivers(void)
Definition: SDL_audio.c:917
SDL_THREAD_PRIORITY_TIME_CRITICAL
@ SDL_THREAD_PRIORITY_TIME_CRITICAL
Definition: SDL_thread.h:63
samples
GLsizei samples
Definition: SDL_opengl_glext.h:1185
SDL_AudioDriver::captureDevicesRemoved
SDL_bool captureDevicesRemoved
Definition: SDL_sysaudio.h:122
SDL_FreeDataQueue
void SDL_FreeDataQueue(SDL_DataQueue *queue)
Definition: SDL_dataqueue.c:88
SDL_AudioSpec::format
SDL_AudioFormat format
Definition: SDL_audio.h:181
SDL_AudioDriverImpl::SkipMixerLock
int SkipMixerLock
Definition: SDL_sysaudio.h:90
SDL_AudioDeviceItem::dupenum
int dupenum
Definition: SDL_sysaudio.h:103
DEFAULT_INPUT_DEVNAME
#define DEFAULT_INPUT_DEVNAME
Definition: SDL_sysaudio.h:33
mark_device_removed
static void mark_device_removed(void *handle, SDL_AudioDeviceItem *devices, SDL_bool *removedFlag)
Definition: SDL_audio.c:520
SDL_MixAudioFormat
#define SDL_MixAudioFormat
Definition: SDL_dynapi_overrides.h:91
devices
EGLDeviceEXT * devices
Definition: eglext.h:621
SDL_THREAD_PRIORITY_HIGH
@ SDL_THREAD_PRIORITY_HIGH
Definition: SDL_thread.h:62
SDL_AudioSpec::callback
SDL_AudioCallback callback
Definition: SDL_audio.h:187
SDL_AudioDriverImpl::GetPendingBytes
int(* GetPendingBytes)(_THIS)
Definition: SDL_sysaudio.h:74
SDL_AudioDeviceItem::next
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:104
stream
GLuint GLuint stream
Definition: SDL_opengl_glext.h:1776
SDL_AudioDriverImpl::OpenDevice
int(* OpenDevice)(_THIS, void *handle, const char *devname, int iscapture)
Definition: SDL_sysaudio.h:68
SDL_AudioStreamGet
#define SDL_AudioStreamGet
Definition: SDL_dynapi_overrides.h:645
SDL_CreateMutex
#define SDL_CreateMutex
Definition: SDL_dynapi_overrides.h:259
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
format_list
static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]
Definition: SDL_audio.c:1615
SDL_AudioSpec
Definition: SDL_audio.h:179
SDL_AudioDriverImpl::PrepareToClose
void(* PrepareToClose)(_THIS)
Definition: SDL_sysaudio.h:78
callback
static Uint32 callback(Uint32 interval, void *param)
Definition: testtimer.c:34
SDL_WriteToDataQueue
int SDL_WriteToDataQueue(SDL_DataQueue *queue, const void *_data, const size_t _len)
Definition: SDL_dataqueue.c:175
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDL_ENABLE
#define SDL_ENABLE
Definition: SDL_events.h:756
SDL_AudioStatus
SDL_AudioStatus
Definition: SDL_audio.h:396
index
GLuint index
Definition: SDL_opengl_glext.h:660
x1
GLuint GLfloat GLfloat GLfloat x1
Definition: SDL_opengl_glext.h:8583
SDL_AudioDevice::iscapture
SDL_bool iscapture
Definition: SDL_sysaudio.h:151
SDL_AudioDriver::name
const char * name
Definition: SDL_sysaudio.h:112
SDL_NextAudioFormat
SDL_AudioFormat SDL_NextAudioFormat(void)
Definition: SDL_audio.c:1651
SDL_OpenedAudioDeviceDisconnected
void SDL_OpenedAudioDeviceDisconnected(SDL_AudioDevice *device)
Definition: SDL_audio.c:490
SDL_AUDIO_ALLOW_CHANNELS_CHANGE
#define SDL_AUDIO_ALLOW_CHANNELS_CHANGE
Definition: SDL_audio.h:142
SDL_AUDIODEVICEADDED
@ SDL_AUDIODEVICEADDED
Definition: SDL_events.h:147
SDL_InitSubSystem
#define SDL_InitSubSystem
Definition: SDL_dynapi_overrides.h:55
SDL_RunAudio
static int SDL_RunAudio(void *devicep)
Definition: SDL_audio.c:688
SDL_AudioDriver::desc
const char * desc
Definition: SDL_sysaudio.h:116
FILL_STUB
#define FILL_STUB(x)
SDL_AudioDriver::outputDeviceCount
int outputDeviceCount
Definition: SDL_sysaudio.h:124
SDL_AudioDriverImpl::FreeDeviceHandle
void(* FreeDeviceHandle)(void *handle)
Definition: SDL_sysaudio.h:82
AudioBootStrap
Definition: SDL_sysaudio.h:178
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
SDL_AUDIOBUFFERQUEUE_PACKETLEN
#define SDL_AUDIOBUFFERQUEUE_PACKETLEN
Definition: SDL_sysaudio.h:63
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:118
SDL_AUDIO_PAUSED
@ SDL_AUDIO_PAUSED
Definition: SDL_audio.h:399
SDL_strncasecmp
#define SDL_strncasecmp
Definition: SDL_dynapi_overrides.h:420
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1737
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDL_AudioDriverImpl::WaitDevice
void(* WaitDevice)(_THIS)
Definition: SDL_sysaudio.h:72
len
GLenum GLsizei len
Definition: SDL_opengl_glext.h:2926
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:387
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDL_AudioDeviceItem::name
char * name
Definition: SDL_sysaudio.h:101
S32
#define S32
AUDIO_F32MSB
#define AUDIO_F32MSB
Definition: SDL_audio.h:113
AudioBootStrap::init
int(* init)(SDL_AudioDriverImpl *impl)
Definition: SDL_sysaudio.h:181
retval
SDL_bool retval
Definition: testgamecontroller.c:65
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
SDL_GetEventState
#define SDL_GetEventState(type)
Definition: SDL_events.h:769
SDL_CreateThreadInternal
SDL_Thread * SDL_CreateThreadInternal(int(*fn)(void *), const char *name, const size_t stacksize, void *data)
Definition: SDL_thread.c:429
SDL_AUDIO_STOPPED
@ SDL_AUDIO_STOPPED
Definition: SDL_audio.h:397
SDL_AUDIO_ALLOW_SAMPLES_CHANGE
#define SDL_AUDIO_ALLOW_SAMPLES_CHANGE
Definition: SDL_audio.h:143
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
SDL_AudioDeviceItem::original_name
char * original_name
Definition: SDL_sysaudio.h:102
SDL_AudioQuit
void SDL_AudioQuit(void)
Definition: SDL_audio.c:1582
SDL_PushEvent
#define SDL_PushEvent
Definition: SDL_dynapi_overrides.h:125
SDL_AUDIO_ALLOW_ANY_CHANGE
#define SDL_AUDIO_ALLOW_ANY_CHANGE
Definition: SDL_audio.h:144
SDL_AudioDriverImpl::OnlyHasDefaultOutputDevice
int OnlyHasDefaultOutputDevice
Definition: SDL_sysaudio.h:92
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
prepare_audiospec
static int prepare_audiospec(const SDL_AudioSpec *orig, SDL_AudioSpec *prepared)
Definition: SDL_audio.c:1150
SDL_GetAudioDeviceStatus
SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1498
SDL_AudioDriverImpl::LockDevice
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
SDL_AudioDriverImpl::ThreadDeinit
void(* ThreadDeinit)(_THIS)
Definition: SDL_sysaudio.h:70
NUM_FORMATS
#define NUM_FORMATS
Definition: SDL_audio.c:1612
SDL_CalculateAudioSpec
void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
Definition: SDL_audio.c:1660
SDL_AudioLockOrUnlockDeviceWithNoMixerLock
static void SDL_AudioLockOrUnlockDeviceWithNoMixerLock(SDL_AudioDevice *device)
Definition: SDL_audio.c:329
SDL_AudioDriverImpl::DetectDevices
void(* DetectDevices)(void)
Definition: SDL_sysaudio.h:67
SDL_AudioStreamPut
#define SDL_AudioStreamPut
Definition: SDL_dynapi_overrides.h:644
SDL_AUDIO_BITSIZE
#define SDL_AUDIO_BITSIZE(x)
Definition: SDL_audio.h:75
AUDIO_F32LSB
#define AUDIO_F32LSB
Definition: SDL_audio.h:112
SDL_AudioDriverImpl::PlayDevice
void(* PlayDevice)(_THIS)
Definition: SDL_sysaudio.h:73
SDL_AudioDeviceItem
Definition: SDL_sysaudio.h:99
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
add_audio_device
static int add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:378
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:486
SDL_AudioSpec::freq
int freq
Definition: SDL_audio.h:180
SDL_AudioDriverImpl::BeginLoopIteration
void(* BeginLoopIteration)(_THIS)
Definition: SDL_sysaudio.h:71
SDL_AudioDriverImpl::OnlyHasDefaultCaptureDevice
int OnlyHasDefaultCaptureDevice
Definition: SDL_sysaudio.h:93
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_AudioSpec::silence
Uint8 silence
Definition: SDL_audio.h:183
SDL_UnlockAudioDevice
void SDL_UnlockAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1554
bootstrap
static const AudioBootStrap *const bootstrap[]
Definition: SDL_audio.c:37
AUDIO_S32LSB
#define AUDIO_S32LSB
Definition: SDL_audio.h:103
SDL_AudioDriverImpl::AllowsArbitraryDeviceNames
int AllowsArbitraryDeviceNames
Definition: SDL_sysaudio.h:94
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_ReadFromDataQueue
size_t SDL_ReadFromDataQueue(SDL_DataQueue *queue, void *_buf, const size_t _len)
Definition: SDL_dataqueue.c:254
SDL_AudioDeviceItem::handle
void * handle
Definition: SDL_sysaudio.h:100
SDL_AudioDriverImpl::ThreadInit
void(* ThreadInit)(_THIS)
Definition: SDL_sysaudio.h:69
SDL_AudioDriver::inputDeviceCount
int inputDeviceCount
Definition: SDL_sysaudio.h:125
spec
SDL_AudioSpec spec
Definition: loopwave.c:31
SDL_BufferQueueFillCallback
static void SDL_BufferQueueFillCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:586
id
GLuint id
Definition: SDL_opengl_glext.h:528
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)
Definition: SDL_audio.c:1208
SDL_AudioDriverImpl::CaptureFromDevice
int(* CaptureFromDevice)(_THIS, void *buffer, int buflen)
Definition: SDL_sysaudio.h:76
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_atoi
#define SDL_atoi
Definition: SDL_dynapi_overrides.h:410
add_capture_device
static SDL_INLINE int add_capture_device(const char *name, void *handle)
Definition: SDL_audio.c:438
SDL_AudioSpec::size
Uint32 size
Definition: SDL_audio.h:186
SDL_BufferQueueDrainCallback
static void SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.c:565
src
GLenum src
Definition: SDL_opengl_glext.h:1737
SDL_getenv
#define SDL_getenv
Definition: SDL_dynapi_overrides.h:378
AudioBootStrap::desc
const char * desc
Definition: SDL_sysaudio.h:180
SDL_AudioStreamClear
#define SDL_AudioStreamClear
Definition: SDL_dynapi_overrides.h:646
AUDIO_S16
#define AUDIO_S16
Definition: SDL_audio.h:96
x2
GLfixed GLfixed x2
Definition: SDL_opengl_glext.h:4583
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:30
free_device_list
static void free_device_list(SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:451
SDL_AUDIO_PLAYING
@ SDL_AUDIO_PLAYING
Definition: SDL_audio.h:398
SDL_snprintf
#define SDL_snprintf
Definition: SDL_dynapi_overrides.h:40
SDL_NewAudioStream
#define SDL_NewAudioStream
Definition: SDL_dynapi_overrides.h:643
SDL_ClearDataQueue
void SDL_ClearDataQueue(SDL_DataQueue *queue, const size_t slack)
Definition: SDL_dataqueue.c:98
SDL_AudioDriverImpl::GetDeviceBuf
Uint8 *(* GetDeviceBuf)(_THIS)
Definition: SDL_sysaudio.h:75
SDL_DestroyMutex
#define SDL_DestroyMutex
Definition: SDL_dynapi_overrides.h:263
AUDIO_S16MSB
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
SDL_AudioDeviceID
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:330
SDL_AudioDriver::inputDevices
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:127
AudioBootStrap::name
const char * name
Definition: SDL_sysaudio.h:179
SDL_strdup
#define SDL_strdup
Definition: SDL_dynapi_overrides.h:397
SDL_strlen
#define SDL_strlen
Definition: SDL_dynapi_overrides.h:393
SDL_CloseAudioDevice
void SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1570
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:162
AUDIO_S16LSB
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
SDL_Event
General event structure.
Definition: SDL_events.h:558
AUDIO_S8
#define AUDIO_S8
Definition: SDL_audio.h:90
SDL_AudioDriver::outputDevicesRemoved
SDL_bool outputDevicesRemoved
Definition: SDL_sysaudio.h:123
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
SDL_Unsupported
#define SDL_Unsupported()
Definition: SDL_error.h:53
SDL_AUDIO_ALLOW_FORMAT_CHANGE
#define SDL_AUDIO_ALLOW_FORMAT_CHANGE
Definition: SDL_audio.h:141
SDL_AtomicSet
#define SDL_AtomicSet
Definition: SDL_dynapi_overrides.h:67
SDL_FreeAudioStream
#define SDL_FreeAudioStream
Definition: SDL_dynapi_overrides.h:648
SDL_ParseAudioFormat
static SDL_AudioFormat SDL_ParseAudioFormat(const char *string)
Definition: SDL_audio.c:891
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
SDL_AtomicGet
#define SDL_AtomicGet
Definition: SDL_dynapi_overrides.h:68
SDL_AUDIODEVICEREMOVED
@ SDL_AUDIODEVICEREMOVED
Definition: SDL_events.h:148
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
SDL_AudioCallback
void(* SDL_AudioCallback)(void *userdata, Uint8 *stream, int len)
Definition: SDL_audio.h:163
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:262
SDL_WasInit
#define SDL_WasInit
Definition: SDL_dynapi_overrides.h:57
device
static SDL_AudioDeviceID device
Definition: loopwave.c:37
SDL_AudioDriver::outputDevices
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:126
SDL_AudioDriverImpl::CloseDevice
void(* CloseDevice)(_THIS)
Definition: SDL_sysaudio.h:79
AUDIO_U16MSB
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
i
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
SDL_ThreadID
#define SDL_ThreadID
Definition: SDL_dynapi_overrides.h:475
SDL_AddAudioDevice
void SDL_AddAudioDevice(const int iscapture, const char *name, void *handle)
Definition: SDL_audio.c:473
close_audio_device
static void close_audio_device(SDL_AudioDevice *device)
Definition: SDL_audio.c:1102
SDL_WaitThread
#define SDL_WaitThread
Definition: SDL_dynapi_overrides.h:478
open_devices
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
CHECK_FMT_STRING
#define CHECK_FMT_STRING(x)
SDL_LockAudioDevice
void SDL_LockAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1538
SDL_AudioDevice
Definition: SDL_sysaudio.h:133
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:121
SDL_AudioDriverImpl::Deinitialize
void(* Deinitialize)(void)
Definition: SDL_sysaudio.h:83
SDL_PauseAudioDevice
void SDL_PauseAudioDevice(SDL_AudioDeviceID devid, int pause_on)
Definition: SDL_audio.c:1520
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:197
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:78
SDL_FreeResampleFilter
void SDL_FreeResampleFilter(void)
Definition: SDL_audiocvt.c:464
is_in_audio_device_thread
static SDL_INLINE SDL_bool is_in_audio_device_thread(SDL_AudioDevice *device)
Definition: SDL_audio.c:299
AudioBootStrap::demand_only
int demand_only
Definition: SDL_sysaudio.h:182