Initial work on the AAudio backend for Android.

This backend is the new priority backend for Android.

mini_al.h

@@ -192,6 +192,9 @@
 // #define MAL_NO_OSS
 //   Disables the OSS backend.
 //
+// #define MAL_NO_AAUDIO
+//   Disables the AAudio backend.
+//
 // #define MAL_NO_OPENSL
 //   Disables the OpenSL|ES backend.
 //
@@ -1164,6 +1167,7 @@ void mal_interleave_pcm_frames(mal_format format, mal_uint32 channels, mal_uint6
         #define MAL_SUPPORT_JACK
     #endif
     #if defined(MAL_ANDROID)
+        #define MAL_SUPPORT_AAUDIO
         #define MAL_SUPPORT_OPENSL
     #endif
     #if defined(__OpenBSD__)    // <-- Change this to "#if defined(MAL_BSD)" to enable sndio on all BSD flavors.
@@ -1219,6 +1223,9 @@ void mal_interleave_pcm_frames(mal_format format, mal_uint32 channels, mal_uint6
 #if !defined(MAL_NO_OSS) && defined(MAL_SUPPORT_OSS)
     #define MAL_ENABLE_OSS
 #endif
+#if !defined(MAL_NO_AAUDIO) && defined(MAL_SUPPORT_AAUDIO)
+    #define MAL_ENABLE_AAUDIO
+#endif
 #if !defined(MAL_NO_OPENSL) && defined(MAL_SUPPORT_OPENSL)
     #define MAL_ENABLE_OPENSL
 #endif
@@ -1256,6 +1263,7 @@ typedef enum
     mal_backend_sndio,
     mal_backend_audio4,
     mal_backend_oss,
+    mal_backend_aaudio,
     mal_backend_opensl,
     mal_backend_openal,
     mal_backend_sdl
@@ -1398,6 +1406,9 @@ typedef union
 #ifdef MAL_SUPPORT_OSS
     char oss[64];                   // "dev/dsp0", etc. "dev/dsp" for the default device.
 #endif
+#ifdef MAL_SUPPORT_AAUDIO
+    mal_int32 aaudio;               // AAudio uses a 32-bit integer for identification.
+#endif
 #ifdef MAL_SUPPORT_OPENSL
     mal_uint32 opensl;              // OpenSL|ES uses a 32-bit unsigned integer for identification.
 #endif
@@ -1744,6 +1755,35 @@ struct mal_context
             int versionMinor;
         } oss;
 #endif
+#ifdef MAL_SUPPORT_AAUDIO
+        struct
+        {
+            mal_handle hAAudio; /* libaaudio.so */
+            mal_proc AAudio_createStreamBuilder;
+            mal_proc AAudioStreamBuilder_delete;
+            mal_proc AAudioStreamBuilder_setDeviceId;
+            mal_proc AAudioStreamBuilder_setDirection;
+            mal_proc AAudioStreamBuilder_setSharingMode;
+            mal_proc AAudioStreamBuilder_setFormat;
+            mal_proc AAudioStreamBuilder_setChannelCount;
+            mal_proc AAudioStreamBuilder_setSampleRate;
+            mal_proc AAudioStreamBuilder_setBufferCapacityInFrames;
+            mal_proc AAudioStreamBuilder_setFramesPerDataCallback;
+            mal_proc AAudioStreamBuilder_setDataCallback;
+            mal_proc AAudioStreamBuilder_openStream;
+            mal_proc AAudioStream_close;
+            mal_proc AAudioStream_getState;
+            mal_proc AAudioStream_waitForStateChange;
+            mal_proc AAudioStream_getFormat;
+            mal_proc AAudioStream_getChannelCount;
+            mal_proc AAudioStream_getSampleRate;
+            mal_proc AAudioStream_getBufferCapacityInFrames;
+            mal_proc AAudioStream_getFramesPerDataCallback;
+            mal_proc AAudioStream_getFramesPerBurst;
+            mal_proc AAudioStream_requestStart;
+            mal_proc AAudioStream_requestStop;
+        } aaudio;
+#endif
 #ifdef MAL_SUPPORT_OPENSL
         struct
         {
@@ -2059,6 +2099,12 @@ MAL_ALIGNED_STRUCT(MAL_SIMD_ALIGNMENT) mal_device
             void* pIntermediaryBuffer;
         } oss;
 #endif
+#ifdef MAL_SUPPORT_AAUDIO
+        struct
+        {
+            /*AAudioStream**/ mal_ptr pStream;
+        } aaudio;
+#endif
 #ifdef MAL_SUPPORT_OPENSL
         struct
         {
@@ -2129,6 +2175,7 @@ MAL_ALIGNED_STRUCT(MAL_SIMD_ALIGNMENT) mal_device
 //   - PulseAudio
 //   - ALSA
 //   - JACK
+//   - AAudio
 //   - OpenSL|ES
 //   - OpenAL
 //   - SDL
@@ -3750,6 +3797,9 @@ mal_uint32 mal_get_standard_sample_rate_priority_index(mal_uint32 sampleRate)
 #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.
 #endif
+#ifdef MAL_ENABLE_AAUDIO
+    #define MAL_HAS_AAUDIO
+#endif
 #ifdef MAL_ENABLE_OPENSL
     #define MAL_HAS_OPENSL      // OpenSL is the only supported backend for Android. It must be present.
 #endif
@@ -3796,6 +3846,7 @@ const mal_backend g_malDefaultBackends[] = {
     mal_backend_pulseaudio,
     mal_backend_alsa,
     mal_backend_jack,
+    mal_backend_aaudio,
     mal_backend_opensl,
     mal_backend_openal,
     mal_backend_sdl,
@@ -3817,6 +3868,7 @@ const char* mal_get_backend_name(mal_backend backend)
         case mal_backend_sndio:      return "sndio";
         case mal_backend_audio4:     return "audio(4)";
         case mal_backend_oss:        return "OSS";
+        case mal_backend_aaudio:     return "AAudio";
         case mal_backend_opensl:     return "OpenSL|ES";
         case mal_backend_openal:     return "OpenAL";
         case mal_backend_sdl:        return "SDL";
@@ -17837,6 +17889,417 @@ mal_result mal_context_init__oss(mal_context* pContext)
 #endif  // OSS
 
 
+///////////////////////////////////////////////////////////////////////////////
+//
+// AAudio Backend
+//
+///////////////////////////////////////////////////////////////////////////////
+#ifdef MAL_HAS_AAUDIO
+#include <AAudio/AAudio.h>
+
+typedef aaudio_result_t       (AAUDIO_API * MAL_PFN_AAudio_createStreamBuilder)                   (AAudioStreamBuilder** ppBuilder);
+typedef aaudio_result_t       (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_delete)                   (AAudioStreamBuilder* pBuilder);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setDeviceId)              (AAudioStreamBuilder* pBuilder, int32_t deviceId);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setDirection)             (AAudioStreamBuilder* pBuilder, aaudio_direction_t direction);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setSharingMode)           (AAudioStreamBuilder* pBuilder, aaudio_sharing_mode_t sharingMode);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setFormat)                (AAudioStreamBuilder* pBuilder, aaudio_format_t format);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setChannelCount)          (AAudioStreamBuilder* pBuilder, int32_t channelCount);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setSampleRate)            (AAudioStreamBuilder* pBuilder, int32_t sampleRate);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setBufferCapacityInFrames)(AAudioStreamBuilder* pBuilder, int32_t numFrames);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setFramesPerDataCallback) (AAudioStreamBuilder* pBuilder, int32_t numFrames);
+typedef void                  (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_setDataCallback)          (AAudioStreamBuilder* pBuilder, AAudioStream_dataCallback callback, void* pUserData);
+typedef aaudio_result_t       (AAUDIO_API * MAL_PFN_AAudioStreamBuilder_openStream)               (AAudioStreamBuilder* pBuilder, AAudioStream** ppStream);
+typedef aaudio_result_t       (AAUDIO_API * MAL_PFN_AAudioStream_close)                           (AAudioStream* pStream);
+typedef aaudio_stream_state_t (AAUDIO_API * MAL_PFN_AAudioStream_getState)                        (AAudioStream* pStream);
+typedef aaudio_result_t       (AAUDIO_API * MAL_PFN_AAudioStream_waitForStateChange)              (AAudioStream* pStream, aaudio_stream_state_t inputState, aaudio_stream_state_t* pNextState, int64_t timeoutInNanoseconds);
+typedef aaudio_format_t       (AAUDIO_API * MAL_PFN_AAudioStream_getFormat)                       (AAudioStream* pStream);
+typedef int32_t               (AAUDIO_API * MAL_PFN_AAudioStream_getChannelCount)                 (AAudioStream* pStream);
+typedef int32_t               (AAUDIO_API * MAL_PFN_AAudioStream_getSampleRate)                   (AAudioStream* pStream);
+typedef int32_t               (AAUDIO_API * MAL_PFN_AAudioStream_getBufferCapacityInFrames)       (AAudioStream* pStream);
+typedef int32_t               (AAUDIO_API * MAL_PFN_AAudioStream_getFramesPerDataCallback)        (AAudioStream* pStream);
+typedef int32_t               (AAUDIO_API * MAL_PFN_AAudioStream_getFramesPerBurst)               (AAudioStream* pStream);
+typedef aaudio_result_t       (AAUDIO_API * MAL_PFN_AAudioStream_requestStart)                    (AAudioStream* pStream);
+typedef aaudio_result_t       (AAUDIO_API * MAL_PFN_AAudioStream_requestStop)                     (AAudioStream* pStream);
+
+mal_result mal_result_from_aaudio(aaudio_result_t resultAA)
+{
+    switch (resultAA)
+    {
+        case AAUDIO_OK: return MAL_SUCCESS;
+        default: break;
+    }
+
+    return MAL_ERROR;
+}
+
+aaudio_data_callback_result_t mal_stream_data_callback__aaudio(AAudioStream* pStream, void* pUserData, void* pAudioData, int32_t frameCount)
+{
+    mal_device* pDevice = (mal_device*)pUserData;
+    mal_assert(pDevice != NULL);
+
+    (void)pStream;
+
+    if (pDevice->type == mal_device_type_playback) {
+        mal_device__read_frames_from_client(pDevice, frameCount, pAudioData);
+    } else {
+        mal_device__send_frames_to_client(pDevice, frameCount, pAudioData);
+    }
+
+    return AAUDIO_CALLBACK_RESULT_CONTINUE;
+}
+
+mal_result mal_open_stream__aaudio(mal_context* pContext, mal_device_type deviceType, const mal_device_id* pDeviceID, mal_share_mode shareMode, const mal_device_config* pConfig, const mal_device* pDevice, AAudioStream** ppStream)
+{
+    AAudioStreamBuilder* pBuilder;
+    aaudio_result_t resultAA;
+
+    (void)pContext;
+    *ppStream = NULL;
+
+    resultAA = ((MAL_PFN_AAudio_createStreamBuilder)pContext->aaudio.AAudio_createStreamBuilder)(&pBuilder);
+    if (resultAA != AAUDIO_OK) {
+        return mal_result_from_aaudio(resultAA);
+    }
+
+    if (pDeviceID != NULL) {
+        ((MAL_PFN_AAudioStreamBuilder_setDeviceId)pContext->aaudio.AAudioStreamBuilder_setDeviceId)(pBuilder, pDeviceID->aaudio);
+    }
+
+    ((MAL_PFN_AAudioStreamBuilder_setDirection)pContext->aaudio.AAudioStreamBuilder_setDirection)(pBuilder, (deviceType == mal_device_type_playback) ? AAUDIO_DIRECTION_OUTPUT : AAUDIO_DIRECTION_INPUT);
+    ((MAL_PFN_AAudioStreamBuilder_setSharingMode)pContext->aaudio.AAudioStreamBuilder_setSharingMode)(pBuilder, (shareMode == mal_share_mode_shared) ? AAUDIO_SHARING_MODE_SHARED : AAUDIO_SHARING_MODE_EXCLUSIVE);
+
+    if (pConfig != NULL) {
+        if (pDevice == NULL || !pDevice->usingDefaultSampleRate) {
+            ((MAL_PFN_AAudioStreamBuilder_setSampleRate)pContext->aaudio.AAudioStreamBuilder_setSampleRate)(pBuilder, pConfig->sampleRate);
+        }
+        if (pDevice == NULL || !pDevice->usingDefaultChannels) {
+            ((MAL_PFN_AAudioStreamBuilder_setChannelCount)pContext->aaudio.AAudioStreamBuilder_setChannelCount)(pBuilder, pConfig->channels);
+        }
+        if (pDevice == NULL || !pDevice->usingDefaultFormat) {
+            ((MAL_PFN_AAudioStreamBuilder_setFormat)pContext->aaudio.AAudioStreamBuilder_setFormat)(pBuilder, (pConfig->format == mal_format_s16) ? AAUDIO_FORMAT_PCM_I16 : AAUDIO_FORMAT_PCM_FLOAT);
+        }
+
+        ((MAL_PFN_AAudioStreamBuilder_setBufferCapacityInFrames)pContext->aaudio.AAudioStreamBuilder_setBufferCapacityInFrames)(pBuilder, pConfig->bufferSizeInFrames);
+
+        /* TODO: Don't set the data callback when synchronous reading and writing is being used. */
+        ((MAL_PFN_AAudioStreamBuilder_setFramesPerDataCallback)pContext->aaudio.AAudioStreamBuilder_setFramesPerDataCallback)(pBuilder, pConfig->bufferSizeInFrames / pConfig->periods);
+        ((MAL_PFN_AAudioStreamBuilder_setDataCallback)pContext->aaudio.AAudioStreamBuilder_setDataCallback)(pBuilder, mal_stream_data_callback__aaudio, (void*)pDevice);
+    }
+
+    resultAA = ((MAL_PFN_AAudioStreamBuilder_openStream)pContext->aaudio.AAudioStreamBuilder_openStream)(pBuilder, ppStream);
+    if (resultAA != AAUDIO_OK) {
+        *ppStream = NULL;
+        ((MAL_PFN_AAudioStreamBuilder_delete)pContext->aaudio.AAudioStreamBuilder_delete)(pBuilder);
+        return mal_result_from_aaudio(resultAA);
+    }
+
+    ((MAL_PFN_AAudioStreamBuilder_delete)pContext->aaudio.AAudioStreamBuilder_delete)(pBuilder);
+    return MAL_SUCCESS;
+}
+
+mal_result mal_close_stream__aaudio(mal_context* pContext, AAudioStream* pStream)
+{
+    return mal_result_from_aaudio(((MAL_PFN_AAudioStream_close)pContext->aaudio.AAudioStream_close)(pStream));
+}
+
+mal_bool32 mal_has_default_device__aaudio(mal_context* pContext, mal_device_type deviceType)
+{
+    /* The only way to know this is to try creating a stream. */
+    AAudioStream* pStream;
+    mal_result result = mal_open_stream__aaudio(pContext, deviceType, NULL, mal_share_mode_shared, NULL, NULL, &pStream);
+    if (result != MAL_SUCCESS) {
+        return MAL_FALSE;
+    }
+
+    mal_close_stream__aaudio(pContext, pStream);
+    return MAL_TRUE;
+}
+
+mal_result mal_wait_for_simple_state_transition__aaudio(mal_context* pContext, AAudioStream* pStream, aaudio_stream_state_t oldState, aaudio_stream_state_t newState)
+{
+    aaudio_stream_state_t actualNewState;
+    aaudio_result_t resultAA = ((MAL_PFN_AAudioStream_waitForStateChange)pContext->aaudio.AAudioStream_waitForStateChange)(pStream, oldState, &actualNewState, 5000000000); /* 5 second timeout. */
+    if (resultAA != AAUDIO_OK) {
+        return mal_result_from_aaudio(resultAA);
+    }
+
+    if (newState != actualNewState) {
+        return MAL_ERROR;   /* Failed to transition into the expected state. */
+    }
+
+    return MAL_SUCCESS;
+}
+
+
+mal_bool32 mal_context_is_device_id_equal__aaudio(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 pID0->aaudio == pID1->aaudio;
+}
+
+mal_result mal_context_enumerate_devices__aaudio(mal_context* pContext, mal_enum_devices_callback_proc callback, void* pUserData)
+{
+    mal_bool32 cbResult = MAL_TRUE;
+
+    mal_assert(pContext != NULL);
+    mal_assert(callback != NULL);
+
+    /* Unfortunately AAudio does not have an enumeration API. Therefore I'm only going to report default devices, but only if it can instantiate a stream. */
+
+    /* Playback. */
+    if (cbResult) {
+        mal_device_info deviceInfo;
+        mal_zero_object(&deviceInfo);
+        deviceInfo.id.aaudio = AAUDIO_UNSPECIFIED;
+        mal_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MAL_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+
+        if (mal_has_default_device__aaudio(pContext, mal_device_type_playback)) {
+            cbResult = callback(pContext, mal_device_type_playback, &deviceInfo, pUserData);
+        }
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        mal_device_info deviceInfo;
+        mal_zero_object(&deviceInfo);
+        deviceInfo.id.aaudio = AAUDIO_UNSPECIFIED;
+        mal_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MAL_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+
+        if (mal_has_default_device__aaudio(pContext, mal_device_type_capture)) {
+            cbResult = callback(pContext, mal_device_type_capture, &deviceInfo, pUserData);
+        }
+    }
+
+    return MAL_SUCCESS;
+}
+
+mal_result mal_context_get_device_info__aaudio(mal_context* pContext, mal_device_type deviceType, const mal_device_id* pDeviceID, mal_share_mode shareMode, mal_device_info* pDeviceInfo)
+{
+    AAudioStream* pStream;
+    mal_result result;
+
+    mal_assert(pContext != NULL);
+
+    /* ID */
+    if (pDeviceID != NULL) {
+        pDeviceInfo->id.aaudio = pDeviceID->aaudio;
+    } else {
+        pDeviceInfo->id.aaudio = AAUDIO_UNSPECIFIED;
+    }
+    
+    /* Name */
+    if (deviceType == mal_device_type_playback) {
+        mal_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MAL_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        mal_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MAL_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+
+    /* We'll need to open the device to get accurate sample rate and channel count information. */
+    result = mal_open_stream__aaudio(pContext, deviceType, pDeviceID, shareMode, NULL, NULL, &pStream);
+    if (result != MAL_SUCCESS) {
+        return result;
+    }
+
+    pDeviceInfo->minChannels   = ((MAL_PFN_AAudioStream_getChannelCount)pContext->aaudio.AAudioStream_getChannelCount)(pStream);
+    pDeviceInfo->maxChannels   = pDeviceInfo->minChannels;
+    pDeviceInfo->minSampleRate = ((MAL_PFN_AAudioStream_getSampleRate)pContext->aaudio.AAudioStream_getSampleRate)(pStream);
+    pDeviceInfo->maxSampleRate = pDeviceInfo->minSampleRate;
+
+    mal_close_stream__aaudio(pContext, pStream);
+    pStream = NULL;
+
+
+    /* AAudio supports s16 and f32. */
+    pDeviceInfo->formatCount = 2;
+    pDeviceInfo->formats[0] = mal_format_s16;
+    pDeviceInfo->formats[1] = mal_format_f32;
+
+    return MAL_SUCCESS;
+}
+
+
+void mal_device_uninit__aaudio(mal_device* pDevice)
+{
+    mal_assert(pDevice != NULL);
+
+    mal_close_stream__aaudio(pDevice->pContext, (AAudioStream*)pDevice->aaudio.pStream);
+    pDevice->aaudio.pStream = NULL;
+}
+
+mal_result mal_device_init__aaudio(mal_context* pContext, mal_device_type type, const mal_device_id* pDeviceID, const mal_device_config* pConfig, mal_device* pDevice)
+{
+    mal_result result;
+
+    mal_assert(pDevice != NULL);
+
+    /* We need to make a copy of the config so we can make an adjustment to the buffer size. */
+    mal_device_config config = *pConfig;
+    config.bufferSizeInFrames = pDevice->bufferSizeInFrames;
+    if (config.bufferSizeInFrames == 0) {
+        config.bufferSizeInFrames = mal_calculate_buffer_size_in_frames_from_milliseconds(pDevice->bufferSizeInMilliseconds, pDevice->sampleRate);
+    }
+
+    /* We first need to try opening the stream. */
+    result = mal_open_stream__aaudio(pContext, type, pDeviceID, pConfig->shareMode, &config, pDevice, (AAudioStream**)&pDevice->aaudio.pStream);
+    if (result != MAL_SUCCESS) {
+        return result;  /* Failed to open the AAudio stream. */
+    }
+
+    pDevice->internalFormat     = (((MAL_PFN_AAudioStream_getFormat)pContext->aaudio.AAudioStream_getFormat)((AAudioStream*)pDevice->aaudio.pStream) == AAUDIO_FORMAT_PCM_I16) ? mal_format_s16 : mal_format_f32;
+    pDevice->internalChannels   = ((MAL_PFN_AAudioStream_getChannelCount)pContext->aaudio.AAudioStream_getChannelCount)((AAudioStream*)pDevice->aaudio.pStream);
+    pDevice->internalSampleRate = ((MAL_PFN_AAudioStream_getSampleRate)pContext->aaudio.AAudioStream_getSampleRate)((AAudioStream*)pDevice->aaudio.pStream);
+    mal_get_standard_channel_map(mal_standard_channel_map_default, pDevice->internalChannels, pDevice->internalChannelMap); /* <-- Cannot find info on channel order, so assuming a default. */
+    pDevice->bufferSizeInFrames = ((MAL_PFN_AAudioStream_getBufferCapacityInFrames)pContext->aaudio.AAudioStream_getBufferCapacityInFrames)((AAudioStream*)pDevice->aaudio.pStream);
+
+    /* TODO: When synchronous reading and writing is supported, use AAudioStream_getFramesPerBurst() instead of AAudioStream_getFramesPerDataCallback(). Keep
+     * using AAudioStream_getFramesPerDataCallback() for asynchronous mode, though. */
+    int32_t framesPerPeriod = ((MAL_PFN_AAudioStream_getFramesPerDataCallback)pContext->aaudio.AAudioStream_getFramesPerDataCallback)((AAudioStream*)pDevice->aaudio.pStream);
+    if (framesPerPeriod > 0) {
+        pDevice->periods = 1;
+    } else {
+        pDevice->periods = pDevice->bufferSizeInFrames / framesPerPeriod;
+    }
+
+    return MAL_SUCCESS;
+}
+
+mal_result mal_device__start_backend__aaudio(mal_device* pDevice)
+{
+    aaudio_result_t resultAA;
+
+    mal_assert(pDevice != NULL);
+
+    resultAA = ((MAL_PFN_AAudioStream_requestStart)pDevice->pContext->aaudio.AAudioStream_requestStart)((AAudioStream*)pDevice->aaudio.pStream);
+    if (resultAA != AAUDIO_OK) {
+        return mal_result_from_aaudio(resultAA);
+    }
+
+    /* Do we actually need to wait for the device to transition into it's started state? */
+
+    /* The device should be in either a starting or started state. If it's not set to started we need to wait for it to transition. It should go from starting to started. */
+    aaudio_stream_state_t currentState = ((MAL_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)((AAudioStream*)pDevice->aaudio.pStream);
+    if (currentState != AAUDIO_STREAM_STATE_STARTED) {
+        mal_result result;
+
+        if (currentState != AAUDIO_STREAM_STATE_STARTING) {
+            return MAL_ERROR;   /* Expecting the stream to be a starting or started state. */
+        }
+
+        result = mal_wait_for_simple_state_transition__aaudio(pDevice->pContext, (AAudioStream*)pDevice->aaudio.pStream, currentState, AAUDIO_STREAM_STATE_STARTED);
+        if (result != MAL_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MAL_SUCCESS;
+}
+
+mal_result mal_device__stop_backend__aaudio(mal_device* pDevice)
+{
+    aaudio_result_t resultAA;
+
+    mal_assert(pDevice != NULL);
+
+    resultAA = ((MAL_PFN_AAudioStream_requestStop)pDevice->pContext->aaudio.AAudioStream_requestStop)((AAudioStream*)pDevice->aaudio.pStream);
+    if (resultAA != AAUDIO_OK) {
+        return mal_result_from_aaudio(resultAA);
+    }
+
+    /* The device should be in either a stopping or stopped state. If it's not set to started we need to wait for it to transition. It should go from stopping to stopped. */
+    aaudio_stream_state_t currentState = ((MAL_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)((AAudioStream*)pDevice->aaudio.pStream);
+    if (currentState != AAUDIO_STREAM_STATE_STOPPED) {
+        mal_result result;
+
+        if (currentState != AAUDIO_STREAM_STATE_STOPPING) {
+            return MAL_ERROR;   /* Expecting the stream to be a stopping or stopped state. */
+        }
+
+        result = mal_wait_for_simple_state_transition__aaudio(pDevice->pContext, (AAudioStream*)pDevice->aaudio.pStream, currentState, AAUDIO_STREAM_STATE_STOPPED);
+        if (result != MAL_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MAL_SUCCESS;
+}
+
+
+mal_result mal_context_uninit__aaudio(mal_context* pContext)
+{
+    mal_assert(pContext != NULL);
+    mal_assert(pContext->backend == mal_backend_aaudio);
+    
+    mal_dlclose(pContext->aaudio.hAAudio);
+    pContext->aaudio.hAAudio = NULL;
+
+    return MAL_SUCCESS;
+}
+
+mal_result mal_context_init__aaudio(mal_context* pContext)
+{
+    mal_assert(pContext != NULL);
+    (void)pContext;
+
+    const char* libNames[] = {
+        "libaaudio.so"
+    };
+
+    for (size_t i = 0; i < mal_countof(libNames); ++i) {
+        pContext->aaudio.hAAudio = mal_dlopen(libNames[i]);
+        if (pContext->aaudio.hAAudio != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->aaudio.hAAudio == NULL) {
+        return MAL_FAILED_TO_INIT_BACKEND;
+    }
+
+    pContext->aaudio.AAudio_createStreamBuilder                    = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudio_createStreamBuilder");
+    pContext->aaudio.AAudioStreamBuilder_delete                    = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_delete");
+    pContext->aaudio.AAudioStreamBuilder_setDeviceId               = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDeviceId");
+    pContext->aaudio.AAudioStreamBuilder_setDirection              = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDirection");
+    pContext->aaudio.AAudioStreamBuilder_setSharingMode            = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setSharingMode");
+    pContext->aaudio.AAudioStreamBuilder_setFormat                 = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setFormat");
+    pContext->aaudio.AAudioStreamBuilder_setChannelCount           = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setChannelCount");
+    pContext->aaudio.AAudioStreamBuilder_setSampleRate             = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setSampleRate");
+    pContext->aaudio.AAudioStreamBuilder_setBufferCapacityInFrames = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setBufferCapacityInFrames");
+    pContext->aaudio.AAudioStreamBuilder_setFramesPerDataCallback  = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setFramesPerDataCallback");
+    pContext->aaudio.AAudioStreamBuilder_setDataCallback           = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDataCallback");
+    pContext->aaudio.AAudioStreamBuilder_openStream                = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStreamBuilder_openStream");
+    pContext->aaudio.AAudioStream_close                            = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_close");
+    pContext->aaudio.AAudioStream_getState                         = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_getState");
+    pContext->aaudio.AAudioStream_waitForStateChange               = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_waitForStateChange");
+    pContext->aaudio.AAudioStream_getFormat                        = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_getFormat");
+    pContext->aaudio.AAudioStream_getChannelCount                  = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_getChannelCount");
+    pContext->aaudio.AAudioStream_getSampleRate                    = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_getSampleRate");
+    pContext->aaudio.AAudioStream_getBufferCapacityInFrames        = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_getBufferCapacityInFrames");
+    pContext->aaudio.AAudioStream_getFramesPerDataCallback         = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_getFramesPerDataCallback");
+    pContext->aaudio.AAudioStream_getFramesPerBurst                = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_getFramesPerBurst");
+    pContext->aaudio.AAudioStream_requestStart                     = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_requestStart");
+    pContext->aaudio.AAudioStream_requestStop                      = (mal_proc)mal_dlsym(pContext->aaudio.hAAudio, "AAudioStream_requestStop");
+
+    pContext->isBackendAsynchronous = MAL_TRUE;
+
+    pContext->onUninit        = mal_context_uninit__aaudio;
+    pContext->onDeviceIDEqual = mal_context_is_device_id_equal__aaudio;
+    pContext->onEnumDevices   = mal_context_enumerate_devices__aaudio;
+    pContext->onGetDeviceInfo = mal_context_get_device_info__aaudio;
+    pContext->onDeviceInit    = mal_device_init__aaudio;
+    pContext->onDeviceUninit  = mal_device_uninit__aaudio;
+    pContext->onDeviceStart   = mal_device__start_backend__aaudio;
+    pContext->onDeviceStop    = mal_device__stop_backend__aaudio;
+
+    return MAL_SUCCESS;
+}
+#endif  // AAudio
+
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 // OpenSL|ES Backend
@@ -20515,6 +20978,12 @@ mal_result mal_context_init(const mal_backend backends[], mal_uint32 backendCoun
                 result = mal_context_init__oss(pContext);
             } break;
         #endif
+        #ifdef MAL_HAS_AAUDIO
+            case mal_backend_aaudio:
+            {
+                result = mal_context_init__aaudio(pContext);
+            } break;
+        #endif
         #ifdef MAL_HAS_OPENSL
             case mal_backend_opensl:
             {
@@ -26750,7 +27219,7 @@ mal_uint64 mal_dsp_read(mal_dsp* pDSP, mal_uint64 frameCount, void* pFramesOut,
         }
     }
 
-    // Slower path. The real is done here. To do this all we need to do is read from the last stage in the pipeline.
+    // Slower path. The real work is done here. To do this all we need to do is read from the last stage in the pipeline.
     mal_assert(pDSP->isPostFormatConversionRequired == MAL_TRUE);
 
     mal_dsp_callback_data data;