Move dead submodules in-tree

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

externals/oboe/samples/LiveEffect/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,46 @@
+#
+# 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.
+#
+cmake_minimum_required(VERSION 3.4.1)
+project(liveEffect LANGUAGES C CXX)
+
+get_filename_component(SAMPLE_ROOT_DIR
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../../.. ABSOLUTE)
+
+### INCLUDE OBOE LIBRARY ###
+set (OBOE_DIR ${SAMPLE_ROOT_DIR}/..)
+add_subdirectory(${OBOE_DIR} ./oboe-bin)
+
+add_library(liveEffect
+    SHARED
+        LiveEffectEngine.cpp
+        jni_bridge.cpp
+        ${SAMPLE_ROOT_DIR}/debug-utils/trace.cpp)
+target_include_directories(liveEffect
+    PRIVATE
+        ${SAMPLE_ROOT_DIR}/debug-utils
+        ${OBOE_DIR}/include)
+target_link_libraries(liveEffect
+    PRIVATE
+        oboe
+        android
+        atomic
+        log)
+target_link_options(liveEffect PRIVATE "-Wl,-z,max-page-size=16384")
+
+# Enable optimization flags: if having problems with source level debugging,
+# disable -Ofast ( and debug ), re-enable it after done debugging.
+target_compile_options(liveEffect PRIVATE -Wall -Werror "$<$<CONFIG:RELEASE>:-Ofast>")
+

externals/oboe/samples/LiveEffect/src/main/cpp/FullDuplexPass.h

@@ -0,0 +1,54 @@
+/*
+ * 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 SAMPLES_FULLDUPLEXPASS_H
+#define SAMPLES_FULLDUPLEXPASS_H
+
+class FullDuplexPass : public oboe::FullDuplexStream {
+public:
+    virtual oboe::DataCallbackResult
+    onBothStreamsReady(
+            const void *inputData,
+            int   numInputFrames,
+            void *outputData,
+            int   numOutputFrames) {
+        // Copy the input samples to the output with a little arbitrary gain change.
+
+        // This code assumes the data format for both streams is Float.
+        const float *inputFloats = static_cast<const float *>(inputData);
+        float *outputFloats = static_cast<float *>(outputData);
+
+        // It also assumes the channel count for each stream is the same.
+        int32_t samplesPerFrame = getOutputStream()->getChannelCount();
+        int32_t numInputSamples = numInputFrames * samplesPerFrame;
+        int32_t numOutputSamples = numOutputFrames * samplesPerFrame;
+
+        // It is possible that there may be fewer input than output samples.
+        int32_t samplesToProcess = std::min(numInputSamples, numOutputSamples);
+        for (int32_t i = 0; i < samplesToProcess; i++) {
+            *outputFloats++ = *inputFloats++ * 0.95; // do some arbitrary processing
+        }
+
+        // If there are fewer input samples then clear the rest of the buffer.
+        int32_t samplesLeft = numOutputSamples - numInputSamples;
+        for (int32_t i = 0; i < samplesLeft; i++) {
+            *outputFloats++ = 0.0; // silence
+        }
+
+        return oboe::DataCallbackResult::Continue;
+    }
+};
+#endif //SAMPLES_FULLDUPLEXPASS_H

externals/oboe/samples/LiveEffect/src/main/cpp/LiveEffectEngine.cpp

@@ -0,0 +1,245 @@
+/**
+ * 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.
+ */
+
+#include <cassert>
+#include <logging_macros.h>
+
+#include "LiveEffectEngine.h"
+
+LiveEffectEngine::LiveEffectEngine() {
+    assert(mOutputChannelCount == mInputChannelCount);
+}
+
+void LiveEffectEngine::setRecordingDeviceId(int32_t deviceId) {
+    mRecordingDeviceId = deviceId;
+}
+
+void LiveEffectEngine::setPlaybackDeviceId(int32_t deviceId) {
+    mPlaybackDeviceId = deviceId;
+}
+
+bool LiveEffectEngine::isAAudioRecommended() {
+    return oboe::AudioStreamBuilder::isAAudioRecommended();
+}
+
+bool LiveEffectEngine::setAudioApi(oboe::AudioApi api) {
+    if (mIsEffectOn) return false;
+    mAudioApi = api;
+    return true;
+}
+
+bool LiveEffectEngine::setEffectOn(bool isOn) {
+    bool success = true;
+    if (isOn != mIsEffectOn) {
+        if (isOn) {
+            success = openStreams() == oboe::Result::OK;
+            if (success) {
+                mIsEffectOn = isOn;
+            }
+        } else {
+            closeStreams();
+            mIsEffectOn = isOn;
+       }
+    }
+    return success;
+}
+
+void LiveEffectEngine::closeStreams() {
+    /*
+    * Note: The order of events is important here.
+    * The playback stream must be closed before the recording stream. If the
+    * recording stream were to be closed first the playback stream's
+    * callback may attempt to read from the recording stream
+    * which would cause the app to crash since the recording stream would be
+    * null.
+    */
+    mDuplexStream->stop();
+    closeStream(mPlayStream);
+    closeStream(mRecordingStream);
+    mDuplexStream.reset();
+}
+
+oboe::Result  LiveEffectEngine::openStreams() {
+    // Note: The order of stream creation is important. We create the playback
+    // stream first, then use properties from the playback stream
+    // (e.g. sample rate) to create the recording stream. By matching the
+    // properties we should get the lowest latency path
+    oboe::AudioStreamBuilder inBuilder, outBuilder;
+    setupPlaybackStreamParameters(&outBuilder);
+    oboe::Result result = outBuilder.openStream(mPlayStream);
+    if (result != oboe::Result::OK) {
+        LOGE("Failed to open output stream. Error %s", oboe::convertToText(result));
+        mSampleRate = oboe::kUnspecified;
+        return result;
+    } else {
+        // The input stream needs to run at the same sample rate as the output.
+        mSampleRate = mPlayStream->getSampleRate();
+    }
+    warnIfNotLowLatency(mPlayStream);
+
+    setupRecordingStreamParameters(&inBuilder, mSampleRate);
+    result = inBuilder.openStream(mRecordingStream);
+    if (result != oboe::Result::OK) {
+        LOGE("Failed to open input stream. Error %s", oboe::convertToText(result));
+        closeStream(mPlayStream);
+        return result;
+    }
+    warnIfNotLowLatency(mRecordingStream);
+
+    mDuplexStream = std::make_unique<FullDuplexPass>();
+    mDuplexStream->setSharedInputStream(mRecordingStream);
+    mDuplexStream->setSharedOutputStream(mPlayStream);
+    mDuplexStream->start();
+    return result;
+}
+
+/**
+ * Sets the stream parameters which are specific to recording,
+ * including the sample rate which is determined from the
+ * playback stream.
+ *
+ * @param builder The recording stream builder
+ * @param sampleRate The desired sample rate of the recording stream
+ */
+oboe::AudioStreamBuilder *LiveEffectEngine::setupRecordingStreamParameters(
+    oboe::AudioStreamBuilder *builder, int32_t sampleRate) {
+    // This sample uses blocking read() because we don't specify a callback
+    builder->setDeviceId(mRecordingDeviceId)
+        ->setDirection(oboe::Direction::Input)
+        ->setSampleRate(sampleRate)
+        ->setChannelCount(mInputChannelCount);
+    return setupCommonStreamParameters(builder);
+}
+
+/**
+ * Sets the stream parameters which are specific to playback, including device
+ * id and the dataCallback function, which must be set for low latency
+ * playback.
+ * @param builder The playback stream builder
+ */
+oboe::AudioStreamBuilder *LiveEffectEngine::setupPlaybackStreamParameters(
+    oboe::AudioStreamBuilder *builder) {
+    builder->setDataCallback(this)
+        ->setErrorCallback(this)
+        ->setDeviceId(mPlaybackDeviceId)
+        ->setDirection(oboe::Direction::Output)
+        ->setChannelCount(mOutputChannelCount);
+
+    return setupCommonStreamParameters(builder);
+}
+
+/**
+ * Set the stream parameters which are common to both recording and playback
+ * streams.
+ * @param builder The playback or recording stream builder
+ */
+oboe::AudioStreamBuilder *LiveEffectEngine::setupCommonStreamParameters(
+    oboe::AudioStreamBuilder *builder) {
+    // We request EXCLUSIVE mode since this will give us the lowest possible
+    // latency.
+    // If EXCLUSIVE mode isn't available the builder will fall back to SHARED
+    // mode.
+    builder->setAudioApi(mAudioApi)
+        ->setFormat(mFormat)
+        ->setFormatConversionAllowed(true)
+        ->setSharingMode(oboe::SharingMode::Exclusive)
+        ->setPerformanceMode(oboe::PerformanceMode::LowLatency);
+    return builder;
+}
+
+/**
+ * Close the stream. AudioStream::close() is a blocking call so
+ * the application does not need to add synchronization between
+ * onAudioReady() function and the thread calling close().
+ * [the closing thread is the UI thread in this sample].
+ * @param stream the stream to close
+ */
+void LiveEffectEngine::closeStream(std::shared_ptr<oboe::AudioStream> &stream) {
+    if (stream) {
+        oboe::Result result = stream->stop();
+        if (result != oboe::Result::OK) {
+            LOGW("Error stopping stream: %s", oboe::convertToText(result));
+        }
+        result = stream->close();
+        if (result != oboe::Result::OK) {
+            LOGE("Error closing stream: %s", oboe::convertToText(result));
+        } else {
+            LOGW("Successfully closed streams");
+        }
+        stream.reset();
+    }
+}
+
+/**
+ * Warn in logcat if non-low latency stream is created
+ * @param stream: newly created stream
+ *
+ */
+void LiveEffectEngine::warnIfNotLowLatency(std::shared_ptr<oboe::AudioStream> &stream) {
+    if (stream->getPerformanceMode() != oboe::PerformanceMode::LowLatency) {
+        LOGW(
+            "Stream is NOT low latency."
+            "Check your requested format, sample rate and channel count");
+    }
+}
+
+/**
+ * Handles playback stream's audio request. In this sample, we simply block-read
+ * from the record stream for the required samples.
+ *
+ * @param oboeStream: the playback stream that requesting additional samples
+ * @param audioData:  the buffer to load audio samples for playback stream
+ * @param numFrames:  number of frames to load to audioData buffer
+ * @return: DataCallbackResult::Continue.
+ */
+oboe::DataCallbackResult LiveEffectEngine::onAudioReady(
+    oboe::AudioStream *oboeStream, void *audioData, int32_t numFrames) {
+    return mDuplexStream->onAudioReady(oboeStream, audioData, numFrames);
+}
+
+/**
+ * Oboe notifies the application for "about to close the stream".
+ *
+ * @param oboeStream: the stream to close
+ * @param error: oboe's reason for closing the stream
+ */
+void LiveEffectEngine::onErrorBeforeClose(oboe::AudioStream *oboeStream,
+                                          oboe::Result error) {
+    LOGE("%s stream Error before close: %s",
+         oboe::convertToText(oboeStream->getDirection()),
+         oboe::convertToText(error));
+}
+
+/**
+ * Oboe notifies application that "the stream is closed"
+ *
+ * @param oboeStream
+ * @param error
+ */
+void LiveEffectEngine::onErrorAfterClose(oboe::AudioStream *oboeStream,
+                                         oboe::Result error) {
+    LOGE("%s stream Error after close: %s",
+         oboe::convertToText(oboeStream->getDirection()),
+         oboe::convertToText(error));
+
+    closeStreams();
+
+    // Restart the stream if the error is a disconnect.
+    if (error == oboe::Result::ErrorDisconnected) {
+        LOGI("Restarting AudioStream");
+        openStreams();
+    }
+}

