internal/oboe: update Oboe to 1.9.3

Author: hajimehoshi

internal/oboe/gen.go

@@ -29,7 +29,7 @@ import (
 	"strings"
 )
 
-const oboeVersion = "1.9.0"
+const oboeVersion = "1.9.3"
 
 func main() {
 	if err := run(); err != nil {

internal/oboe/oboe_aaudio_AudioStreamAAudio_android.cpp

@@ -20,8 +20,8 @@
 
 #include "oboe_aaudio_AAudioLoader_android.h"
 #include "oboe_aaudio_AudioStreamAAudio_android.h"
-#include "oboe_common_AudioClock_android.h"
 #include "oboe_common_OboeDebug_android.h"
+#include "oboe_oboe_AudioClock_android.h"
 #include "oboe_oboe_Utilities_android.h"
 #include "oboe_aaudio_AAudioExtensions_android.h"
 

internal/oboe/oboe_aaudio_AudioStreamAAudio_android.h

@@ -100,6 +100,14 @@ class AudioStreamAAudio : public AudioStream {
         mAdpfOpenAttempted = false;
     }
 
+    oboe::Result reportWorkload(int32_t appWorkload) override {
+        if (!isPerformanceHintEnabled()) {
+            return oboe::Result::ErrorInvalidState;
+        }
+        mAdpfWrapper.reportWorkload(appWorkload);
+        return oboe::Result::OK;
+    }
+
 protected:
     static void internalErrorCallback(
             AAudioStream *stream,

internal/oboe/oboe_common_AdpfWrapper_android.cpp

@@ -18,8 +18,8 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+#include "oboe_oboe_AudioClock_android.h"
 #include "oboe_common_AdpfWrapper_android.h"
-#include "oboe_common_AudioClock_android.h"
 #include "oboe_common_OboeDebug_android.h"
 
 typedef APerformanceHintManager* (*APH_getManager)();
@@ -120,5 +120,22 @@ void AdpfWrapper::onEndCallback(double durationScaler) {
         int64_t actualDurationNanos = endCallbackNanos - mBeginCallbackNanos;
         int64_t scaledDurationNanos = static_cast<int64_t>(actualDurationNanos * durationScaler);
         reportActualDuration(scaledDurationNanos);
+        // When the workload is non-zero, update the conversion factor from workload
+        // units to nanoseconds duration.
+        if (mPreviousWorkload > 0) {
+            mNanosPerWorkloadUnit = ((double) scaledDurationNanos) / mPreviousWorkload;
+        }
+    }
+}
+
+void AdpfWrapper::reportWorkload(int32_t appWorkload) {
+    if (isOpen()) {
+        // Compare with previous workload. If we think we will need more
+        // time to render the callback then warn ADPF as soon as possible.
+        if (appWorkload > mPreviousWorkload && mNanosPerWorkloadUnit > 0.0) {
+            int64_t predictedDuration = (int64_t) (appWorkload * mNanosPerWorkloadUnit);
+            reportActualDuration(predictedDuration);
+        }
+        mPreviousWorkload = appWorkload;
     }
 }

internal/oboe/oboe_common_AdpfWrapper_android.h

@@ -75,11 +75,15 @@ class AdpfWrapper {
      */
     void reportActualDuration(int64_t actualDurationNanos);
 
+    void reportWorkload(int32_t appWorkload);
+
 private:
     std::mutex               mLock;
     APerformanceHintSession* mHintSession = nullptr;
     int64_t                  mBeginCallbackNanos = 0;
     static bool              sUseAlternativeHack;
+    int32_t                  mPreviousWorkload = 0;
+    double                   mNanosPerWorkloadUnit = 0.0;
 };
 
 #endif //SYNTHMARK_ADPF_WRAPPER_H

internal/oboe/oboe_common_AudioStreamBuilder_android.cpp

@@ -100,8 +100,10 @@ Result AudioStreamBuilder::openStreamInternal(AudioStream **streamPP) {
         return result;
     }
 
+#ifndef OBOE_SUPPRESS_LOG_SPAM
     LOGI("%s() %s -------- %s --------",
          __func__, getDirection() == Direction::Input ? "INPUT" : "OUTPUT", getVersionText());
+#endif
 
     if (streamPP == nullptr) {
         return Result::ErrorNull;
@@ -180,24 +182,26 @@ Result AudioStreamBuilder::openStreamInternal(AudioStream **streamPP) {
         AAudioExtensions::getInstance().setMMapEnabled(wasMMapOriginallyEnabled); // restore original
     }
     if (result == Result::OK) {
-
-        int32_t  optimalBufferSize = -1;
-        // Use a reasonable default buffer size.
-        if (streamP->getDirection() == Direction::Input) {
-            // For input, small size does not improve latency because the stream is usually
-            // run close to empty. And a low size can result in XRuns so always use the maximum.
-            optimalBufferSize = streamP->getBufferCapacityInFrames();
-        } else if (streamP->getPerformanceMode() == PerformanceMode::LowLatency
-                && streamP->getDirection() == Direction::Output)  { // Output check is redundant.
-            optimalBufferSize = streamP->getFramesPerBurst() *
-                                    kBufferSizeInBurstsForLowLatencyStreams;
-        }
-        if (optimalBufferSize >= 0) {
-            auto setBufferResult = streamP->setBufferSizeInFrames(optimalBufferSize);
-            if (!setBufferResult) {
-                LOGW("Failed to setBufferSizeInFrames(%d). Error was %s",
-                     optimalBufferSize,
-                     convertToText(setBufferResult.error()));
+        // AAudio supports setBufferSizeInFrames() so use it.
+        if (streamP->getAudioApi() == AudioApi::AAudio) {
+            int32_t  optimalBufferSize = -1;
+            // Use a reasonable default buffer size.
+            if (streamP->getDirection() == Direction::Input) {
+                // For input, small size does not improve latency because the stream is usually
+                // run close to empty. And a low size can result in XRuns so always use the maximum.
+                optimalBufferSize = streamP->getBufferCapacityInFrames();
+            } else if (streamP->getPerformanceMode() == PerformanceMode::LowLatency
+                    && streamP->getDirection() == Direction::Output)  { // Output check is redundant.
+                optimalBufferSize = streamP->getFramesPerBurst() *
+                                        kBufferSizeInBurstsForLowLatencyStreams;
+            }
+            if (optimalBufferSize >= 0) {
+                auto setBufferResult = streamP->setBufferSizeInFrames(optimalBufferSize);
+                if (!setBufferResult) {
+                    LOGW("Failed to setBufferSizeInFrames(%d). Error was %s",
+                         optimalBufferSize,
+                         convertToText(setBufferResult.error()));
+                }
             }
         }
 

internal/oboe/oboe_common_AudioStream_android.cpp

@@ -18,10 +18,10 @@
 #include <pthread.h>
 #include <thread>
 
+#include "oboe_oboe_AudioClock_android.h"
 #include "oboe_oboe_AudioStream_android.h"
-#include "oboe_common_OboeDebug_android.h"
-#include "oboe_common_AudioClock_android.h"
 #include "oboe_oboe_Utilities_android.h"
+#include "oboe_common_OboeDebug_android.h"
 
 namespace oboe {
 

internal/oboe/oboe_common_StabilizedCallback_android.cpp

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include "oboe_oboe_StabilizedCallback_android.h"
-#include "oboe_common_AudioClock_android.h"
 #include "oboe_common_Trace_android.h"
+#include "oboe_oboe_AudioClock_android.h"
+#include "oboe_oboe_StabilizedCallback_android.h"
 
 constexpr int32_t kLoadGenerationStepSizeNanos = 20000;
 constexpr float kPercentageOfCallbackToUse = 0.8;

internal/oboe/oboe_common_AudioClock_android.h renamed to internal/oboe/oboe_oboe_AudioClock_android.h

@@ -23,7 +23,6 @@
 
 namespace oboe {
 
-// TODO: Move this class into the public headers because it is useful when calculating stream latency
 class AudioClock {
 public:
     static int64_t getNanoseconds(clockid_t clockId = CLOCK_MONOTONIC) {

internal/oboe/oboe_oboe_AudioStream_android.h

@@ -26,8 +26,6 @@
 #include "oboe_oboe_AudioStreamBuilder_android.h"
 #include "oboe_oboe_AudioStreamBase_android.h"
 
-/** WARNING - UNDER CONSTRUCTION - THIS API WILL CHANGE. */
-
 namespace oboe {
 
 /**
@@ -517,18 +515,18 @@ class AudioStream : public AudioStreamBase {
      *
      * The flag will be checked in the Oboe data callback. If it transitions from false to true
      * then the PerformanceHint feature will be started.
-     * This only needs to be called once.
+     * This only needs to be called once for each stream.
      *
      * You may want to enable this if you have a dynamically changing workload
-     * and you notice that you are getting underruns and glitches when your workload increases.
+     * and you notice that you are getting under-runs and glitches when your workload increases.
      * This might happen, for example, if you suddenly go from playing one note to
      * ten notes on a synthesizer.
      *
-     * Try the CPU Load test in OboeTester if you would like to experiment with this interactively.
+     * Try the "CPU Load" test in OboeTester if you would like to experiment with this interactively.
      *
      * On some devices, this may be implemented using the "ADPF" library.
      *
-     * @param enabled true if you would like a performance boost
+     * @param enabled true if you would like a performance boost, default is false
      */
     void setPerformanceHintEnabled(bool enabled) {
         mPerformanceHintEnabled = enabled;
@@ -544,6 +542,36 @@ class AudioStream : public AudioStreamBase {
         return mPerformanceHintEnabled;
     }
 
+    /**
+     * Use this to give the performance manager more information about your workload.
+     * You can call this at the beginning of the callback when you figure
+     * out what your workload will be.
+     *
+     * Call this if (1) you have called setPerformanceHintEnabled(true), and
+     * (2) you have a varying workload, and
+     * (3) you hear glitches when your workload suddenly increases.
+     *
+     * This might happen when you go from a single note to a big chord on a synthesizer.
+     *
+     * The workload can be in your own units. If you are synthesizing music
+     * then the workload could be the number of active voices.
+     * If your app is a game then it could be the number of sound effects.
+     * The units are arbitrary. They just have to be proportional to
+     * the estimated computational load. For example, if some of your voices take 20%
+     * more computation than a basic voice then assign 6 units to the complex voice
+     * and 5 units to the basic voice.
+     *
+     * The performance hint code can use this as an advance warning that the callback duration
+     * will probably increase. Rather than wait for the long duration and possibly under-run,
+     * we can boost the CPU immediately before we start doing the calculations.
+     *
+     * @param appWorkload workload in application units, such as number of voices
+     * @return OK or an error such as ErrorInvalidState if the PerformanceHint was not enabled.
+     */
+    virtual oboe::Result reportWorkload(int32_t appWorkload) {
+        return oboe::Result::ErrorUnimplemented;
+    }
+
 protected:
 
     /**

internal/oboe/oboe_oboe_FullDuplexStream_android.h

@@ -53,39 +53,69 @@ class FullDuplexStream : public AudioStreamDataCallback {
     virtual ~FullDuplexStream() = default;
 
     /**
-     * Sets the input stream. Calling this is mandatory.
+     * Sets the input stream.
      *
+     * @deprecated Call setSharedInputStream(std::shared_ptr<AudioStream> &stream) instead.
      * @param stream the output stream
      */
     void setInputStream(AudioStream *stream) {
-        mInputStream = stream;
+        mRawInputStream = stream;
+    }
+
+    /**
+     * Sets the input stream. Calling this is mandatory.
+     *
+     * @param stream the output stream
+     */
+    void setSharedInputStream(std::shared_ptr<AudioStream> &stream) {
+        mSharedInputStream = stream;
     }
 
     /**
-     * Gets the input stream
+     * Gets the current input stream. This function tries to return the shared input stream if it
+     * is set before the raw input stream.
      *
-     * @return the input stream
+     * @return pointer to an output stream or nullptr.
      */
     AudioStream *getInputStream() {
-        return mInputStream;
+        if (mSharedInputStream) {
+            return mSharedInputStream.get();
+        } else {
+            return mRawInputStream;
+        }
     }
 
     /**
-     * Sets the output stream. Calling this is mandatory.
+     * Sets the output stream.
      *
+     * @deprecated Call setSharedOutputStream(std::shared_ptr<AudioStream> &stream) instead.
      * @param stream the output stream
      */
     void setOutputStream(AudioStream *stream) {
-        mOutputStream = stream;
+        mRawOutputStream = stream;
+    }
+
+    /**
+     * Sets the output stream. Calling this is mandatory.
+     *
+     * @param stream the output stream
+     */
+    void setSharedOutputStream(std::shared_ptr<AudioStream> &stream) {
+        mSharedOutputStream = stream;
     }
 
     /**
-     * Gets the output stream
+     * Gets the current output stream. This function tries to return the shared output stream if it
+     * is set before the raw output stream.
      *
-     * @return the output stream
+     * @return pointer to an output stream or nullptr.
      */
     AudioStream *getOutputStream() {
-        return mOutputStream;
+        if (mSharedOutputStream) {
+            return mSharedOutputStream.get();
+        } else {
+            return mRawOutputStream;
+        }
     }
 
     /**
@@ -123,10 +153,10 @@ class FullDuplexStream : public AudioStreamDataCallback {
         Result outputResult = Result::OK;
         Result inputResult = Result::OK;
         if (getOutputStream()) {
-            outputResult = mOutputStream->requestStop();
+            outputResult = getOutputStream()->requestStop();
         }
         if (getInputStream()) {
-            inputResult = mInputStream->requestStop();
+            inputResult = getOutputStream()->requestStop();
         }
         if (outputResult != Result::OK) {
             return outputResult;
@@ -312,8 +342,10 @@ class FullDuplexStream : public AudioStreamDataCallback {
     // Discard some callbacks so the input and output reach equilibrium.
     int32_t              mCountCallbacksToDiscard = kNumCallbacksToDiscard;
 
-    AudioStream   *mInputStream = nullptr;
-    AudioStream   *mOutputStream = nullptr;
+    AudioStream *mRawInputStream = nullptr;
+    AudioStream *mRawOutputStream = nullptr;
+    std::shared_ptr<AudioStream> mSharedInputStream;
+    std::shared_ptr<AudioStream> mSharedOutputStream;
 
     int32_t              mBufferSize = 0;
     std::unique_ptr<float[]> mInputBuffer;

internal/oboe/oboe_oboe_Oboe_android.h

@@ -36,5 +36,6 @@
 #include "oboe_oboe_FifoBuffer_android.h"
 #include "oboe_oboe_OboeExtensions_android.h"
 #include "oboe_oboe_FullDuplexStream_android.h"
+#include "oboe_oboe_AudioClock_android.h"
 
 #endif //OBOE_OBOE_H

internal/oboe/oboe_oboe_Version_android.h

@@ -37,7 +37,7 @@
 #define OBOE_VERSION_MINOR 9
 
 // Type: 16-bit unsigned int. Min value: 0 Max value: 65535. See below for description.
-#define OBOE_VERSION_PATCH 0
+#define OBOE_VERSION_PATCH 3
 
 #define OBOE_STRINGIFY(x) #x
 #define OBOE_TOSTRING(x) OBOE_STRINGIFY(x)

internal/oboe/oboe_opensles_AudioInputStreamOpenSLES_android.cpp

@@ -106,7 +106,7 @@ Result AudioInputStreamOpenSLES::open() {
             SL_DATAFORMAT_PCM,       // formatType
             static_cast<SLuint32>(mChannelCount),           // numChannels
             static_cast<SLuint32>(mSampleRate * kMillisPerSecond), // milliSamplesPerSec
-            bitsPerSample,                      // bitsPerSample
+            bitsPerSample,                      // mBitsPerSample
             bitsPerSample,                      // containerSize;
             channelCountToChannelMask(mChannelCount), // channelMask
             getDefaultByteOrder(),
@@ -212,7 +212,7 @@ Result AudioInputStreamOpenSLES::close() {
     LOGD("AudioInputStreamOpenSLES::%s()", __func__);
     std::lock_guard<std::mutex> lock(mLock);
     Result result = Result::OK;
-    if (getState() == StreamState::Closed){
+    if (getState() == StreamState::Closed) {
         result = Result::ErrorClosed;
     } else {
         (void) requestStop_l();