Skip to content

M
miniaudio
Commit 81ab9468 authored by David Reid's avatar David Reid
Browse files
Options

sndio: Migrate over to the new backend callback system.

parent 7023f7e7
Show whitespace changes
Inline Side-by-side
Showing with 106 additions and 107 deletions
miniaudio.h
View file @ 81ab9468
...@@ -27004,7 +27004,7 @@ static ma_result ma_context_enumerate_devices__sndio(ma_context* pContext, ma_en ...@@ -27004,7 +27004,7 @@ static ma_result ma_context_enumerate_devices__sndio(ma_context* pContext, ma_en
return MA_SUCCESS; return MA_SUCCESS;
} }
static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_share_mode shareMode, ma_device_info* pDeviceInfo) static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
{ {
char devid[256]; char devid[256];
struct ma_sio_hdl* handle; struct ma_sio_hdl* handle;
...@@ -27012,7 +27012,6 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi ...@@ -27012,7 +27012,6 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi
unsigned int iConfig; unsigned int iConfig;
MA_ASSERT(pContext != NULL); MA_ASSERT(pContext != NULL);
(void)shareMode;
/* We need to open the device before we can get information about it. */ /* We need to open the device before we can get information about it. */
if (pDeviceID == NULL) { if (pDeviceID == NULL) {
...@@ -27032,6 +27031,8 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi ...@@ -27032,6 +27031,8 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi
return MA_ERROR; return MA_ERROR;
} }
pDeviceInfo->nativeDataFormatCount = 0;
for (iConfig = 0; iConfig < caps.nconf; iConfig += 1) { for (iConfig = 0; iConfig < caps.nconf; iConfig += 1) {
/* /*
The main thing we care about is that the encoding is supported by miniaudio. If it is, we want to give The main thing we care about is that the encoding is supported by miniaudio. If it is, we want to give
...@@ -27048,8 +27049,6 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi ...@@ -27048,8 +27049,6 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi
unsigned int le; unsigned int le;
unsigned int msb; unsigned int msb;
ma_format format; ma_format format;
ma_bool32 formatExists = MA_FALSE;
ma_uint32 iExistingFormat;
if ((caps.confs[iConfig].enc & (1UL << iEncoding)) == 0) { if ((caps.confs[iConfig].enc & (1UL << iEncoding)) == 0) {
continue; continue;
...@@ -27065,18 +27064,6 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi ...@@ -27065,18 +27064,6 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi
continue; /* Format not supported. */ continue; /* Format not supported. */
} }
/* Add this format if it doesn't already exist. */
for (iExistingFormat = 0; iExistingFormat < pDeviceInfo->formatCount; iExistingFormat += 1) {
if (pDeviceInfo->formats[iExistingFormat] == format) {
formatExists = MA_TRUE;
break;
}
}
if (!formatExists) {
pDeviceInfo->formats[pDeviceInfo->formatCount++] = format;
}
}
/* Channels. */ /* Channels. */
for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) { for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) {
...@@ -27099,23 +27086,12 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi ...@@ -27099,23 +27086,12 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi
channels = caps.rchan[iChannel]; channels = caps.rchan[iChannel];
} }
if (pDeviceInfo->minChannels > channels) {
pDeviceInfo->minChannels = channels;
}
if (pDeviceInfo->maxChannels < channels) {
pDeviceInfo->maxChannels = channels;
}
}
/* Sample rates. */ /* Sample Rates. */
for (iRate = 0; iRate < MA_SIO_NRATE; iRate += 1) { for (iRate = 0; iRate < MA_SIO_NRATE; iRate += 1) {
if ((caps.confs[iConfig].rate & (1UL << iRate)) != 0) { if ((caps.confs[iConfig].rate & (1UL << iRate)) != 0) {
unsigned int rate = caps.rate[iRate]; ma_device_info_add_native_data_format(pDeviceInfo, format, channels, caps.rate[iRate], 0);
if (pDeviceInfo->minSampleRate > rate) {
pDeviceInfo->minSampleRate = rate;
} }
if (pDeviceInfo->maxSampleRate < rate) {
pDeviceInfo->maxSampleRate = rate;
} }
} }
} }
...@@ -27125,7 +27101,7 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi ...@@ -27125,7 +27101,7 @@ static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_devi
return MA_SUCCESS; return MA_SUCCESS;
} }
static void ma_device_uninit__sndio(ma_device* pDevice) static ma_result ma_device_uninit__sndio(ma_device* pDevice)
{ {
MA_ASSERT(pDevice != NULL); MA_ASSERT(pDevice != NULL);
...@@ -27136,9 +27112,11 @@ static void ma_device_uninit__sndio(ma_device* pDevice) ...@@ -27136,9 +27112,11 @@ static void ma_device_uninit__sndio(ma_device* pDevice)
if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) { if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback); ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback);
} }
return MA_SUCCESS;
} }
static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_device_config* pConfig, ma_device_type deviceType, ma_device* pDevice) static ma_result ma_device_init_handle__sndio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
{ {
const char* pDeviceName; const char* pDeviceName;
ma_ptr handle; ma_ptr handle;
...@@ -27155,38 +27133,34 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev ...@@ -27155,38 +27133,34 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev
ma_uint32 internalPeriodSizeInFrames; ma_uint32 internalPeriodSizeInFrames;
ma_uint32 internalPeriods; ma_uint32 internalPeriods;
MA_ASSERT(pContext != NULL);
MA_ASSERT(pConfig != NULL); MA_ASSERT(pConfig != NULL);
MA_ASSERT(deviceType != ma_device_type_duplex); MA_ASSERT(deviceType != ma_device_type_duplex);
MA_ASSERT(pDevice != NULL); MA_ASSERT(pDevice != NULL);
if (deviceType == ma_device_type_capture) { if (deviceType == ma_device_type_capture) {
openFlags = MA_SIO_REC; openFlags = MA_SIO_REC;
pDeviceID = pConfig->capture.pDeviceID;
format = pConfig->capture.format;
channels = pConfig->capture.channels;
sampleRate = pConfig->sampleRate;
} else { } else {
openFlags = MA_SIO_PLAY; openFlags = MA_SIO_PLAY;
pDeviceID = pConfig->playback.pDeviceID;
format = pConfig->playback.format;
channels = pConfig->playback.channels;
sampleRate = pConfig->sampleRate;
} }
pDeviceID = pDescriptor->pDeviceID;
format = pDescriptor->format;
channels = pDescriptor->channels;
sampleRate = pDescriptor->sampleRate;
pDeviceName = MA_SIO_DEVANY; pDeviceName = MA_SIO_DEVANY;
if (pDeviceID != NULL) { if (pDeviceID != NULL) {
pDeviceName = pDeviceID->sndio; pDeviceName = pDeviceID->sndio;
} }
handle = (ma_ptr)((ma_sio_open_proc)pContext->sndio.sio_open)(pDeviceName, openFlags, 0); handle = (ma_ptr)((ma_sio_open_proc)pDevice->pContext->sndio.sio_open)(pDeviceName, openFlags, 0);
if (handle == NULL) { if (handle == NULL) {
return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to open device.", MA_FAILED_TO_OPEN_BACKEND_DEVICE); return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to open device.", MA_FAILED_TO_OPEN_BACKEND_DEVICE);
} }
/* We need to retrieve the device caps to determine the most appropriate format to use. */ /* We need to retrieve the device caps to determine the most appropriate format to use. */
if (((ma_sio_getcap_proc)pContext->sndio.sio_getcap)((struct ma_sio_hdl*)handle, &caps) == 0) { if (((ma_sio_getcap_proc)pDevice->pContext->sndio.sio_getcap)((struct ma_sio_hdl*)handle, &caps) == 0) {
((ma_sio_close_proc)pContext->sndio.sio_close)((struct ma_sio_hdl*)handle); ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve device caps.", MA_ERROR); return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve device caps.", MA_ERROR);
} }
...@@ -27199,26 +27173,32 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev ...@@ -27199,26 +27173,32 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev
value returned by ma_find_best_channels_from_sio_cap__sndio(). value returned by ma_find_best_channels_from_sio_cap__sndio().
*/ */
if (deviceType == ma_device_type_capture) { if (deviceType == ma_device_type_capture) {
if (pDevice->capture.usingDefaultFormat) { if (format == ma_format_unknown) {
format = ma_find_best_format_from_sio_cap__sndio(&caps); format = ma_find_best_format_from_sio_cap__sndio(&caps);
} }
if (pDevice->capture.usingDefaultChannels) {
if (channels == 0) {
if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) { if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) {
channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format); channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format);
} else {
channels = MA_DEFAULT_CHANNELS;
} }
} }
} else { } else {
if (pDevice->playback.usingDefaultFormat) { if (format == ma_format_unknown) {
format = ma_find_best_format_from_sio_cap__sndio(&caps); format = ma_find_best_format_from_sio_cap__sndio(&caps);
} }
if (pDevice->playback.usingDefaultChannels) {
if (channels == 0) {
if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) { if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) {
channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format); channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format);
} else {
channels = MA_DEFAULT_CHANNELS;
} }
} }
} }
if (pDevice->usingDefaultSampleRate) { if (sampleRate == 0) {
sampleRate = ma_find_best_sample_rate_from_sio_cap__sndio(&caps, pConfig->deviceType, format, channels); sampleRate = ma_find_best_sample_rate_from_sio_cap__sndio(&caps, pConfig->deviceType, format, channels);
} }
...@@ -27251,6 +27231,7 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev ...@@ -27251,6 +27231,7 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev
case ma_format_s16: case ma_format_s16:
case ma_format_f32: case ma_format_f32:
case ma_format_unknown:
default: default:
{ {
par.bits = 16; par.bits = 16;
...@@ -27267,20 +27248,18 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev ...@@ -27267,20 +27248,18 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev
par.rate = sampleRate; par.rate = sampleRate;
internalPeriodSizeInFrames = pConfig->periodSizeInFrames; internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, par.rate, pConfig->performanceProfile);
if (internalPeriodSizeInFrames == 0) {
internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pConfig->periodSizeInMilliseconds, par.rate);
}
par.round = internalPeriodSizeInFrames; par.round = internalPeriodSizeInFrames;
par.appbufsz = par.round * pConfig->periods; par.appbufsz = par.round * pDescriptor->periodCount;
if (((ma_sio_setpar_proc)pContext->sndio.sio_setpar)((struct ma_sio_hdl*)handle, &par) == 0) { if (((ma_sio_setpar_proc)pDevice->pContext->sndio.sio_setpar)((struct ma_sio_hdl*)handle, &par) == 0) {
((ma_sio_close_proc)pContext->sndio.sio_close)((struct ma_sio_hdl*)handle); ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to set buffer size.", MA_FORMAT_NOT_SUPPORTED); return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to set buffer size.", MA_FORMAT_NOT_SUPPORTED);
} }
if (((ma_sio_getpar_proc)pContext->sndio.sio_getpar)((struct ma_sio_hdl*)handle, &par) == 0) {
((ma_sio_close_proc)pContext->sndio.sio_close)((struct ma_sio_hdl*)handle); if (((ma_sio_getpar_proc)pDevice->pContext->sndio.sio_getpar)((struct ma_sio_hdl*)handle, &par) == 0) {
((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve buffer size.", MA_FORMAT_NOT_SUPPORTED); return ma_post_error(pDevice, MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve buffer size.", MA_FORMAT_NOT_SUPPORTED);
} }
...@@ -27292,22 +27271,17 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev ...@@ -27292,22 +27271,17 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev
if (deviceType == ma_device_type_capture) { if (deviceType == ma_device_type_capture) {
pDevice->sndio.handleCapture = handle; pDevice->sndio.handleCapture = handle;
pDevice->capture.internalFormat = internalFormat;
pDevice->capture.internalChannels = internalChannels;
pDevice->capture.internalSampleRate = internalSampleRate;
ma_get_standard_channel_map(ma_standard_channel_map_sndio, pDevice->capture.internalChannels, pDevice->capture.internalChannelMap);
pDevice->capture.internalPeriodSizeInFrames = internalPeriodSizeInFrames;
pDevice->capture.internalPeriods = internalPeriods;
} else { } else {
pDevice->sndio.handlePlayback = handle; pDevice->sndio.handlePlayback = handle;
pDevice->playback.internalFormat = internalFormat;
pDevice->playback.internalChannels = internalChannels;
pDevice->playback.internalSampleRate = internalSampleRate;
ma_get_standard_channel_map(ma_standard_channel_map_sndio, pDevice->playback.internalChannels, pDevice->playback.internalChannelMap);
pDevice->playback.internalPeriodSizeInFrames = internalPeriodSizeInFrames;
pDevice->playback.internalPeriods = internalPeriods;
} }
pDescriptor->format = internalFormat;
pDescriptor->channels = internalChannels;
pDescriptor->sampleRate = internalSampleRate;
ma_get_standard_channel_map(ma_standard_channel_map_sndio, pDevice->playback.internalChannels, pDevice->playback.internalChannelMap);
pDescriptor->periodSizeInFrames = internalPeriodSizeInFrames;
pDescriptor->periodCount = internalPeriods;
#ifdef MA_DEBUG_OUTPUT #ifdef MA_DEBUG_OUTPUT
printf("DEVICE INFO\n"); printf("DEVICE INFO\n");
printf(" Format: %s\n", ma_get_format_name(internalFormat)); printf(" Format: %s\n", ma_get_format_name(internalFormat));
...@@ -27322,7 +27296,7 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev ...@@ -27322,7 +27296,7 @@ static ma_result ma_device_init_handle__sndio(ma_context* pContext, const ma_dev
return MA_SUCCESS; return MA_SUCCESS;
} }
static ma_result ma_device_init__sndio(ma_context* pContext, const ma_device_config* pConfig, ma_device* pDevice) static ma_result ma_device_init__sndio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
{ {
MA_ASSERT(pDevice != NULL); MA_ASSERT(pDevice != NULL);
...@@ -27333,14 +27307,14 @@ static ma_result ma_device_init__sndio(ma_context* pContext, const ma_device_con ...@@ -27333,14 +27307,14 @@ static ma_result ma_device_init__sndio(ma_context* pContext, const ma_device_con
} }
if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) { if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
ma_result result = ma_device_init_handle__sndio(pContext, pConfig, ma_device_type_capture, pDevice); ma_result result = ma_device_init_handle__sndio(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
if (result != MA_SUCCESS) { if (result != MA_SUCCESS) {
return result; return result;
} }
} }
if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) { if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
ma_result result = ma_device_init_handle__sndio(pContext, pConfig, ma_device_type_playback, pDevice); ma_result result = ma_device_init_handle__sndio(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
if (result != MA_SUCCESS) { if (result != MA_SUCCESS) {
return result; return result;
} }
...@@ -27349,6 +27323,21 @@ static ma_result ma_device_init__sndio(ma_context* pContext, const ma_device_con ...@@ -27349,6 +27323,21 @@ static ma_result ma_device_init__sndio(ma_context* pContext, const ma_device_con
return MA_SUCCESS; return MA_SUCCESS;
} }
static ma_result ma_device_start__sndio(ma_device* pDevice)
{
MA_ASSERT(pDevice != NULL);
if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
((ma_sio_start_proc)pDevice->pContext->sndio.sio_start)((struct ma_sio_hdl*)pDevice->sndio.handleCapture);
}
if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
((ma_sio_start_proc)pDevice->pContext->sndio.sio_start)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback); /* <-- Doesn't actually playback until data is written. */
}
return MA_SUCCESS;
}
static ma_result ma_device_stop__sndio(ma_device* pDevice) static ma_result ma_device_stop__sndio(ma_device* pDevice)
{ {
MA_ASSERT(pDevice != NULL); MA_ASSERT(pDevice != NULL);
...@@ -27414,6 +27403,7 @@ static ma_result ma_device_read__sndio(ma_device* pDevice, void* pPCMFrames, ma_ ...@@ -27414,6 +27403,7 @@ static ma_result ma_device_read__sndio(ma_device* pDevice, void* pPCMFrames, ma_
return MA_SUCCESS; return MA_SUCCESS;
} }
#if 0
static ma_result ma_device_main_loop__sndio(ma_device* pDevice) static ma_result ma_device_main_loop__sndio(ma_device* pDevice)
{ {
ma_result result = MA_SUCCESS; ma_result result = MA_SUCCESS;
...@@ -27584,6 +27574,7 @@ static ma_result ma_device_main_loop__sndio(ma_device* pDevice) ...@@ -27584,6 +27574,7 @@ static ma_result ma_device_main_loop__sndio(ma_device* pDevice)
return result; return result;
} }
#endif
static ma_result ma_context_uninit__sndio(ma_context* pContext) static ma_result ma_context_uninit__sndio(ma_context* pContext)
{ {
...@@ -27594,7 +27585,7 @@ static ma_result ma_context_uninit__sndio(ma_context* pContext) ...@@ -27594,7 +27585,7 @@ static ma_result ma_context_uninit__sndio(ma_context* pContext)
return MA_SUCCESS; return MA_SUCCESS;
} }
static ma_result ma_context_init__sndio(const ma_context_config* pConfig, ma_context* pContext) static ma_result ma_context_init__sndio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
{ {
#ifndef MA_NO_RUNTIME_LINKING #ifndef MA_NO_RUNTIME_LINKING
const char* libsndioNames[] = { const char* libsndioNames[] = {
...@@ -27636,14 +27627,17 @@ static ma_result ma_context_init__sndio(const ma_context_config* pConfig, ma_con ...@@ -27636,14 +27627,17 @@ static ma_result ma_context_init__sndio(const ma_context_config* pConfig, ma_con
pContext->sndio.sio_initpar = sio_initpar; pContext->sndio.sio_initpar = sio_initpar;
#endif #endif
pContext->onUninit = ma_context_uninit__sndio; pCallbacks->onContextInit = ma_context_init__sndio;
pContext->onEnumDevices = ma_context_enumerate_devices__sndio; pCallbacks->onContextUninit = ma_context_uninit__sndio;
pContext->onGetDeviceInfo = ma_context_get_device_info__sndio; pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__sndio;
pContext->onDeviceInit = ma_device_init__sndio; pCallbacks->onContextGetDeviceInfo = ma_context_get_device_info__sndio;
pContext->onDeviceUninit = ma_device_uninit__sndio; pCallbacks->onDeviceInit = ma_device_init__sndio;
pContext->onDeviceStart = NULL; /* Not required for synchronous backends. */ pCallbacks->onDeviceUninit = ma_device_uninit__sndio;
pContext->onDeviceStop = NULL; /* Not required for synchronous backends. */ pCallbacks->onDeviceStart = ma_device_start__sndio;
pContext->onDeviceMainLoop = ma_device_main_loop__sndio; pCallbacks->onDeviceStop = ma_device_stop__sndio;
pCallbacks->onDeviceRead = ma_device_read__sndio;
pCallbacks->onDeviceWrite = ma_device_write__sndio;
pCallbacks->onDeviceAudioThread = NULL;
(void)pConfig; (void)pConfig;
return MA_SUCCESS; return MA_SUCCESS;
...@@ -32252,6 +32246,12 @@ MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendC ...@@ -32252,6 +32246,12 @@ MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendC
pContext->callbacks.onContextInit = ma_context_init__coreaudio; pContext->callbacks.onContextInit = ma_context_init__coreaudio;
} break; } break;
#endif #endif
#ifdef MA_HAS_SNDIO
case ma_backend_sndio:
{
pContext->callbacks.onContextInit = ma_context_init__sndio;
} break;
#endif
#ifdef MA_HAS_AUDIO4 #ifdef MA_HAS_AUDIO4
case ma_backend_audio4: case ma_backend_audio4:
{ {
...@@ -32370,8 +32370,7 @@ MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendC ...@@ -32370,8 +32370,7 @@ MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendC
#ifdef MA_HAS_SNDIO #ifdef MA_HAS_SNDIO
case ma_backend_sndio: case ma_backend_sndio:
{ {
ma_post_log_message(pContext, NULL, MA_LOG_LEVEL_VERBOSE, "Attempting to initialize sndio backend..."); /*result = ma_context_init__sndio(pConfig, pContext);*/
result = ma_context_init__sndio(pConfig, pContext);
} break; } break;
#endif #endif
#ifdef MA_HAS_AUDIO4 #ifdef MA_HAS_AUDIO4
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment