android/internal/oboe: Update Oboe to 1.6.0

audio/internal/oboe/README-oboe.md

@@ -1,4 +1,4 @@
-# Oboe [![Build Status](https://travis-ci.org/google/oboe.svg?branch=master)](https://travis-ci.org/google/oboe)
+# Oboe [![Build CI](https://github.com/google/oboe/workflows/Build%20CI/badge.svg)](https://github.com/google/oboe/actions)
 
 [![Introduction to Oboe video](docs/images/getting-started-video.jpg)](https://www.youtube.com/watch?v=csfHAbr5ilI&list=PLWz5rJ2EKKc_duWv9IPNvx9YBudNMmLSa)
 
@@ -12,9 +12,6 @@ Oboe is a C++ library which makes it easy to build high-performance audio apps o
 - Workarounds for some known issues
 - [Used by popular apps and frameworks](docs/AppsUsingOboe.md)
 
-## Requirements
-To build Oboe you'll need a compiler which supports C++14 and the Android header files. The easiest way to obtain these is by downloading the Android NDK r17 or above. It can be installed using Android Studio's SDK manager, or via [direct download](https://developer.android.com/ndk/downloads/).
-
 ## Documentation
 - [Getting Started Guide](docs/GettingStarted.md)
 - [Full Guide to Oboe](docs/FullGuide.md)
@@ -25,6 +22,10 @@ To build Oboe you'll need a compiler which supports C++14 and the Android header
 - [Frequently Asked Questions](docs/FAQ.md) (FAQ)
 - [Our roadmap](https://github.com/google/oboe/milestones) - Vote on a feature/issue by adding a thumbs up to the first comment.
 
+### Community
+- Reddit: [r/androidaudiodev](https://www.reddit.com/r/androidaudiodev/)
+- StackOverflow: [#oboe](https://stackoverflow.com/questions/tagged/oboe)
+
 ## Testing
 - [**OboeTester** app for measuring latency, glitches, etc.](https://github.com/google/oboe/tree/master/apps/OboeTester/docs)
 - [Oboe unit tests](https://github.com/google/oboe/tree/master/tests)
@@ -32,14 +33,12 @@ To build Oboe you'll need a compiler which supports C++14 and the Android header
 ## Videos
 - [Getting started with Oboe](https://www.youtube.com/playlist?list=PLWz5rJ2EKKc_duWv9IPNvx9YBudNMmLSa)
 - [Low Latency Audio - Because Your Ears Are Worth It](https://www.youtube.com/watch?v=8vOf_fDtur4) (Android Dev Summit '18)
-- [Real-time audio with the 100 oscillator synthesizer](https://www.youtube.com/watch?v=J04iPJBkAKs) (DroidCon Berlin '18)
 - [Winning on Android](https://www.youtube.com/watch?v=tWBojmBpS74) - How to optimize an Android audio app. (ADC '18)
-- [Real-Time Processing on Android](https://youtu.be/hY9BrS2uX-c) (ADC '19)
 
 ## Sample code and apps
 - Sample apps can be found in the [samples directory](samples). 
 - A complete "effects processor" app called FXLab can  be found in the [apps/fxlab folder](apps/fxlab). 
-- Also check out the [Rhythm Game codelab](https://codelabs.developers.google.com/codelabs/musicalgame-using-oboe/index.html#0).
+- Also check out the [Rhythm Game codelab](https://developer.android.com/codelabs/musicalgame-using-oboe?hl=en#0).
 
 ### Third party sample code
 - [Ableton Link integration demo](https://github.com/jbloit/AndroidLinkAudio) (author: jbloit)

audio/internal/oboe/gen.go

@@ -28,7 +28,7 @@ import (
 	"strings"
 )
 
-const oboeVersion = "1.5.0"
+const oboeVersion = "1.6.0"
 
 func main() {
 	if err := run(); err != nil {

audio/internal/oboe/oboe_aaudio_AAudioExtensions_android.h

@@ -0,0 +1,172 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OBOE_AAUDIO_EXTENSIONS_H
+#define OBOE_AAUDIO_EXTENSIONS_H
+
+#include <dlfcn.h>
+#include <stdint.h>
+
+#include <sys/system_properties.h>
+
+#include "oboe_common_OboeDebug_android.h"
+#include "oboe_oboe_Oboe_android.h"
+#include "oboe_aaudio_AAudioLoader_android.h"
+
+namespace oboe {
+
+#define LIB_AAUDIO_NAME          "libaaudio.so"
+#define FUNCTION_IS_MMAP         "AAudioStream_isMMapUsed"
+#define FUNCTION_SET_MMAP_POLICY "AAudio_setMMapPolicy"
+#define FUNCTION_GET_MMAP_POLICY "AAudio_getMMapPolicy"
+
+#define AAUDIO_ERROR_UNAVAILABLE  static_cast<aaudio_result_t>(Result::ErrorUnavailable)
+
+typedef struct AAudioStreamStruct         AAudioStream;
+
+/**
+ * Call some AAudio test routines that are not part of the normal API.
+ */
+class AAudioExtensions {
+public:
+    AAudioExtensions() {
+        int32_t policy = getIntegerProperty("aaudio.mmap_policy", 0);
+        mMMapSupported = isPolicyEnabled(policy);
+
+        policy = getIntegerProperty("aaudio.mmap_exclusive_policy", 0);
+        mMMapExclusiveSupported = isPolicyEnabled(policy);
+    }
+
+    static bool isPolicyEnabled(int32_t policy) {
+        return (policy == AAUDIO_POLICY_AUTO || policy == AAUDIO_POLICY_ALWAYS);
+    }
+
+    static AAudioExtensions &getInstance() {
+        static AAudioExtensions instance;
+        return instance;
+    }
+
+    bool isMMapUsed(oboe::AudioStream *oboeStream) {
+        AAudioStream *aaudioStream = (AAudioStream *) oboeStream->getUnderlyingStream();
+        return isMMapUsed(aaudioStream);
+    }
+
+    bool isMMapUsed(AAudioStream *aaudioStream) {
+        if (loadSymbols()) return false;
+        if (mAAudioStream_isMMap == nullptr) return false;
+        return mAAudioStream_isMMap(aaudioStream);
+    }
+
+    /**
+     * Controls whether the MMAP data path can be selected when opening a stream.
+     * It has no effect after the stream has been opened.
+     * It only affects the application that calls it. Other apps are not affected.
+     *
+     * @param enabled
+     * @return 0 or a negative error code
+     */
+    int32_t setMMapEnabled(bool enabled) {
+        if (loadSymbols()) return AAUDIO_ERROR_UNAVAILABLE;
+        if (mAAudio_setMMapPolicy == nullptr) return false;
+        return mAAudio_setMMapPolicy(enabled ? AAUDIO_POLICY_AUTO : AAUDIO_POLICY_NEVER);
+    }
+
+    bool isMMapEnabled() {
+        if (loadSymbols()) return false;
+        if (mAAudio_getMMapPolicy == nullptr) return false;
+        int32_t policy = mAAudio_getMMapPolicy();
+        return isPolicyEnabled(policy);
+    }
+
+    bool isMMapSupported() {
+        return mMMapSupported;
+    }
+
+    bool isMMapExclusiveSupported() {
+        return mMMapExclusiveSupported;
+    }
+
+private:
+
+    enum {
+        AAUDIO_POLICY_NEVER = 1,
+        AAUDIO_POLICY_AUTO,
+        AAUDIO_POLICY_ALWAYS
+    };
+    typedef int32_t aaudio_policy_t;
+
+    int getIntegerProperty(const char *name, int defaultValue) {
+        int result = defaultValue;
+        char valueText[PROP_VALUE_MAX] = {0};
+        if (__system_property_get(name, valueText) != 0) {
+            result = atoi(valueText);
+        }
+        return result;
+    }
+
+    /**
+     * Load the function pointers.
+     * This can be called multiple times.
+     * It should only be called from one thread.
+     *
+     * @return 0 if successful or negative error.
+     */
+    aaudio_result_t loadSymbols() {
+        if (mAAudio_getMMapPolicy != nullptr) {
+            return 0;
+        }
+
+        void *libHandle = AAudioLoader::getInstance()->getLibHandle();
+        if (libHandle == nullptr) {
+            LOGI("%s() could not find " LIB_AAUDIO_NAME, __func__);
+            return AAUDIO_ERROR_UNAVAILABLE;
+        }
+
+        mAAudioStream_isMMap = (bool (*)(AAudioStream *stream))
+                dlsym(libHandle, FUNCTION_IS_MMAP);
+        if (mAAudioStream_isMMap == nullptr) {
+            LOGI("%s() could not find " FUNCTION_IS_MMAP, __func__);
+            return AAUDIO_ERROR_UNAVAILABLE;
+        }
+
+        mAAudio_setMMapPolicy = (int32_t (*)(aaudio_policy_t policy))
+                dlsym(libHandle, FUNCTION_SET_MMAP_POLICY);
+        if (mAAudio_setMMapPolicy == nullptr) {
+            LOGI("%s() could not find " FUNCTION_SET_MMAP_POLICY, __func__);
+            return AAUDIO_ERROR_UNAVAILABLE;
+        }
+
+        mAAudio_getMMapPolicy = (aaudio_policy_t (*)())
+                dlsym(libHandle, FUNCTION_GET_MMAP_POLICY);
+        if (mAAudio_getMMapPolicy == nullptr) {
+            LOGI("%s() could not find " FUNCTION_GET_MMAP_POLICY, __func__);
+            return AAUDIO_ERROR_UNAVAILABLE;
+        }
+
+        return 0;
+    }
+
+    bool      mMMapSupported = false;
+    bool      mMMapExclusiveSupported = false;
+
+    bool    (*mAAudioStream_isMMap)(AAudioStream *stream) = nullptr;
+    int32_t (*mAAudio_setMMapPolicy)(aaudio_policy_t policy) = nullptr;
+    aaudio_policy_t (*mAAudio_getMMapPolicy)() = nullptr;
+};
+
+} // namespace oboe
+
+#endif //OBOE_AAUDIO_EXTENSIONS_H

audio/internal/oboe/oboe_aaudio_AAudioLoader_android.cpp

@@ -24,10 +24,17 @@
 namespace oboe {
 
 AAudioLoader::~AAudioLoader() {
-    if (mLibHandle != nullptr) {
-        dlclose(mLibHandle);
-        mLibHandle = nullptr;
-    }
+    // Issue 360: thread_local variables with non-trivial destructors
+    // will cause segfaults if the containing library is dlclose()ed on
+    // devices running M or newer, or devices before M when using a static STL.
+    // The simple workaround is to not call dlclose.
+    // https://github.com/android/ndk/wiki/Changelog-r22#known-issues
+    //
+    // The libaaudio and libaaudioclient do not use thread_local.
+    // But, to be safe, we should avoid dlclose() if possible.
+    // Because AAudioLoader is a static Singleton, we can safely skip
+    // calling dlclose() without causing a resource leak.
+    LOGI("%s() dlclose(%s) not called, OK", __func__, LIB_AAUDIO_NAME);
 }
 
 AAudioLoader* AAudioLoader::getInstance() {
@@ -90,8 +97,6 @@ int AAudioLoader::open() {
 
     stream_getTimestamp        = load_I_PSKPLPL("AAudioStream_getTimestamp");
 
-    stream_isMMapUsed          = load_B_PS("AAudioStream_isMMapUsed");
-
     stream_getChannelCount     = load_I_PS("AAudioStream_getChannelCount");
     if (stream_getChannelCount == nullptr) {
         // Use old alias if needed.
@@ -304,7 +309,6 @@ AAudioLoader::signature_I_PSKPLPL AAudioLoader::load_I_PSKPLPL(const char *funct
             == AAUDIO_PERFORMANCE_MODE_POWER_SAVING, ERRMSG);
     static_assert((int32_t)PerformanceMode::LowLatency
             == AAUDIO_PERFORMANCE_MODE_LOW_LATENCY, ERRMSG);
-#endif
 
 // The aaudio_ usage, content and input_preset types were added in NDK 17,
 // which is the first version to support Android Pie (API 28).
@@ -343,6 +347,9 @@ AAudioLoader::signature_I_PSKPLPL AAudioLoader::load_I_PSKPLPL(const char *funct
 
     static_assert((int32_t)SessionId::None == AAUDIO_SESSION_ID_NONE, ERRMSG);
     static_assert((int32_t)SessionId::Allocate == AAUDIO_SESSION_ID_ALLOCATE, ERRMSG);
-#endif
+
+#endif // __NDK_MAJOR__ >= 17
+
+#endif // AAUDIO_AAUDIO_H
 
 } // namespace oboe

audio/internal/oboe/oboe_aaudio_AAudioLoader_android.h

@@ -52,6 +52,12 @@ typedef int32_t aaudio_usage_t;
 typedef int32_t aaudio_content_type_t;
 typedef int32_t aaudio_input_preset_t;
 typedef int32_t aaudio_session_id_t;
+
+// There are a few definitions used by Oboe.
+#define AAUDIO_OK                      static_cast<aaudio_result_t>(Result::OK)
+#define AAUDIO_ERROR_TIMEOUT           static_cast<aaudio_result_t>(Result::ErrorTimeout)
+#define AAUDIO_STREAM_STATE_STARTING   static_cast<aaudio_stream_state_t>(StreamState::Starting)
+#define AAUDIO_STREAM_STATE_STARTED    static_cast<aaudio_stream_state_t>(StreamState::Started)
 #else
 #include <aaudio/AAudio.h>
 #include <android/ndk-version.h>
@@ -63,7 +69,6 @@ typedef int32_t aaudio_session_id_t;
 
 namespace oboe {
 
-
 /**
  * The AAudio API was not available in early versions of Android.
  * To avoid linker errors, we dynamically link with the functions by name using dlsym().
@@ -133,6 +138,8 @@ class AAudioLoader {
      */
     int open();
 
+    void *getLibHandle() const { return mLibHandle; }
+
     // Function pointers into the AAudio shared library.
     signature_I_PPB   createStreamBuilder = nullptr;
 
@@ -167,8 +174,6 @@ class AAudioLoader {
 
     signature_I_PSKPLPL stream_getTimestamp = nullptr;
 
-    signature_B_PS      stream_isMMapUsed = nullptr;
-
     signature_I_PS   stream_close = nullptr;
 
     signature_I_PS   stream_getChannelCount = nullptr;

audio/internal/oboe/oboe_aaudio_AudioStreamAAudio_android.cpp

@@ -23,6 +23,7 @@
 #include "oboe_common_AudioClock_android.h"
 #include "oboe_common_OboeDebug_android.h"
 #include "oboe_oboe_Utilities_android.h"
+#include "oboe_aaudio_AAudioExtensions_android.h"
 
 #ifdef __ANDROID__
 #include <sys/system_properties.h>
@@ -281,6 +282,7 @@ Result AudioStreamAAudio::open() {
             mLibLoader->stream_getPerformanceMode(mAAudioStream));
     mBufferCapacityInFrames = mLibLoader->stream_getBufferCapacity(mAAudioStream);
     mBufferSizeInFrames = mLibLoader->stream_getBufferSize(mAAudioStream);
+    mFramesPerBurst = mLibLoader->stream_getFramesPerBurst(mAAudioStream);
 
     // These were added in P so we have to check for the function pointer.
     if (mLibLoader->stream_getUsage != nullptr) {
@@ -317,8 +319,13 @@ Result AudioStreamAAudio::close() {
 
     AudioStream::close();
 
-    // This will delete the AAudio stream object so we need to null out the pointer.
-    AAudioStream *stream = mAAudioStream.exchange(nullptr);
+    AAudioStream *stream = nullptr;
+    {
+        // Wait for any methods using mAAudioStream to finish.
+        std::unique_lock<std::shared_mutex> lock2(mAAudioStreamLock);
+        // Closing will delete *mAAudioStream so we need to null out the pointer atomically.
+        stream = mAAudioStream.exchange(nullptr);
+    }
     if (stream != nullptr) {
         if (OboeGlobals::areWorkaroundsEnabled()) {
             // Make sure we are really stopped. Do it under mLock
@@ -540,29 +547,27 @@ Result AudioStreamAAudio::waitForStateChange(StreamState currentState,
 }
 
 ResultWithValue<int32_t> AudioStreamAAudio::setBufferSizeInFrames(int32_t requestedFrames) {
+    int32_t adjustedFrames = requestedFrames;
+    if (adjustedFrames > mBufferCapacityInFrames) {
+        adjustedFrames = mBufferCapacityInFrames;
+    }
+    // This calls getBufferSize() so avoid recursive lock.
+    adjustedFrames = QuirksManager::getInstance().clipBufferSize(*this, adjustedFrames);
 
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
-
     if (stream != nullptr) {
-        int32_t adjustedFrames = requestedFrames;
-        if (adjustedFrames > mBufferCapacityInFrames) {
-            adjustedFrames = mBufferCapacityInFrames;
-        }
-        adjustedFrames = QuirksManager::getInstance().clipBufferSize(*this, adjustedFrames);
-
         int32_t newBufferSize = mLibLoader->stream_setBufferSize(mAAudioStream, adjustedFrames);
-
         // Cache the result if it's valid
         if (newBufferSize > 0) mBufferSizeInFrames = newBufferSize;
-
         return ResultWithValue<int32_t>::createBasedOnSign(newBufferSize);
-
     } else {
         return ResultWithValue<int32_t>(Result::ErrorClosed);
     }
 }
 
-StreamState AudioStreamAAudio::getState() const {
+StreamState AudioStreamAAudio::getState() {
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
     if (stream != nullptr) {
         aaudio_stream_state_t aaudioState = mLibLoader->stream_getState(stream);
@@ -579,6 +584,7 @@ StreamState AudioStreamAAudio::getState() const {
 }
 
 int32_t AudioStreamAAudio::getBufferSizeInFrames() {
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
     if (stream != nullptr) {
         mBufferSizeInFrames = mLibLoader->stream_getBufferSize(stream);
@@ -586,29 +592,34 @@ int32_t AudioStreamAAudio::getBufferSizeInFrames() {
     return mBufferSizeInFrames;
 }
 
-int32_t AudioStreamAAudio::getFramesPerBurst() {
-    AAudioStream *stream = mAAudioStream.load();
-    if (stream != nullptr) {
-        mFramesPerBurst = mLibLoader->stream_getFramesPerBurst(stream);
-    }
-    return mFramesPerBurst;
-}
-
 void AudioStreamAAudio::updateFramesRead() {
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
+// Set to 1 for debugging race condition #1180 with mAAudioStream.
+// See also DEBUG_CLOSE_RACE in OboeTester.
+// This was left in the code so that we could test the fix again easily in the future.
+// We could not trigger the race condition without adding these get calls and the sleeps.
+#define DEBUG_CLOSE_RACE 0
+#if DEBUG_CLOSE_RACE
+    // This is used when testing race conditions with close().
+    // See DEBUG_CLOSE_RACE in OboeTester
+    AudioClock::sleepForNanos(400 * kNanosPerMillisecond);
+#endif // DEBUG_CLOSE_RACE
     if (stream != nullptr) {
         mFramesRead = mLibLoader->stream_getFramesRead(stream);
     }
 }
 
 void AudioStreamAAudio::updateFramesWritten() {
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
     if (stream != nullptr) {
         mFramesWritten = mLibLoader->stream_getFramesWritten(stream);
     }
 }
 
-ResultWithValue<int32_t> AudioStreamAAudio::getXRunCount() const {
+ResultWithValue<int32_t> AudioStreamAAudio::getXRunCount() {
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
     if (stream != nullptr) {
         return ResultWithValue<int32_t>::createBasedOnSign(mLibLoader->stream_getXRunCount(stream));
@@ -620,11 +631,12 @@ ResultWithValue<int32_t> AudioStreamAAudio::getXRunCount() const {
 Result AudioStreamAAudio::getTimestamp(clockid_t clockId,
                                    int64_t *framePosition,
                                    int64_t *timeNanoseconds) {
+    if (getState() != StreamState::Started) {
+        return Result::ErrorInvalidState;
+    }
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
     if (stream != nullptr) {
-        if (getState() != StreamState::Started) {
-            return Result::ErrorInvalidState;
-        }
         return static_cast<Result>(mLibLoader->stream_getTimestamp(stream, clockId,
                                                framePosition, timeNanoseconds));
     } else {
@@ -633,11 +645,6 @@ Result AudioStreamAAudio::getTimestamp(clockid_t clockId,
 }
 
 ResultWithValue<double> AudioStreamAAudio::calculateLatencyMillis() {
-    AAudioStream *stream = mAAudioStream.load();
-    if (stream == nullptr) {
-        return ResultWithValue<double>(Result::ErrorClosed);
-    }
-
     // Get the time that a known audio frame was presented.
     int64_t hardwareFrameIndex;
     int64_t hardwareFrameHardwareTime;
@@ -675,9 +682,10 @@ ResultWithValue<double> AudioStreamAAudio::calculateLatencyMillis() {
 }
 
 bool AudioStreamAAudio::isMMapUsed() {
+    std::shared_lock<std::shared_mutex> lock(mAAudioStreamLock);
     AAudioStream *stream = mAAudioStream.load();
     if (stream != nullptr) {
-        return mLibLoader->stream_isMMapUsed(stream);
+        return AAudioExtensions::getInstance().isMMapUsed(stream);
     } else {
         return false;
     }

audio/internal/oboe/oboe_aaudio_AudioStreamAAudio_android.h

@@ -18,6 +18,7 @@
 #define OBOE_STREAM_AAUDIO_H_
 
 #include <atomic>
+#include <shared_mutex>
 #include <mutex>
 #include <thread>
 
@@ -67,8 +68,7 @@ public:
 
     ResultWithValue<int32_t> setBufferSizeInFrames(int32_t requestedFrames) override;
     int32_t getBufferSizeInFrames() override;
-    int32_t getFramesPerBurst() override;
-    ResultWithValue<int32_t> getXRunCount() const override;
+    ResultWithValue<int32_t> getXRunCount()  override;
     bool isXRunCountSupported() const override { return true; }
 
     ResultWithValue<double> calculateLatencyMillis() override;
@@ -81,7 +81,7 @@ public:
                                        int64_t *framePosition,
                                        int64_t *timeNanoseconds) override;
 
-    StreamState getState() const override;
+    StreamState getState() override;
 
     AudioApi getAudioApi() const override {
         return AudioApi::AAudio;
@@ -120,6 +120,7 @@ private:
 
     // pointer to the underlying 'C' AAudio stream, valid if open, null if closed
     std::atomic<AAudioStream *> mAAudioStream{nullptr};
+    std::shared_mutex           mAAudioStreamLock; // to protect mAAudioStream while closing
 
     static AAudioLoader *mLibLoader;
 

audio/internal/oboe/oboe_common_AudioStreamBuilder_android.cpp

@@ -16,6 +16,8 @@
 
 #include <sys/types.h>
 
+
+#include "oboe_aaudio_AAudioExtensions_android.h"
 #include "oboe_aaudio_AudioStreamAAudio_android.h"
 #include "oboe_common_FilterAudioStream_android.h"
 #include "oboe_common_OboeDebug_android.h"
@@ -89,6 +91,7 @@ bool AudioStreamBuilder::isCompatible(AudioStreamBase &other) {
 Result AudioStreamBuilder::openStream(AudioStream **streamPP) {
     auto result = isValidConfig();
     if (result != Result::OK) {
+        LOGW("%s() invalid config %d", __func__, result);
         return result;
     }
 
@@ -109,7 +112,6 @@ Result AudioStreamBuilder::openStream(AudioStream **streamPP) {
     // Do we need to make a child stream and convert.
     if (conversionNeeded) {
         AudioStream *tempStream;
-
         result = childBuilder.openStream(&tempStream);
         if (result != Result::OK) {
             return result;
@@ -156,7 +158,20 @@ Result AudioStreamBuilder::openStream(AudioStream **streamPP) {
         }
     }
 
-    result = streamP->open(); // TODO review API
+    // If MMAP has a problem in this case then disable it temporarily.
+    bool wasMMapOriginallyEnabled = AAudioExtensions::getInstance().isMMapEnabled();
+    bool wasMMapTemporarilyDisabled = false;
+    if (wasMMapOriginallyEnabled) {
+        bool isMMapSafe = QuirksManager::getInstance().isMMapSafe(childBuilder);
+        if (!isMMapSafe) {
+            AAudioExtensions::getInstance().setMMapEnabled(false);
+            wasMMapTemporarilyDisabled = true;
+        }
+    }
+    result = streamP->open();
+    if (wasMMapTemporarilyDisabled) {
+        AAudioExtensions::getInstance().setMMapEnabled(wasMMapOriginallyEnabled); // restore original
+    }
     if (result == Result::OK) {
 
         int32_t  optimalBufferSize = -1;
@@ -188,24 +203,16 @@ Result AudioStreamBuilder::openStream(AudioStream **streamPP) {
 
 Result AudioStreamBuilder::openManagedStream(oboe::ManagedStream &stream) {
     stream.reset();
-    auto result = isValidConfig();
-    if (result != Result::OK) {
-        return result;
-    }
     AudioStream *streamptr;
-    result = openStream(&streamptr);
+    auto result = openStream(&streamptr);
     stream.reset(streamptr);
     return result;
 }
 
 Result AudioStreamBuilder::openStream(std::shared_ptr<AudioStream> &sharedStream) {
     sharedStream.reset();
-    auto result = isValidConfig();
-    if (result != Result::OK) {
-        return result;
-    }
     AudioStream *streamptr;
-    result = openStream(&streamptr);
+    auto result = openStream(&streamptr);
     if (result == Result::OK) {
         sharedStream.reset(streamptr);
         // Save a weak_ptr in the stream for use with callbacks.

audio/internal/oboe/oboe_common_DataConversionFlowGraph_android.cpp

@@ -20,6 +20,8 @@
 #include "oboe_common_DataConversionFlowGraph_android.h"
 #include "oboe_common_SourceFloatCaller_android.h"
 #include "oboe_common_SourceI16Caller_android.h"
+#include "oboe_common_SourceI24Caller_android.h"
+#include "oboe_common_SourceI32Caller_android.h"
 
 #include "oboe_flowgraph_ClipToRange_android.h"
 #include "oboe_flowgraph_MonoToMultiConverter_android.h"
@@ -28,9 +30,11 @@
 #include "oboe_flowgraph_SinkFloat_android.h"
 #include "oboe_flowgraph_SinkI16_android.h"
 #include "oboe_flowgraph_SinkI24_android.h"
+#include "oboe_flowgraph_SinkI32_android.h"
 #include "oboe_flowgraph_SourceFloat_android.h"
 #include "oboe_flowgraph_SourceI16_android.h"
 #include "oboe_flowgraph_SourceI24_android.h"
+#include "oboe_flowgraph_SourceI32_android.h"
 #include "oboe_flowgraph_SampleRateConverter_android.h"
 
 using namespace oboe;
@@ -116,6 +120,14 @@ Result DataConversionFlowGraph::configure(AudioStream *sourceStream, AudioStream
                 mSourceCaller = std::make_unique<SourceI16Caller>(sourceChannelCount,
                                                                   actualSourceFramesPerCallback);
                 break;
+            case AudioFormat::I24:
+                mSourceCaller = std::make_unique<SourceI24Caller>(sourceChannelCount,
+                                                                  actualSourceFramesPerCallback);
+                break;
+            case AudioFormat::I32:
+                mSourceCaller = std::make_unique<SourceI32Caller>(sourceChannelCount,
+                                                                  actualSourceFramesPerCallback);
+                break;
             default:
                 LOGE("%s() Unsupported source caller format = %d", __func__, sourceFormat);
                 return Result::ErrorIllegalArgument;
@@ -132,6 +144,12 @@ Result DataConversionFlowGraph::configure(AudioStream *sourceStream, AudioStream
             case AudioFormat::I16:
                 mSource = std::make_unique<SourceI16>(sourceChannelCount);
                 break;
+            case AudioFormat::I24:
+                mSource = std::make_unique<SourceI24>(sourceChannelCount);
+                break;
+            case AudioFormat::I32:
+                mSource = std::make_unique<SourceI32>(sourceChannelCount);
+                break;
             default:
                 LOGE("%s() Unsupported source format = %d", __func__, sourceFormat);
                 return Result::ErrorIllegalArgument;
@@ -202,6 +220,12 @@ Result DataConversionFlowGraph::configure(AudioStream *sourceStream, AudioStream
         case AudioFormat::I16:
             mSink = std::make_unique<SinkI16>(sinkChannelCount);
             break;
+        case AudioFormat::I24:
+            mSink = std::make_unique<SinkI24>(sinkChannelCount);
+            break;
+        case AudioFormat::I32:
+            mSink = std::make_unique<SinkI32>(sinkChannelCount);
+            break;
         default:
             LOGE("%s() Unsupported sink format = %d", __func__, sinkFormat);
             return Result::ErrorIllegalArgument;;

audio/internal/oboe/oboe_common_FilterAudioStream_android.cpp

@@ -48,7 +48,7 @@ Result FilterAudioStream::configureFlowGraph() {
     AudioStream *sourceStream =  isOutput ? this : mChildStream.get();
     AudioStream *sinkStream =  isOutput ? mChildStream.get() : this;
 
-    mRateScaler = ((double) sourceStream->getSampleRate()) / sinkStream->getSampleRate();
+    mRateScaler = ((double) getSampleRate()) / mChildStream->getSampleRate();
 
     return mFlowGraph->configure(sourceStream, sinkStream);
 }

audio/internal/oboe/oboe_common_FilterAudioStream_android.h

@@ -56,6 +56,7 @@ public:
         mBufferCapacityInFrames = mChildStream->getBufferCapacityInFrames();
         mPerformanceMode = mChildStream->getPerformanceMode();
         mInputPreset = mChildStream->getInputPreset();
+        mFramesPerBurst = mChildStream->getFramesPerBurst();
     }
 
     virtual ~FilterAudioStream() = default;
@@ -113,7 +114,7 @@ public:
             int32_t numFrames,
             int64_t timeoutNanoseconds) override;
 
-    StreamState getState() const override {
+    StreamState getState() override {
         return mChildStream->getState();
     }
 
@@ -128,10 +129,6 @@ public:
         return mChildStream->isXRunCountSupported();
     }
 
-    int32_t getFramesPerBurst() override {
-        return mChildStream->getFramesPerBurst();
-    }
-
     AudioApi getAudioApi() const override {
         return mChildStream->getAudioApi();
     }
@@ -159,7 +156,7 @@ public:
         return mBufferSizeInFrames;
     }
 
-    ResultWithValue<int32_t> getXRunCount() const override {
+    ResultWithValue<int32_t> getXRunCount() override {
         return mChildStream->getXRunCount();
     }
 
@@ -173,7 +170,10 @@ public:
             int64_t *timeNanoseconds) override {
         int64_t childPosition = 0;
         Result result = mChildStream->getTimestamp(clockId, &childPosition, timeNanoseconds);
-        *framePosition = childPosition * mRateScaler;
+        // It is OK if framePosition is null.
+        if (framePosition) {
+            *framePosition = childPosition * mRateScaler;
+        }
         return result;
     }
 

audio/internal/oboe/oboe_common_QuirksManager_android.cpp

@@ -20,10 +20,6 @@
 #include "oboe_common_OboeDebug_android.h"
 #include "oboe_common_QuirksManager_android.h"
 
-#ifndef __ANDROID_API_R__
-#define __ANDROID_API_R__ 30
-#endif
-
 using namespace oboe;
 
 int32_t QuirksManager::DeviceQuirks::clipBufferSize(AudioStream &stream,
@@ -74,6 +70,10 @@ public:
 
         std::string chipname = getPropertyString("ro.hardware.chipname");
         isExynos9810 = (chipname == "exynos9810");
+        isExynos990 = (chipname == "exynos990");
+        isExynos850 = (chipname == "exynos850");
+
+        mBuildChangelist = getPropertyInteger("ro.build.changelist", 0);
     }
 
     virtual ~SamsungDeviceQuirks() = default;
@@ -87,9 +87,9 @@ public:
         return kTopMargin;
     }
 
-    // See Oboe issue #824 for more information.
+    // See Oboe issues #824 and #1247 for more information.
     bool isMonoMMapActuallyStereo() const override {
-        return isExynos9810; // TODO We can make this version specific if it gets fixed.
+        return isExynos9810 || isExynos850; // TODO We can make this version specific if it gets fixed.
     }
 
     bool isAAudioMMapPossible(const AudioStreamBuilder &builder) const override {
@@ -98,6 +98,17 @@ public:
                 && builder.getInputPreset() != oboe::InputPreset::Camcorder;
     }
 
+    bool isMMapSafe(const AudioStreamBuilder &builder) override {
+        const bool isInput = builder.getDirection() == Direction::Input;
+        // This detects b/159066712 , S20 LSI has corrupt low latency audio recording
+        // and turns off MMAP.
+        // See also https://github.com/google/oboe/issues/892
+        bool mRecordingCorrupted = isInput
+            && isExynos990
+            && mBuildChangelist < 19350896;
+        return !mRecordingCorrupted;
+    }
+
 private:
     // Stay farther away from DSP position on Exynos devices.
     static constexpr int32_t kBottomMarginExynos = 2;
@@ -105,6 +116,9 @@ private:
     static constexpr int32_t kTopMargin = 1;
     bool isExynos = false;
     bool isExynos9810 = false;
+    bool isExynos990 = false;
+    bool isExynos850 = false;
+    int mBuildChangelist = 0;
 };
 
 QuirksManager::QuirksManager() {
@@ -170,6 +184,19 @@ bool QuirksManager::isConversionNeeded(
         LOGI("QuirksManager::%s() forcing internal format to I16 for low latency", __func__);
     }
 
+    // Add quirk for float output on API <21
+    if (isFloat
+            && !isInput
+            && getSdkVersion() < __ANDROID_API_L__
+            && builder.isFormatConversionAllowed()
+            ) {
+        childBuilder.setFormat(AudioFormat::I16);
+        conversionNeeded = true;
+        LOGI("QuirksManager::%s() float was requested but not supported on pre-L devices, "
+             "creating an underlying I16 stream and using format conversion to provide a float "
+             "stream", __func__);
+    }
+
     // Channel Count conversions
     if (OboeGlobals::areWorkaroundsEnabled()
             && builder.isChannelConversionAllowed()
@@ -203,3 +230,8 @@ bool QuirksManager::isConversionNeeded(
 
     return conversionNeeded;
 }
+
+bool QuirksManager::isMMapSafe(AudioStreamBuilder &builder) {
+    if (!OboeGlobals::areWorkaroundsEnabled()) return true;
+    return mDeviceQuirks->isMMapSafe(builder);
+}

audio/internal/oboe/oboe_common_QuirksManager_android.h

@@ -21,6 +21,10 @@
 #include "oboe_oboe_AudioStreamBuilder_android.h"
 #include "oboe_aaudio_AudioStreamAAudio_android.h"
 
+#ifndef __ANDROID_API_R__
+#define __ANDROID_API_R__ 30
+#endif
+
 namespace oboe {
 
 /**
@@ -98,6 +102,10 @@ public:
 
         virtual bool isAAudioMMapPossible(const AudioStreamBuilder &builder) const;
 
+        virtual bool isMMapSafe(const AudioStreamBuilder & /* builder */ ) {
+            return true;
+        }
+
         static constexpr int32_t kDefaultBottomMarginInBursts = 0;
         static constexpr int32_t kDefaultTopMarginInBursts = 0;
 
@@ -108,6 +116,8 @@ public:
         static constexpr int32_t kCommonNativeRate = 48000; // very typical native sample rate
     };
 
+    bool isMMapSafe(AudioStreamBuilder &builder);
+
 private:
 
     static constexpr int32_t kChannelCountMono = 1;

audio/internal/oboe/oboe_common_SourceI24Caller_android.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <unistd.h>
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+#include "oboe_common_SourceI24Caller_android.h"
+
+#if FLOWGRAPH_ANDROID_INTERNAL
+#include <audio_utils/primitives.h>
+#endif
+
+using namespace oboe;
+using namespace flowgraph;
+
+int32_t SourceI24Caller::onProcess(int32_t numFrames) {
+    int32_t numBytes = mStream->getBytesPerFrame() * numFrames;
+    int32_t bytesRead = mBlockReader.read((uint8_t *) mConversionBuffer.get(), numBytes);
+    int32_t framesRead = bytesRead / mStream->getBytesPerFrame();
+
+    float *floatData = output.getBuffer();
+    const uint8_t *byteData = mConversionBuffer.get();
+    int32_t numSamples = framesRead * output.getSamplesPerFrame();
+
+#if FLOWGRAPH_ANDROID_INTERNAL
+    memcpy_to_float_from_p24(floatData, byteData, numSamples);
+#else
+    static const float scale = 1. / (float)(1UL << 31);
+    for (int i = 0; i < numSamples; i++) {
+        // Assemble the data assuming Little Endian format.
+        int32_t pad = byteData[2];
+        pad <<= 8;
+        pad |= byteData[1];
+        pad <<= 8;
+        pad |= byteData[0];
+        pad <<= 8; // Shift to 32 bit data so the sign is correct.
+        byteData += kBytesPerI24Packed;
+        *floatData++ = pad * scale; // scale to range -1.0 to 1.0
+    }
+#endif
+
+    return framesRead;
+}

audio/internal/oboe/oboe_common_SourceI24Caller_android.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OBOE_SOURCE_I24_CALLER_H
+#define OBOE_SOURCE_I24_CALLER_H
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+#include "oboe_common_AudioSourceCaller_android.h"
+#include "oboe_common_FixedBlockReader_android.h"
+
+namespace oboe {
+
+/**
+ * AudioSource that uses callback to get more data.
+ */
+class SourceI24Caller : public AudioSourceCaller {
+public:
+    SourceI24Caller(int32_t channelCount, int32_t framesPerCallback)
+    : AudioSourceCaller(channelCount, framesPerCallback, kBytesPerI24Packed) {
+        mConversionBuffer = std::make_unique<uint8_t[]>(
+                kBytesPerI24Packed * channelCount * output.getFramesPerBuffer());
+    }
+
+    int32_t onProcess(int32_t numFrames) override;
+
+    const char *getName() override {
+        return "SourceI24Caller";
+    }
+
+private:
+    std::unique_ptr<uint8_t[]>  mConversionBuffer;
+    static constexpr int kBytesPerI24Packed = 3;
+};
+
+}
+#endif //OBOE_SOURCE_I16_CALLER_H

audio/internal/oboe/oboe_common_SourceI32Caller_android.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <unistd.h>
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+#include "oboe_common_SourceI32Caller_android.h"
+
+#if FLOWGRAPH_ANDROID_INTERNAL
+#include <audio_utils/primitives.h>
+#endif
+
+using namespace oboe;
+using namespace flowgraph;
+
+int32_t SourceI32Caller::onProcess(int32_t numFrames) {
+    int32_t numBytes = mStream->getBytesPerFrame() * numFrames;
+    int32_t bytesRead = mBlockReader.read((uint8_t *) mConversionBuffer.get(), numBytes);
+    int32_t framesRead = bytesRead / mStream->getBytesPerFrame();
+
+    float *floatData = output.getBuffer();
+    const int32_t *intData = mConversionBuffer.get();
+    int32_t numSamples = framesRead * output.getSamplesPerFrame();
+
+#if FLOWGRAPH_ANDROID_INTERNAL
+    memcpy_to_float_from_i32(floatData, shortData, numSamples);
+#else
+    for (int i = 0; i < numSamples; i++) {
+        *floatData++ = *intData++ * kScale;
+    }
+#endif
+
+    return framesRead;
+}

audio/internal/oboe/oboe_common_SourceI32Caller_android.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OBOE_SOURCE_I32_CALLER_H
+#define OBOE_SOURCE_I32_CALLER_H
+
+#include <memory.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+#include "oboe_common_AudioSourceCaller_android.h"
+#include "oboe_common_FixedBlockReader_android.h"
+
+namespace oboe {
+
+/**
+ * AudioSource that uses callback to get more data.
+ */
+class SourceI32Caller : public AudioSourceCaller {
+public:
+    SourceI32Caller(int32_t channelCount, int32_t framesPerCallback)
+    : AudioSourceCaller(channelCount, framesPerCallback, sizeof(int32_t)) {
+        mConversionBuffer = std::make_unique<int32_t[]>(channelCount * output.getFramesPerBuffer());
+    }
+
+    int32_t onProcess(int32_t numFrames) override;
+
+    const char *getName() override {
+        return "SourceI32Caller";
+    }
+
+private:
+    std::unique_ptr<int32_t[]>  mConversionBuffer;
+    static constexpr float kScale = 1.0 / (1UL << 31);
+};
+
+}
+#endif //OBOE_SOURCE_I32_CALLER_H

audio/internal/oboe/oboe_common_Utilities_android.cpp

@@ -60,6 +60,12 @@ int32_t convertFormatToSizeInBytes(AudioFormat format) {
         case AudioFormat::Float:
             size = sizeof(float);
             break;
+        case AudioFormat::I24:
+            size = 3; // packed 24-bit data
+            break;
+        case AudioFormat::I32:
+            size = sizeof(int32_t);
+            break;
         default:
             break;
     }
@@ -98,6 +104,8 @@ const char *convertToText<AudioFormat>(AudioFormat format) {
         case AudioFormat::Unspecified:  return "Unspecified";
         case AudioFormat::I16:          return "I16";
         case AudioFormat::Float:        return "Float";
+        case AudioFormat::I24:          return "I24";
+        case AudioFormat::I32:          return "I32";
         default:                        return "Unrecognized format";
     }
 }

audio/internal/oboe/oboe_flowgraph_FlowgraphUtilities_android.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLOWGRAPH_UTILITIES_H
+#define FLOWGRAPH_UTILITIES_H
+
+#include <unistd.h>
+
+using namespace FLOWGRAPH_OUTER_NAMESPACE::flowgraph;
+
+class FlowgraphUtilities {
+public:
+// This was copied from audio_utils/primitives.h
+/**
+ * Convert a single-precision floating point value to a Q0.31 integer value.
+ * Rounds to nearest, ties away from 0.
+ *
+ * Values outside the range [-1.0, 1.0) are properly clamped to -2147483648 and 2147483647,
+ * including -Inf and +Inf. NaN values are considered undefined, and behavior may change
+ * depending on hardware and future implementation of this function.
+ */
+static int32_t clamp32FromFloat(float f)
+{
+    static const float scale = (float)(1UL << 31);
+    static const float limpos = 1.;
+    static const float limneg = -1.;
+
+    if (f <= limneg) {
+        return -0x80000000; /* or 0x80000000 */
+    } else if (f >= limpos) {
+        return 0x7fffffff;
+    }
+    f *= scale;
+    /* integer conversion is through truncation (though int to float is not).
+     * ensure that we round to nearest, ties away from 0.
+     */
+    return f > 0 ? f + 0.5 : f - 0.5;
+}
+
+};
+
+#endif // FLOWGRAPH_UTILITIES_H

audio/internal/oboe/oboe_flowgraph_SinkFloat_android.cpp

@@ -28,7 +28,7 @@ SinkFloat::SinkFloat(int32_t channelCount)
 int32_t SinkFloat::read(void *data, int32_t numFrames) {
     // printf("SinkFloat::read(,,%d)\n", numFrames);
     float *floatData = (float *) data;
-    int32_t channelCount = input.getSamplesPerFrame();
+    const int32_t channelCount = input.getSamplesPerFrame();
 
     int32_t framesLeft = numFrames;
     while (framesLeft > 0) {

audio/internal/oboe/oboe_flowgraph_SinkFloat_android.h

@@ -32,6 +32,7 @@ namespace flowgraph {
 class SinkFloat : public FlowGraphSink {
 public:
     explicit SinkFloat(int32_t channelCount);
+    ~SinkFloat() override = default;
 
     int32_t read(void *data, int32_t numFrames) override;
 

audio/internal/oboe/oboe_flowgraph_SinkI32_android.cpp

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if FLOWGRAPH_ANDROID_INTERNAL
+#include <audio_utils/primitives.h>
+#endif
+
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+#include "oboe_flowgraph_FlowgraphUtilities_android.h"
+#include "oboe_flowgraph_SinkI32_android.h"
+
+using namespace FLOWGRAPH_OUTER_NAMESPACE::flowgraph;
+
+SinkI32::SinkI32(int32_t channelCount)
+        : FlowGraphSink(channelCount) {}
+
+int32_t SinkI32::read(void *data, int32_t numFrames) {
+    int32_t *intData = (int32_t *) data;
+    const int32_t channelCount = input.getSamplesPerFrame();
+
+    int32_t framesLeft = numFrames;
+    while (framesLeft > 0) {
+        // Run the graph and pull data through the input port.
+        int32_t framesRead = pullData(framesLeft);
+        if (framesRead <= 0) {
+            break;
+        }
+        const float *signal = input.getBuffer();
+        int32_t numSamples = framesRead * channelCount;
+#if FLOWGRAPH_ANDROID_INTERNAL
+        memcpy_to_i32_from_float(intData, signal, numSamples);
+        intData += numSamples;
+        signal += numSamples;
+#else
+        for (int i = 0; i < numSamples; i++) {
+            *intData++ = FlowgraphUtilities::clamp32FromFloat(*signal++);
+        }
+#endif
+        framesLeft -= framesRead;
+    }
+    return numFrames - framesLeft;
+}

audio/internal/oboe/oboe_flowgraph_SinkI32_android.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLOWGRAPH_SINK_I32_H
+#define FLOWGRAPH_SINK_I32_H
+
+#include <stdint.h>
+
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+
+namespace FLOWGRAPH_OUTER_NAMESPACE {
+namespace flowgraph {
+
+class SinkI32 : public FlowGraphSink {
+public:
+    explicit SinkI32(int32_t channelCount);
+    ~SinkI32() override = default;
+
+    int32_t read(void *data, int32_t numFrames) override;
+
+    const char *getName() override {
+        return "SinkI32";
+    }
+};
+
+} /* namespace flowgraph */
+} /* namespace FLOWGRAPH_OUTER_NAMESPACE */
+
+#endif //FLOWGRAPH_SINK_I32_H

audio/internal/oboe/oboe_flowgraph_SourceFloat_android.cpp

@@ -28,11 +28,11 @@ SourceFloat::SourceFloat(int32_t channelCount)
 
 int32_t SourceFloat::onProcess(int32_t numFrames) {
     float *outputBuffer = output.getBuffer();
-    int32_t channelCount = output.getSamplesPerFrame();
+    const int32_t channelCount = output.getSamplesPerFrame();
 
-    int32_t framesLeft = mSizeInFrames - mFrameIndex;
-    int32_t framesToProcess = std::min(numFrames, framesLeft);
-    int32_t numSamples = framesToProcess * channelCount;
+    const int32_t framesLeft = mSizeInFrames - mFrameIndex;
+    const int32_t framesToProcess = std::min(numFrames, framesLeft);
+    const int32_t numSamples = framesToProcess * channelCount;
 
     const float *floatBase = (float *) mData;
     const float *floatData = &floatBase[mFrameIndex * channelCount];

audio/internal/oboe/oboe_flowgraph_SourceFloat_android.h

@@ -31,6 +31,7 @@ namespace flowgraph {
 class SourceFloat : public FlowGraphSourceBuffered {
 public:
     explicit SourceFloat(int32_t channelCount);
+    ~SourceFloat() override = default;
 
     int32_t onProcess(int32_t numFrames) override;
 

audio/internal/oboe/oboe_flowgraph_SourceI32_android.cpp

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <algorithm>
+#include <unistd.h>
+
+#if FLOWGRAPH_ANDROID_INTERNAL
+#include <audio_utils/primitives.h>
+#endif
+
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+#include "oboe_flowgraph_SourceI32_android.h"
+
+using namespace FLOWGRAPH_OUTER_NAMESPACE::flowgraph;
+
+SourceI32::SourceI32(int32_t channelCount)
+        : FlowGraphSourceBuffered(channelCount) {
+}
+
+int32_t SourceI32::onProcess(int32_t numFrames) {
+    float *floatData = output.getBuffer();
+    const int32_t channelCount = output.getSamplesPerFrame();
+
+    const int32_t framesLeft = mSizeInFrames - mFrameIndex;
+    const int32_t framesToProcess = std::min(numFrames, framesLeft);
+    const int32_t numSamples = framesToProcess * channelCount;
+
+    const int32_t *intBase = static_cast<const int32_t *>(mData);
+    const int32_t *intData = &intBase[mFrameIndex * channelCount];
+
+#if FLOWGRAPH_ANDROID_INTERNAL
+    memcpy_to_float_from_i32(floatData, intData, numSamples);
+#else
+    for (int i = 0; i < numSamples; i++) {
+        *floatData++ = *intData++ * kScale;
+    }
+#endif
+
+    mFrameIndex += framesToProcess;
+    return framesToProcess;
+}

audio/internal/oboe/oboe_flowgraph_SourceI32_android.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLOWGRAPH_SOURCE_I32_H
+#define FLOWGRAPH_SOURCE_I32_H
+
+#include <stdint.h>
+
+#include "oboe_flowgraph_FlowGraphNode_android.h"
+
+namespace FLOWGRAPH_OUTER_NAMESPACE {
+namespace flowgraph {
+
+class SourceI32 : public FlowGraphSourceBuffered {
+public:
+    explicit SourceI32(int32_t channelCount);
+    ~SourceI32() override = default;
+
+    int32_t onProcess(int32_t numFrames) override;
+
+    const char *getName() override {
+        return "SourceI32";
+    }
+private:
+    static constexpr float kScale = 1.0 / (1UL << 31);
+};
+
+} /* namespace flowgraph */
+} /* namespace FLOWGRAPH_OUTER_NAMESPACE */
+
+#endif //FLOWGRAPH_SOURCE_I32_H

audio/internal/oboe/oboe_oboe_AudioStreamBase_android.h

@@ -196,11 +196,6 @@ protected:
     int32_t                         mBufferCapacityInFrames = kUnspecified;
     /** Stream buffer size specified as a number of audio frames */
     int32_t                         mBufferSizeInFrames = kUnspecified;
-    /**
-     * Number of frames which will be copied to/from the audio device in a single read/write
-     * operation
-     */
-    int32_t                         mFramesPerBurst = kUnspecified;
 
     /** Stream sharing mode */
     SharingMode                     mSharingMode = SharingMode::Shared;
@@ -235,6 +230,8 @@ protected:
             case AudioFormat::Unspecified:
             case AudioFormat::I16:
             case AudioFormat::Float:
+            case AudioFormat::I24:
+            case AudioFormat::I32:
                 break;
 
             default:

audio/internal/oboe/oboe_oboe_AudioStreamBuilder_android.h

@@ -391,11 +391,11 @@ public:
     }
 
     /**
-     * If true then  Oboe might convert data formats to achieve optimal results.
+     * If true then Oboe might convert data formats to achieve optimal results.
      * On some versions of Android, for example, a float stream could not get a
      * low latency data path. So an I16 stream might be opened and converted to float.
      *
-     * Default is true.
+     * Default is false.
      */
     AudioStreamBuilder *setFormatConversionAllowed(bool allowed) {
         mFormatConversionAllowed = allowed;
@@ -429,7 +429,8 @@ public:
     /**
      * Create and open a stream object based on the current settings.
      *
-     * The caller owns the pointer to the AudioStream object.
+     * The caller owns the pointer to the AudioStream object
+     * and must delete it when finished.
      *
      * @deprecated Use openStream(std::shared_ptr<oboe::AudioStream> &stream) instead.
      * @param stream pointer to a variable to receive the stream address
@@ -455,6 +456,8 @@ public:
      * The caller must create a unique ptr, and pass by reference so it can be
      * modified to point to an opened stream. The caller owns the unique ptr,
      * and it will be automatically closed and deleted when going out of scope.
+     *
+     * @deprecated Use openStream(std::shared_ptr<oboe::AudioStream> &stream) instead.
      * @param stream Reference to the ManagedStream (uniqueptr) used to keep track of stream
      * @return OBOE_OK if successful or a negative error code.
      */

audio/internal/oboe/oboe_oboe_AudioStream_android.h

@@ -130,7 +130,7 @@ public:
      *
      * @return state or a negative error.
      */
-    virtual StreamState getState() const = 0;
+    virtual StreamState getState() = 0;
 
     /**
      * Wait until the stream's current state no longer matches the input state.
@@ -191,7 +191,7 @@ public:
      * @return a result which is either Result::OK with the xRun count as the value, or a
      * Result::Error* code
      */
-    virtual ResultWithValue<int32_t> getXRunCount() const {
+    virtual ResultWithValue<int32_t> getXRunCount() {
         return ResultWithValue<int32_t>(Result::ErrorUnimplemented);
     }
 
@@ -205,7 +205,9 @@ public:
      *
      * @return burst size
      */
-    virtual int32_t getFramesPerBurst() = 0;
+    int32_t getFramesPerBurst() const {
+        return mFramesPerBurst;
+    }
 
     /**
      * Get the number of bytes in each audio frame. This is calculated using the channel count
@@ -537,6 +539,12 @@ protected:
 
     oboe::Result         mErrorCallbackResult = oboe::Result::OK;
 
+    /**
+     * Number of frames which will be copied to/from the audio device in a single read/write
+     * operation
+     */
+    int32_t              mFramesPerBurst = kUnspecified;
+
 private:
 
     // Log the scheduler if it changes.

audio/internal/oboe/oboe_oboe_Definitions_android.h

@@ -17,7 +17,6 @@
 #ifndef OBOE_DEFINITIONS_H
 #define OBOE_DEFINITIONS_H
 
-
 #include <cstdint>
 #include <type_traits>
 
@@ -108,9 +107,36 @@ namespace oboe {
         I16 = 1, // AAUDIO_FORMAT_PCM_I16,
 
         /**
-         * Single precision floating points.
+         * Single precision floating point.
+         *
+         * This is the recommended format for most applications.
+         * But note that the use of Float may prevent the opening of
+         * a low-latency input path on OpenSL ES or Legacy AAudio streams.
          */
         Float = 2, // AAUDIO_FORMAT_PCM_FLOAT,
+
+        /**
+         * Signed 24-bit integers, packed into 3 bytes.
+         *
+         * Note that the use of this format does not guarantee that
+         * the full precision will be provided.  The underlying device may
+         * be using I16 format.
+         *
+         * Added in API 31 (S).
+         */
+        I24 = 3, // AAUDIO_FORMAT_PCM_I24_PACKED
+
+        /**
+         * Signed 32-bit integers.
+         *
+         * Note that the use of this format does not guarantee that
+         * the full precision will be provided.  The underlying device may
+         * be using I16 format.
+         *
+         * Added in API 31 (S).
+         */
+        I32 = 4, // AAUDIO_FORMAT_PCM_I32
+
     };
 
     /**

audio/internal/oboe/oboe_oboe_Version_android.h

@@ -34,7 +34,7 @@
 #define OBOE_VERSION_MAJOR 1
 
 // Type: 8-bit unsigned int. Min value: 0 Max value: 255. See below for description.
-#define OBOE_VERSION_MINOR 5
+#define OBOE_VERSION_MINOR 6
 
 // Type: 16-bit unsigned int. Min value: 0 Max value: 65535. See below for description.
 #define OBOE_VERSION_PATCH 0

audio/internal/oboe/oboe_opensles_AudioStreamBuffered_android.h

@@ -49,7 +49,7 @@ public:
 
     int32_t getBufferCapacityInFrames() const override;
 
-    ResultWithValue<int32_t> getXRunCount() const override {
+    ResultWithValue<int32_t> getXRunCount() override {
         return ResultWithValue<int32_t>(mXRunCount);
     }
 

audio/internal/oboe/oboe_opensles_AudioStreamOpenSLES_android.cpp

@@ -354,10 +354,6 @@ SLresult AudioStreamOpenSLES::registerBufferQueueCallback() {
     return result;
 }
 
-int32_t AudioStreamOpenSLES::getFramesPerBurst() {
-    return mFramesPerBurst;
-}
-
 int64_t AudioStreamOpenSLES::getFramesProcessedByServer() {
     updateServiceFrameCounter();
     int64_t millis64 = mPositionMillis.get();

audio/internal/oboe/oboe_opensles_AudioStreamOpenSLES_android.h

@@ -56,10 +56,7 @@ public:
      *
      * @return state or a negative error.
      */
-    StreamState getState() const override { return mState.load(); }
-
-    int32_t getFramesPerBurst() override;
-
+    StreamState getState() override { return mState.load(); }
 
     AudioApi getAudioApi() const override {
         return AudioApi::OpenSLES;

audio/internal/oboe/oboe_opensles_OpenSLESUtilities_android.cpp

@@ -83,6 +83,8 @@ SLuint32 OpenSLES_ConvertFormatToRepresentation(AudioFormat format) {
             return SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT;
         case AudioFormat::Float:
             return SL_ANDROID_PCM_REPRESENTATION_FLOAT;
+        case AudioFormat::I24:
+        case AudioFormat::I32:
         case AudioFormat::Invalid:
         case AudioFormat::Unspecified:
         default: