From 30b705cceee1a001a45577f5542af36524e44a1b Mon Sep 17 00:00:00 2001 From: David Reid Date: Sat, 11 Aug 2018 21:07:31 +1000 Subject: [PATCH] Rename the audioio backend to audio(4). --- README.md | 2 +- mini_al.h | 261 +++++++++++++++++++++++++++--------------------------- 2 files changed, 131 insertions(+), 132 deletions(-) diff --git a/README.md b/README.md index cda309ce..f5645310 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ Backends - PulseAudio - JACK - sndio (OpenBSD) -- audioio/audio(4) (NetBSD and OpenBSD) +- audio(4) (NetBSD and OpenBSD) - OSS (FreeBSD) - OpenSL|ES (Android only) - OpenAL diff --git a/mini_al.h b/mini_al.h index 010530e6..1c332b21 100644 --- a/mini_al.h +++ b/mini_al.h @@ -21,7 +21,7 @@ // - PulseAudio // - JACK // - sndio (OpenBSD) -// - audioio/audio(4) (NetBSD and OpenBSD) +// - audio(4) (NetBSD and OpenBSD) // - OSS (FreeBSD) // - OpenSL|ES (Android only) // - OpenAL @@ -121,8 +121,7 @@ // - Sample data is always native-endian and interleaved. For example, mal_format_s16 means signed 16-bit // integer samples, interleaved. Let me know if you need non-interleaved and I'll look into it. // - The sndio backend is currently only enabled on OpenBSD builds. -// - The audioio/audio(4) backend is supported on OpenBSD, but you may need to disable sndiod before you -// can use it. +// - The audio(4) backend is supported on OpenBSD, but you may need to disable sndiod before you can use it. // // // @@ -188,8 +187,8 @@ // #define MAL_NO_SNDIO // Disables the sndio backend. // -// #define MAL_NO_AUDIOIO -// Disables the audioio backend. +// #define MAL_NO_AUDIO4 +// Disables the audio(4) backend. // // #define MAL_NO_OSS // Disables the OSS backend. @@ -1162,7 +1161,7 @@ void mal_pcm_convert(void* pOut, mal_format formatOut, const void* pIn, mal_form #define MAL_SUPPORT_SNDIO // sndio is only supported on OpenBSD for now. May be expanded later if there's demand. #endif #if defined(__NetBSD__) || defined(__OpenBSD__) - #define MAL_SUPPORT_AUDIOIO // Only support audioio on platforms with known support. + #define MAL_SUPPORT_AUDIO4 // Only support audio(4) on platforms with known support. #endif #if defined(__FreeBSD__) || defined(__DragonFly__) #define MAL_SUPPORT_OSS // Only support OSS on specific platforms with known support. @@ -1205,8 +1204,8 @@ void mal_pcm_convert(void* pOut, mal_format formatOut, const void* pIn, mal_form #if !defined(MAL_NO_SNDIO) && defined(MAL_SUPPORT_SNDIO) #define MAL_ENABLE_SNDIO #endif -#if !defined(MAL_NO_AUDIOIO) && defined(MAL_SUPPORT_AUDIOIO) - #define MAL_ENABLE_AUDIOIO +#if !defined(MAL_NO_AUDIO4) && defined(MAL_SUPPORT_AUDIO4) + #define MAL_ENABLE_AUDIO4 #endif #if !defined(MAL_NO_OSS) && defined(MAL_SUPPORT_OSS) #define MAL_ENABLE_OSS @@ -1236,7 +1235,7 @@ typedef enum mal_backend_jack, mal_backend_coreaudio, mal_backend_sndio, - mal_backend_audioio, + mal_backend_audio4, mal_backend_oss, mal_backend_opensl, mal_backend_openal, @@ -1374,8 +1373,8 @@ typedef union #ifdef MAL_SUPPORT_SNDIO char sndio[256]; // "snd/0", etc. #endif -#ifdef MAL_SUPPORT_AUDIOIO - char audioio[256]; // "/dev/audio", etc. +#ifdef MAL_SUPPORT_AUDIO4 + char audio4[256]; // "/dev/audio", etc. #endif #ifdef MAL_SUPPORT_OSS char oss[64]; // "dev/dsp0", etc. "dev/dsp" for the default device. @@ -1709,11 +1708,11 @@ struct mal_context mal_proc sio_initpar; } sndio; #endif -#ifdef MAL_SUPPORT_AUDIOIO +#ifdef MAL_SUPPORT_AUDIO4 struct { int _unused; - } audioio; + } audio4; #endif #ifdef MAL_SUPPORT_OSS struct @@ -2017,14 +2016,14 @@ MAL_ALIGNED_STRUCT(MAL_SIMD_ALIGNMENT) mal_device void* pIntermediaryBuffer; } sndio; #endif -#ifdef MAL_SUPPORT_AUDIOIO +#ifdef MAL_SUPPORT_AUDIO4 struct { int fd; mal_uint32 fragmentSizeInFrames; mal_bool32 breakFromMainLoop; void* pIntermediaryBuffer; - } audioio; + } audio4; #endif #ifdef MAL_SUPPORT_OSS struct @@ -2100,7 +2099,7 @@ MAL_ALIGNED_STRUCT(MAL_SIMD_ALIGNMENT) mal_device // - WinMM // - Core Audio (Apple) // - sndio -// - audioio +// - audio(4) // - OSS // - PulseAudio // - ALSA @@ -3711,8 +3710,8 @@ mal_uint32 mal_get_standard_sample_rate_priority_index(mal_uint32 sampleRate) #ifdef MAL_ENABLE_SNDIO #define MAL_HAS_SNDIO #endif -#ifdef MAL_ENABLE_AUDIOIO - #define MAL_HAS_AUDIOIO // When enabled, always assume audioio is available. +#ifdef MAL_ENABLE_AUDIO4 + #define MAL_HAS_AUDIO4 // When enabled, always assume audio(4) is available. #endif #ifdef MAL_ENABLE_OSS #define MAL_HAS_OSS // OSS is the only supported backend for Unix and BSD, so it must be present else this library is useless. @@ -3758,7 +3757,7 @@ const mal_backend g_malDefaultBackends[] = { mal_backend_winmm, mal_backend_coreaudio, mal_backend_sndio, - mal_backend_audioio, + mal_backend_audio4, mal_backend_oss, mal_backend_pulseaudio, mal_backend_alsa, @@ -3782,7 +3781,7 @@ const char* mal_get_backend_name(mal_backend backend) case mal_backend_jack: return "JACK"; case mal_backend_coreaudio: return "Core Audio"; case mal_backend_sndio: return "sndio"; - case mal_backend_audioio: return "audioio"; + case mal_backend_audio4: return "audio(4)"; case mal_backend_oss: return "OSS"; case mal_backend_opensl: return "OpenSL|ES"; case mal_backend_openal: return "OpenAL"; @@ -15597,24 +15596,24 @@ mal_result mal_context_init__sndio(mal_context* pContext) /////////////////////////////////////////////////////////////////////////////// // -// audioio Backend +// audio(4) Backend // /////////////////////////////////////////////////////////////////////////////// -#ifdef MAL_HAS_AUDIOIO +#ifdef MAL_HAS_AUDIO4 #include #include #include #include -#include +#include #if defined(__OpenBSD__) #include #if defined(OpenBSD) && OpenBSD >= 201709 - #define MAL_AUDIOIO_USE_NEW_API + #define MAL_AUDIO4_USE_NEW_API #endif #endif -void mal_construct_device_id__audioio(char* id, size_t idSize, const char* base, int deviceIndex) +void mal_construct_device_id__audio4(char* id, size_t idSize, const char* base, int deviceIndex) { mal_assert(id != NULL); mal_assert(idSize > 0); @@ -15627,7 +15626,7 @@ void mal_construct_device_id__audioio(char* id, size_t idSize, const char* base, mal_itoa_s(deviceIndex, id+baseLen, idSize-baseLen, 10); } -mal_result mal_extract_device_index_from_id__audioio(const char* id, const char* base, int* pIndexOut) +mal_result mal_extract_device_index_from_id__audio4(const char* id, const char* base, int* pIndexOut) { mal_assert(id != NULL); mal_assert(base != NULL); @@ -15655,18 +15654,18 @@ mal_result mal_extract_device_index_from_id__audioio(const char* id, const char* return MAL_SUCCESS; } -mal_bool32 mal_context_is_device_id_equal__audioio(mal_context* pContext, const mal_device_id* pID0, const mal_device_id* pID1) +mal_bool32 mal_context_is_device_id_equal__audio4(mal_context* pContext, const mal_device_id* pID0, const mal_device_id* pID1) { mal_assert(pContext != NULL); mal_assert(pID0 != NULL); mal_assert(pID1 != NULL); (void)pContext; - return mal_strcmp(pID0->audioio, pID1->audioio) == 0; + return mal_strcmp(pID0->audio4, pID1->audio4) == 0; } -#if !defined(MAL_AUDIOIO_USE_NEW_API) -mal_format mal_format_from_encoding__audioio(unsigned int encoding, unsigned int precision) +#if !defined(MAL_AUDIO4_USE_NEW_API) +mal_format mal_format_from_encoding__audio4(unsigned int encoding, unsigned int precision) { if (precision == 8 && (encoding == AUDIO_ENCODING_ULINEAR || encoding == AUDIO_ENCODING_ULINEAR || encoding == AUDIO_ENCODING_ULINEAR_LE || encoding == AUDIO_ENCODING_ULINEAR_BE)) { return mal_format_u8; @@ -15693,12 +15692,12 @@ mal_format mal_format_from_encoding__audioio(unsigned int encoding, unsigned int return mal_format_unknown; // Encoding not supported. } -mal_format mal_format_from_prinfo__audioio(struct audio_prinfo* prinfo) +mal_format mal_format_from_prinfo__audio4(struct audio_prinfo* prinfo) { - return mal_format_from_encoding__audioio(prinfo->encoding, prinfo->precision); + return mal_format_from_encoding__audio4(prinfo->encoding, prinfo->precision); } #else -mal_format mal_format_from_swpar__audioio(struct audio_swpar* par) +mal_format mal_format_from_swpar__audio4(struct audio_swpar* par) { if (par->bits == 8 && par->bps == 1 && par->sig == 0) { return mal_format_u8; @@ -15718,7 +15717,7 @@ mal_format mal_format_from_swpar__audioio(struct audio_swpar* par) } #endif -mal_result mal_context_get_device_info_from_fd__audioio(mal_context* pContext, mal_device_type deviceType, int fd, mal_device_info* pInfoOut) +mal_result mal_context_get_device_info_from_fd__audio4(mal_context* pContext, mal_device_type deviceType, int fd, mal_device_info* pInfoOut) { mal_assert(pContext != NULL); mal_assert(fd >= 0); @@ -15735,7 +15734,7 @@ mal_result mal_context_get_device_info_from_fd__audioio(mal_context* pContext, m // Name. mal_strcpy_s(pInfoOut->name, sizeof(pInfoOut->name), fdDevice.name); -#if !defined(MAL_AUDIOIO_USE_NEW_API) +#if !defined(MAL_AUDIO4_USE_NEW_API) // Supported formats. We get this by looking at the encodings. int counter = 0; for (;;) { @@ -15746,7 +15745,7 @@ mal_result mal_context_get_device_info_from_fd__audioio(mal_context* pContext, m break; } - mal_format format = mal_format_from_encoding__audioio(encoding.encoding, encoding.precision); + mal_format format = mal_format_from_encoding__audio4(encoding.encoding, encoding.precision); if (format != mal_format_unknown) { pInfoOut->formats[pInfoOut->formatCount++] = format; } @@ -15776,7 +15775,7 @@ mal_result mal_context_get_device_info_from_fd__audioio(mal_context* pContext, m return MAL_ERROR; } - mal_format format = mal_format_from_swpar__audioio(&fdPar); + mal_format format = mal_format_from_swpar__audio4(&fdPar); if (format == mal_format_unknown) { return MAL_FORMAT_NOT_SUPPORTED; } @@ -15797,7 +15796,7 @@ mal_result mal_context_get_device_info_from_fd__audioio(mal_context* pContext, m return MAL_SUCCESS; } -mal_result mal_context_enumerate_devices__audioio(mal_context* pContext, mal_enum_devices_callback_proc callback, void* pUserData) +mal_result mal_context_enumerate_devices__audio4(mal_context* pContext, mal_enum_devices_callback_proc callback, void* pUserData) { mal_assert(pContext != NULL); mal_assert(callback != NULL); @@ -15827,8 +15826,8 @@ mal_result mal_context_enumerate_devices__audioio(mal_context* pContext, mal_enu // Supports playback. mal_device_info deviceInfo; mal_zero_object(&deviceInfo); - mal_construct_device_id__audioio(deviceInfo.id.audioio, sizeof(deviceInfo.id.audioio), "/dev/audio", iDevice); - if (mal_context_get_device_info_from_fd__audioio(pContext, mal_device_type_playback, fd, &deviceInfo) == MAL_SUCCESS) { + mal_construct_device_id__audio4(deviceInfo.id.audio4, sizeof(deviceInfo.id.audio4), "/dev/audio", iDevice); + if (mal_context_get_device_info_from_fd__audio4(pContext, mal_device_type_playback, fd, &deviceInfo) == MAL_SUCCESS) { isTerminating = !callback(pContext, mal_device_type_playback, &deviceInfo, pUserData); } @@ -15843,8 +15842,8 @@ mal_result mal_context_enumerate_devices__audioio(mal_context* pContext, mal_enu // Supports capture. mal_device_info deviceInfo; mal_zero_object(&deviceInfo); - mal_construct_device_id__audioio(deviceInfo.id.audioio, sizeof(deviceInfo.id.audioio), "/dev/audio", iDevice); - if (mal_context_get_device_info_from_fd__audioio(pContext, mal_device_type_capture, fd, &deviceInfo) == MAL_SUCCESS) { + mal_construct_device_id__audio4(deviceInfo.id.audio4, sizeof(deviceInfo.id.audio4), "/dev/audio", iDevice); + if (mal_context_get_device_info_from_fd__audio4(pContext, mal_device_type_capture, fd, &deviceInfo) == MAL_SUCCESS) { isTerminating = !callback(pContext, mal_device_type_capture, &deviceInfo, pUserData); } @@ -15860,7 +15859,7 @@ mal_result mal_context_enumerate_devices__audioio(mal_context* pContext, mal_enu return MAL_SUCCESS; } -mal_result mal_context_get_device_info__audioio(mal_context* pContext, mal_device_type deviceType, const mal_device_id* pDeviceID, mal_share_mode shareMode, mal_device_info* pDeviceInfo) +mal_result mal_context_get_device_info__audio4(mal_context* pContext, mal_device_type deviceType, const mal_device_id* pDeviceID, mal_share_mode shareMode, mal_device_info* pDeviceInfo) { mal_assert(pContext != NULL); (void)shareMode; @@ -15875,12 +15874,12 @@ mal_result mal_context_get_device_info__audioio(mal_context* pContext, mal_devic mal_strcpy_s(ctlid, sizeof(ctlid), "/dev/audioctl"); } else { // Specific device. We need to convert from "/dev/audioN" to "/dev/audioctlN". - mal_result result = mal_extract_device_index_from_id__audioio(pDeviceID->audioio, "/dev/audio", &deviceIndex); + mal_result result = mal_extract_device_index_from_id__audio4(pDeviceID->audio4, "/dev/audio", &deviceIndex); if (result != MAL_SUCCESS) { return result; } - mal_construct_device_id__audioio(ctlid, sizeof(ctlid), "/dev/audioctl", deviceIndex); + mal_construct_device_id__audio4(ctlid, sizeof(ctlid), "/dev/audioctl", deviceIndex); } fd = open(ctlid, (deviceType == mal_device_type_playback) ? O_WRONLY : O_RDONLY, 0); @@ -15889,44 +15888,44 @@ mal_result mal_context_get_device_info__audioio(mal_context* pContext, mal_devic } if (deviceIndex == -1) { - mal_strcpy_s(pDeviceInfo->id.audioio, sizeof(pDeviceInfo->id.audioio), "/dev/audio"); + mal_strcpy_s(pDeviceInfo->id.audio4, sizeof(pDeviceInfo->id.audio4), "/dev/audio"); } else { - mal_construct_device_id__audioio(pDeviceInfo->id.audioio, sizeof(pDeviceInfo->id.audioio), "/dev/audio", deviceIndex); + mal_construct_device_id__audio4(pDeviceInfo->id.audio4, sizeof(pDeviceInfo->id.audio4), "/dev/audio", deviceIndex); } - mal_result result = mal_context_get_device_info_from_fd__audioio(pContext, deviceType, fd, pDeviceInfo); + mal_result result = mal_context_get_device_info_from_fd__audio4(pContext, deviceType, fd, pDeviceInfo); close(fd); return result; } -void mal_device_uninit__audioio(mal_device* pDevice) +void mal_device_uninit__audio4(mal_device* pDevice) { mal_assert(pDevice != NULL); - close(pDevice->audioio.fd); - mal_free(pDevice->audioio.pIntermediaryBuffer); + close(pDevice->audio4.fd); + mal_free(pDevice->audio4.pIntermediaryBuffer); } -mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type deviceType, const mal_device_id* pDeviceID, const mal_device_config* pConfig, mal_device* pDevice) +mal_result mal_device_init__audio4(mal_context* pContext, mal_device_type deviceType, const mal_device_id* pDeviceID, const mal_device_config* pConfig, mal_device* pDevice) { (void)pContext; mal_assert(pDevice != NULL); - mal_zero_object(&pDevice->audioio); + mal_zero_object(&pDevice->audio4); // The first thing to do is open the file. const char* deviceName = "/dev/audio"; if (pDeviceID != NULL) { - deviceName = pDeviceID->audioio; + deviceName = pDeviceID->audio4; } - pDevice->audioio.fd = open(deviceName, (deviceType == mal_device_type_playback) ? O_WRONLY : O_RDONLY, 0); - if (pDevice->audioio.fd == -1) { - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to open device.", MAL_FAILED_TO_OPEN_BACKEND_DEVICE); + pDevice->audio4.fd = open(deviceName, (deviceType == mal_device_type_playback) ? O_WRONLY : O_RDONLY, 0); + if (pDevice->audio4.fd == -1) { + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to open device.", MAL_FAILED_TO_OPEN_BACKEND_DEVICE); } -#if !defined(MAL_AUDIOIO_USE_NEW_API) +#if !defined(MAL_AUDIO4_USE_NEW_API) audio_info_t fdInfo; AUDIO_INITINFO(&fdInfo); @@ -15939,7 +15938,7 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic fdInfo.mode = AUMODE_RECORD; } - // Format. Note that it looks like audioio does not support floating point formats. In this case + // Format. Note that it looks like audio4 does not support floating point formats. In this case // we just fall back to s16. switch (pDevice->format) { @@ -15974,8 +15973,8 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic mal_device_info nativeInfo; mal_result result = mal_context_get_device_info(pContext, deviceType, pDeviceID, pConfig->shareMode, &nativeInfo); if (result != MAL_SUCCESS) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to retrieve device format.", result); + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to retrieve device format.", result); } prinfo->channels = nativeInfo.maxChannels; @@ -15983,20 +15982,20 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic // We need to apply the settings so far so we can get back the actual sample rate which we need for calculating // the default buffer size below. - if (ioctl(pDevice->audioio.fd, AUDIO_SETINFO, &fdInfo) < 0) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to set device format. AUDIO_SETINFO failed.", MAL_FORMAT_NOT_SUPPORTED); + if (ioctl(pDevice->audio4.fd, AUDIO_SETINFO, &fdInfo) < 0) { + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to set device format. AUDIO_SETINFO failed.", MAL_FORMAT_NOT_SUPPORTED); } - if (ioctl(pDevice->audioio.fd, AUDIO_GETINFO, &fdInfo) < 0) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] AUDIO_GETINFO failed.", MAL_FORMAT_NOT_SUPPORTED); + if (ioctl(pDevice->audio4.fd, AUDIO_GETINFO, &fdInfo) < 0) { + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] AUDIO_GETINFO failed.", MAL_FORMAT_NOT_SUPPORTED); } - pDevice->internalFormat = mal_format_from_prinfo__audioio(prinfo); + pDevice->internalFormat = mal_format_from_prinfo__audio4(prinfo); if (pDevice->internalFormat == mal_format_unknown) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] The device's internal device format is not supported by mini_al. The device is unusable.", MAL_FORMAT_NOT_SUPPORTED); + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] The device's internal device format is not supported by mini_al. The device is unusable.", MAL_FORMAT_NOT_SUPPORTED); } pDevice->internalChannels = prinfo->channels; @@ -16009,7 +16008,7 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic pDevice->bufferSizeInFrames = mal_calculate_buffer_size_in_frames_from_milliseconds(pDevice->bufferSizeInMilliseconds, pDevice->internalSampleRate); } - // What mini_al calls a fragment, audioio calls a block. + // What mini_al calls a fragment, audio4 calls a block. mal_uint32 fragmentSizeInBytes = pDevice->bufferSizeInFrames * mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); if (fragmentSizeInBytes < 16) { fragmentSizeInBytes = 16; @@ -16020,25 +16019,25 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic fdInfo.hiwat = mal_max(pDevice->periods, 5); fdInfo.lowat = (unsigned int)(fdInfo.hiwat * 0.75); fdInfo.blocksize = fragmentSizeInBytes / fdInfo.hiwat; - if (ioctl(pDevice->audioio.fd, AUDIO_SETINFO, &fdInfo) < 0) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to set internal buffer size. AUDIO_SETINFO failed.", MAL_FORMAT_NOT_SUPPORTED); + if (ioctl(pDevice->audio4.fd, AUDIO_SETINFO, &fdInfo) < 0) { + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to set internal buffer size. AUDIO_SETINFO failed.", MAL_FORMAT_NOT_SUPPORTED); } pDevice->periods = fdInfo.hiwat; pDevice->bufferSizeInFrames = (fdInfo.blocksize * fdInfo.hiwat) / mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); - pDevice->audioio.fragmentSizeInFrames = fdInfo.blocksize / mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); + pDevice->audio4.fragmentSizeInFrames = fdInfo.blocksize / mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); #else // We need to retrieve the format of the device so we can know the channel count and sample rate. Then we // can calculate the buffer size. struct audio_swpar fdPar; - if (ioctl(pDevice->audioio.fd, AUDIO_GETPAR, &fdPar) < 0) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to retrieve initial device parameters.", MAL_FORMAT_NOT_SUPPORTED); + if (ioctl(pDevice->audio4.fd, AUDIO_GETPAR, &fdPar) < 0) { + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to retrieve initial device parameters.", MAL_FORMAT_NOT_SUPPORTED); } // Set the initial internal formats so we can do calculations below. - pDevice->internalFormat = mal_format_from_swpar__audioio(&fdPar); + pDevice->internalFormat = mal_format_from_swpar__audio4(&fdPar); if (deviceType == mal_device_type_playback) { pDevice->internalChannels = fdPar.pchan; } else { @@ -16050,7 +16049,7 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic pDevice->bufferSizeInFrames = mal_calculate_buffer_size_in_frames_from_milliseconds(pDevice->bufferSizeInMilliseconds, pDevice->internalSampleRate); } - // What mini_al calls a fragment, audioio calls a block. + // What mini_al calls a fragment, audio4 calls a block. mal_uint32 bufferSizeInBytes = pDevice->bufferSizeInFrames * mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); if (bufferSizeInBytes < 16) { bufferSizeInBytes = 16; @@ -16059,17 +16058,17 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic fdPar.nblks = pDevice->periods; fdPar.round = bufferSizeInBytes / fdPar.nblks; - if (ioctl(pDevice->audioio.fd, AUDIO_SETPAR, &fdPar) < 0) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to set device parameters.", MAL_FORMAT_NOT_SUPPORTED); + if (ioctl(pDevice->audio4.fd, AUDIO_SETPAR, &fdPar) < 0) { + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to set device parameters.", MAL_FORMAT_NOT_SUPPORTED); } - if (ioctl(pDevice->audioio.fd, AUDIO_GETPAR, &fdPar) < 0) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to retrieve actual device parameters.", MAL_FORMAT_NOT_SUPPORTED); + if (ioctl(pDevice->audio4.fd, AUDIO_GETPAR, &fdPar) < 0) { + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to retrieve actual device parameters.", MAL_FORMAT_NOT_SUPPORTED); } - pDevice->internalFormat = mal_format_from_swpar__audioio(&fdPar); + pDevice->internalFormat = mal_format_from_swpar__audio4(&fdPar); if (deviceType == mal_device_type_playback) { pDevice->internalChannels = fdPar.pchan; } else { @@ -16079,7 +16078,7 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic pDevice->periods = fdPar.nblks; pDevice->bufferSizeInFrames = (fdPar.nblks * fdPar.round) / mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); - pDevice->audioio.fragmentSizeInFrames = fdPar.round / mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); + pDevice->audio4.fragmentSizeInFrames = fdPar.round / mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels); #endif @@ -16090,17 +16089,17 @@ mal_result mal_device_init__audioio(mal_context* pContext, mal_device_type devic // When not using MMAP mode we need to use an intermediary buffer to the data transfer between the client // and device. Everything is done by the size of a fragment. - pDevice->audioio.pIntermediaryBuffer = mal_malloc(pDevice->audioio.fragmentSizeInFrames * mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels)); - if (pDevice->audioio.pIntermediaryBuffer == NULL) { - close(pDevice->audioio.fd); - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to allocate memory for intermediary buffer.", MAL_OUT_OF_MEMORY); + pDevice->audio4.pIntermediaryBuffer = mal_malloc(pDevice->audio4.fragmentSizeInFrames * mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels)); + if (pDevice->audio4.pIntermediaryBuffer == NULL) { + close(pDevice->audio4.fd); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to allocate memory for intermediary buffer.", MAL_OUT_OF_MEMORY); } return MAL_SUCCESS; } -mal_result mal_device__start_backend__audioio(mal_device* pDevice) +mal_result mal_device__start_backend__audio4(mal_device* pDevice) { mal_assert(pDevice != NULL); @@ -16111,11 +16110,11 @@ mal_result mal_device__start_backend__audioio(mal_device* pDevice) if (pDevice->type == mal_device_type_playback) { // Playback. Need to load the entire buffer, which means we need to write a fragment for each period. for (mal_uint32 iPeriod = 0; iPeriod < pDevice->periods; iPeriod += 1) { - mal_device__read_frames_from_client(pDevice, pDevice->audioio.fragmentSizeInFrames, pDevice->audioio.pIntermediaryBuffer); + mal_device__read_frames_from_client(pDevice, pDevice->audio4.fragmentSizeInFrames, pDevice->audio4.pIntermediaryBuffer); - int bytesWritten = write(pDevice->audioio.fd, pDevice->audioio.pIntermediaryBuffer, pDevice->audioio.fragmentSizeInFrames * mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels)); + int bytesWritten = write(pDevice->audio4.fd, pDevice->audio4.pIntermediaryBuffer, pDevice->audio4.fragmentSizeInFrames * mal_get_bytes_per_frame(pDevice->internalFormat, pDevice->internalChannels)); if (bytesWritten == -1) { - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to send initial chunk of data to the device.", MAL_FAILED_TO_SEND_DATA_TO_DEVICE); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to send initial chunk of data to the device.", MAL_FAILED_TO_SEND_DATA_TO_DEVICE); } } } else { @@ -16125,37 +16124,37 @@ mal_result mal_device__start_backend__audioio(mal_device* pDevice) return MAL_SUCCESS; } -mal_result mal_device__stop_backend__audioio(mal_device* pDevice) +mal_result mal_device__stop_backend__audio4(mal_device* pDevice) { mal_assert(pDevice != NULL); #if defined(__NetBSD__) - if (ioctl(pDevice->audioio.fd, AUDIO_FLUSH, 0) < 0) { - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to stop device. AUDIO_FLUSH failed.", MAL_FAILED_TO_STOP_BACKEND_DEVICE); + if (ioctl(pDevice->audio4.fd, AUDIO_FLUSH, 0) < 0) { + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to stop device. AUDIO_FLUSH failed.", MAL_FAILED_TO_STOP_BACKEND_DEVICE); } #else - if (ioctl(pDevice->audioio.fd, AUDIO_STOP, 0) < 0) { - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to stop device. AUDIO_FLUSH failed.", MAL_FAILED_TO_STOP_BACKEND_DEVICE); + if (ioctl(pDevice->audio4.fd, AUDIO_STOP, 0) < 0) { + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to stop device. AUDIO_FLUSH failed.", MAL_FAILED_TO_STOP_BACKEND_DEVICE); } #endif return MAL_SUCCESS; } -mal_result mal_device__break_main_loop__audioio(mal_device* pDevice) +mal_result mal_device__break_main_loop__audio4(mal_device* pDevice) { mal_assert(pDevice != NULL); - pDevice->audioio.breakFromMainLoop = MAL_TRUE; + pDevice->audio4.breakFromMainLoop = MAL_TRUE; return MAL_SUCCESS; } -mal_result mal_device__main_loop__audioio(mal_device* pDevice) +mal_result mal_device__main_loop__audio4(mal_device* pDevice) { mal_assert(pDevice != NULL); - pDevice->audioio.breakFromMainLoop = MAL_FALSE; - while (!pDevice->audioio.breakFromMainLoop) { + pDevice->audio4.breakFromMainLoop = MAL_FALSE; + while (!pDevice->audio4.breakFromMainLoop) { // Break from the main loop if the device isn't started anymore. Likely what's happened is the application // has requested that the device be stopped. if (!mal_device_is_started(pDevice)) { @@ -16164,54 +16163,54 @@ mal_result mal_device__main_loop__audioio(mal_device* pDevice) if (pDevice->type == mal_device_type_playback) { // Playback. - mal_device__read_frames_from_client(pDevice, pDevice->audioio.fragmentSizeInFrames, pDevice->audioio.pIntermediaryBuffer); + mal_device__read_frames_from_client(pDevice, pDevice->audio4.fragmentSizeInFrames, pDevice->audio4.pIntermediaryBuffer); - int bytesWritten = write(pDevice->audioio.fd, pDevice->audioio.pIntermediaryBuffer, pDevice->audioio.fragmentSizeInFrames * pDevice->internalChannels * mal_get_bytes_per_sample(pDevice->internalFormat)); + int bytesWritten = write(pDevice->audio4.fd, pDevice->audio4.pIntermediaryBuffer, pDevice->audio4.fragmentSizeInFrames * pDevice->internalChannels * mal_get_bytes_per_sample(pDevice->internalFormat)); if (bytesWritten < 0) { - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to send data from the client to the device.", MAL_FAILED_TO_SEND_DATA_TO_DEVICE); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to send data from the client to the device.", MAL_FAILED_TO_SEND_DATA_TO_DEVICE); } } else { // Capture. - int bytesRead = read(pDevice->audioio.fd, pDevice->audioio.pIntermediaryBuffer, pDevice->audioio.fragmentSizeInFrames * mal_get_bytes_per_sample(pDevice->internalFormat)); + int bytesRead = read(pDevice->audio4.fd, pDevice->audio4.pIntermediaryBuffer, pDevice->audio4.fragmentSizeInFrames * mal_get_bytes_per_sample(pDevice->internalFormat)); if (bytesRead < 0) { - return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audioio] Failed to read data from the device to be sent to the client.", MAL_FAILED_TO_READ_DATA_FROM_DEVICE); + return mal_post_error(pDevice, MAL_LOG_LEVEL_ERROR, "[audio4] Failed to read data from the device to be sent to the client.", MAL_FAILED_TO_READ_DATA_FROM_DEVICE); } mal_uint32 framesRead = (mal_uint32)bytesRead / pDevice->internalChannels / mal_get_bytes_per_sample(pDevice->internalFormat); - mal_device__send_frames_to_client(pDevice, framesRead, pDevice->audioio.pIntermediaryBuffer); + mal_device__send_frames_to_client(pDevice, framesRead, pDevice->audio4.pIntermediaryBuffer); } } return MAL_SUCCESS; } -mal_result mal_context_uninit__audioio(mal_context* pContext) +mal_result mal_context_uninit__audio4(mal_context* pContext) { mal_assert(pContext != NULL); - mal_assert(pContext->backend == mal_backend_audioio); + mal_assert(pContext->backend == mal_backend_audio4); (void)pContext; return MAL_SUCCESS; } -mal_result mal_context_init__audioio(mal_context* pContext) +mal_result mal_context_init__audio4(mal_context* pContext) { mal_assert(pContext != NULL); - pContext->onUninit = mal_context_uninit__audioio; - pContext->onDeviceIDEqual = mal_context_is_device_id_equal__audioio; - pContext->onEnumDevices = mal_context_enumerate_devices__audioio; - pContext->onGetDeviceInfo = mal_context_get_device_info__audioio; - pContext->onDeviceInit = mal_device_init__audioio; - pContext->onDeviceUninit = mal_device_uninit__audioio; - pContext->onDeviceStart = mal_device__start_backend__audioio; - pContext->onDeviceStop = mal_device__stop_backend__audioio; - pContext->onDeviceBreakMainLoop = mal_device__break_main_loop__audioio; - pContext->onDeviceMainLoop = mal_device__main_loop__audioio; + pContext->onUninit = mal_context_uninit__audio4; + pContext->onDeviceIDEqual = mal_context_is_device_id_equal__audio4; + pContext->onEnumDevices = mal_context_enumerate_devices__audio4; + pContext->onGetDeviceInfo = mal_context_get_device_info__audio4; + pContext->onDeviceInit = mal_device_init__audio4; + pContext->onDeviceUninit = mal_device_uninit__audio4; + pContext->onDeviceStart = mal_device__start_backend__audio4; + pContext->onDeviceStop = mal_device__stop_backend__audio4; + pContext->onDeviceBreakMainLoop = mal_device__break_main_loop__audio4; + pContext->onDeviceMainLoop = mal_device__main_loop__audio4; return MAL_SUCCESS; } -#endif // audioio +#endif // audio4 /////////////////////////////////////////////////////////////////////////////// @@ -19416,10 +19415,10 @@ mal_result mal_context_init(const mal_backend backends[], mal_uint32 backendCoun result = mal_context_init__sndio(pContext); } break; #endif - #ifdef MAL_HAS_AUDIOIO - case mal_backend_audioio: + #ifdef MAL_HAS_AUDIO4 + case mal_backend_audio4: { - result = mal_context_init__audioio(pContext); + result = mal_context_init__audio4(pContext); } break; #endif #ifdef MAL_HAS_OSS @@ -27355,7 +27354,7 @@ mal_uint64 mal_sine_wave_read(mal_sine_wave* pSineWave, mal_uint64 count, float* // - Add support for specifying the size of a device's buffer in milliseconds. You can still set the buffer size in // frames if that suits you. When bufferSizeInFrames is 0, bufferSizeInMilliseconds will be used. If both are non-0 // then bufferSizeInFrames will take priority. If both are set to 0 the default buffer size is used. -// - Add support for the audioio/audio(4) backend to OpenBSD. +// - Add support for the audio(4) backend to OpenBSD. // - Fix a bug with the ALSA backend that was causing problems on Raspberry Pi. This significantly improves the // Raspberry Pi experience. // - Fix a bug where an incorrect number of samples is returned from sinc resampling. @@ -27363,7 +27362,7 @@ mal_uint64 mal_sine_wave_read(mal_sine_wave* pSineWave, mal_uint64 count, float* // // v0.8.4 - 2018-08-06 // - Add sndio backend for OpenBSD. -// - Add audioio backend for NetBSD. +// - Add audio(4) backend for NetBSD. // - Drop support for the OSS backend on everything except FreeBSD and DragonFly BSD. // - Formats are now native-endian (were previously little-endian). // - Mark some APIs as deprecated: