SDL_audio.c File Reference
`#include "../SDL_internal.h"`
`#include "SDL.h"`
`#include "SDL_audio.h"`
`#include "SDL_audio_c.h"`
`#include "SDL_audiomem.h"`
`#include "SDL_sysaudio.h"`
Include dependency graph for SDL_audio.c:

Go to the source code of this file.

## Macros

#define | _THIS SDL_AudioDevice *_this
#define | DEFAULT_OUTPUT_DEVNAME "System audio output device"
#define | DEFAULT_INPUT_DEVNAME "System audio capture device"
#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_AudioDevice * | get_audio_device (SDL_AudioDeviceID id)
static void | SDL_AudioDetectDevices_Default (void)
static void | SDL_AudioThreadInit_Default (_THIS)
static void | SDL_AudioWaitDevice_Default (_THIS)
static void | SDL_AudioPlayDevice_Default (_THIS)
static int | SDL_AudioGetPendingBytes_Default (_THIS)
static Uint8 * | SDL_AudioGetDeviceBuf_Default (_THIS)
static void | SDL_AudioWaitDone_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 | finalize_audio_entry_points (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 | free_audio_queue (SDL_AudioBufferQueue *buffer)
static void | SDL_BufferQueueDrainCallback (void *userdata, Uint8 *stream, int _len)
int | SDL_QueueAudio (SDL_AudioDeviceID devid, const void *_data, Uint32 len)
Uint32 | SDL_GetQueuedAudioSize (SDL_AudioDeviceID devid)
void | SDL_ClearQueuedAudio (SDL_AudioDeviceID devid)
int | SDL_RunAudio (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_AudioDevice * | open_devices [16]
AudioBootStrap | BSD_AUDIO_bootstrap
AudioBootStrap | DSP_bootstrap
AudioBootStrap | ALSA_bootstrap
AudioBootStrap | PULSEAUDIO_bootstrap
AudioBootStrap | QSAAUDIO_bootstrap
AudioBootStrap | SUNAUDIO_bootstrap
AudioBootStrap | ARTS_bootstrap
AudioBootStrap | ESD_bootstrap
AudioBootStrap | NACLAUD_bootstrap
AudioBootStrap | NAS_bootstrap
AudioBootStrap | XAUDIO2_bootstrap
AudioBootStrap | DSOUND_bootstrap
AudioBootStrap | WINMM_bootstrap
AudioBootStrap | PAUDIO_bootstrap
AudioBootStrap | HAIKUAUDIO_bootstrap
AudioBootStrap | COREAUDIO_bootstrap
AudioBootStrap | SNDMGR_bootstrap
AudioBootStrap | DISKAUD_bootstrap
AudioBootStrap | DUMMYAUD_bootstrap
AudioBootStrap | DCAUD_bootstrap
AudioBootStrap | DART_bootstrap
AudioBootStrap | NDSAUD_bootstrap
AudioBootStrap | FUSIONSOUND_bootstrap
AudioBootStrap | ANDROIDAUD_bootstrap
AudioBootStrap | PSPAUD_bootstrap
AudioBootStrap | SNDIO_bootstrap
AudioBootStrap | EmscriptenAudio_bootstrap
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

#define _THIS SDL_AudioDevice *_this

Definition at line 31 of file SDL_audio.c.

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

Referenced by SDL_ParseAudioFormat().

#define DEFAULT_INPUT_DEVNAME "System audio capture device"

Definition at line 38 of file SDL_audio.c.

Referenced by open_audio_device(), and SDL_AudioDetectDevices_Default().

#define DEFAULT_OUTPUT_DEVNAME "System audio output device"

Definition at line 37 of file SDL_audio.c.

Referenced by open_audio_device(), and SDL_AudioDetectDevices_Default().

#define FILL_STUB | ( |  | x | ) |

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

Referenced by finalize_audio_entry_points().

#define NUM_FORMATS 10

Definition at line 1371 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

## Function Documentation

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

static

Definition at line 293 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().

{
int retval = -1;
const size_t size = sizeof (SDL_AudioDeviceItem) + SDL_strlen(name) + 1;
SDL_AudioDeviceItem *item = (SDL_AudioDeviceItem *) SDL_malloc(size);
if (item == NULL) {
return -1;
}
SDL_assert(handle != NULL); /* we reserve NULL, audio backends can't use it. */
item->handle = handle;
SDL_strlcpy(item->name, name, size - sizeof (SDL_AudioDeviceItem));
SDL_LockMutex(current_audio.detectionLock);
item->next = *devices;
*devices = item;
retval = (*devCount)++;
SDL_UnlockMutex(current_audio.detectionLock);
return retval;
}
SDL_strlcpy
#define SDL_strlcpy
Definition: SDL_dynapi_overrides.h:400
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:266
SDL_AudioDeviceItem
Definition: SDL_sysaudio.h:98
SDL_AudioDeviceItem::next
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:101
SDL_AudioDeviceItem::name
char name[]
Definition: SDL_sysaudio.h:105
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDeviceItem::handle
void * handle
Definition: SDL_sysaudio.h:100
size
GLsizeiptr size
Definition: SDL_opengl_glext.h:537
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:123
retval
SDL_bool retval
Definition: testgamecontroller.c:65
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
NULL
#define NULL
Definition: begin_code.h:143
SDL_strlen
#define SDL_strlen
Definition: SDL_dynapi_overrides.h:399
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:268
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:380

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

static

Definition at line 317 of file SDL_audio.c.

References add_audio_device(), SDL_AudioDriver::inputDeviceCount, SDL_AudioDriver::inputDevices, and SDL_INLINE.

Referenced by SDL_AddAudioDevice().

{
/* !!! FIXME: add this later. SDL_assert(current_audio.impl.HasCaptureSupport);*/
return add_audio_device(name, handle, &current_audio.inputDevices, &current_audio.inputDeviceCount);
}
SDL_AudioDriver::inputDeviceCount
int inputDeviceCount
Definition: SDL_sysaudio.h:127
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
add_audio_device
static int add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:293
SDL_AudioDriver::inputDevices
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:129

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

static

Definition at line 324 of file SDL_audio.c.

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

Referenced by SDL_AddAudioDevice().

{
return add_audio_device(name, handle, &current_audio.outputDevices, &current_audio.outputDeviceCount);
}
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
add_audio_device
static int add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:293
SDL_AudioDriver::outputDevices
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:128
SDL_AudioDriver::outputDeviceCount
int outputDeviceCount
Definition: SDL_sysaudio.h:126

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

static

Definition at line 779 of file SDL_audio.c.

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

Referenced by SDL_GetNumAudioDevices().

{
SDL_AudioDeviceItem *item = *devices;
SDL_AudioDeviceItem *prev = NULL;
int total = 0;
while (item) {
SDL_AudioDeviceItem *next = item->next;
if (item->handle != NULL) {
total++;
prev = item;
} else {
if (prev) {
prev->next = next;
} else {
*devices = next;
}
SDL_free(item);
}
item = next;
}
*devCount = total;
*removedFlag = SDL_FALSE;
}
SDL_AudioDeviceItem
Definition: SDL_sysaudio.h:98
SDL_AudioDeviceItem::next
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:101
SDL_AudioDeviceItem::handle
void * handle
Definition: SDL_sysaudio.h:100
SDL_free
void SDL_free(void *mem)
NULL
#define NULL
Definition: begin_code.h:143
SDL_FALSE
Definition: SDL_stdinc.h:128

static void close_audio_device | ( | SDL_AudioDevice * | device | ) |

static

Definition at line 873 of file SDL_audio.c.

References SDL_AudioCVT::buf, SDL_AudioDevice::buffer_queue_head, SDL_AudioDevice::buffer_queue_pool, SDL_AudioDriverImpl::CloseDevice, SDL_AudioDevice::convert, SDL_AudioDevice::enabled, SDL_AudioDevice::fake_stream, free_audio_queue(), SDL_AudioDriver::impl, SDL_AudioDevice::mixer_lock, SDL_AudioCVT::needed, NULL, SDL_AudioDevice::opened, SDL_DestroyMutex, SDL_FreeAudioMem, SDL_WaitThread, SDL_AudioDevice::shutdown, and SDL_AudioDevice::thread.

Referenced by open_audio_device(), and SDL_CloseAudioDevice().

{
device->enabled = 0;
device->shutdown = 1;
if (device->thread != NULL) {
SDL_WaitThread(device->thread, NULL);
}
if (device->mixer_lock != NULL) {
SDL_DestroyMutex(device->mixer_lock);
}
SDL_FreeAudioMem(device->fake_stream);
if (device->convert.needed) {
SDL_FreeAudioMem(device->convert.buf);
}
if (device->opened) {
current_audio.impl.CloseDevice(device);
device->opened = 0;
}
free_audio_queue(device->buffer_queue_head);
free_audio_queue(device->buffer_queue_pool);
SDL_FreeAudioMem(device);
}
SDL_AudioDevice::mixer_lock
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:171
SDL_AudioCVT::buf
Uint8 * buf
Definition: SDL_audio.h:206
SDL_FreeAudioMem
#define SDL_FreeAudioMem
Definition: SDL_audiomem.h:24
SDL_AudioDevice::opened
int opened
Definition: SDL_sysaudio.h:165
SDL_AudioDevice::shutdown
int shutdown
Definition: SDL_sysaudio.h:163
SDL_AudioDevice::buffer_queue_pool
SDL_AudioBufferQueue * buffer_queue_pool
Definition: SDL_sysaudio.h:180
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDevice::buffer_queue_head
SDL_AudioBufferQueue * buffer_queue_head
Definition: SDL_sysaudio.h:178
SDL_AudioCVT::needed
int needed
Definition: SDL_audio.h:202
SDL_AudioDevice::fake_stream
Uint8 * fake_stream
Definition: SDL_sysaudio.h:168
NULL
#define NULL
Definition: begin_code.h:143
free_audio_queue
static void free_audio_queue(SDL_AudioBufferQueue *buffer)
Definition: SDL_audio.c:423
SDL_AudioDriverImpl::CloseDevice
void(* CloseDevice)(_THIS)
Definition: SDL_sysaudio.h:79
SDL_DestroyMutex
#define SDL_DestroyMutex
Definition: SDL_dynapi_overrides.h:269
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice::thread
SDL_Thread * thread
Definition: SDL_sysaudio.h:174
SDL_AudioDevice::enabled
int enabled
Definition: SDL_sysaudio.h:162
SDL_AudioDevice::convert
SDL_AudioCVT convert
Definition: SDL_sysaudio.h:153
SDL_WaitThread
#define SDL_WaitThread
Definition: SDL_dynapi_overrides.h:482

static void finalize_audio_entry_points | ( | void |  | ) |

static

Definition at line 262 of file SDL_audio.c.

References FILL_STUB.

Referenced by SDL_AudioInit().

{
/*
* Fill in stub functions for unused driver entry points. This lets us
* blindly call them without having to check for validity first.
*/
#define FILL_STUB(x) \
if (current_audio.impl.x == NULL) { \
current_audio.impl.x = SDL_Audio##x##_Default; \
}
FILL_STUB(DetectDevices);
FILL_STUB(OpenDevice);
FILL_STUB(ThreadInit);
FILL_STUB(WaitDevice);
FILL_STUB(PlayDevice);
FILL_STUB(GetPendingBytes);
FILL_STUB(GetDeviceBuf);
FILL_STUB(WaitDone);
FILL_STUB(CloseDevice);
FILL_STUB(LockDevice);
FILL_STUB(UnlockDevice);
FILL_STUB(FreeDeviceHandle);
FILL_STUB(Deinitialize);
#undef FILL_STUB
}
FILL_STUB
#define FILL_STUB(x)

static void free_audio_queue | ( | SDL_AudioBufferQueue * | buffer | ) |

static

Definition at line 423 of file SDL_audio.c.

References SDL_AudioBufferQueue::next, SDL_free(), and SDLCALL.

Referenced by close_audio_device(), SDL_ClearQueuedAudio(), and SDL_QueueAudio().

{
while (buffer) {
SDL_AudioBufferQueue *next = buffer->next;
SDL_free(buffer);
buffer = next;
}
}
SDL_AudioBufferQueue
Definition: SDL_sysaudio.h:61
SDL_AudioBufferQueue::next
struct SDL_AudioBufferQueue * next
Definition: SDL_sysaudio.h:66
SDL_free
void SDL_free(void *mem)

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

static

Definition at line 330 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().

{
SDL_AudioDeviceItem *item, *next;
for (item = *devices; item != NULL; item = next) {
next = item->next;
if (item->handle != NULL) {
current_audio.impl.FreeDeviceHandle(item->handle);
}
SDL_free(item);
}
*devices = NULL;
*devCount = 0;
}
SDL_AudioDeviceItem
Definition: SDL_sysaudio.h:98
SDL_AudioDeviceItem::next
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:101
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDeviceItem::handle
void * handle
Definition: SDL_sysaudio.h:100
SDL_free
void SDL_free(void *mem)
NULL
#define NULL
Definition: begin_code.h:143
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDriverImpl::FreeDeviceHandle
void(* FreeDeviceHandle)(void *handle)
Definition: SDL_sysaudio.h:82

static SDL_AudioDevice* get_audio_device | ( | SDL_AudioDeviceID | id | ) |

static

Definition at line 150 of file SDL_audio.c.

References NULL, SDL_arraysize, and SDL_SetError.

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

{
id--;
if ((id >= SDL_arraysize(open_devices)) || (open_devices[id] == NULL)) {
SDL_SetError("Invalid audio device ID");
return NULL;
}
return open_devices[id];
}
open_devices
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
id
GLuint id
Definition: SDL_opengl_glext.h:528
NULL
#define NULL
Definition: begin_code.h:143
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93

static SDL_INLINE SDL_bool is_in_audio_device_thread | ( | SDL_AudioDevice * | device | ) |

static

Definition at line 231 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().

{
/* The device thread locks the same mutex, but not through the public API.
This check is in case the application, in the audio callback,
tries to lock the thread that we've already locked from the
device thread...just in case we only have non-recursive mutexes. */
if (device->thread && (SDL_ThreadID() == device->threadid)) {
return SDL_TRUE;
}
return SDL_FALSE;
}
SDL_ThreadID
#define SDL_ThreadID
Definition: SDL_dynapi_overrides.h:479
SDL_AudioDevice::threadid
SDL_threadID threadid
Definition: SDL_sysaudio.h:175
SDL_TRUE
Definition: SDL_stdinc.h:129
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_AudioDevice::thread
SDL_Thread * thread
Definition: SDL_sysaudio.h:174

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

static

Definition at line 390 of file SDL_audio.c.

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

Referenced by SDL_RemoveAudioDevice().

{
SDL_AudioDeviceItem *item;
SDL_assert(handle != NULL);
for (item = devices; item != NULL; item = item->next) {
if (item->handle == handle) {
item->handle = NULL;
*removedFlag = SDL_TRUE;
return;
}
}
}
SDL_AudioDeviceItem
Definition: SDL_sysaudio.h:98
SDL_AudioDeviceItem::next
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:101
SDL_AudioDeviceItem::handle
void * handle
Definition: SDL_sysaudio.h:100
SDL_TRUE
Definition: SDL_stdinc.h:129
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
NULL
#define NULL
Definition: begin_code.h:143

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

References SDL_AudioDriverImpl::AllowsArbitraryDeviceNames, SDL_AudioCVT::buf, SDL_AudioDevice::buffer_queue_pool, SDL_AudioSpec::callback, SDL_AudioSpec::channels, close_audio_device(), SDL_AudioDevice::convert, SDL_AudioBufferQueue::datalen, DEFAULT_INPUT_DEVNAME, DEFAULT_OUTPUT_DEVNAME, SDL_AudioDriver::detectionLock, SDL_AudioDevice::enabled, SDL_AudioDevice::fake_stream, SDL_AudioSpec::format, SDL_AudioSpec::freq, SDL_AudioDeviceItem::handle, SDL_AudioDriverImpl::HasCaptureSupport, i, SDL_AudioDevice::id, SDL_AudioDriver::impl, SDL_AudioDriver::inputDevices, SDL_AudioDevice::iscapture, SDL_AudioCVT::len, SDL_AudioCVT::len_cvt, SDL_AudioCVT::len_mult, SDL_AudioCVT::len_ratio, SDL_AudioDevice::mixer_lock, SDL_AudioDeviceItem::name, SDL_AudioCVT::needed, SDL_AudioBufferQueue::next, SDL_AudioDeviceItem::next, NULL, SDL_AudioDriverImpl::OnlyHasDefaultInputDevice, SDL_AudioDriverImpl::OnlyHasDefaultOutputDevice, SDL_AudioDriverImpl::OpenDevice, SDL_AudioDevice::opened, SDL_AudioDriver::outputDevices, SDL_AudioDevice::paused, prepare_audiospec(), SDL_AudioDriverImpl::ProvidesOwnCallbackThread, SDL_AudioSpec::samples, SDL_AllocAudioMem, SDL_arraysize, SDL_assert, SDL_AUDIO_ALLOW_CHANNELS_CHANGE, SDL_AUDIO_ALLOW_FORMAT_CHANGE, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE, SDL_AUDIOBUFFERQUEUE_PACKETLEN, SDL_BufferQueueDrainCallback(), SDL_BuildAudioCVT, SDL_CalculateAudioSpec(), SDL_CloseAudioDevice(), SDL_CreateMutex, SDL_CreateThread, SDL_FALSE, SDL_getenv, SDL_INIT_AUDIO, SDL_LockMutex, SDL_malloc, SDL_OutOfMemory, SDL_RunAudio(), SDL_SetError, SDL_snprintf, SDL_strcmp, SDL_TRUE, SDL_UnlockMutex, SDL_WasInit, SDL_zerop, SDL_AudioSpec::size, SDL_AudioDriverImpl::SkipMixerLock, SDL_AudioDevice::spec, SDL_AudioBufferQueue::startpos, SDL_AudioDevice::thread, and SDL_AudioSpec::userdata.

Referenced by SDL_OpenAudio(), and SDL_OpenAudioDevice().

{
SDL_AudioDeviceID id = 0;
SDL_AudioSpec _obtained;
SDL_AudioDevice *device;
SDL_bool build_cvt;
void *handle = NULL;
Uint32 stream_len;
int i = 0;
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_SetError("Audio subsystem is not initialized");
return 0;
}
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
SDL_SetError("No capture support");
return 0;
}
/* Find an available device ID... */
for (id = min_id - 1; id < SDL_arraysize(open_devices); id++) {
if (open_devices[id] == NULL) {
break;
}
}
if (id == SDL_arraysize(open_devices)) {
SDL_SetError("Too many open audio devices");
return 0;
}
if (!obtained) {
obtained = &_obtained;
}
if (!prepare_audiospec(desired, obtained)) {
return 0;
}
/* If app doesn't care about a specific device, let the user override. */
if (devname == NULL) {
devname = SDL_getenv("SDL_AUDIO_DEVICE_NAME");
}
/*
* Catch device names at the high level for the simple case...
* This lets us have a basic "device enumeration" for systems that
* don't have multiple devices, but makes sure the device name is
* always NULL when it hits the low level.
*
* Also make sure that the simple case prevents multiple simultaneous
* opens of the default system device.
*/
if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
if ((devname) && (SDL_strcmp(devname, DEFAULT_INPUT_DEVNAME) != 0)) {
SDL_SetError("No such device");
return 0;
}
devname = NULL;
for (i = 0; i < SDL_arraysize(open_devices); i++) {
if ((open_devices[i]) && (open_devices[i]->iscapture)) {
SDL_SetError("Audio device already open");
return 0;
}
}
} else if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
if ((devname) && (SDL_strcmp(devname, DEFAULT_OUTPUT_DEVNAME) != 0)) {
SDL_SetError("No such device");
return 0;
}
devname = NULL;
for (i = 0; i < SDL_arraysize(open_devices); i++) {
if ((open_devices[i]) && (!open_devices[i]->iscapture)) {
SDL_SetError("Audio device already open");
return 0;
}
}
} else if (devname != NULL) {
/* if the app specifies an exact string, we can pass the backend
an actual device handle thingey, which saves them the effort of
figuring out what device this was (such as, reenumerating
everything again to find the matching human-readable name).
It might still need to open a device based on the string for,
say, a network audio server, but this optimizes some cases. */
SDL_AudioDeviceItem *item;
SDL_LockMutex(current_audio.detectionLock);
for (item = iscapture ? current_audio.inputDevices : current_audio.outputDevices; item; item = item->next) {
if ((item->handle != NULL) && (SDL_strcmp(item->name, devname) == 0)) {
handle = item->handle;
break;
}
}
SDL_UnlockMutex(current_audio.detectionLock);
}
if (!current_audio.impl.AllowsArbitraryDeviceNames) {
/* has to be in our device list, or the default device. */
if ((handle == NULL) && (devname != NULL)) {
SDL_SetError("No such device.");
return 0;
}
}
device = (SDL_AudioDevice *) SDL_AllocAudioMem(sizeof(SDL_AudioDevice));
if (device == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_zerop(device);
device->id = id + 1;
device->spec = *obtained;
device->enabled = 1;
device->paused = 1;
device->iscapture = iscapture;
/* Create a mutex for locking the sound buffers */
if (!current_audio.impl.SkipMixerLock) {
device->mixer_lock = SDL_CreateMutex();
if (device->mixer_lock == NULL) {
close_audio_device(device);
SDL_SetError("Couldn't create mixer lock");
return 0;
}
}
if (current_audio.impl.OpenDevice(device, handle, devname, iscapture) < 0) {
close_audio_device(device);
return 0;
}
device->opened = 1;
/* See if we need to do any conversion */
build_cvt = SDL_FALSE;
if (obtained->freq != device->spec.freq) {
if (allowed_changes & SDL_AUDIO_ALLOW_FREQUENCY_CHANGE) {
obtained->freq = device->spec.freq;
} else {
build_cvt = SDL_TRUE;
}
}
if (obtained->format != device->spec.format) {
if (allowed_changes & SDL_AUDIO_ALLOW_FORMAT_CHANGE) {
obtained->format = device->spec.format;
} else {
build_cvt = SDL_TRUE;
}
}
if (obtained->channels != device->spec.channels) {
if (allowed_changes & SDL_AUDIO_ALLOW_CHANNELS_CHANGE) {
obtained->channels = device->spec.channels;
} else {
build_cvt = SDL_TRUE;
}
}
/* If the audio driver changes the buffer size, accept it.
This needs to be done after the format is modified above,
otherwise it might not have the correct buffer size.
*/
if (device->spec.samples != obtained->samples) {
obtained->samples = device->spec.samples;
SDL_CalculateAudioSpec(obtained);
}
if (build_cvt) {
/* Build an audio conversion block */
if (SDL_BuildAudioCVT(&device->convert,
obtained->format, obtained->channels,
obtained->freq,
device->spec.format, device->spec.channels,
device->spec.freq) < 0) {
close_audio_device(device);
return 0;
}
if (device->convert.needed) {
device->convert.len = (int) (((double) device->spec.size) /
device->convert.len_ratio);
device->convert.buf =
(Uint8 *) SDL_AllocAudioMem(device->convert.len *
device->convert.len_mult);
if (device->convert.buf == NULL) {
close_audio_device(device);
SDL_OutOfMemory();
return 0;
}
}
}
/* Allocate a fake audio memory buffer */
stream_len = (device->convert.needed) ? device->convert.len_cvt : 0;
if (device->spec.size > stream_len) {
stream_len = device->spec.size;
}
SDL_assert(stream_len > 0);
device->fake_stream = (Uint8 *)SDL_AllocAudioMem(stream_len);
if (device->fake_stream == NULL) {
close_audio_device(device);
SDL_OutOfMemory();
return 0;
}
if (device->spec.callback == NULL) { /* use buffer queueing? */
/* pool a few packets to start. Enough for two callbacks. */
const int packetlen = SDL_AUDIOBUFFERQUEUE_PACKETLEN;
const int wantbytes = ((device->convert.needed) ? device->convert.len : device->spec.size) * 2;
const int wantpackets = (wantbytes / packetlen) + ((wantbytes % packetlen) ? packetlen : 0);
for (i = 0; i < wantpackets; i++) {
SDL_AudioBufferQueue *packet = (SDL_AudioBufferQueue *) SDL_malloc(sizeof (SDL_AudioBufferQueue));
if (packet) { /* don't care if this fails, we'll deal later. */
packet->datalen = 0;
packet->startpos = 0;
packet->next = device->buffer_queue_pool;
device->buffer_queue_pool = packet;
}
}
device->spec.callback = SDL_BufferQueueDrainCallback;
device->spec.userdata = device;
}
/* add it to our list of open devices. */
open_devices[id] = device;
/* Start the audio thread if necessary */
if (!current_audio.impl.ProvidesOwnCallbackThread) {
/* Start the audio thread */
char name[64];
SDL_snprintf(name, sizeof (name), "SDLAudioDev%d", (int) device->id);
/* !!! FIXME: this is nasty. */
#if defined(__WIN32__) && !defined(HAVE_LIBC)
#undef SDL_CreateThread
#if SDL_DYNAMIC_API
device->thread = SDL_CreateThread_REAL(SDL_RunAudio, name, device, NULL, NULL);
#else
device->thread = SDL_CreateThread(SDL_RunAudio, name, device, NULL, NULL);
#endif
#else
device->thread = SDL_CreateThread(SDL_RunAudio, name, device);
#endif
if (device->thread == NULL) {
SDL_CloseAudioDevice(device->id);
SDL_SetError("Couldn't create audio thread");
return 0;
}
}
return device->id;
}
open_devices
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
SDL_AudioDevice::id
SDL_AudioDeviceID id
Definition: SDL_sysaudio.h:147
SDL_AUDIO_ALLOW_FREQUENCY_CHANGE
#define SDL_AUDIO_ALLOW_FREQUENCY_CHANGE
Definition: SDL_audio.h:140
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:266
id
GLuint id
Definition: SDL_opengl_glext.h:528
SDL_AudioBufferQueue::datalen
Uint32 datalen
Definition: SDL_sysaudio.h:64
SDL_AudioDevice::mixer_lock
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:171
SDL_AudioCVT::len
int len
Definition: SDL_audio.h:207
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_AudioCVT::buf
Uint8 * buf
Definition: SDL_audio.h:206
SDL_AudioDeviceItem
Definition: SDL_sysaudio.h:98
SDL_BuildAudioCVT
#define SDL_BuildAudioCVT
Definition: SDL_dynapi_overrides.h:94
SDL_AudioDeviceItem::next
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:101
SDL_CreateMutex
#define SDL_CreateMutex
Definition: SDL_dynapi_overrides.h:265
SDL_AudioDriverImpl::HasCaptureSupport
int HasCaptureSupport
Definition: SDL_sysaudio.h:91
SDL_AudioCVT::len_ratio
double len_ratio
Definition: SDL_audio.h:210
DEFAULT_INPUT_DEVNAME
#define DEFAULT_INPUT_DEVNAME
Definition: SDL_audio.c:38
SDL_AudioDevice::opened
int opened
Definition: SDL_sysaudio.h:165
SDL_AudioDriverImpl::ProvidesOwnCallbackThread
int ProvidesOwnCallbackThread
Definition: SDL_sysaudio.h:89
SDL_AudioSpec
Definition: SDL_audio.h:168
SDL_AudioDevice::buffer_queue_pool
SDL_AudioBufferQueue * buffer_queue_pool
Definition: SDL_sysaudio.h:180
SDL_AudioSpec::samples
Uint16 samples
Definition: SDL_audio.h:174
SDL_AudioDevice::spec
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:150
SDL_AudioDeviceItem::name
char name[]
Definition: SDL_sysaudio.h:105
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
SDL_AudioDevice::iscapture
int iscapture
Definition: SDL_sysaudio.h:161
SDL_AudioCVT::len_mult
int len_mult
Definition: SDL_audio.h:209
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDeviceItem::handle
void * handle
Definition: SDL_sysaudio.h:100
SDL_RunAudio
int SDL_RunAudio(void *devicep)
Definition: SDL_audio.c:595
SDL_zerop
#define SDL_zerop(x)
Definition: SDL_stdinc.h:356
SDL_AUDIO_ALLOW_CHANNELS_CHANGE
#define SDL_AUDIO_ALLOW_CHANNELS_CHANGE
Definition: SDL_audio.h:142
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:123
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:126
DEFAULT_OUTPUT_DEVNAME
#define DEFAULT_OUTPUT_DEVNAME
Definition: SDL_audio.c:37
SDL_AudioBufferQueue
Definition: SDL_sysaudio.h:61
SDL_AudioBufferQueue::next
struct SDL_AudioBufferQueue * next
Definition: SDL_sysaudio.h:66
SDL_AudioDriverImpl::OnlyHasDefaultOutputDevice
int OnlyHasDefaultOutputDevice
Definition: SDL_sysaudio.h:92
SDL_AudioSpec::freq
int freq
Definition: SDL_audio.h:170
SDL_AudioSpec::channels
Uint8 channels
Definition: SDL_audio.h:172
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
prepare_audiospec
static int prepare_audiospec(const SDL_AudioSpec *orig, SDL_AudioSpec *prepared)
Definition: SDL_audio.c:905
SDL_AudioCVT::needed
int needed
Definition: SDL_audio.h:202
SDL_AudioDriverImpl::SkipMixerLock
int SkipMixerLock
Definition: SDL_sysaudio.h:90
SDL_CalculateAudioSpec
void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
Definition: SDL_audio.c:1419
SDL_TRUE
Definition: SDL_stdinc.h:129
SDL_AllocAudioMem
#define SDL_AllocAudioMem
Definition: SDL_audiomem.h:23
SDL_AudioSpec::callback
SDL_AudioCallback callback
Definition: SDL_audio.h:177
SDL_AudioDevice::fake_stream
Uint8 * fake_stream
Definition: SDL_sysaudio.h:168
SDL_CreateThread
#define SDL_CreateThread
Definition: SDL_dynapi_overrides.h:47
SDL_getenv
#define SDL_getenv
Definition: SDL_dynapi_overrides.h:384
SDL_AudioDriver::outputDevices
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:128
SDL_AudioSpec::size
Uint32 size
Definition: SDL_audio.h:176
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:42
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
SDL_AudioCVT::len_cvt
int len_cvt
Definition: SDL_audio.h:208
SDL_AudioDriverImpl::OpenDevice
int(* OpenDevice)(_THIS, void *handle, const char *devname, int iscapture)
Definition: SDL_sysaudio.h:72
NULL
#define NULL
Definition: begin_code.h:143
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_AudioDriverImpl::AllowsArbitraryDeviceNames
int AllowsArbitraryDeviceNames
Definition: SDL_sysaudio.h:94
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:76
SDL_AudioDeviceID
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:303
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioSpec::format
SDL_AudioFormat format
Definition: SDL_audio.h:171
SDL_AudioDevice::paused
int paused
Definition: SDL_sysaudio.h:164
SDL_AudioBufferQueue::startpos
Uint32 startpos
Definition: SDL_sysaudio.h:65
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_AudioSpec::userdata
void * userdata
Definition: SDL_audio.h:178
SDL_AUDIO_ALLOW_FORMAT_CHANGE
#define SDL_AUDIO_ALLOW_FORMAT_CHANGE
Definition: SDL_audio.h:141
SDL_snprintf
#define SDL_snprintf
Definition: SDL_dynapi_overrides.h:46
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:268
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:380
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:423
SDL_AudioDriverImpl::OnlyHasDefaultInputDevice
int OnlyHasDefaultInputDevice
Definition: SDL_sysaudio.h:93
SDL_AudioDevice::thread
SDL_Thread * thread
Definition: SDL_sysaudio.h:174
SDL_WasInit
#define SDL_WasInit
Definition: SDL_dynapi_overrides.h:63
SDL_CloseAudioDevice
void SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1329
SDL_AudioDevice::enabled
int enabled
Definition: SDL_sysaudio.h:162
SDL_AUDIOBUFFERQUEUE_PACKETLEN
#define SDL_AUDIOBUFFERQUEUE_PACKETLEN
Definition: SDL_sysaudio.h:58
SDL_AudioDevice::convert
SDL_AudioCVT convert
Definition: SDL_sysaudio.h:153
SDL_BufferQueueDrainCallback
static void SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int _len)
Definition: SDL_audio.c:433
SDL_AudioDriver::inputDevices
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:129
close_audio_device
static void close_audio_device(SDL_AudioDevice *device)
Definition: SDL_audio.c:873

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

static

Definition at line 905 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().

{
SDL_memcpy(prepared, orig, sizeof(SDL_AudioSpec));
if (orig->freq == 0) {
const char *env = SDL_getenv("SDL_AUDIO_FREQUENCY");
if ((!env) || ((prepared->freq = SDL_atoi(env)) == 0)) {
prepared->freq = 22050; /* a reasonable default */
}
}
if (orig->format == 0) {
const char *env = SDL_getenv("SDL_AUDIO_FORMAT");
if ((!env) || ((prepared->format = SDL_ParseAudioFormat(env)) == 0)) {
prepared->format = AUDIO_S16; /* a reasonable default */
}
}
switch (orig->channels) {
case 0:{
const char *env = SDL_getenv("SDL_AUDIO_CHANNELS");
if ((!env) || ((prepared->channels = (Uint8) SDL_atoi(env)) == 0)) {
prepared->channels = 2; /* a reasonable default */
}
break;
}
case 1: /* Mono */
case 2: /* Stereo */
case 4: /* surround */
case 6: /* surround with center and lfe */
break;
default:
SDL_SetError("Unsupported number of audio channels.");
return 0;
}
if (orig->samples == 0) {
const char *env = SDL_getenv("SDL_AUDIO_SAMPLES");
if ((!env) || ((prepared->samples = (Uint16) SDL_atoi(env)) == 0)) {
/* Pick a default of ~46 ms at desired frequency */
/* !!! FIXME: remove this when the non-Po2 resampling is in. */
const int samples = (prepared->freq / 1000) * 46;
int power2 = 1;
while (power2 < samples) {
power2 *= 2;
}
prepared->samples = power2;
}
}
/* Calculate the silence and size of the audio specification */
SDL_CalculateAudioSpec(prepared);
return 1;
}
SDL_AudioSpec
Definition: SDL_audio.h:168
SDL_AudioSpec::samples
Uint16 samples
Definition: SDL_audio.h:174
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:393
SDL_AudioSpec::freq
int freq
Definition: SDL_audio.h:170
SDL_AudioSpec::channels
Uint8 channels
Definition: SDL_audio.h:172
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_CalculateAudioSpec
void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
Definition: SDL_audio.c:1419
samples
GLsizei samples
Definition: SDL_opengl_glext.h:1185
SDL_atoi
#define SDL_atoi
Definition: SDL_dynapi_overrides.h:416
SDL_getenv
#define SDL_getenv
Definition: SDL_dynapi_overrides.h:384
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_AudioSpec::format
SDL_AudioFormat format
Definition: SDL_audio.h:171
AUDIO_S16
#define AUDIO_S16
Definition: SDL_audio.h:96
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:147
SDL_ParseAudioFormat
static SDL_AudioFormat SDL_ParseAudioFormat(const char *string)
Definition: SDL_audio.c:670

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

Definition at line 347 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().

{
const int device_index = iscapture ? add_capture_device(name, handle) : add_output_device(name, handle);
if (device_index != -1) {
/* Post the event, if desired */
if (SDL_GetEventState(SDL_AUDIODEVICEADDED) == SDL_ENABLE) {
SDL_Event event;
SDL_zero(event);
event.adevice.type = SDL_AUDIODEVICEADDED;
event.adevice.which = device_index;
event.adevice.iscapture = iscapture;
SDL_PushEvent(&event);
}
}
}
add_output_device
static SDL_INLINE int add_output_device(const char *name, void *handle)
Definition: SDL_audio.c:324
SDL_ENABLE
#define SDL_ENABLE
Definition: SDL_events.h:718
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
SDL_AUDIODEVICEADDED
Definition: SDL_events.h:141
SDL_GetEventState
#define SDL_GetEventState(type)
Definition: SDL_events.h:731
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDL_PushEvent
#define SDL_PushEvent
Definition: SDL_dynapi_overrides.h:131
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:355
add_capture_device
static SDL_INLINE int add_capture_device(const char *name, void *handle)
Definition: SDL_audio.c:317
SDL_Event
General event structure.
Definition: SDL_events.h:521

static void SDL_AudioCloseDevice_Default | ( | _THIS |  | ) |

static

Definition at line 209 of file SDL_audio.c.

{ /* no-op. */
}

static void SDL_AudioDeinitialize_Default | ( | void |  | ) |

static

Definition at line 214 of file SDL_audio.c.

{ /* no-op. */
}

static void SDL_AudioDetectDevices_Default | ( | void |  | ) |

static

Definition at line 164 of file SDL_audio.c.

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

{
/* you have to write your own implementation if these assertions fail. */
SDL_assert(current_audio.impl.OnlyHasDefaultOutputDevice);
SDL_assert(current_audio.impl.OnlyHasDefaultInputDevice || !current_audio.impl.HasCaptureSupport);
SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, (void *) ((size_t) 0x1));
if (current_audio.impl.HasCaptureSupport) {
SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, (void *) ((size_t) 0x2));
}
}
x1
GLuint GLfloat GLfloat GLfloat x1
Definition: SDL_opengl_glext.h:8583
SDL_AudioDriverImpl::HasCaptureSupport
int HasCaptureSupport
Definition: SDL_sysaudio.h:91
DEFAULT_INPUT_DEVNAME
#define DEFAULT_INPUT_DEVNAME
Definition: SDL_audio.c:38
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
x2
GLfixed GLfixed x2
Definition: SDL_opengl_glext.h:4583
DEFAULT_OUTPUT_DEVNAME
#define DEFAULT_OUTPUT_DEVNAME
Definition: SDL_audio.c:37
SDL_AudioDriverImpl::OnlyHasDefaultOutputDevice
int OnlyHasDefaultOutputDevice
Definition: SDL_sysaudio.h:92
SDL_TRUE
Definition: SDL_stdinc.h:129
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_AudioDriverImpl::OnlyHasDefaultInputDevice
int OnlyHasDefaultInputDevice
Definition: SDL_sysaudio.h:93
SDL_AddAudioDevice
void SDL_AddAudioDevice(const int iscapture, const char *name, void *handle)
Definition: SDL_audio.c:347

static void SDL_AudioFreeDeviceHandle_Default | ( | void * | handle | ) |

static

Definition at line 219 of file SDL_audio.c.

{ /* no-op. */
}

static Uint8* SDL_AudioGetDeviceBuf_Default | ( | _THIS |  | ) |

static

Definition at line 198 of file SDL_audio.c.

References NULL.

{
return NULL;
}
NULL
#define NULL
Definition: begin_code.h:143

static int SDL_AudioGetPendingBytes_Default | ( | _THIS |  | ) |

static

Definition at line 192 of file SDL_audio.c.

{
return 0;
}

int SDL_AudioInit | ( | const char * | driver_name | ) |

Definition at line 711 of file SDL_audio.c.

References AudioBootStrap::demand_only, SDL_AudioDriver::desc, AudioBootStrap::desc, SDL_AudioDriverImpl::DetectDevices, SDL_AudioDriver::detectionLock, finalize_audio_entry_points(), 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.

{
int i = 0;
int initialized = 0;
int tried_to_init = 0;
if (SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_AudioQuit(); /* shutdown driver if already running. */
}
SDL_zero(current_audio);
SDL_zero(open_devices);
/* Select the proper audio driver */
if (driver_name == NULL) {
driver_name = SDL_getenv("SDL_AUDIODRIVER");
}
for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
/* make sure we should even try this driver before doing so... */
const AudioBootStrap *backend = bootstrap[i];
if ((driver_name && (SDL_strncasecmp(backend->name, driver_name, SDL_strlen(driver_name)) != 0)) ||
(!driver_name && backend->demand_only)) {
continue;
}
tried_to_init = 1;
SDL_zero(current_audio);
current_audio.name = backend->name;
current_audio.desc = backend->desc;
initialized = backend->init(&current_audio.impl);
}
if (!initialized) {
/* specific drivers will set the error message if they fail... */
if (!tried_to_init) {
if (driver_name) {
SDL_SetError("Audio target '%s' not available", driver_name);
} else {
SDL_SetError("No available audio device");
}
}
SDL_zero(current_audio);
return -1; /* No driver was available, so fail. */
}
current_audio.detectionLock = SDL_CreateMutex();
finalize_audio_entry_points();
/* Make sure we have a list of devices available at startup. */
current_audio.impl.DetectDevices();
return 0;
}
open_devices
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
SDL_AudioDriver::name
const char * name
Definition: SDL_sysaudio.h:114
SDL_AudioDriverImpl::DetectDevices
void(* DetectDevices)(void)
Definition: SDL_sysaudio.h:71
AudioBootStrap::name
const char * name
Definition: SDL_sysaudio.h:191
SDL_CreateMutex
#define SDL_CreateMutex
Definition: SDL_dynapi_overrides.h:265
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_strncasecmp
#define SDL_strncasecmp
Definition: SDL_dynapi_overrides.h:426
finalize_audio_entry_points
static void finalize_audio_entry_points(void)
Definition: SDL_audio.c:262
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:123
AudioBootStrap
Definition: SDL_sysaudio.h:189
SDL_AudioDriver::desc
const char * desc
Definition: SDL_sysaudio.h:118
SDL_AudioQuit
void SDL_AudioQuit(void)
Definition: SDL_audio.c:1345
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:355
SDL_getenv
#define SDL_getenv
Definition: SDL_dynapi_overrides.h:384
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:42
bootstrap
static const AudioBootStrap *const bootstrap[]
Definition: SDL_audio.c:76
NULL
#define NULL
Definition: begin_code.h:143
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:76
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_strlen
#define SDL_strlen
Definition: SDL_dynapi_overrides.h:399
AudioBootStrap::demand_only
int demand_only
Definition: SDL_sysaudio.h:194
AudioBootStrap::init
int(* init)(SDL_AudioDriverImpl *impl)
Definition: SDL_sysaudio.h:193
AudioBootStrap::desc
const char * desc
Definition: SDL_sysaudio.h:192
SDL_WasInit
#define SDL_WasInit
Definition: SDL_dynapi_overrides.h:63

static void SDL_AudioLockDevice_Default | ( | SDL_AudioDevice * | device | ) |

static

Definition at line 245 of file SDL_audio.c.

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

{
if (!is_in_audio_device_thread(device)) {
SDL_LockMutex(device->mixer_lock);
}
}
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:266
SDL_AudioDevice::mixer_lock
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:171
is_in_audio_device_thread
static SDL_INLINE SDL_bool is_in_audio_device_thread(SDL_AudioDevice *device)
Definition: SDL_audio.c:231

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

static

Definition at line 225 of file SDL_audio.c.

References SDL_INLINE, and SDL_Unsupported.

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

static void SDL_AudioPlayDevice_Default | ( | _THIS |  | ) |

static

Definition at line 187 of file SDL_audio.c.

{ /* no-op. */
}

void SDL_AudioQuit | ( | void |  | ) |

Definition at line 1345 of file SDL_audio.c.

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

Referenced by SDL_AudioInit().