externals/oboe/samples/LiveEffect/src/main/cpp/LiveEffectEngine.h

@@ -0,0 +1,83 @@
+/*
+ * 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 OBOE_LIVEEFFECTENGINE_H
+#define OBOE_LIVEEFFECTENGINE_H
+
+#include <jni.h>
+#include <oboe/Oboe.h>
+#include <string>
+#include <thread>
+#include "FullDuplexPass.h"
+
+class LiveEffectEngine : public oboe::AudioStreamCallback {
+public:
+    LiveEffectEngine();
+
+    void setRecordingDeviceId(int32_t deviceId);
+    void setPlaybackDeviceId(int32_t deviceId);
+
+    /**
+     * @param isOn
+     * @return true if it succeeds
+     */
+    bool setEffectOn(bool isOn);
+
+    /*
+     * oboe::AudioStreamDataCallback interface implementation
+     */
+    oboe::DataCallbackResult onAudioReady(oboe::AudioStream *oboeStream,
+                                          void *audioData, int32_t numFrames) override;
+
+    /*
+     * oboe::AudioStreamErrorCallback interface implementation
+     */
+    void onErrorBeforeClose(oboe::AudioStream *oboeStream, oboe::Result error) override;
+    void onErrorAfterClose(oboe::AudioStream *oboeStream, oboe::Result error) override;
+
+    bool setAudioApi(oboe::AudioApi);
+    bool isAAudioRecommended(void);
+
+private:
+    bool              mIsEffectOn = false;
+    int32_t           mRecordingDeviceId = oboe::kUnspecified;
+    int32_t           mPlaybackDeviceId = oboe::kUnspecified;
+    const oboe::AudioFormat mFormat = oboe::AudioFormat::Float; // for easier processing
+    oboe::AudioApi    mAudioApi = oboe::AudioApi::AAudio;
+    int32_t           mSampleRate = oboe::kUnspecified;
+    const int32_t     mInputChannelCount = oboe::ChannelCount::Stereo;
+    const int32_t     mOutputChannelCount = oboe::ChannelCount::Stereo;
+
+    std::unique_ptr<FullDuplexPass> mDuplexStream;
+    std::shared_ptr<oboe::AudioStream> mRecordingStream;
+    std::shared_ptr<oboe::AudioStream> mPlayStream;
+
+    oboe::Result openStreams();
+
+    void closeStreams();
+
+    void closeStream(std::shared_ptr<oboe::AudioStream> &stream);
+
+    oboe::AudioStreamBuilder *setupCommonStreamParameters(
+        oboe::AudioStreamBuilder *builder);
+    oboe::AudioStreamBuilder *setupRecordingStreamParameters(
+        oboe::AudioStreamBuilder *builder, int32_t sampleRate);
+    oboe::AudioStreamBuilder *setupPlaybackStreamParameters(
+        oboe::AudioStreamBuilder *builder);
+    void warnIfNotLowLatency(std::shared_ptr<oboe::AudioStream> &stream);
+};
+
+#endif  // OBOE_LIVEEFFECTENGINE_H

