Move dead submodules in-tree

Signed-off-by: swurl <swurl@swurl.xyz>

1 files changed, 111 insertions, 0 deletions

diff --git a/externals/oboe/apps/OboeTester/app/src/main/cpp/TestRoutingCrash.cpp b/externals/oboe/apps/OboeTester/app/src/main/cpp/TestRoutingCrash.cpp
new file mode 100644
index 0000000000..0a0c30ba32
--- /dev/null
+++ b/externals/oboe/apps/OboeTester/app/src/main/cpp/TestRoutingCrash.cpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2023 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 <stdlib.h>
+#include <aaudio/AAudioExtensions.h>
+
+#include "common/OboeDebug.h"
+#include "oboe/AudioClock.h"
+#include "TestRoutingCrash.h"
+
+using namespace oboe;
+
+// open start start an Oboe stream
+int32_t TestRoutingCrash::start(bool useInput) {
+
+    mDataCallback = std::make_shared<MyDataCallback>(this);
+
+    // Disable MMAP because we are trying to crash a Legacy Stream.
+    bool wasMMapEnabled = AAudioExtensions::getInstance().isMMapEnabled();
+    AAudioExtensions::getInstance().setMMapEnabled(false);
+
+    AudioStreamBuilder builder;
+    oboe::Result result = builder.setFormat(oboe::AudioFormat::Float)
+#if 1
+            ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
+#else
+            ->setPerformanceMode(oboe::PerformanceMode::None)
+#endif
+            ->setDirection(useInput ? oboe::Direction::Input : oboe::Direction::Output)
+            ->setChannelCount(kChannelCount)
+            ->setDataCallback(mDataCallback)
+            // Use VoiceCommunication so we can reroute it by setting SpeakerPhone ON/OFF.
+            ->setUsage(oboe::Usage::VoiceCommunication)
+            ->openStream(mStream);
+    if (result != oboe::Result::OK) {
+        return (int32_t) result;
+    }
+
+    AAudioExtensions::getInstance().setMMapEnabled(wasMMapEnabled);
+    return (int32_t) mStream->requestStart();
+}
+
+int32_t TestRoutingCrash::stop() {
+    oboe::Result result1 =  mStream->requestStop();
+    oboe::Result result2 =   mStream->close();
+    return (int32_t)((result1 != oboe::Result::OK) ? result1 : result2);
+}
+
+// Callback that sleeps then touches the audio buffer.
+DataCallbackResult TestRoutingCrash::MyDataCallback::onAudioReady(
+        AudioStream *audioStream,
+        void *audioData,
+        int32_t numFrames) {
+    float *floatData = (float *) audioData;
+
+    // If I call getTimestamp() here it does NOT crash!
+
+    // Simulate the timing of a heavy workload by sleeping.
+    // Otherwise the window for the crash is very narrow.
+    const double kDutyCycle = 0.7;
+    const double bufferTimeNanos = 1.0e9 * numFrames / (double) audioStream->getSampleRate();
+    const int64_t targetDurationNanos = (int64_t) (bufferTimeNanos * kDutyCycle);
+    if (targetDurationNanos > 0) {
+        AudioClock::sleepForNanos(targetDurationNanos);
+    }
+    const double kFilterCoefficient = 0.95; // low pass IIR filter
+    const double sleepMicros = targetDurationNanos * 0.0001;
+    mParent->averageSleepTimeMicros = ((1.0 - kFilterCoefficient) * sleepMicros)
+            + (kFilterCoefficient * mParent->averageSleepTimeMicros);
+
+    // If I call getTimestamp() here it crashes.
+    audioStream->getTimestamp(CLOCK_MONOTONIC); // Trigger a restoreTrack_l() in framework.
+
+    const int numSamples = numFrames * kChannelCount;
+    if (audioStream->getDirection() == oboe::Direction::Input) {
+        // Read buffer and write sum of samples to a member variable.
+        // We just want to touch the memory and not get optimized away by the compiler.
+        float sum = 0.0f;
+        for (int i = 0; i < numSamples; i++) {
+            sum += *floatData++;
+        }
+        mInputSum = sum;
+    } else {
+        // Fill mono buffer with a sine wave.
+        // If the routing occurred then the buffer may be dead and
+        // we may be writing into unallocated memory.
+        for (int i = 0; i < numSamples; i++) {
+            *floatData++ = sinf(mPhase) * 0.2f;
+            mPhase += kPhaseIncrement;
+            // Wrap the phase around in a circle.
+            if (mPhase >= M_PI) mPhase -= 2 * M_PI;
+        }
+    }
+
+    // If I call getTimestamp() here it does NOT crash!
+
+    return oboe::DataCallbackResult::Continue;
+}