{
SDL_AudioDeviceID i;
if (!current_audio.name) { /* not initialized?! */
return;
}
for (i = 0; i < SDL_arraysize(open_devices); i++) {
if (open_devices[i] != NULL) {
SDL_CloseAudioDevice(i+1);
}
}
free_device_list(&current_audio.outputDevices, &current_audio.outputDeviceCount);
free_device_list(&current_audio.inputDevices, &current_audio.inputDeviceCount);
/* Free the driver data */
current_audio.impl.Deinitialize();
SDL_DestroyMutex(current_audio.detectionLock);
SDL_zero(current_audio);
SDL_zero(open_devices);
}
open_devices
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
SDL_AudioDriver::name
const char * name
Definition: SDL_sysaudio.h:114
SDL_AudioDriver::inputDeviceCount
int inputDeviceCount
Definition: SDL_sysaudio.h:127
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:123
SDL_AudioDriverImpl::Deinitialize
void(* Deinitialize)(void)
Definition: SDL_sysaudio.h:83
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:355
SDL_AudioDriver::outputDevices
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:128
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:42
NULL
#define NULL
Definition: begin_code.h:143
free_device_list
static void free_device_list(SDL_AudioDeviceItem **devices, int *devCount)
Definition: SDL_audio.c:330
SDL_DestroyMutex
#define SDL_DestroyMutex
Definition: SDL_dynapi_overrides.h:269
SDL_AudioDeviceID
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:303
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDriver::outputDeviceCount
int outputDeviceCount
Definition: SDL_sysaudio.h:126
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
SDL_CloseAudioDevice
void SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1329
SDL_AudioDriver::inputDevices
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:129

static void SDL_AudioThreadInit_Default | ( | _THIS |  | ) |

static

Definition at line 177 of file SDL_audio.c.

{ /* no-op. */
}

static void SDL_AudioUnlockDevice_Default | ( | SDL_AudioDevice * | device | ) |

static

Definition at line 253 of file SDL_audio.c.

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

{
if (!is_in_audio_device_thread(device)) {
SDL_UnlockMutex(device->mixer_lock);
}
}
SDL_AudioDevice::mixer_lock
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:171
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:268
is_in_audio_device_thread
static SDL_INLINE SDL_bool is_in_audio_device_thread(SDL_AudioDevice *device)
Definition: SDL_audio.c:231

static void SDL_AudioWaitDevice_Default | ( | _THIS |  | ) |

static

Definition at line 182 of file SDL_audio.c.

{ /* no-op. */
}

static void SDL_AudioWaitDone_Default | ( | _THIS |  | ) |

static

Definition at line 204 of file SDL_audio.c.

{ /* no-op. */
}

static void SDL_BufferQueueDrainCallback | ( | void * | userdata,
|  | Uint8 * | stream,
|  | int | _len
| ) |  |

static

Definition at line 433 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue_head, SDL_AudioDevice::buffer_queue_pool, SDL_AudioDevice::buffer_queue_tail, SDL_AudioBufferQueue::data, SDL_AudioBufferQueue::datalen, SDL_AudioBufferQueue::next, NULL, SDL_AudioDevice::queued_bytes, SDL_assert, SDL_memcpy, SDL_memset, SDL_min, SDL_AudioSpec::silence, SDL_AudioDevice::spec, and SDL_AudioBufferQueue::startpos.

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

{
/* this function always holds the mixer lock before being called. */
Uint32 len = (Uint32) _len;
SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;
SDL_AudioBufferQueue *buffer;
SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */
SDL_assert(_len >= 0); /* this shouldn't ever happen, right?! */
while ((len > 0) && ((buffer = device->buffer_queue_head) != NULL)) {
const Uint32 avail = buffer->datalen - buffer->startpos;
const Uint32 cpy = SDL_min(len, avail);
SDL_assert(device->queued_bytes >= avail);
SDL_memcpy(stream, buffer->data + buffer->startpos, cpy);
buffer->startpos += cpy;
stream += cpy;
device->queued_bytes -= cpy;
len -= cpy;
if (buffer->startpos == buffer->datalen) { /* packet is done, put it in the pool. */
device->buffer_queue_head = buffer->next;
SDL_assert((buffer->next != NULL) || (buffer == device->buffer_queue_tail));
buffer->next = device->buffer_queue_pool;
device->buffer_queue_pool = buffer;
}
}
SDL_assert((device->buffer_queue_head != NULL) == (device->queued_bytes != 0));
if (len > 0) { /* fill any remaining space in the stream with silence. */
SDL_assert(device->buffer_queue_head == NULL);
SDL_memset(stream, device->spec.silence, len);
}
if (device->buffer_queue_head == NULL) {
device->buffer_queue_tail = NULL; /* in case we drained the queue entirely. */
}
}
SDL_AudioBufferQueue::datalen
Uint32 datalen
Definition: SDL_sysaudio.h:64
SDL_min
#define SDL_min(x, y)
Definition: SDL_stdinc.h:345
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_AudioSpec::silence
Uint8 silence
Definition: SDL_audio.h:173
stream
GLuint GLuint stream
Definition: SDL_opengl_glext.h:1776
SDL_AudioDevice::buffer_queue_pool
SDL_AudioBufferQueue * buffer_queue_pool
Definition: SDL_sysaudio.h:180
SDL_AudioDevice::spec
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:150
len
GLenum GLsizei len
Definition: SDL_opengl_glext.h:2926
SDL_AudioDevice::queued_bytes
Uint32 queued_bytes
Definition: SDL_sysaudio.h:181
SDL_AudioDevice::buffer_queue_head
SDL_AudioBufferQueue * buffer_queue_head
Definition: SDL_sysaudio.h:178
SDL_AudioDevice::buffer_queue_tail
SDL_AudioBufferQueue * buffer_queue_tail
Definition: SDL_sysaudio.h:179
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:393
SDL_AudioBufferQueue
Definition: SDL_sysaudio.h:61
SDL_AudioBufferQueue::next
struct SDL_AudioBufferQueue * next
Definition: SDL_sysaudio.h:66
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
NULL
#define NULL
Definition: begin_code.h:143
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioBufferQueue::startpos
Uint32 startpos
Definition: SDL_sysaudio.h:65
buffer
GLuint buffer
Definition: SDL_opengl_glext.h:533
SDL_AudioBufferQueue::data
Uint8 data[SDL_AUDIOBUFFERQUEUE_PACKETLEN]
Definition: SDL_sysaudio.h:63
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:392

void SDL_CalculateAudioSpec | ( | SDL_AudioSpec * | spec | ) |

Definition at line 1419 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().

{
switch (spec->format) {
case AUDIO_U8:
spec->silence = 0x80;
break;
default:
spec->silence = 0x00;
break;
}
spec->size = SDL_AUDIO_BITSIZE(spec->format) / 8;
spec->size *= spec->channels;
spec->size *= spec->samples;
}
SDL_AudioSpec::silence
Uint8 silence
Definition: SDL_audio.h:173
SDL_AudioSpec::samples
Uint16 samples
Definition: SDL_audio.h:174
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDL_AudioSpec::channels
Uint8 channels
Definition: SDL_audio.h:172
SDL_AUDIO_BITSIZE
#define SDL_AUDIO_BITSIZE(x)
Definition: SDL_audio.h:75
SDL_AudioSpec::size
Uint32 size
Definition: SDL_audio.h:176
SDL_AudioSpec::format
SDL_AudioFormat format
Definition: SDL_audio.h:171

void SDL_ClearQueuedAudio | ( | SDL_AudioDeviceID | dev | ) |

Drop any queued audio data waiting to be sent to the hardware.

Immediately after this call, SDL_GetQueuedAudioSize() will return 0 and the hardware will start playing silence if more audio isn't queued.

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 use the audio callback or queue audio with SDL_QueueAudio(), 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

  dev | The device ID of which to clear the audio queue.

See also
  SDL_QueueAudio
  SDL_GetQueuedAudioSize

Definition at line 573 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue_head, SDL_AudioDevice::buffer_queue_tail, free_audio_queue(), get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, NULL, SDL_AudioDevice::queued_bytes, SDLCALL, and SDL_AudioDriverImpl::UnlockDevice.

{
SDL_AudioDevice *device = get_audio_device(devid);
SDL_AudioBufferQueue *buffer = NULL;
if (!device) {
return; /* nothing to do. */
}
/* Blank out the device and release the mutex. Free it afterwards. */
current_audio.impl.LockDevice(device);
buffer = device->buffer_queue_head;
device->buffer_queue_tail = NULL;
device->buffer_queue_head = NULL;
device->queued_bytes = 0;
current_audio.impl.UnlockDevice(device);
free_audio_queue(buffer);
}
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriverImpl::UnlockDevice
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:81
SDL_AudioDevice::queued_bytes
Uint32 queued_bytes
Definition: SDL_sysaudio.h:181
SDL_AudioDevice::buffer_queue_head
SDL_AudioBufferQueue * buffer_queue_head
Definition: SDL_sysaudio.h:178
SDL_AudioDevice::buffer_queue_tail
SDL_AudioBufferQueue * buffer_queue_tail
Definition: SDL_sysaudio.h:179
SDL_AudioBufferQueue
Definition: SDL_sysaudio.h:61
SDL_AudioDriverImpl::LockDevice
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
NULL
#define NULL
Definition: begin_code.h:143
free_audio_queue
static void free_audio_queue(SDL_AudioBufferQueue *buffer)
Definition: SDL_audio.c:423
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
buffer
GLuint buffer
Definition: SDL_opengl_glext.h:533
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

void SDL_CloseAudio | ( | void |  | ) |

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

Definition at line 1339 of file SDL_audio.c.

References SDL_CloseAudioDevice().

{
SDL_CloseAudioDevice(1);
}
SDL_CloseAudioDevice
void SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1329

void SDL_CloseAudioDevice | ( | SDL_AudioDeviceID | devid | ) |

Definition at line 1329 of file SDL_audio.c.

References close_audio_device(), get_audio_device(), and NULL.

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

{
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
close_audio_device(device);
open_devices[devid - 1] = NULL;
}
}
open_devices
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
NULL
#define NULL
Definition: begin_code.h:143
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150
close_audio_device
static void close_audio_device(SDL_AudioDevice *device)
Definition: SDL_audio.c:873

SDL_AudioFormat SDL_FirstAudioFormat | ( | SDL_AudioFormat | format | ) |

Definition at line 1398 of file SDL_audio.c.

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

{
for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
if (format_list[format_idx][0] == format) {
break;
}
}
format_idx_sub = 0;
return SDL_NextAudioFormat();
}
format_idx_sub
static int format_idx_sub
Definition: SDL_audio.c:1373
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
format_idx
static int format_idx
Definition: SDL_audio.c:1372
format_list
static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]
Definition: SDL_audio.c:1374
SDL_NextAudioFormat
SDL_AudioFormat SDL_NextAudioFormat(void)
Definition: SDL_audio.c:1410
NUM_FORMATS
#define NUM_FORMATS
Definition: SDL_audio.c:1371

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 833 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.

{
const char *retval = NULL;
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_SetError("Audio subsystem is not initialized");
return NULL;
}
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
SDL_SetError("No capture support");
return NULL;
}
if (index >= 0) {
SDL_AudioDeviceItem *item;
int i;
SDL_LockMutex(current_audio.detectionLock);
item = iscapture ? current_audio.inputDevices : current_audio.outputDevices;
i = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
if (index < i) {
for (i--; i > index; i--, item = item->next) {
SDL_assert(item != NULL);
}
SDL_assert(item != NULL);
retval = item->name;
}
SDL_UnlockMutex(current_audio.detectionLock);
}
if (retval == NULL) {
SDL_SetError("No such device");
}
return retval;
}
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:266
SDL_AudioDeviceItem
Definition: SDL_sysaudio.h:98
SDL_AudioDeviceItem::next
struct SDL_AudioDeviceItem * next
Definition: SDL_sysaudio.h:101
SDL_AudioDriverImpl::HasCaptureSupport
int HasCaptureSupport
Definition: SDL_sysaudio.h:91
SDL_AudioDriver::inputDeviceCount
int inputDeviceCount
Definition: SDL_sysaudio.h:127
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:123
retval
SDL_bool retval
Definition: testgamecontroller.c:65
index
GLuint index
Definition: SDL_opengl_glext.h:660
SDL_AudioDriver::outputDevices
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:128
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:42
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
NULL
#define NULL
Definition: begin_code.h:143
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:76
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDriver::outputDeviceCount
int outputDeviceCount
Definition: SDL_sysaudio.h:126
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:268
SDL_WasInit
#define SDL_WasInit
Definition: SDL_dynapi_overrides.h:63
SDL_AudioDriver::inputDevices
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:129

SDL_AudioStatus SDL_GetAudioDeviceStatus | ( | SDL_AudioDeviceID | devid | ) |

Definition at line 1257 of file SDL_audio.c.

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

Referenced by SDL_GetAudioStatus().

{
SDL_AudioDevice *device = get_audio_device(devid);
SDL_AudioStatus status = SDL_AUDIO_STOPPED;
if (device && device->enabled) {
if (device->paused) {
status = SDL_AUDIO_PAUSED;
} else {
status = SDL_AUDIO_PLAYING;
}
}
return status;
}
SDL_AudioStatus
SDL_AudioStatus
Definition: SDL_audio.h:368
SDL_AUDIO_PAUSED
Definition: SDL_audio.h:372
SDL_AUDIO_STOPPED
Definition: SDL_audio.h:370
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioDevice::paused
int paused
Definition: SDL_sysaudio.h:164
SDL_AUDIO_PLAYING
Definition: SDL_audio.h:371
SDL_AudioDevice::enabled
int enabled
Definition: SDL_sysaudio.h:162
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

const char* SDL_GetAudioDriver | ( | int | index | ) |

Definition at line 702 of file SDL_audio.c.

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

{
if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
return bootstrap[index]->name;
}
return NULL;
}
SDL_GetNumAudioDrivers
int SDL_GetNumAudioDrivers(void)
Definition: SDL_audio.c:696
AudioBootStrap::name
const char * name
Definition: SDL_sysaudio.h:191
index
GLuint index
Definition: SDL_opengl_glext.h:660
bootstrap
static const AudioBootStrap *const bootstrap[]
Definition: SDL_audio.c:76
NULL
#define NULL
Definition: begin_code.h:143

SDL_AudioStatus SDL_GetAudioStatus | ( | void |  | ) |

Definition at line 1273 of file SDL_audio.c.

References SDL_GetAudioDeviceStatus().

{
return SDL_GetAudioDeviceStatus(1);
}
SDL_GetAudioDeviceStatus
SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1257

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

References SDL_AudioDriver::name.

{
return current_audio.name;
}
SDL_AudioDriver::name
const char * name
Definition: SDL_sysaudio.h:114
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33

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 807 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.

{
int retval = 0;
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
return -1;
}
SDL_LockMutex(current_audio.detectionLock);
if (iscapture && current_audio.captureDevicesRemoved) {
clean_out_device_list(&current_audio.inputDevices, &current_audio.inputDeviceCount, &current_audio.captureDevicesRemoved);
}
if (!iscapture && current_audio.outputDevicesRemoved) {
clean_out_device_list(&current_audio.outputDevices, &current_audio.outputDeviceCount, &current_audio.outputDevicesRemoved);
current_audio.outputDevicesRemoved = SDL_FALSE;
}
retval = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
SDL_UnlockMutex(current_audio.detectionLock);
return retval;
}
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:266
SDL_AudioDriver::captureDevicesRemoved
SDL_bool captureDevicesRemoved
Definition: SDL_sysaudio.h:124
clean_out_device_list
static void clean_out_device_list(SDL_AudioDeviceItem **devices, int *devCount, SDL_bool *removedFlag)
Definition: SDL_audio.c:779
SDL_AudioDriver::inputDeviceCount
int inputDeviceCount
Definition: SDL_sysaudio.h:127
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:123
retval
SDL_bool retval
Definition: testgamecontroller.c:65
SDL_AudioDriver::outputDevices
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:128
SDL_AudioDriver::outputDevicesRemoved
SDL_bool outputDevicesRemoved
Definition: SDL_sysaudio.h:125
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:76
SDL_AudioDriver::outputDeviceCount
int outputDeviceCount
Definition: SDL_sysaudio.h:126
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:268
SDL_WasInit
#define SDL_WasInit
Definition: SDL_dynapi_overrides.h:63
SDL_AudioDriver::inputDevices
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:129

int SDL_GetNumAudioDrivers | ( | void |  | ) |

Definition at line 696 of file SDL_audio.c.

References SDL_arraysize.

Referenced by SDL_GetAudioDriver().

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

Uint32 SDL_GetQueuedAudioSize | ( | SDL_AudioDeviceID | dev | ) |

Get the number of bytes of still-queued audio.

This is the number of bytes that have been queued for playback with SDL_QueueAudio(), but have not yet been sent to the hardware.

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.

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 use the audio callback or queue audio with SDL_QueueAudio(), but not both.

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

Parameters

  dev | The 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 557 of file SDL_audio.c.

References SDL_AudioSpec::callback, get_audio_device(), SDL_AudioDriverImpl::GetPendingBytes, SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, SDL_AudioDevice::queued_bytes, retval, SDL_BufferQueueDrainCallback(), SDL_AudioDevice::spec, and SDL_AudioDriverImpl::UnlockDevice.

{
Uint32 retval = 0;
SDL_AudioDevice *device = get_audio_device(devid);
/* Nothing to do unless we're set up for queueing. */
if (device && (device->spec.callback == SDL_BufferQueueDrainCallback)) {
current_audio.impl.LockDevice(device);
retval = device->queued_bytes + current_audio.impl.GetPendingBytes(device);
current_audio.impl.UnlockDevice(device);
}
return retval;
}
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_AudioDevice::spec
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:150
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriverImpl::UnlockDevice
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:81
SDL_AudioDevice::queued_bytes
Uint32 queued_bytes
Definition: SDL_sysaudio.h:181
retval
SDL_bool retval
Definition: testgamecontroller.c:65
SDL_AudioSpec::callback
SDL_AudioCallback callback
Definition: SDL_audio.h:177
SDL_AudioDriverImpl::LockDevice
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioDriverImpl::GetPendingBytes
int(* GetPendingBytes)(_THIS)
Definition: SDL_sysaudio.h:76
SDL_BufferQueueDrainCallback
static void SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int _len)
Definition: SDL_audio.c:433
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

void SDL_LockAudio | ( | void |  | ) |

Definition at line 1307 of file SDL_audio.c.

References SDL_LockAudioDevice().

{
SDL_LockAudioDevice(1);
}
SDL_LockAudioDevice
void SDL_LockAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1297

void SDL_LockAudioDevice | ( | SDL_AudioDeviceID | devid | ) |

Definition at line 1297 of file SDL_audio.c.

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

Referenced by SDL_LockAudio().

{
/* Obtain a lock on the mixing buffers */
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
current_audio.impl.LockDevice(device);
}
}
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriverImpl::LockDevice
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

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

References SDL_AudioDevice::convert, SDL_AudioSpec::format, get_audio_device(), SDL_AudioCVT::needed, NULL, SDL_MixAudioFormat, SDL_AudioDevice::spec, and SDL_AudioCVT::src_format.

{
/* Mix the user-level audio format */
SDL_AudioDevice *device = get_audio_device(1);
if (device != NULL) {
SDL_AudioFormat format;
if (device->convert.needed) {
format = device->convert.src_format;
} else {
format = device->spec.format;
}
SDL_MixAudioFormat(dst, src, format, len, volume);
}
}
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1737
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
SDL_MixAudioFormat
#define SDL_MixAudioFormat
Definition: SDL_dynapi_overrides.h:97
SDL_AudioDevice::spec
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:150
SDL_AudioFormat
Uint16 SDL_AudioFormat
Audio format flags.
Definition: SDL_audio.h:64
len
GLenum GLsizei len
Definition: SDL_opengl_glext.h:2926
SDL_AudioCVT::needed
int needed
Definition: SDL_audio.h:202
SDL_AudioCVT::src_format
SDL_AudioFormat src_format
Definition: SDL_audio.h:203
NULL
#define NULL
Definition: begin_code.h:143
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioSpec::format
SDL_AudioFormat format
Definition: SDL_audio.h:171
SDL_AudioDevice::convert
SDL_AudioCVT convert
Definition: SDL_sysaudio.h:153
src
GLenum src
Definition: SDL_opengl_glext.h:1737
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

SDL_AudioFormat SDL_NextAudioFormat | ( | void |  | ) |

Definition at line 1410 of file SDL_audio.c.

References format_idx, format_idx_sub, format_list, and NUM_FORMATS.

Referenced by SDL_FirstAudioFormat().