externals/oboe/samples/LiveEffect/src/main/cpp/jni_bridge.cpp

@@ -0,0 +1,134 @@
+/**
+ * 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.
+ */
+
+#include <jni.h>
+#include <logging_macros.h>
+#include "LiveEffectEngine.h"
+
+static const int kOboeApiAAudio = 0;
+static const int kOboeApiOpenSLES = 1;
+
+static LiveEffectEngine *engine = nullptr;
+
+extern "C" {
+
+JNIEXPORT jboolean JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_create(JNIEnv *env,
+                                                               jclass) {
+    if (engine == nullptr) {
+        engine = new LiveEffectEngine();
+    }
+
+    return (engine != nullptr) ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_delete(JNIEnv *env,
+                                                               jclass) {
+    if (engine) {
+        engine->setEffectOn(false);
+        delete engine;
+        engine = nullptr;
+    }
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_setEffectOn(
+    JNIEnv *env, jclass, jboolean isEffectOn) {
+    if (engine == nullptr) {
+        LOGE(
+            "Engine is null, you must call createEngine before calling this "
+            "method");
+        return JNI_FALSE;
+    }
+
+    return engine->setEffectOn(isEffectOn) ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_setRecordingDeviceId(
+    JNIEnv *env, jclass, jint deviceId) {
+    if (engine == nullptr) {
+        LOGE(
+            "Engine is null, you must call createEngine before calling this "
+            "method");
+        return;
+    }
+
+    engine->setRecordingDeviceId(deviceId);
+}
+
+JNIEXPORT void JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_setPlaybackDeviceId(
+    JNIEnv *env, jclass, jint deviceId) {
+    if (engine == nullptr) {
+        LOGE(
+            "Engine is null, you must call createEngine before calling this "
+            "method");
+        return;
+    }
+
+    engine->setPlaybackDeviceId(deviceId);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_setAPI(JNIEnv *env,
+                                                               jclass type,
+                                                               jint apiType) {
+    if (engine == nullptr) {
+        LOGE(
+            "Engine is null, you must call createEngine "
+            "before calling this method");
+        return JNI_FALSE;
+    }
+
+    oboe::AudioApi audioApi;
+    switch (apiType) {
+        case kOboeApiAAudio:
+            audioApi = oboe::AudioApi::AAudio;
+            break;
+        case kOboeApiOpenSLES:
+            audioApi = oboe::AudioApi::OpenSLES;
+            break;
+        default:
+            LOGE("Unknown API selection to setAPI() %d", apiType);
+            return JNI_FALSE;
+    }
+
+    return engine->setAudioApi(audioApi) ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_isAAudioRecommended(
+    JNIEnv *env, jclass type) {
+    if (engine == nullptr) {
+        LOGE(
+            "Engine is null, you must call createEngine "
+            "before calling this method");
+        return JNI_FALSE;
+    }
+    return engine->isAAudioRecommended() ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_com_google_oboe_samples_liveEffect_LiveEffectEngine_native_1setDefaultStreamValues(JNIEnv *env,
+                                               jclass type,
+                                               jint sampleRate,
+                                               jint framesPerBurst) {
+    oboe::DefaultStreamValues::SampleRate = (int32_t) sampleRate;
+    oboe::DefaultStreamValues::FramesPerBurst = (int32_t) framesPerBurst;
+}
+} // extern "C"

externals/oboe/samples/LiveEffect/src/main/cpp/ndk-stl-config.cmake

@@ -0,0 +1,40 @@
+# Copy shared STL files to Android Studio output directory so they can be
+# packaged in the APK.
+# Usage:
+#
+#   find_package(ndk-stl REQUIRED)
+#
+# or
+#
+#   find_package(ndk-stl REQUIRED PATHS ".")
+
+if(NOT ${ANDROID_STL} MATCHES "_shared")
+  return()
+endif()
+
+function(configure_shared_stl lib_path so_base)
+  message("Configuring STL ${so_base} for ${ANDROID_ABI}")
+  configure_file(
+    "${ANDROID_NDK}/sources/cxx-stl/${lib_path}/libs/${ANDROID_ABI}/lib${so_base}.so" 
+    "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${so_base}.so" 
+    COPYONLY)
+endfunction()
+
+if("${ANDROID_STL}" STREQUAL "libstdc++")
+  # The default minimal system C++ runtime library.
+elseif("${ANDROID_STL}" STREQUAL "gabi++_shared")
+  # The GAbi++ runtime (shared).
+  message(FATAL_ERROR "gabi++_shared was not configured by ndk-stl package")
+elseif("${ANDROID_STL}" STREQUAL "stlport_shared")
+  # The STLport runtime (shared).
+  configure_shared_stl("stlport" "stlport_shared")
+elseif("${ANDROID_STL}" STREQUAL "gnustl_shared")
+  # The GNU STL (shared).
+  configure_shared_stl("gnu-libstdc++/4.9" "gnustl_shared")
+elseif("${ANDROID_STL}" STREQUAL "c++_shared")
+  # The LLVM libc++ runtime (shared).
+  configure_shared_stl("llvm-libc++" "c++_shared")
+else()
+   message(FATAL_ERROR "STL configuration ANDROID_STL=${ANDROID_STL} is not supported")
+endif()
+