/* Simple DirectMedia Layer Copyright (C) 1997-2023 Sam Lantinga This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ #include "SDL_internal.h" #ifdef SDL_AUDIO_DRIVER_ALSA #ifndef SDL_ALSA_NON_BLOCKING #define SDL_ALSA_NON_BLOCKING 0 #endif // without the thread, you will detect devices on startup, but will not get further hotplug events. But that might be okay. #ifndef SDL_ALSA_HOTPLUG_THREAD #define SDL_ALSA_HOTPLUG_THREAD 1 #endif // Allow access to a raw mixing buffer #include #include // For kill() #include #include "../SDL_sysaudio.h" #include "SDL_alsa_audio.h" #ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC #endif #define loop for(;;) #define LOGDEBUG(...) SDL_LogDebug(SDL_LOG_CATEGORY_AUDIO,"ALSA:" __VA_ARGS__) //TODO: cleanup once the code settled down static int (*ALSA_snd_pcm_open)(snd_pcm_t **, const char *, snd_pcm_stream_t, int); static int (*ALSA_snd_pcm_close)(snd_pcm_t *pcm); static int (*ALSA_snd_pcm_start)(snd_pcm_t *pcm); static snd_pcm_sframes_t (*ALSA_snd_pcm_writei)(snd_pcm_t *, const void *, snd_pcm_uframes_t); static snd_pcm_sframes_t (*ALSA_snd_pcm_readi)(snd_pcm_t *, void *, snd_pcm_uframes_t); static int (*ALSA_snd_pcm_recover)(snd_pcm_t *, int, int); static int (*ALSA_snd_pcm_prepare)(snd_pcm_t *); static int (*ALSA_snd_pcm_drain)(snd_pcm_t *); static const char *(*ALSA_snd_strerror)(int); static size_t (*ALSA_snd_pcm_hw_params_sizeof)(void); static size_t (*ALSA_snd_pcm_sw_params_sizeof)(void); static void (*ALSA_snd_pcm_hw_params_copy)(snd_pcm_hw_params_t *, const snd_pcm_hw_params_t *); static int (*ALSA_snd_pcm_hw_params_any)(snd_pcm_t *, snd_pcm_hw_params_t *); static int (*ALSA_snd_pcm_hw_params_set_access)(snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_access_t); static int (*ALSA_snd_pcm_hw_params_set_format)(snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_format_t); static int (*ALSA_snd_pcm_hw_params_set_channels)(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int); static int (*ALSA_snd_pcm_hw_params_get_channels)(const snd_pcm_hw_params_t *, unsigned int *); static int (*ALSA_snd_pcm_hw_params_set_rate_near)(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *, int *); static int (*ALSA_snd_pcm_hw_params_set_period_size_near)(snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_uframes_t *, int *); static int (*ALSA_snd_pcm_hw_params_get_period_size)(const snd_pcm_hw_params_t *, snd_pcm_uframes_t *, int *); static int (*ALSA_snd_pcm_hw_params_set_periods_min)(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *, int *); static int (*ALSA_snd_pcm_hw_params_set_periods_first)(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *, int *); static int (*ALSA_snd_pcm_hw_params_get_periods)(const snd_pcm_hw_params_t *, unsigned int *, int *); static int (*ALSA_snd_pcm_hw_params_set_buffer_size_near)(snd_pcm_t *pcm, snd_pcm_hw_params_t *, snd_pcm_uframes_t *); static int (*ALSA_snd_pcm_hw_params_get_buffer_size)(const snd_pcm_hw_params_t *, snd_pcm_uframes_t *); static int (*ALSA_snd_pcm_hw_params)(snd_pcm_t *, snd_pcm_hw_params_t *); static int (*ALSA_snd_pcm_sw_params_current)(snd_pcm_t *, snd_pcm_sw_params_t *); static int (*ALSA_snd_pcm_sw_params_set_start_threshold)(snd_pcm_t *, snd_pcm_sw_params_t *, snd_pcm_uframes_t); static int (*ALSA_snd_pcm_sw_params)(snd_pcm_t *, snd_pcm_sw_params_t *); static int (*ALSA_snd_pcm_nonblock)(snd_pcm_t *, int); static int (*ALSA_snd_pcm_wait)(snd_pcm_t *, int); static int (*ALSA_snd_pcm_sw_params_set_avail_min)(snd_pcm_t *, snd_pcm_sw_params_t *, snd_pcm_uframes_t); static int (*ALSA_snd_pcm_reset)(snd_pcm_t *); static int (*ALSA_snd_device_name_hint)(int, const char *, void ***); static char *(*ALSA_snd_device_name_get_hint)(const void *, const char *); static int (*ALSA_snd_device_name_free_hint)(void **); static snd_pcm_sframes_t (*ALSA_snd_pcm_avail)(snd_pcm_t *); static size_t (*ALSA_snd_ctl_card_info_sizeof)(void); static size_t (*ALSA_snd_pcm_info_sizeof)(void); static int (*ALSA_snd_card_next)(int*); static int (*ALSA_snd_ctl_open)(snd_ctl_t **,const char *,int); static int (*ALSA_snd_ctl_close)(snd_ctl_t *); static int (*ALSA_snd_ctl_card_info)(snd_ctl_t *, snd_ctl_card_info_t *); static int (*ALSA_snd_ctl_pcm_next_device)(snd_ctl_t *, int *); static unsigned int (*ALSA_snd_pcm_info_get_subdevices_count)(const snd_pcm_info_t *); static void (*ALSA_snd_pcm_info_set_device)(snd_pcm_info_t *, unsigned int); static void (*ALSA_snd_pcm_info_set_subdevice)(snd_pcm_info_t *, unsigned int); static void (*ALSA_snd_pcm_info_set_stream)(snd_pcm_info_t *, snd_pcm_stream_t); static int (*ALSA_snd_ctl_pcm_info)(snd_ctl_t *, snd_pcm_info_t *); static unsigned int (*ALSA_snd_pcm_info_get_subdevices_count)(const snd_pcm_info_t *); static const char *(*ALSA_snd_ctl_card_info_get_id)(const snd_ctl_card_info_t *); static const char *(*ALSA_snd_pcm_info_get_name)(const snd_pcm_info_t *); static const char *(*ALSA_snd_pcm_info_get_subdevice_name)(const snd_pcm_info_t *); static const char *(*ALSA_snd_ctl_card_info_get_name)(const snd_ctl_card_info_t *); static void (*ALSA_snd_ctl_card_info_clear)(snd_ctl_card_info_t *); static int (*ALSA_snd_pcm_hw_free)(snd_pcm_t *); static int (*ALSA_snd_pcm_hw_params_set_channels_near)(snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *); static snd_pcm_chmap_query_t **(*ALSA_snd_pcm_query_chmaps)(snd_pcm_t *pcm); static void (*ALSA_snd_pcm_free_chmaps)(snd_pcm_chmap_query_t **maps); static int (*ALSA_snd_pcm_set_chmap)(snd_pcm_t *, const snd_pcm_chmap_t *); static int (*ALSA_snd_pcm_chmap_print)(const snd_pcm_chmap_t *, size_t, char *); #ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC #define snd_pcm_hw_params_sizeof ALSA_snd_pcm_hw_params_sizeof #define snd_pcm_sw_params_sizeof ALSA_snd_pcm_sw_params_sizeof static const char *alsa_library = SDL_AUDIO_DRIVER_ALSA_DYNAMIC; static void *alsa_handle = NULL; static int load_alsa_sym(const char *fn, void **addr) { *addr = SDL_LoadFunction(alsa_handle, fn); if (!*addr) { // Don't call SDL_SetError(): SDL_LoadFunction already did. return 0; } return 1; } // cast funcs to char* first, to please GCC's strict aliasing rules. #define SDL_ALSA_SYM(x) \ if (!load_alsa_sym(#x, (void **)(char *)&ALSA_##x)) \ return -1 #else #define SDL_ALSA_SYM(x) ALSA_##x = x #endif static int load_alsa_syms(void) { SDL_ALSA_SYM(snd_pcm_open); SDL_ALSA_SYM(snd_pcm_close); SDL_ALSA_SYM(snd_pcm_start); SDL_ALSA_SYM(snd_pcm_writei); SDL_ALSA_SYM(snd_pcm_readi); SDL_ALSA_SYM(snd_pcm_recover); SDL_ALSA_SYM(snd_pcm_prepare); SDL_ALSA_SYM(snd_pcm_drain); SDL_ALSA_SYM(snd_strerror); SDL_ALSA_SYM(snd_pcm_hw_params_sizeof); SDL_ALSA_SYM(snd_pcm_sw_params_sizeof); SDL_ALSA_SYM(snd_pcm_hw_params_copy); SDL_ALSA_SYM(snd_pcm_hw_params_any); SDL_ALSA_SYM(snd_pcm_hw_params_set_access); SDL_ALSA_SYM(snd_pcm_hw_params_set_format); SDL_ALSA_SYM(snd_pcm_hw_params_set_channels); SDL_ALSA_SYM(snd_pcm_hw_params_get_channels); SDL_ALSA_SYM(snd_pcm_hw_params_set_rate_near); SDL_ALSA_SYM(snd_pcm_hw_params_set_period_size_near); SDL_ALSA_SYM(snd_pcm_hw_params_get_period_size); SDL_ALSA_SYM(snd_pcm_hw_params_set_periods_min); SDL_ALSA_SYM(snd_pcm_hw_params_set_periods_first); SDL_ALSA_SYM(snd_pcm_hw_params_get_periods); SDL_ALSA_SYM(snd_pcm_hw_params_set_buffer_size_near); SDL_ALSA_SYM(snd_pcm_hw_params_get_buffer_size); SDL_ALSA_SYM(snd_pcm_hw_params); SDL_ALSA_SYM(snd_pcm_sw_params_current); SDL_ALSA_SYM(snd_pcm_sw_params_set_start_threshold); SDL_ALSA_SYM(snd_pcm_sw_params); SDL_ALSA_SYM(snd_pcm_nonblock); SDL_ALSA_SYM(snd_pcm_wait); SDL_ALSA_SYM(snd_pcm_sw_params_set_avail_min); SDL_ALSA_SYM(snd_pcm_reset); SDL_ALSA_SYM(snd_device_name_hint); SDL_ALSA_SYM(snd_device_name_get_hint); SDL_ALSA_SYM(snd_device_name_free_hint); SDL_ALSA_SYM(snd_pcm_avail); SDL_ALSA_SYM(snd_ctl_card_info_sizeof); SDL_ALSA_SYM(snd_pcm_info_sizeof); SDL_ALSA_SYM(snd_card_next); SDL_ALSA_SYM(snd_ctl_open); SDL_ALSA_SYM(snd_ctl_close); SDL_ALSA_SYM(snd_ctl_card_info); SDL_ALSA_SYM(snd_ctl_pcm_next_device); SDL_ALSA_SYM(snd_pcm_info_get_subdevices_count); SDL_ALSA_SYM(snd_pcm_info_set_device); SDL_ALSA_SYM(snd_pcm_info_set_subdevice); SDL_ALSA_SYM(snd_pcm_info_set_stream); SDL_ALSA_SYM(snd_ctl_pcm_info); SDL_ALSA_SYM(snd_pcm_info_get_subdevices_count); SDL_ALSA_SYM(snd_ctl_card_info_get_id); SDL_ALSA_SYM(snd_pcm_info_get_name); SDL_ALSA_SYM(snd_pcm_info_get_subdevice_name); SDL_ALSA_SYM(snd_ctl_card_info_get_name); SDL_ALSA_SYM(snd_ctl_card_info_clear); SDL_ALSA_SYM(snd_pcm_hw_free); SDL_ALSA_SYM(snd_pcm_hw_params_set_channels_near); SDL_ALSA_SYM(snd_pcm_query_chmaps); SDL_ALSA_SYM(snd_pcm_free_chmaps); SDL_ALSA_SYM(snd_pcm_set_chmap); SDL_ALSA_SYM(snd_pcm_chmap_print); return 0; } #undef SDL_ALSA_SYM #ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC static void UnloadALSALibrary(void) { if (alsa_handle) { SDL_UnloadObject(alsa_handle); alsa_handle = NULL; } } static int LoadALSALibrary(void) { int retval = 0; if (!alsa_handle) { alsa_handle = SDL_LoadObject(alsa_library); if (!alsa_handle) { retval = -1; // Don't call SDL_SetError(): SDL_LoadObject already did. } else { retval = load_alsa_syms(); if (retval < 0) { UnloadALSALibrary(); } } } return retval; } #else static void UnloadALSALibrary(void) { } static int LoadALSALibrary(void) { load_alsa_syms(); return 0; } #endif // SDL_AUDIO_DRIVER_ALSA_DYNAMIC typedef struct ALSA_Device { // the unicity key is the couple (id,iscapture) char *id; // empty means canonical default char *name; struct ALSA_Device *next; SDL_bool iscapture; } ALSA_Device; static const ALSA_Device default_output_handle = { "", "default", NULL, SDL_FALSE }; static const ALSA_Device default_capture_handle = { "", "default", NULL, SDL_TRUE }; // TODO: Figure out the "right"(TM) way. For the moment we presume that if a system is using a // software mixer for application audio sharing which is not the linux native alsa[dmix], for // instance jack/pulseaudio2[pipewire]/pulseaudio1/esound/etc, we expect the system integrators did // configure the canonical default to the right alsa PCM plugin for their software mixer. // // All the above may be completely wrong. static char *get_pcm_str(void *handle) { ALSA_Device *dev; size_t pcm_len; char *pcm_str; SDL_assert(handle != NULL); // SDL2 used NULL to mean "default" but that's not true in SDL3. dev = (ALSA_Device *)handle; // If the user does not want to go thru the default PCM or the canonical default, the // the configuration space being _massive_, give the user the ability to specify // its own PCMs using environment variables. It will have to fit SDL constraints though. if (dev->iscapture) pcm_str = SDL_getenv("SDL_AUDIO_ALSA_PCM_CAPTURE"); else pcm_str = SDL_getenv("SDL_AUDIO_ALSA_PCM_PLAYBACK"); if (pcm_str) return SDL_strdup(pcm_str); if (SDL_strlen(dev->id) == 0) pcm_str = SDL_strdup("default"); else { #define PCM_STR_FMT "default:CARD=%s" pcm_len = (size_t)SDL_snprintf(0, 0, PCM_STR_FMT, dev->id); pcm_str = SDL_malloc(pcm_len + 1); if (pcm_str != NULL) SDL_snprintf(pcm_str, pcm_len + 1, PCM_STR_FMT, dev->id); #undef PCM_STR_FMT } return pcm_str; } // sdl channel map with alsa names "FL FR" // The literal names are sdl names. // Faith: loading the whole frame in one shot may help naive compilers. #define SWIZ2(T) \ static void swizzle_alsa_channels_2_##T(int *swizzle_map, void *buffer, const Uint32 bufferlen) \ { \ T *ptr = (T *)buffer; \ Uint32 i; \ for (i = 0; i < bufferlen; i++, ptr += 2) { \ const T front_left = ptr[0]; \ const T front_right = ptr[1]; \ ptr[swizzle_map[0]] = front_left; \ ptr[swizzle_map[1]] = front_right; \ } \ } // sdl channel map with alsa names "FL FR LFE" // The literal names are sdl names. // Faith: loading the whole frame in one shot may help naive compilers. #define SWIZ3(T) \ static void swizzle_alsa_channels_3_##T(int *swizzle_map, void *buffer, const Uint32 bufferlen) \ { \ T *ptr = (T *)buffer; \ Uint32 i; \ for (i = 0; i < bufferlen; i++, ptr += 3) { \ const T front_left = ptr[0]; \ const T front_right = ptr[1]; \ const T subwoofer = ptr[2]; \ ptr[swizzle_map[0]] = front_left; \ ptr[swizzle_map[1]] = front_right; \ ptr[swizzle_map[2]] = subwoofer; \ } \ } // sdl channel map with alsa names "FL FR RL RR"; // The literal names are sdl names. // Faith: loading the whole frame in one shot may help naive compilers. #define SWIZ4(T) \ static void swizzle_alsa_channels_4_##T(int *swizzle_map, void *buffer, const Uint32 bufferlen) \ { \ T *ptr = (T *)buffer; \ Uint32 i; \ for (i = 0; i < bufferlen; i++, ptr += 4) { \ const T front_left = ptr[0]; \ const T front_right = ptr[1]; \ const T back_left = ptr[2]; \ const T back_right = ptr[3]; \ ptr[swizzle_map[0]] = front_left; \ ptr[swizzle_map[1]] = front_right; \ ptr[swizzle_map[2]] = back_left; \ ptr[swizzle_map[3]] = back_right; \ } \ } // sdl channel map with alsa names "FL FR LFE RL RR" // The literal names are sdl names. // Faith: loading the whole frame in one shot may help naive compilers. #define SWIZ5(T) \ static void swizzle_alsa_channels_5_##T(int *swizzle_map, void *buffer, const Uint32 bufferlen) \ { \ T *ptr = (T *)buffer; \ Uint32 i; \ for (i = 0; i < bufferlen; i++, ptr += 5) { \ const T front_left = ptr[0]; \ const T front_right = ptr[1]; \ const T subwoofer = ptr[2]; \ const T back_left = ptr[3]; \ const T back_right = ptr[4]; \ ptr[swizzle_map[0]] = front_left; \ ptr[swizzle_map[1]] = front_right; \ ptr[swizzle_map[2]] = subwoofer; \ ptr[swizzle_map[3]] = back_left; \ ptr[swizzle_map[4]] = back_right; \ } \ } // sdl channel map with alsa names "FL FR FC LFE SL SR" // The literal names are sdl names. // Faith: loading the whole frame in one shot may help naive compilers. #define SWIZ6(T) \ static void swizzle_alsa_channels_6_##T(int *swizzle_map, void *buffer, const Uint32 bufferlen) \ { \ T *ptr = (T *)buffer; \ Uint32 i; \ for (i = 0; i < bufferlen; i++, ptr += 6) { \ const T front_left = ptr[0]; \ const T front_right = ptr[1]; \ const T front_center = ptr[2]; \ const T subwoofer = ptr[3]; \ const T side_left = ptr[4]; \ const T side_right = ptr[5]; \ ptr[swizzle_map[0]] = front_left; \ ptr[swizzle_map[1]] = front_right; \ ptr[swizzle_map[2]] = front_center; \ ptr[swizzle_map[3]] = subwoofer; \ ptr[swizzle_map[4]] = side_left; \ ptr[swizzle_map[5]] = side_right; \ } \ } // sdl channel map with alsa names "FL FR FC LFE RC SL SR". // The literal names are sdl names. // Faith: loading the whole frame in one shot may help naive compilers. #define SWIZ7(T) \ static void swizzle_alsa_channels_7_##T(int *swizzle_map, void *buffer, const Uint32 bufferlen) \ { \ T *ptr = (T *)buffer; \ Uint32 i; \ for (i = 0; i < bufferlen; i++, ptr += 7) { \ const T front_left = ptr[0]; \ const T front_right = ptr[1]; \ const T front_center = ptr[2]; \ const T subwoofer = ptr[3]; \ const T back_center = ptr[4]; \ const T side_left = ptr[5]; \ const T side_right = ptr[6]; \ ptr[swizzle_map[0]] = front_left; \ ptr[swizzle_map[1]] = front_right; \ ptr[swizzle_map[2]] = front_center; \ ptr[swizzle_map[3]] = subwoofer; \ ptr[swizzle_map[4]] = back_center; \ ptr[swizzle_map[5]] = side_left; \ ptr[swizzle_map[6]] = side_right; \ } \ } // sdl channel map with alsa names "FL FR FC LFE RL RR SL SR" // The literal names are sdl names. // Faith: loading the whole frame in one shot may help naive compilers. #define SWIZ8(T) \ static void swizzle_alsa_channels_8_##T(int *swizzle_map, void *buffer, const Uint32 bufferlen) \ { \ T *ptr = (T *)buffer; \ Uint32 i; \ for (i = 0; i < bufferlen; i++, ptr += 8) { \ const T front_left = ptr[0]; \ const T front_right = ptr[1]; \ const T front_center = ptr[2]; \ const T subwoofer = ptr[3]; \ const T back_left = ptr[4]; \ const T back_right = ptr[5]; \ const T side_left = ptr[6]; \ const T side_right = ptr[7]; \ ptr[swizzle_map[0]] = front_left; \ ptr[swizzle_map[1]] = front_right; \ ptr[swizzle_map[2]] = front_center; \ ptr[swizzle_map[3]] = subwoofer; \ ptr[swizzle_map[4]] = back_left; \ ptr[swizzle_map[5]] = back_right; \ ptr[swizzle_map[6]] = side_left; \ ptr[swizzle_map[7]] = side_right; \ } \ } #define CHANNEL_SWIZZLE(x) \ x(Uint64) \ x(Uint32) \ x(Uint16) \ x(Uint8) CHANNEL_SWIZZLE(SWIZ2) CHANNEL_SWIZZLE(SWIZ3) CHANNEL_SWIZZLE(SWIZ4) CHANNEL_SWIZZLE(SWIZ5) CHANNEL_SWIZZLE(SWIZ6) CHANNEL_SWIZZLE(SWIZ7) CHANNEL_SWIZZLE(SWIZ8) #undef CHANNEL_SWIZZLE #undef SWIZ2 #undef SWIZ3 #undef SWIZ4 #undef SWIZ5 #undef SWIZ6 #undef SWIZ7 #undef SWIZ8 // Called right before feeding device->hidden->mixbuf to the hardware. Swizzle // channels from Windows/Mac order to the format alsalib will want. static void swizzle_alsa_channels(SDL_AudioDevice *device, void *buffer, Uint32 bufferlen) { int *swizzle_map = device->hidden->swizzle_map; switch (device->spec.channels) { #define CHANSWIZ(chans) \ case chans: \ switch ((device->spec.format & (0xFF))) { \ case 8: \ swizzle_alsa_channels_##chans##_Uint8(swizzle_map, buffer, bufferlen); \ break; \ case 16: \ swizzle_alsa_channels_##chans##_Uint16(swizzle_map, buffer, bufferlen); \ break; \ case 32: \ swizzle_alsa_channels_##chans##_Uint32(swizzle_map, buffer, bufferlen); \ break; \ case 64: \ swizzle_alsa_channels_##chans##_Uint64(swizzle_map, buffer, bufferlen); \ break; \ default: \ SDL_assert(!"unhandled bitsize"); \ break; \ } \ return; CHANSWIZ(2); CHANSWIZ(3); CHANSWIZ(4); CHANSWIZ(5); CHANSWIZ(6); CHANSWIZ(7); CHANSWIZ(8); #undef CHANSWIZ default: break; } } // Some devices have the right channel map, no swizzling necessary static void no_swizzle(SDL_AudioDevice *device, void *buffer, Uint32 bufferlen) { } // This function waits until it is possible to write a full sound buffer static int ALSA_WaitDevice(SDL_AudioDevice *device) { const int fulldelay = (int) ((((Uint64) device->sample_frames) * 1000) / device->spec.freq); const int delay = SDL_max(fulldelay, 10); while (!SDL_AtomicGet(&device->shutdown)) { const int rc = ALSA_snd_pcm_wait(device->hidden->pcm, delay); if (rc < 0 && (rc != -EAGAIN)) { const int status = ALSA_snd_pcm_recover(device->hidden->pcm, rc, 0); if (status < 0) { // Hmm, not much we can do - abort SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "ALSA: snd_pcm_wait failed (unrecoverable): %s", ALSA_snd_strerror(rc)); return -1; } continue; } if (rc > 0) { break; // ready to go! } // Timed out! Make sure we aren't shutting down and then wait again. } return 0; } static int ALSA_PlayDevice(SDL_AudioDevice *device, const Uint8 *buffer, int buflen) { SDL_assert(buffer == device->hidden->mixbuf); Uint8 *sample_buf = (Uint8 *) buffer; // !!! FIXME: deal with this without casting away constness const int frame_size = SDL_AUDIO_FRAMESIZE(device->spec); snd_pcm_uframes_t frames_left = (snd_pcm_uframes_t) (buflen / frame_size); device->hidden->swizzle_func(device, sample_buf, frames_left); while ((frames_left > 0) && !SDL_AtomicGet(&device->shutdown)) { const int rc = ALSA_snd_pcm_writei(device->hidden->pcm, sample_buf, frames_left); //SDL_LogInfo(SDL_LOG_CATEGORY_AUDIO, "ALSA PLAYDEVICE: WROTE %d of %d bytes", (rc >= 0) ? ((int) (rc * frame_size)) : rc, (int) (frames_left * frame_size)); SDL_assert(rc != 0); // assuming this can't happen if we used snd_pcm_wait and queried for available space. if (rc < 0) { SDL_assert(rc != -EAGAIN); // assuming this can't happen if we used snd_pcm_wait and queried for available space. snd_pcm_recover won't handle it! const int status = ALSA_snd_pcm_recover(device->hidden->pcm, rc, 0); if (status < 0) { // Hmm, not much we can do - abort SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "ALSA write failed (unrecoverable): %s", ALSA_snd_strerror(rc)); return -1; } continue; } sample_buf += rc * frame_size; frames_left -= rc; } return 0; } static Uint8 *ALSA_GetDeviceBuf(SDL_AudioDevice *device, int *buffer_size) { snd_pcm_sframes_t rc = ALSA_snd_pcm_avail(device->hidden->pcm); if (rc <= 0) { // Wait a bit and try again, maybe the hardware isn't quite ready yet? SDL_Delay(1); rc = ALSA_snd_pcm_avail(device->hidden->pcm); if (rc <= 0) { // We'll catch it next time *buffer_size = 0; return NULL; } } const int requested_frames = SDL_min(device->sample_frames, rc); const int requested_bytes = requested_frames * SDL_AUDIO_FRAMESIZE(device->spec); SDL_assert(requested_bytes <= *buffer_size); //SDL_LogInfo(SDL_LOG_CATEGORY_AUDIO, "ALSA GETDEVICEBUF: NEED %d BYTES", requested_bytes); *buffer_size = requested_bytes; return device->hidden->mixbuf; } static int ALSA_CaptureFromDevice(SDL_AudioDevice *device, void *buffer, int buflen) { const int frame_size = SDL_AUDIO_FRAMESIZE(device->spec); SDL_assert((buflen % frame_size) == 0); const snd_pcm_sframes_t total_available = ALSA_snd_pcm_avail(device->hidden->pcm); const int total_frames = SDL_min(buflen / frame_size, total_available); const int rc = ALSA_snd_pcm_readi(device->hidden->pcm, buffer, total_frames); SDL_assert(rc != -EAGAIN); // assuming this can't happen if we used snd_pcm_wait and queried for available space. snd_pcm_recover won't handle it! if (rc < 0) { const int status = ALSA_snd_pcm_recover(device->hidden->pcm, rc, 0); if (status < 0) { // Hmm, not much we can do - abort SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "ALSA read failed (unrecoverable): %s", ALSA_snd_strerror(rc)); return -1; } return 0; // go back to WaitDevice and try again. } else if (rc > 0) { device->hidden->swizzle_func(device, buffer, total_frames - rc); } //SDL_LogInfo(SDL_LOG_CATEGORY_AUDIO, "ALSA: captured %d bytes", rc * frame_size); return rc * frame_size; } static void ALSA_FlushCapture(SDL_AudioDevice *device) { ALSA_snd_pcm_reset(device->hidden->pcm); } static void ALSA_CloseDevice(SDL_AudioDevice *device) { if (device->hidden) { if (device->hidden->pcm) { // Wait for the submitted audio to drain. ALSA_snd_pcm_drop() can hang, so don't use that. SDL_Delay(((device->sample_frames * 1000) / device->spec.freq) * 2); ALSA_snd_pcm_close(device->hidden->pcm); } SDL_free(device->hidden->mixbuf); SDL_free(device->hidden); } } // To make easier to track parameters during the whole alsa pcm configuration: struct ALSA_pcm_cfg_ctx { SDL_AudioDevice *device; snd_pcm_hw_params_t *hwparams; snd_pcm_sw_params_t *swparams; SDL_AudioFormat matched_sdl_format; unsigned int chans_n; unsigned int target_chans_n; unsigned int rate; snd_pcm_uframes_t persize; // alsa period size, sdl audio device sample_frames snd_pcm_chmap_query_t **chmap_queries; unsigned int sdl_chmap[SDL_AUDIO_ALSA__CHMAP_CHANS_N_MAX]; unsigned int alsa_chmap_installed[SDL_AUDIO_ALSA__CHMAP_CHANS_N_MAX]; unsigned int periods; }; // The following are sdl channel maps with alsa position values, from 0 channels to 8 channels. // See SDL3/SDL_audio.h // Strictly speaking those are "parameters" of channel maps, like alsa hwparams and swparams, they // have to be "reduced/refined" until an exact channel map. Only the 6 channels map requires such // "reduction/refine". static enum snd_pcm_chmap_position sdl_channel_maps[SDL_AUDIO_ALSA__SDL_CHMAPS_N][SDL_AUDIO_ALSA__CHMAP_CHANS_N_MAX] = { // 0 channels { }, // 1 channel { SND_CHMAP_MONO, }, // 2 channels { SND_CHMAP_FL, SND_CHMAP_FR, }, // 3 channels { SND_CHMAP_FL, SND_CHMAP_FR, SND_CHMAP_LFE, }, // 4 channels { SND_CHMAP_FL, SND_CHMAP_FR, SND_CHMAP_RL, SND_CHMAP_RR, }, // 5 channels { SND_CHMAP_FL, SND_CHMAP_FR, SND_CHMAP_LFE, SND_CHMAP_RL, SND_CHMAP_RR, }, // 6 channels // XXX: here we encode not a uniq channel map but a set of channel maps. We will reduce it each // time we are going to work with an alsa 6 channels map. { SND_CHMAP_FL, SND_CHMAP_FR, SND_CHMAP_FC, SND_CHMAP_LFE, // The 2 following channel positions are (SND_CHMAP_SL,SND_CHMAP_SR) or // (SND_CHMAP_RL,SND_CHMAP_RR) SND_CHMAP_UNKNOWN, SND_CHMAP_UNKNOWN, }, // 7 channels { SND_CHMAP_FL, SND_CHMAP_FR, SND_CHMAP_FC, SND_CHMAP_LFE, SND_CHMAP_RC, SND_CHMAP_SL, SND_CHMAP_SR, }, // 8 channels { SND_CHMAP_FL, SND_CHMAP_FR, SND_CHMAP_FC, SND_CHMAP_LFE, SND_CHMAP_RL, SND_CHMAP_RR, SND_CHMAP_SL, SND_CHMAP_SR, }, }; // Helper for the function right below. static SDL_bool has_pos(unsigned int *chmap, unsigned int pos) { unsigned int chan_idx = 0; loop { if (chan_idx == 6) return SDL_FALSE; if (chmap[chan_idx] == pos) return SDL_TRUE; ++chan_idx; } } // XXX: Each time we are going to work on an alsa 6 channels map, we must reduce the set of channel // maps which is encoded in sdl_channel_maps[6] to a uniq one. #define HAVE_NONE 0 #define HAVE_REAR 1 #define HAVE_SIDE 2 #define HAVE_BOTH 3 static void sdl_6chans_set_rear_or_side_channels_from_alsa_6chans(unsigned int *sdl_6chans, unsigned int *alsa_6chans) { unsigned int chan_idx; unsigned int state; // For alsa channel maps with 6 channels and with SND_CHMAP_FL,SND_CHMAP_FR,SND_CHMAP_FC, // SND_CHMAP_LFE, reduce our 6 channels maps to a uniq one. if (!has_pos(alsa_6chans, SND_CHMAP_FL) || !has_pos(alsa_6chans, SND_CHMAP_FR) || !has_pos(alsa_6chans, SND_CHMAP_FC) || !has_pos(alsa_6chans, SND_CHMAP_LFE)) { sdl_6chans[4] = SND_CHMAP_UNKNOWN; sdl_6chans[5] = SND_CHMAP_UNKNOWN; LOGDEBUG("6channels:unsupported channel map"); return; } chan_idx = 0; state = HAVE_NONE; loop { if (chan_idx == 6) break; if (alsa_6chans[chan_idx] == SND_CHMAP_SL || alsa_6chans[chan_idx] == SND_CHMAP_SR) { if (state == HAVE_NONE) { state = HAVE_SIDE; } else if (state == HAVE_REAR) { state = HAVE_BOTH; break; } } else if (alsa_6chans[chan_idx] == SND_CHMAP_RL || alsa_6chans[chan_idx] == SND_CHMAP_RR) { if (state == HAVE_NONE) { state = HAVE_REAR; } else if (state == HAVE_SIDE) { state = HAVE_BOTH; break; } } ++chan_idx; } if (state == HAVE_BOTH || state == HAVE_NONE) { sdl_6chans[4] = SND_CHMAP_UNKNOWN; sdl_6chans[5] = SND_CHMAP_UNKNOWN; LOGDEBUG("6channels:unsupported channel map"); } else if (state == HAVE_REAR) { sdl_6chans[4] = SND_CHMAP_RL; sdl_6chans[5] = SND_CHMAP_RR; LOGDEBUG("6channels:sdl map set to rear"); } else { // state == HAVE_SIDE sdl_6chans[4] = SND_CHMAP_SL; sdl_6chans[5] = SND_CHMAP_SR; LOGDEBUG("6channels:sdl map set to side"); } } #undef HAVE_NONE #undef HAVE_REAR #undef HAVE_SIDE #undef HAVE_BOTH static void swizzle_map_compute_alsa_subscan(struct ALSA_pcm_cfg_ctx *ctx, unsigned int sdl_pos_idx) { unsigned int alsa_pos_idx = 0; loop { SDL_assert(alsa_pos_idx != ctx->chans_n); // no 0 channels or not found matching position should happen here (actually enforce playback/capture symmetry). if (ctx->alsa_chmap_installed[alsa_pos_idx] == ctx->sdl_chmap[sdl_pos_idx]) { LOGDEBUG("swizzle sdl %u <-> alsa %u", sdl_pos_idx,alsa_pos_idx); ctx->device->hidden->swizzle_map[sdl_pos_idx] = alsa_pos_idx; return; } ++alsa_pos_idx; } } // XXX: this must stay playback/capture symetric. static void swizzle_map_compute(struct ALSA_pcm_cfg_ctx *ctx) { unsigned int sdl_pos_idx = 0; loop { if (sdl_pos_idx == ctx->chans_n) break; swizzle_map_compute_alsa_subscan(ctx, sdl_pos_idx); ++sdl_pos_idx; } } #define CHMAP_INSTALLED 0 #define REDUCE_CHANS_N 1 #define CHMAP_NOT_FOUND 2 // Should always be a queried alsa channel map unless the queried alsa channel map was of type VAR, // namely we can program the channel positions directly from the sdl channel map. static int alsa_chmap_install(struct ALSA_pcm_cfg_ctx *ctx, unsigned int *chmap) { int status; char logdebug_chmap_str[128]; snd_pcm_chmap_t *chmap_to_install = (snd_pcm_chmap_t*)SDL_stack_alloc(unsigned int, 1 + ctx->chans_n); chmap_to_install->channels = ctx->chans_n; SDL_memcpy(chmap_to_install->pos, chmap, sizeof(unsigned int) * ctx->chans_n); ALSA_snd_pcm_chmap_print(chmap_to_install,sizeof(logdebug_chmap_str),logdebug_chmap_str); LOGDEBUG("channel map to install:%s",logdebug_chmap_str); status = ALSA_snd_pcm_set_chmap(ctx->device->hidden->pcm, chmap_to_install); if (status < 0) { return SDL_SetError("ALSA: failed to install channel map: %s", ALSA_snd_strerror(status)); } SDL_memcpy(ctx->alsa_chmap_installed, chmap, ctx->chans_n * sizeof(unsigned int)); return CHMAP_INSTALLED; } // We restrict the alsa channel maps because in the unordered matches we do only simple accounting. // This is to handle mostly alsa channel maps with SND_CHMAP_NA position fillers (or weird...). static SDL_bool alsa_chmap_has_duplicate_position(struct ALSA_pcm_cfg_ctx *ctx, unsigned int *pos) { unsigned int chan_idx; if (ctx->chans_n < 2) {// we need at least 2 positions LOGDEBUG("channel map:no duplicate"); return SDL_FALSE; } chan_idx = 1; loop { unsigned seen_idx; if (chan_idx == ctx->chans_n) { LOGDEBUG("channel map:no duplicate"); return SDL_FALSE; } seen_idx = 0; loop { if (pos[seen_idx] == pos[chan_idx]) { LOGDEBUG("channel map:have duplicate"); return SDL_TRUE; } ++seen_idx; if (seen_idx == chan_idx) break; } ++chan_idx; } } static int alsa_chmap_cfg_ordered_fixed_or_paired(struct ALSA_pcm_cfg_ctx *ctx) { char logdebug_chmap_str[128]; snd_pcm_chmap_query_t **chmap_query = ctx->chmap_queries; loop { unsigned int chan_idx; unsigned int *alsa_chmap; if (*chmap_query == NULL) break; if (((*chmap_query)->map.channels != ctx->chans_n) || ((*chmap_query)->type != SND_CHMAP_TYPE_FIXED && (*chmap_query)->type != SND_CHMAP_TYPE_PAIRED)) { ++chmap_query; continue; } ALSA_snd_pcm_chmap_print(&(*chmap_query)->map,sizeof(logdebug_chmap_str),logdebug_chmap_str); LOGDEBUG("channel map:ordered:fixed|paired:%s",logdebug_chmap_str); alsa_chmap = (*chmap_query)->map.pos; SDL_memcpy(ctx->sdl_chmap, sdl_channel_maps[ctx->chans_n], ctx->chans_n * sizeof(unsigned int)); if (ctx->chans_n == 6) sdl_6chans_set_rear_or_side_channels_from_alsa_6chans(ctx->sdl_chmap, alsa_chmap); if (alsa_chmap_has_duplicate_position(ctx, alsa_chmap)) { ++chmap_query; continue; } chan_idx = 0; loop { if (chan_idx == ctx->chans_n) return alsa_chmap_install(ctx, alsa_chmap); if (ctx->sdl_chmap[chan_idx] != alsa_chmap[chan_idx]) break; // nope, try next alsa channel map. ++chan_idx; } ++chmap_query; } return CHMAP_NOT_FOUND; } // Here, the alsa channel positions can be programmed in the alsa frame (cf HDMI). // If the alsa channel map is VAR, we only check we have the unordered set of channel positions we // are looking for. static int alsa_chmap_cfg_ordered_var(struct ALSA_pcm_cfg_ctx *ctx) { char logdebug_chmap_str[128]; snd_pcm_chmap_query_t **chmap_query = ctx->chmap_queries; loop { unsigned int pos_matches_n; unsigned int chan_idx; unsigned int *alsa_chmap; if (*chmap_query == NULL) break; if ((*chmap_query)->map.channels != ctx->chans_n || (*chmap_query)->type != SND_CHMAP_TYPE_VAR) { ++chmap_query; continue; } ALSA_snd_pcm_chmap_print(&(*chmap_query)->map,sizeof(logdebug_chmap_str),logdebug_chmap_str); LOGDEBUG("channel map:ordered:var:%s",logdebug_chmap_str); alsa_chmap = (*chmap_query)->map.pos; SDL_memcpy(ctx->sdl_chmap, sdl_channel_maps[ctx->chans_n], ctx->chans_n * sizeof(unsigned int)); if (ctx->chans_n == 6) sdl_6chans_set_rear_or_side_channels_from_alsa_6chans(ctx->sdl_chmap, alsa_chmap); if (alsa_chmap_has_duplicate_position(ctx, alsa_chmap)) { ++chmap_query; continue; } pos_matches_n = 0; chan_idx = 0; loop { unsigned int subscan_chan_idx; if (chan_idx == ctx->chans_n) break; subscan_chan_idx = 0; loop { if (subscan_chan_idx == ctx->chans_n) break; if (ctx->sdl_chmap[chan_idx] == alsa_chmap[subscan_chan_idx]) { ++pos_matches_n; break; } ++subscan_chan_idx; } ++chan_idx; } if (pos_matches_n == ctx->chans_n) return alsa_chmap_install(ctx, ctx->sdl_chmap); // XXX: we program the sdl chmap here ++chmap_query; } return CHMAP_NOT_FOUND; } static int alsa_chmap_cfg_ordered(struct ALSA_pcm_cfg_ctx *ctx) { int status; status = alsa_chmap_cfg_ordered_fixed_or_paired(ctx); if (status != CHMAP_NOT_FOUND) return status; return alsa_chmap_cfg_ordered_var(ctx); } // In the unordered case, we are just interested to get the same unordered set of alsa channel // positions than in the sdl channel map since we will swizzle (no duplicate channel position). static int alsa_chmap_cfg_unordered(struct ALSA_pcm_cfg_ctx *ctx) { char logdebug_chmap_str[128]; snd_pcm_chmap_query_t **chmap_query = ctx->chmap_queries; loop { unsigned int pos_matches_n; unsigned int chan_idx; unsigned int *alsa_chmap; if (*chmap_query == NULL) break; if (((*chmap_query)->map.channels != ctx->chans_n) || ((*chmap_query)->type != SND_CHMAP_TYPE_FIXED && (*chmap_query)->type != SND_CHMAP_TYPE_PAIRED)) { ++chmap_query; continue; } ALSA_snd_pcm_chmap_print(&(*chmap_query)->map,sizeof(logdebug_chmap_str),logdebug_chmap_str); LOGDEBUG("channel map:unordered:fixed|paired:%s",logdebug_chmap_str); alsa_chmap = (*chmap_query)->map.pos; SDL_memcpy(ctx->sdl_chmap, sdl_channel_maps[ctx->chans_n], ctx->chans_n * sizeof(unsigned int)); if (ctx->chans_n == 6) sdl_6chans_set_rear_or_side_channels_from_alsa_6chans(ctx->sdl_chmap, alsa_chmap); if (alsa_chmap_has_duplicate_position(ctx, alsa_chmap)) { ++chmap_query; continue; } pos_matches_n = 0; chan_idx = 0; loop { unsigned int subscan_chan_idx; if (chan_idx == ctx->chans_n) break; subscan_chan_idx = 0; loop { if (subscan_chan_idx == ctx->chans_n) break; if (ctx->sdl_chmap[chan_idx] == alsa_chmap[subscan_chan_idx]) { ++pos_matches_n; break; } ++subscan_chan_idx; } ++chan_idx; } if (pos_matches_n == ctx->chans_n) return alsa_chmap_install(ctx, alsa_chmap); ++chmap_query; } return CHMAP_NOT_FOUND; } static int alsa_chmap_cfg(struct ALSA_pcm_cfg_ctx *ctx) { int status; ctx->chmap_queries = ALSA_snd_pcm_query_chmaps(ctx->device->hidden->pcm); if (ctx->chmap_queries == NULL) // let's try to reduce the number of channels anyway... return REDUCE_CHANS_N; //---------------------------------------------------------------------------------------------- status = alsa_chmap_cfg_ordered(ctx); // we prefer first channel maps we don't need to swizzle if (status == CHMAP_INSTALLED) { LOGDEBUG("swizzling off"); ctx->device->hidden->swizzle_func = no_swizzle; return 0; } if (status != CHMAP_NOT_FOUND) return status; // < 0 error code // Fall-thru //---------------------------------------------------------------------------------------------- status = alsa_chmap_cfg_unordered(ctx); // those we will have to swizzle if (status == CHMAP_INSTALLED) { LOGDEBUG("swizzling on"); swizzle_map_compute(ctx); // fine grained swizzle configuration ctx->device->hidden->swizzle_func = swizzle_alsa_channels; return 0; } if (status == CHMAP_NOT_FOUND) return REDUCE_CHANS_N; return status; // < 0 error code } static int ALSA_pcm_cfg_hw(struct ALSA_pcm_cfg_ctx *ctx) { unsigned int target_chans_n = ctx->device->spec.channels; // we start at what was specified loop { int status; snd_pcm_format_t alsa_format; const SDL_AudioFormat *closefmts; if (target_chans_n == 0) { return SDL_SetError("ALSA: tried all numbers of channels"); } status = ALSA_snd_pcm_hw_params_any(ctx->device->hidden->pcm, ctx->hwparams); if (status < 0) { return SDL_SetError("ALSA: Couldn't get hardware config: %s", ALSA_snd_strerror(status)); } // SDL only uses interleaved sample output status = ALSA_snd_pcm_hw_params_set_access(ctx->device->hidden->pcm, ctx->hwparams, SND_PCM_ACCESS_RW_INTERLEAVED); if (status < 0) { return SDL_SetError("ALSA: Couldn't set interleaved access: %s", ALSA_snd_strerror(status)); } // Try for a closest match on audio format alsa_format = 0; closefmts = SDL_ClosestAudioFormats(ctx->device->spec.format); ctx->matched_sdl_format = 0; while ((ctx->matched_sdl_format = *(closefmts++)) != 0) { // XXX: we are forcing the same endianness, namely we won't need byte swapping upon // writing/reading to/from the SDL audio buffer. switch (ctx->matched_sdl_format) { case SDL_AUDIO_U8: alsa_format = SND_PCM_FORMAT_U8; break; case SDL_AUDIO_S8: alsa_format = SND_PCM_FORMAT_S8; break; case SDL_AUDIO_S16LE: alsa_format = SND_PCM_FORMAT_S16_LE; break; case SDL_AUDIO_S16BE: alsa_format = SND_PCM_FORMAT_S16_BE; break; case SDL_AUDIO_S32LE: alsa_format = SND_PCM_FORMAT_S32_LE; break; case SDL_AUDIO_S32BE: alsa_format = SND_PCM_FORMAT_S32_BE; break; case SDL_AUDIO_F32LE: alsa_format = SND_PCM_FORMAT_FLOAT_LE; break; case SDL_AUDIO_F32BE: alsa_format = SND_PCM_FORMAT_FLOAT_BE; break; default: continue; } if (ALSA_snd_pcm_hw_params_set_format(ctx->device->hidden->pcm, ctx->hwparams, alsa_format) >= 0) { break; } } if (ctx->matched_sdl_format == 0) { return SDL_SetError("ALSA: Unsupported audio format: %s", ALSA_snd_strerror(status)); } // let alsa approximate the number of channels ctx->chans_n = target_chans_n; status = ALSA_snd_pcm_hw_params_set_channels_near(ctx->device->hidden->pcm, ctx->hwparams, &(ctx->chans_n)); if (status < 0) { return SDL_SetError("ALSA: Couldn't set audio channels: %s", ALSA_snd_strerror(status)); } // let alsa approximate the audio rate ctx->rate = ctx->device->spec.freq; status = ALSA_snd_pcm_hw_params_set_rate_near(ctx->device->hidden->pcm, ctx->hwparams, &(ctx->rate), NULL); if (status < 0) { return SDL_SetError("ALSA: Couldn't set audio frequency: %s", ALSA_snd_strerror(status)); } // let approximate the period size to the requested buffer size ctx->persize = ctx->device->sample_frames; status = ALSA_snd_pcm_hw_params_set_period_size_near(ctx->device->hidden->pcm, ctx->hwparams, &(ctx->persize), NULL); if (status < 0) { return SDL_SetError("ALSA: Couldn't set the period size: %s", ALSA_snd_strerror(status)); } // let approximate the minimun number of periods per buffer (we target a double buffer) ctx->periods = 2; status = ALSA_snd_pcm_hw_params_set_periods_min(ctx->device->hidden->pcm, ctx->hwparams, &(ctx->periods), NULL); if (status < 0) { return SDL_SetError("ALSA: Couldn't set the minimum number of periods per buffer: %s", ALSA_snd_strerror(status)); } // restrict the number of periods per buffer to an approximation of the approximated minimum // number of periods per buffer done right above status = ALSA_snd_pcm_hw_params_set_periods_first(ctx->device->hidden->pcm, ctx->hwparams, &(ctx->periods), NULL); if (status < 0) { return SDL_SetError("ALSA: Couldn't set the number of periods per buffer: %s", ALSA_snd_strerror(status)); } // install the hw parameters status = ALSA_snd_pcm_hw_params(ctx->device->hidden->pcm, ctx->hwparams); if (status < 0) { return SDL_SetError("ALSA: installation of hardware parameter failed: %s", ALSA_snd_strerror(status)); } //========================================================================================== // Here the alsa pcm is in SND_PCM_STATE_PREPARED state, let's figure out a good fit for // SDL channel map, it may request to reduce the number of channels though. status = alsa_chmap_cfg(ctx); if (status < 0) return status; // we forward the SDL error if (status == CHMAP_INSTALLED) return 0; // we are finished here // status == REDUCE_CHANS_N LOGDEBUG("reducing target chans_n to %u\n",target_chans_n-1); ALSA_snd_pcm_free_chmaps(ctx->chmap_queries); ALSA_snd_pcm_hw_free(ctx->device->hidden->pcm); // uninstall those hw params target_chans_n--; } } #undef CHMAP_INSTALLED #undef REDUCE_CHANS_N #undef CHMAP_NOT_FOUND static int ALSA_pcm_cfg_sw(struct ALSA_pcm_cfg_ctx *ctx) { int status; status = ALSA_snd_pcm_sw_params_current(ctx->device->hidden->pcm, ctx->swparams); if (status < 0) { return SDL_SetError("ALSA: Couldn't get software config: %s", ALSA_snd_strerror(status)); } status = ALSA_snd_pcm_sw_params_set_avail_min(ctx->device->hidden->pcm, ctx->swparams, ctx->persize); // will become device->sample_frames if the alsa pcm configuration is successful if (status < 0) { return SDL_SetError("Couldn't set minimum available samples: %s", ALSA_snd_strerror(status)); } status = ALSA_snd_pcm_sw_params_set_start_threshold(ctx->device->hidden->pcm, ctx->swparams, 1); if (status < 0) { return SDL_SetError("ALSA: Couldn't set start threshold: %s", ALSA_snd_strerror(status)); } status = ALSA_snd_pcm_sw_params(ctx->device->hidden->pcm, ctx->swparams); if (status < 0) { return SDL_SetError("Couldn't set software audio parameters: %s", ALSA_snd_strerror(status)); } return 0; } static int ALSA_OpenDevice(SDL_AudioDevice *device) { struct ALSA_pcm_cfg_ctx cfg_ctx; // used to track everything here int status = 0; char *pcm_str; const SDL_bool iscapture = device->iscapture; //device->spec.channels = 8; //SDL_LogSetPriority(SDL_LOG_CATEGORY_AUDIO, SDL_LOG_PRIORITY_VERBOSE); LOGDEBUG("channels requested %u",device->spec.channels); memset(&cfg_ctx,0,sizeof(cfg_ctx)); cfg_ctx.device = device; // Initialize all variables that we clean on shutdown cfg_ctx.device->hidden = (struct SDL_PrivateAudioData *)SDL_calloc(1, sizeof(*cfg_ctx.device->hidden)); if (cfg_ctx.device->hidden == NULL) { return SDL_OutOfMemory(); } // Open the audio device pcm_str = get_pcm_str(cfg_ctx.device->handle); if (pcm_str == NULL) { status = SDL_OutOfMemory(); goto err_free_device_hidden; } status = ALSA_snd_pcm_open(&cfg_ctx.device->hidden->pcm, pcm_str, iscapture ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK); SDL_free(pcm_str); if (status < 0) { status = SDL_SetError("ALSA: Couldn't open audio device: %s", ALSA_snd_strerror(status)); goto err_free_device_hidden; } // Now we need to configure the opened pcm as close as possible from the requested parameters we // can reasonably deal with (and that could change) snd_pcm_hw_params_alloca(&(cfg_ctx.hwparams)); snd_pcm_sw_params_alloca(&(cfg_ctx.swparams)); status = ALSA_pcm_cfg_hw(&cfg_ctx); // alsa pcm "hardware" part of the pcm if (status < 0) { goto err_close_pcm; } // from here, we get only the alsa chmap queries in cfg_ctx to explicitely clean, hwparams is // uninstalled upon pcm closing // This is useful for debugging if (SDL_getenv("SDL_AUDIO_ALSA_DEBUG")) { snd_pcm_uframes_t bufsize; ALSA_snd_pcm_hw_params_get_buffer_size(cfg_ctx.hwparams, &bufsize); SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "ALSA: period size = %ld, periods = %u, buffer size = %lu", cfg_ctx.persize, cfg_ctx.periods, bufsize); } status = ALSA_pcm_cfg_sw(&cfg_ctx); // alsa pcm "software" part of the pcm if (status < 0) { goto err_cleanup_ctx; } // Now we can update the following parameters in the spec: cfg_ctx.device->spec.format = cfg_ctx.matched_sdl_format; cfg_ctx.device->spec.channels = cfg_ctx.chans_n; cfg_ctx.device->spec.freq = cfg_ctx.rate; cfg_ctx.device->sample_frames = cfg_ctx.persize; // Calculate the final parameters for this audio specification SDL_UpdatedAudioDeviceFormat(cfg_ctx.device); // Allocate mixing buffer if (!iscapture) { cfg_ctx.device->hidden->mixbuf = (Uint8 *)SDL_malloc(cfg_ctx.device->buffer_size); if (cfg_ctx.device->hidden->mixbuf == NULL) { status = SDL_OutOfMemory(); goto err_cleanup_ctx; } SDL_memset(cfg_ctx.device->hidden->mixbuf, cfg_ctx.device->silence_value, cfg_ctx.device->buffer_size); } #if !SDL_ALSA_NON_BLOCKING if (!iscapture) { ALSA_snd_pcm_nonblock(cfg_ctx.device->hidden->pcm, 0); } #endif ALSA_snd_pcm_start(cfg_ctx.device->hidden->pcm); return 0; // We're ready to rock and roll. :-) err_cleanup_ctx: ALSA_snd_pcm_free_chmaps(cfg_ctx.chmap_queries); err_close_pcm: ALSA_snd_pcm_close(cfg_ctx.device->hidden->pcm); err_free_device_hidden: SDL_free(cfg_ctx.device->hidden); cfg_ctx.device->hidden = NULL; return status; } static ALSA_Device *hotplug_devices = NULL; static int hotplug_device_process(snd_ctl_t *ctl, snd_ctl_card_info_t *ctl_card_info, int dev_idx, snd_pcm_stream_t direction, ALSA_Device **unseen, ALSA_Device **seen) { int r; unsigned int subdevs_n; unsigned int subdev_idx; snd_pcm_info_t *pcm_info; SDL_bool iscapture = direction == SND_PCM_STREAM_CAPTURE ? SDL_TRUE : SDL_FALSE; // used for the unicity of the device pcm_info = (snd_pcm_info_t*)SDL_stack_alloc(Uint8,ALSA_snd_pcm_info_sizeof()); memset(pcm_info,0,ALSA_snd_pcm_info_sizeof()); subdev_idx = 0; subdevs_n = 1; // we have at least one subdevice (substream since the direction is a stream in alsa terminology) loop { ALSA_Device *unseen_prev_adev; ALSA_Device *adev; ALSA_snd_pcm_info_set_stream(pcm_info, direction); ALSA_snd_pcm_info_set_device(pcm_info, dev_idx); ALSA_snd_pcm_info_set_subdevice(pcm_info, subdev_idx); // we have at least one subdevice (substream) of index 0 r = ALSA_snd_ctl_pcm_info(ctl, pcm_info); if (r < 0) { // first call to ALSA_snd_ctl_pcm_info if (subdev_idx == 0 && r == -ENOENT) // no such direction/stream for this device return 0; return -1; } if (subdev_idx == 0) subdevs_n = ALSA_snd_pcm_info_get_subdevices_count(pcm_info); // building the unseen list scanning the list of hotplug devices, if it is already there // using the id, move it to the seen list. unseen_prev_adev = NULL; adev = *unseen; loop { if (adev == NULL) break; // the unicity key is the couple (id,iscapture) if (SDL_strcmp(adev->id, ALSA_snd_ctl_card_info_get_id(ctl_card_info)) == 0 && adev->iscapture == iscapture) { // unchain from unseen if (*unseen == adev) // head *unseen = adev->next; else unseen_prev_adev->next = adev->next; // chain to seen adev->next = *seen; *seen = adev; break; } unseen_prev_adev = adev; adev = adev->next; } if (adev == NULL) { // newly seen device int name_len; adev = SDL_malloc(sizeof(*adev)); if (adev == NULL) return SDL_OutOfMemory(); adev->id = SDL_strdup(ALSA_snd_ctl_card_info_get_id(ctl_card_info)); if (adev->id == NULL) { SDL_free(adev); return SDL_OutOfMemory(); } #define NAME_FMT "%s:%s" name_len = SDL_snprintf(0,0,NAME_FMT, ALSA_snd_ctl_card_info_get_name(ctl_card_info), ALSA_snd_pcm_info_get_name(pcm_info)); adev->name = SDL_malloc((size_t)(name_len + 1)); if (adev->name == NULL) { SDL_free(adev->id); SDL_free(adev); return SDL_OutOfMemory(); } SDL_snprintf(adev->name,(size_t)(name_len + 1),NAME_FMT, ALSA_snd_ctl_card_info_get_name(ctl_card_info), ALSA_snd_pcm_info_get_name(pcm_info)); #undef NAME_FMT if (direction == SND_PCM_STREAM_CAPTURE) adev->iscapture = SDL_TRUE; else adev->iscapture = SDL_FALSE; if (SDL_AddAudioDevice(iscapture, adev->name, NULL, adev) == NULL) { SDL_free(adev->id); SDL_free(adev->name); SDL_free(adev); return SDL_OutOfMemory(); } adev->id = SDL_strdup(ALSA_snd_ctl_card_info_get_id(ctl_card_info)); adev->name = SDL_strdup(ALSA_snd_pcm_info_get_name(pcm_info)); if (direction == SND_PCM_STREAM_CAPTURE) adev->iscapture = SDL_TRUE; else adev->iscapture = SDL_FALSE; adev->next = *seen; *seen = adev; } ++subdev_idx; if (subdev_idx == subdevs_n) return 0; memset(pcm_info,0,ALSA_snd_pcm_info_sizeof()); } } static void ALSA_HotplugIteration(SDL_bool *has_default_output, SDL_bool *has_default_capture) { int r; snd_ctl_t *ctl; int card_idx, dev_idx; snd_ctl_card_info_t *ctl_card_info; ALSA_Device *unseen; ALSA_Device *seen; char ctl_name[sizeof("hw:")+sizeof("4294967295")-1]; if (has_default_output != NULL) *has_default_output = SDL_TRUE; if (has_default_capture != NULL) *has_default_capture = SDL_TRUE; ctl_card_info = alloca(ALSA_snd_ctl_card_info_sizeof()); memset(ctl_card_info,0,ALSA_snd_ctl_card_info_sizeof()); unseen = hotplug_devices; seen = NULL; card_idx = -1; loop { r = ALSA_snd_card_next(&card_idx); if (r < 0) goto error_remove_all_devices; if (card_idx == -1) break; sprintf(ctl_name, "hw:%d", card_idx); // card_idx >= 0 r = ALSA_snd_ctl_open(&ctl, ctl_name, 0); if (r < 0) continue; r = ALSA_snd_ctl_card_info(ctl, ctl_card_info); if (r < 0) goto error_close_ctl; dev_idx = -1; loop { r = ALSA_snd_ctl_pcm_next_device(ctl, &dev_idx); if (r < 0) goto error_close_ctl; if (dev_idx == -1) break; r = hotplug_device_process(ctl, ctl_card_info, dev_idx, SND_PCM_STREAM_PLAYBACK, &unseen, &seen); if (r < 0) goto error_close_ctl; r = hotplug_device_process(ctl, ctl_card_info, dev_idx, SND_PCM_STREAM_CAPTURE, &unseen, &seen); if (r < 0) goto error_close_ctl; } ALSA_snd_ctl_close(ctl); ALSA_snd_ctl_card_info_clear(ctl_card_info); } // remove only the unseen devices loop { ALSA_Device *next; if (unseen == NULL) break; SDL_AudioDeviceDisconnected(SDL_FindPhysicalAudioDeviceByHandle(unseen)); SDL_free(unseen->name); SDL_free(unseen->id); next = unseen->next; SDL_free(unseen); unseen = next; } // update hotplug devices to be the seen devices hotplug_devices = seen; return; error_close_ctl: ALSA_snd_ctl_close(ctl); error_remove_all_devices: // remove the unseen loop { ALSA_Device *next; if (unseen == NULL) break; SDL_AudioDeviceDisconnected(SDL_FindPhysicalAudioDeviceByHandle(unseen)); SDL_free(unseen->name); SDL_free(unseen->id); next = unseen->next; SDL_free(unseen); unseen = next; } // remove the seen loop { ALSA_Device *next; if (seen == NULL) break; SDL_AudioDeviceDisconnected(SDL_FindPhysicalAudioDeviceByHandle(seen)); SDL_free(seen->name); SDL_free(seen->id); next = seen->next; SDL_free(seen); seen = next; } hotplug_devices = NULL; return; } #if SDL_ALSA_HOTPLUG_THREAD static SDL_AtomicInt ALSA_hotplug_shutdown; static SDL_Thread *ALSA_hotplug_thread; static int SDLCALL ALSA_HotplugThread(void *arg) { SDL_SetThreadPriority(SDL_THREAD_PRIORITY_LOW); while (!SDL_AtomicGet(&ALSA_hotplug_shutdown)) { // Block awhile before checking again, unless we're told to stop. const Uint64 ticks = SDL_GetTicks() + 5000; while (!SDL_AtomicGet(&ALSA_hotplug_shutdown) && SDL_GetTicks() < ticks) { SDL_Delay(100); } ALSA_HotplugIteration(NULL, NULL); // run the check. } return 0; } #endif static void ALSA_DetectDevices(SDL_AudioDevice **default_output, SDL_AudioDevice **default_capture) { // ALSA doesn't have a concept of a changeable default device, afaik, so we expose a generic default // device here. It's the best we can do at this level. SDL_bool has_default_output = SDL_FALSE, has_default_capture = SDL_FALSE; ALSA_HotplugIteration(&has_default_output, &has_default_capture); // run once now before a thread continues to check. if (has_default_output) { *default_output = SDL_AddAudioDevice(/*iscapture=*/SDL_FALSE, "ALSA default output device", NULL, (void*)&default_output_handle); } if (has_default_capture) { *default_capture = SDL_AddAudioDevice(/*iscapture=*/SDL_TRUE, "ALSA default capture device", NULL, (void*)&default_capture_handle); } #if SDL_ALSA_HOTPLUG_THREAD SDL_AtomicSet(&ALSA_hotplug_shutdown, 0); ALSA_hotplug_thread = SDL_CreateThread(ALSA_HotplugThread, "SDLHotplugALSA", NULL); // if the thread doesn't spin, oh well, you just don't get further hotplug events. #endif } static void ALSA_DeinitializeStart(void) { ALSA_Device *dev; ALSA_Device *next; #if SDL_ALSA_HOTPLUG_THREAD if (ALSA_hotplug_thread) { SDL_AtomicSet(&ALSA_hotplug_shutdown, 1); SDL_WaitThread(ALSA_hotplug_thread, NULL); ALSA_hotplug_thread = NULL; } #endif // Shutting down! Clean up any data we've gathered. for (dev = hotplug_devices; dev; dev = next) { //SDL_LogInfo(SDL_LOG_CATEGORY_AUDIO, "ALSA: at shutdown, removing %s device '%s'", dev->iscapture ? "capture" : "output", dev->name); next = dev->next; SDL_free(dev->name); SDL_free(dev); } hotplug_devices = NULL; } static void ALSA_Deinitialize(void) { UnloadALSALibrary(); } static SDL_bool ALSA_Init(SDL_AudioDriverImpl *impl) { if (LoadALSALibrary() < 0) { return SDL_FALSE; } impl->DetectDevices = ALSA_DetectDevices; impl->OpenDevice = ALSA_OpenDevice; impl->WaitDevice = ALSA_WaitDevice; impl->GetDeviceBuf = ALSA_GetDeviceBuf; impl->PlayDevice = ALSA_PlayDevice; impl->CloseDevice = ALSA_CloseDevice; impl->DeinitializeStart = ALSA_DeinitializeStart; impl->Deinitialize = ALSA_Deinitialize; impl->WaitCaptureDevice = ALSA_WaitDevice; impl->CaptureFromDevice = ALSA_CaptureFromDevice; impl->FlushCapture = ALSA_FlushCapture; impl->HasCaptureSupport = SDL_TRUE; return SDL_TRUE; } AudioBootStrap ALSA_bootstrap = { "alsa", "ALSA PCM audio", ALSA_Init, SDL_FALSE }; #undef loop #endif // SDL_AUDIO_DRIVER_ALSA