{
if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
return 0;
}
return format_list[format_idx][format_idx_sub++];
}
format_idx_sub
static int format_idx_sub
Definition: SDL_audio.c:1373
format_idx
static int format_idx
Definition: SDL_audio.c:1372
format_list
static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]
Definition: SDL_audio.c:1374
NUM_FORMATS
#define NUM_FORMATS
Definition: SDL_audio.c:1371

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.
- `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 1219 of file SDL_audio.c.

References NULL, open_audio_device(), SDL_assert, SDL_AUDIO_ALLOW_ANY_CHANGE, SDL_INIT_AUDIO, SDL_InitSubSystem, SDL_SetError, and SDL_WasInit.

{
SDL_AudioDeviceID id = 0;
/* Start up the audio driver, if necessary. This is legacy behaviour! */
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
return -1;
}
}
/* SDL_OpenAudio() is legacy and can only act on Device ID #1. */
if (open_devices[0] != NULL) {
SDL_SetError("Audio device is already opened");
return -1;
}
if (obtained) {
id = open_audio_device(NULL, 0, desired, obtained,
SDL_AUDIO_ALLOW_ANY_CHANGE, 1);
} else {
id = open_audio_device(NULL, 0, desired, NULL, 0, 1);
}
SDL_assert((id == 0) || (id == 1));
return (id == 0) ? -1 : 0;
}
open_devices
static SDL_AudioDevice * open_devices[16]
Definition: SDL_audio.c:34
SDL_InitSubSystem
#define SDL_InitSubSystem
Definition: SDL_dynapi_overrides.h:61
SDL_AUDIO_ALLOW_ANY_CHANGE
#define SDL_AUDIO_ALLOW_ANY_CHANGE
Definition: SDL_audio.h:143
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
NULL
#define NULL
Definition: begin_code.h:143
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
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:962
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:76
SDL_AudioDeviceID
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:303
SDL_WasInit
#define SDL_WasInit
Definition: SDL_dynapi_overrides.h:63

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

References open_audio_device().

{
return open_audio_device(device, iscapture, desired, obtained,
allowed_changes, 2);
}
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:962

void SDL_OpenedAudioDeviceDisconnected | ( | SDL_AudioDevice * | device | ) |

Definition at line 364 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_AUDIODEVICEREMOVED, SDL_ENABLE, SDL_GetEventState, SDL_PushEvent, SDL_zero, and SDL_AudioDriverImpl::UnlockDevice.

{
SDL_assert(get_audio_device(device->id) == device);
if (!device->enabled) {
return;
}
/* Ends the audio callback and mark the device as STOPPED, but the
app still needs to close the device to free resources. */
current_audio.impl.LockDevice(device);
device->enabled = 0;
current_audio.impl.UnlockDevice(device);
/* Post the event, if desired */
if (SDL_GetEventState(SDL_AUDIODEVICEREMOVED) == SDL_ENABLE) {
SDL_Event event;
SDL_zero(event);
event.adevice.type = SDL_AUDIODEVICEREMOVED;
event.adevice.which = device->id;
event.adevice.iscapture = device->iscapture ? 1 : 0;
SDL_PushEvent(&event);
}
}
SDL_AudioDevice::id
SDL_AudioDeviceID id
Definition: SDL_sysaudio.h:147
SDL_ENABLE
#define SDL_ENABLE
Definition: SDL_events.h:718
SDL_AudioDevice::iscapture
int iscapture
Definition: SDL_sysaudio.h:161
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriverImpl::UnlockDevice
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:81
SDL_AUDIODEVICEREMOVED
Definition: SDL_events.h:142
SDL_GetEventState
#define SDL_GetEventState(type)
Definition: SDL_events.h:731
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDL_PushEvent
#define SDL_PushEvent
Definition: SDL_dynapi_overrides.h:131
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:355
SDL_AudioDriverImpl::LockDevice
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_Event
General event structure.
Definition: SDL_events.h:521
SDL_AudioDevice::enabled
int enabled
Definition: SDL_sysaudio.h:162
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

static SDL_AudioFormat SDL_ParseAudioFormat | ( | const char * | string | ) |

static

Definition at line 670 of file SDL_audio.c.

References CHECK_FMT_STRING, and S32.

Referenced by prepare_audiospec().

{
#define CHECK_FMT_STRING(x) if (SDL_strcmp(string, #x) == 0) return AUDIO_##x
CHECK_FMT_STRING(U8);
CHECK_FMT_STRING(S8);
CHECK_FMT_STRING(U16LSB);
CHECK_FMT_STRING(S16LSB);
CHECK_FMT_STRING(U16MSB);
CHECK_FMT_STRING(S16MSB);
CHECK_FMT_STRING(U16SYS);
CHECK_FMT_STRING(S16SYS);
CHECK_FMT_STRING(U16);
CHECK_FMT_STRING(S16);
CHECK_FMT_STRING(S32LSB);
CHECK_FMT_STRING(S32MSB);
CHECK_FMT_STRING(S32SYS);
CHECK_FMT_STRING(S32);
CHECK_FMT_STRING(F32LSB);
CHECK_FMT_STRING(F32MSB);
CHECK_FMT_STRING(F32SYS);
CHECK_FMT_STRING(F32);
#undef CHECK_FMT_STRING
return 0;
}
S32
#define S32
CHECK_FMT_STRING
#define CHECK_FMT_STRING(x)

void SDL_PauseAudio | ( | int | pause_on | ) |

Definition at line 1290 of file SDL_audio.c.

References SDL_PauseAudioDevice().

{
SDL_PauseAudioDevice(1, pause_on);
}
SDL_PauseAudioDevice
void SDL_PauseAudioDevice(SDL_AudioDeviceID devid, int pause_on)
Definition: SDL_audio.c:1279

void SDL_PauseAudioDevice | ( | SDL_AudioDeviceID | devid,
|  | int | pause_on
| ) |  |

Definition at line 1279 of file SDL_audio.c.

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

Referenced by SDL_PauseAudio().

{
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
current_audio.impl.LockDevice(device);
device->paused = pause_on;
current_audio.impl.UnlockDevice(device);
}
}
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriverImpl::UnlockDevice
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:81
SDL_AudioDriverImpl::LockDevice
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioDevice::paused
int paused
Definition: SDL_sysaudio.h:164
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

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

Queue more audio on non-callback 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

  dev | The device ID to which we will queue audio.
  data | The data to queue to the device for later playback.
  len | The 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 475 of file SDL_audio.c.

References SDL_AudioDevice::buffer_queue_head, SDL_AudioDevice::buffer_queue_pool, SDL_AudioDevice::buffer_queue_tail, SDL_AudioSpec::callback, SDL_AudioBufferQueue::data, SDL_AudioBufferQueue::datalen, free_audio_queue(), get_audio_device(), SDL_AudioDriver::impl, SDL_AudioDriverImpl::LockDevice, SDL_AudioBufferQueue::next, NULL, SDL_AudioDevice::queued_bytes, SDL_assert, SDL_AUDIOBUFFERQUEUE_PACKETLEN, SDL_BufferQueueDrainCallback(), SDL_malloc, SDL_memcpy, SDL_min, SDL_OutOfMemory, SDL_SetError, SDL_AudioDevice::spec, SDL_AudioBufferQueue::startpos, and SDL_AudioDriverImpl::UnlockDevice.

{
SDL_AudioDevice *device = get_audio_device(devid);
const Uint8 *data = (const Uint8 *) _data;
SDL_AudioBufferQueue *orighead;
SDL_AudioBufferQueue *origtail;
Uint32 origlen;
Uint32 datalen;
if (!device) {
return -1; /* get_audio_device() will have set the error state */
}
if (device->spec.callback != SDL_BufferQueueDrainCallback) {
return SDL_SetError("Audio device has a callback, queueing not allowed");
}
current_audio.impl.LockDevice(device);
orighead = device->buffer_queue_head;
origtail = device->buffer_queue_tail;
origlen = origtail ? origtail->datalen : 0;
while (len > 0) {
SDL_AudioBufferQueue *packet = device->buffer_queue_tail;
SDL_assert(!packet || (packet->datalen <= SDL_AUDIOBUFFERQUEUE_PACKETLEN));
if (!packet || (packet->datalen >= SDL_AUDIOBUFFERQUEUE_PACKETLEN)) {
/* tail packet missing or completely full; we need a new packet. */
packet = device->buffer_queue_pool;
if (packet != NULL) {
/* we have one available in the pool. */
device->buffer_queue_pool = packet->next;
} else {
/* Have to allocate a new one! */
packet = (SDL_AudioBufferQueue *) SDL_malloc(sizeof (SDL_AudioBufferQueue));
if (packet == NULL) {
/* uhoh, reset so we've queued nothing new, free what we can. */
if (!origtail) {
packet = device->buffer_queue_head; /* whole queue. */
} else {
packet = origtail->next; /* what we added to existing queue. */
origtail->next = NULL;
origtail->datalen = origlen;
}
device->buffer_queue_head = orighead;
device->buffer_queue_tail = origtail;
device->buffer_queue_pool = NULL;
current_audio.impl.UnlockDevice(device);
free_audio_queue(packet); /* give back what we can. */
return SDL_OutOfMemory();
}
}
packet->datalen = 0;
packet->startpos = 0;
packet->next = NULL;
SDL_assert((device->buffer_queue_head != NULL) == (device->queued_bytes != 0));
if (device->buffer_queue_tail == NULL) {
device->buffer_queue_head = packet;
} else {
device->buffer_queue_tail->next = packet;
}
device->buffer_queue_tail = packet;
}
datalen = SDL_min(len, SDL_AUDIOBUFFERQUEUE_PACKETLEN - packet->datalen);
SDL_memcpy(packet->data + packet->datalen, data, datalen);
data += datalen;
len -= datalen;
packet->datalen += datalen;
device->queued_bytes += datalen;
}
current_audio.impl.UnlockDevice(device);
return 0;
}
SDL_AudioBufferQueue::datalen
Uint32 datalen
Definition: SDL_sysaudio.h:64
SDL_min
#define SDL_min(x, y)
Definition: SDL_stdinc.h:345
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1967
SDL_AudioDevice::buffer_queue_pool
SDL_AudioBufferQueue * buffer_queue_pool
Definition: SDL_sysaudio.h:180
SDL_AudioDevice::spec
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:150
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriverImpl::UnlockDevice
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:81
len
GLenum GLsizei len
Definition: SDL_opengl_glext.h:2926
SDL_AudioDevice::queued_bytes
Uint32 queued_bytes
Definition: SDL_sysaudio.h:181
SDL_AudioDevice::buffer_queue_head
SDL_AudioBufferQueue * buffer_queue_head
Definition: SDL_sysaudio.h:178
SDL_AudioDevice::buffer_queue_tail
SDL_AudioBufferQueue * buffer_queue_tail
Definition: SDL_sysaudio.h:179
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:393
SDL_AudioBufferQueue
Definition: SDL_sysaudio.h:61
SDL_AudioBufferQueue::next
struct SDL_AudioBufferQueue * next
Definition: SDL_sysaudio.h:66
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_AudioSpec::callback
SDL_AudioCallback callback
Definition: SDL_audio.h:177
SDL_AudioDriverImpl::LockDevice
void(* LockDevice)(_THIS)
Definition: SDL_sysaudio.h:80
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
NULL
#define NULL
Definition: begin_code.h:143
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
free_audio_queue
static void free_audio_queue(SDL_AudioBufferQueue *buffer)
Definition: SDL_audio.c:423
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioBufferQueue::startpos
Uint32 startpos
Definition: SDL_sysaudio.h:65
SDL_AudioBufferQueue::data
Uint8 data[SDL_AUDIOBUFFERQUEUE_PACKETLEN]
Definition: SDL_sysaudio.h:63
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:380
SDL_AUDIOBUFFERQUEUE_PACKETLEN
#define SDL_AUDIOBUFFERQUEUE_PACKETLEN
Definition: SDL_sysaudio.h:58
SDL_BufferQueueDrainCallback
static void SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int _len)
Definition: SDL_audio.c:433
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

void SDL_RemoveAudioDevice | ( | const int | iscapture,
|  | void * | handle
| ) |  |

Definition at line 405 of file SDL_audio.c.

References SDL_AudioDriver::captureDevicesRemoved, SDL_AudioDriver::detectionLock, SDL_AudioDriverImpl::FreeDeviceHandle, SDL_AudioDriver::impl, SDL_AudioDriver::inputDevices, mark_device_removed(), SDL_AudioDriver::outputDevices, SDL_AudioDriver::outputDevicesRemoved, SDL_LockMutex, and SDL_UnlockMutex.

{
SDL_LockMutex(current_audio.detectionLock);
if (iscapture) {
mark_device_removed(handle, current_audio.inputDevices, &current_audio.captureDevicesRemoved);
} else {
mark_device_removed(handle, current_audio.outputDevices, &current_audio.outputDevicesRemoved);
}
SDL_UnlockMutex(current_audio.detectionLock);
current_audio.impl.FreeDeviceHandle(handle);
}
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:266
SDL_AudioDriver::captureDevicesRemoved
SDL_bool captureDevicesRemoved
Definition: SDL_sysaudio.h:124
mark_device_removed
static void mark_device_removed(void *handle, SDL_AudioDeviceItem *devices, SDL_bool *removedFlag)
Definition: SDL_audio.c:390
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriver::detectionLock
SDL_mutex * detectionLock
Definition: SDL_sysaudio.h:123
SDL_AudioDriver::outputDevices
SDL_AudioDeviceItem * outputDevices
Definition: SDL_sysaudio.h:128
SDL_AudioDriver::outputDevicesRemoved
SDL_bool outputDevicesRemoved
Definition: SDL_sysaudio.h:125
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDriverImpl::FreeDeviceHandle
void(* FreeDeviceHandle)(void *handle)
Definition: SDL_sysaudio.h:82
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:268
SDL_AudioDriver::inputDevices
SDL_AudioDeviceItem * inputDevices
Definition: SDL_sysaudio.h:129

int SDL_RunAudio | ( | void * | devicep | ) |

Definition at line 595 of file SDL_audio.c.

References SDL_AudioCVT::buf, SDL_AudioSpec::callback, SDL_AudioDevice::convert, SDL_AudioDevice::enabled, SDL_AudioDevice::fake_stream, SDL_AudioSpec::freq, SDL_AudioDriverImpl::GetDeviceBuf, SDL_AudioDriver::impl, SDL_AudioCVT::len, SDL_AudioCVT::len_cvt, SDL_AudioDevice::mixer_lock, SDL_AudioCVT::needed, NULL, SDL_AudioDevice::paused, SDL_AudioDriverImpl::PlayDevice, SDL_AudioSpec::samples, SDL_ConvertAudio, SDL_Delay, SDL_LockMutex, SDL_memcpy, 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::threadid, SDL_AudioDriverImpl::ThreadInit, SDL_AudioSpec::userdata, void, SDL_AudioDriverImpl::WaitDevice, and SDL_AudioDriverImpl::WaitDone.

Referenced by open_audio_device().

{
SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
const int silence = (int) device->spec.silence;
const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
const int stream_len = (device->convert.needed) ? device->convert.len : device->spec.size;
Uint8 *stream;
void *udata = device->spec.userdata;
void (SDLCALL *fill) (void *, Uint8 *, int) = device->spec.callback;
/* The audio mixing is always a high priority thread */
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
/* Perform any thread setup */
device->threadid = SDL_ThreadID();
current_audio.impl.ThreadInit(device);
/* Loop, filling the audio buffers */
while (!device->shutdown) {
/* Fill the current buffer with sound */
if (device->convert.needed) {
stream = device->convert.buf;
} else if (device->enabled) {
stream = current_audio.impl.GetDeviceBuf(device);
} else {
/* if the device isn't enabled, we still write to the
fake_stream, so the app's callback will fire with
a regular frequency, in case they depend on that
for timing or progress. They can use hotplug
now to know if the device failed. */
stream = NULL;
}
if (stream == NULL) {
stream = device->fake_stream;
}
/* !!! FIXME: this should be LockDevice. */
SDL_LockMutex(device->mixer_lock);
if (device->paused) {
SDL_memset(stream, silence, stream_len);
} else {
(*fill) (udata, stream, stream_len);
}
SDL_UnlockMutex(device->mixer_lock);
/* Convert the audio if necessary */
if (device->enabled && device->convert.needed) {
SDL_ConvertAudio(&device->convert);
stream = current_audio.impl.GetDeviceBuf(device);
if (stream == NULL) {
stream = device->fake_stream;
} else {
SDL_memcpy(stream, device->convert.buf,
device->convert.len_cvt);
}
}
/* Ready current buffer for play and change current buffer */
if (stream == device->fake_stream) {
SDL_Delay(delay);
} else {
current_audio.impl.PlayDevice(device);
current_audio.impl.WaitDevice(device);
}
}
/* Wait for the audio to drain. */
current_audio.impl.WaitDone(device);
return 0;
}
SDL_ThreadID
#define SDL_ThreadID
Definition: SDL_dynapi_overrides.h:479
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:266
SDL_AudioDevice::mixer_lock
SDL_mutex * mixer_lock
Definition: SDL_sysaudio.h:171
SDL_AudioCVT::len
int len
Definition: SDL_audio.h:207
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_AudioSpec::silence
Uint8 silence
Definition: SDL_audio.h:173
SDL_AudioCVT::buf
Uint8 * buf
Definition: SDL_audio.h:206
stream
GLuint GLuint stream
Definition: SDL_opengl_glext.h:1776
SDL_AudioDevice::shutdown
int shutdown
Definition: SDL_sysaudio.h:163
SDL_AudioDevice::threadid
SDL_threadID threadid
Definition: SDL_sysaudio.h:175
SDL_AudioDriverImpl::PlayDevice
void(* PlayDevice)(_THIS)
Definition: SDL_sysaudio.h:75
SDL_AudioSpec::samples
Uint16 samples
Definition: SDL_audio.h:174
SDL_AudioDriverImpl::WaitDevice
void(* WaitDevice)(_THIS)
Definition: SDL_sysaudio.h:74
SDL_AudioDevice::spec
SDL_AudioSpec spec
Definition: SDL_sysaudio.h:150
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_THREAD_PRIORITY_HIGH
Definition: SDL_thread.h:62
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:393
SDL_AudioDriverImpl::ThreadInit
void(* ThreadInit)(_THIS)
Definition: SDL_sysaudio.h:73
SDL_AudioSpec::freq
int freq
Definition: SDL_audio.h:170
SDL_ConvertAudio
#define SDL_ConvertAudio
Definition: SDL_dynapi_overrides.h:95
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_AudioCVT::needed
int needed
Definition: SDL_audio.h:202
SDL_AudioSpec::callback
SDL_AudioCallback callback
Definition: SDL_audio.h:177
SDL_AudioDevice::fake_stream
Uint8 * fake_stream
Definition: SDL_sysaudio.h:168
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:490
SDL_AudioSpec::size
Uint32 size
Definition: SDL_audio.h:176
SDL_AudioCVT::len_cvt
int len_cvt
Definition: SDL_audio.h:208
NULL
#define NULL
Definition: begin_code.h:143
void
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
Definition: SDL_dynapi_procs.h:93
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
SDL_AudioDevice::paused
int paused
Definition: SDL_sysaudio.h:164
SDL_AudioDriverImpl::GetDeviceBuf
Uint8 *(* GetDeviceBuf)(_THIS)
Definition: SDL_sysaudio.h:77
SDL_AudioSpec::userdata
void * userdata
Definition: SDL_audio.h:178
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:268
SDL_AudioDevice::enabled
int enabled
Definition: SDL_sysaudio.h:162
SDL_AudioDevice::convert
SDL_AudioCVT convert
Definition: SDL_sysaudio.h:153
SDLCALL
#define SDLCALL
Definition: SDL_internal.h:31
SDL_SetThreadPriority
#define SDL_SetThreadPriority
Definition: SDL_dynapi_overrides.h:481
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:392
SDL_AudioDriverImpl::WaitDone
void(* WaitDone)(_THIS)
Definition: SDL_sysaudio.h:78

void SDL_UnlockAudio | ( | void |  | ) |

Definition at line 1323 of file SDL_audio.c.

References SDL_UnlockAudioDevice().

{
SDL_UnlockAudioDevice(1);
}
SDL_UnlockAudioDevice
void SDL_UnlockAudioDevice(SDL_AudioDeviceID devid)
Definition: SDL_audio.c:1313

void SDL_UnlockAudioDevice | ( | SDL_AudioDeviceID | devid | ) |

Definition at line 1313 of file SDL_audio.c.

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

Referenced by SDL_UnlockAudio().

{
/* Obtain a lock on the mixing buffers */
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
current_audio.impl.UnlockDevice(device);
}
}
current_audio
static SDL_AudioDriver current_audio
Definition: SDL_audio.c:33
SDL_AudioDriverImpl::UnlockDevice
void(* UnlockDevice)(_THIS)
Definition: SDL_sysaudio.h:81
SDL_AudioDriver::impl
SDL_AudioDriverImpl impl
Definition: SDL_sysaudio.h:120
SDL_AudioDevice
Definition: SDL_sysaudio.h:143
get_audio_device
static SDL_AudioDevice * get_audio_device(SDL_AudioDeviceID id)
Definition: SDL_audio.c:150

## Variable Documentation

AudioBootStrap ALSA_bootstrap

AudioBootStrap ANDROIDAUD_bootstrap

AudioBootStrap ARTS_bootstrap

const AudioBootStrap* const bootstrap[]

static

Definition at line 76 of file SDL_audio.c.

AudioBootStrap BSD_AUDIO_bootstrap

AudioBootStrap COREAUDIO_bootstrap

SDL_AudioDriver current_audio

static

Definition at line 33 of file SDL_audio.c.

AudioBootStrap DART_bootstrap

AudioBootStrap DCAUD_bootstrap

AudioBootStrap DISKAUD_bootstrap

AudioBootStrap DSOUND_bootstrap

AudioBootStrap DSP_bootstrap

AudioBootStrap DUMMYAUD_bootstrap

Definition at line 44 of file SDL_dummyaudio.c.

AudioBootStrap EmscriptenAudio_bootstrap

AudioBootStrap ESD_bootstrap

int format_idx

static

Definition at line 1372 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

int format_idx_sub

static

Definition at line 1373 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS]

static

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

Definition at line 1374 of file SDL_audio.c.

Referenced by SDL_FirstAudioFormat(), and SDL_NextAudioFormat().

AudioBootStrap FUSIONSOUND_bootstrap

AudioBootStrap HAIKUAUDIO_bootstrap

AudioBootStrap NACLAUD_bootstrap

AudioBootStrap NAS_bootstrap

AudioBootStrap NDSAUD_bootstrap

SDL_AudioDevice* open_devices[16]

static

Definition at line 34 of file SDL_audio.c.

AudioBootStrap PAUDIO_bootstrap

AudioBootStrap PSPAUD_bootstrap

AudioBootStrap PULSEAUDIO_bootstrap

AudioBootStrap QSAAUDIO_bootstrap

AudioBootStrap SNDIO_bootstrap

AudioBootStrap SNDMGR_bootstrap

AudioBootStrap SUNAUDIO_bootstrap

AudioBootStrap WINMM_bootstrap

AudioBootStrap XAUDIO2_bootstrap