expo-juce 0.3.1 → 0.3.2

package/ios/juce_modules/juce_audio_devices/native/oboe/src/common/DataConversionFlowGraph.cpp

@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 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 <memory>
+
+#include "OboeDebug.h"
+#include "DataConversionFlowGraph.h"
+#include "SourceFloatCaller.h"
+#include "SourceI16Caller.h"
+#include "SourceI24Caller.h"
+#include "SourceI32Caller.h"
+
+#include <flowgraph/MonoToMultiConverter.h>
+#include <flowgraph/MultiToMonoConverter.h>
+#include <flowgraph/RampLinear.h>
+#include <flowgraph/SinkFloat.h>
+#include <flowgraph/SinkI16.h>
+#include <flowgraph/SinkI24.h>
+#include <flowgraph/SinkI32.h>
+#include <flowgraph/SourceFloat.h>
+#include <flowgraph/SourceI16.h>
+#include <flowgraph/SourceI24.h>
+#include <flowgraph/SourceI32.h>
+#include <flowgraph/SampleRateConverter.h>
+
+using namespace oboe;
+using namespace flowgraph;
+using namespace resampler;
+
+void DataConversionFlowGraph::setSource(const void *buffer, int32_t numFrames) {
+    mSource->setData(buffer, numFrames);
+}
+
+static MultiChannelResampler::Quality convertOboeSRQualityToMCR(SampleRateConversionQuality quality) {
+    switch (quality) {
+        case SampleRateConversionQuality::Fastest:
+            return MultiChannelResampler::Quality::Fastest;
+        case SampleRateConversionQuality::Low:
+            return MultiChannelResampler::Quality::Low;
+        default:
+        case SampleRateConversionQuality::Medium:
+            return MultiChannelResampler::Quality::Medium;
+        case SampleRateConversionQuality::High:
+            return MultiChannelResampler::Quality::High;
+        case SampleRateConversionQuality::Best:
+            return MultiChannelResampler::Quality::Best;
+    }
+}
+
+// Chain together multiple processors.
+// Callback Output
+//     Use SourceCaller that calls original app callback from the flowgraph.
+//     The child callback from FilteredAudioStream read()s from the flowgraph.
+// Callback Input
+//     Child callback from FilteredAudioStream writes()s to the flowgraph.
+//     The output of the flowgraph goes through a BlockWriter to the app callback.
+// Blocking Write
+//     Write buffer is set on an AudioSource.
+//     Data is pulled through the graph and written to the child stream.
+// Blocking Read
+//     Reads in a loop from the flowgraph Sink to fill the read buffer.
+//     A SourceCaller then does a blocking read from the child Stream.
+//
+Result DataConversionFlowGraph::configure(AudioStream *sourceStream, AudioStream *sinkStream) {
+
+    FlowGraphPortFloatOutput *lastOutput = nullptr;
+
+    bool isOutput = sourceStream->getDirection() == Direction::Output;
+    bool isInput = !isOutput;
+    mFilterStream = isOutput ? sourceStream : sinkStream;
+
+    AudioFormat sourceFormat = sourceStream->getFormat();
+    int32_t sourceChannelCount = sourceStream->getChannelCount();
+    int32_t sourceSampleRate = sourceStream->getSampleRate();
+    int32_t sourceFramesPerCallback = sourceStream->getFramesPerDataCallback();
+
+    AudioFormat sinkFormat = sinkStream->getFormat();
+    int32_t sinkChannelCount = sinkStream->getChannelCount();
+    int32_t sinkSampleRate = sinkStream->getSampleRate();
+    int32_t sinkFramesPerCallback = sinkStream->getFramesPerDataCallback();
+
+    LOGI("%s() flowgraph converts channels: %d to %d, format: %d to %d"
+         ", rate: %d to %d, cbsize: %d to %d, qual = %d",
+            __func__,
+            sourceChannelCount, sinkChannelCount,
+            sourceFormat, sinkFormat,
+            sourceSampleRate, sinkSampleRate,
+            sourceFramesPerCallback, sinkFramesPerCallback,
+            sourceStream->getSampleRateConversionQuality());
+
+    // Source
+    // IF OUTPUT and using a callback then call back to the app using a SourceCaller.
+    // OR IF INPUT and NOT using a callback then read from the child stream using a SourceCaller.
+    bool isDataCallbackSpecified = sourceStream->isDataCallbackSpecified();
+    if ((isDataCallbackSpecified && isOutput)
+        || (!isDataCallbackSpecified && isInput)) {
+        int32_t actualSourceFramesPerCallback = (sourceFramesPerCallback == kUnspecified)
+                ? sourceStream->getFramesPerBurst()
+                : sourceFramesPerCallback;
+        switch (sourceFormat) {
+            case AudioFormat::Float:
+                mSourceCaller = std::make_unique<SourceFloatCaller>(sourceChannelCount,
+                                                                    actualSourceFramesPerCallback);
+                break;
+            case AudioFormat::I16:
+                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;
+        }
+        mSourceCaller->setStream(sourceStream);
+        lastOutput = &mSourceCaller->output;
+    } else {
+        // IF OUTPUT and NOT using a callback then write to the child stream using a BlockWriter.
+        // OR IF INPUT and using a callback then write to the app using a BlockWriter.
+        switch (sourceFormat) {
+            case AudioFormat::Float:
+                mSource = std::make_unique<SourceFloat>(sourceChannelCount);
+                break;
+            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;
+        }
+        if (isInput) {
+            int32_t actualSinkFramesPerCallback = (sinkFramesPerCallback == kUnspecified)
+                    ? sinkStream->getFramesPerBurst()
+                    : sinkFramesPerCallback;
+            // The BlockWriter is after the Sink so use the SinkStream size.
+            mBlockWriter.open(actualSinkFramesPerCallback * sinkStream->getBytesPerFrame());
+            mAppBuffer = std::make_unique<uint8_t[]>(
+                    kDefaultBufferSize * sinkStream->getBytesPerFrame());
+        }
+        lastOutput = &mSource->output;
+    }
+
+    // If we are going to reduce the number of channels then do it before the
+    // sample rate converter.
+    if (sourceChannelCount > sinkChannelCount) {
+        if (sinkChannelCount == 1) {
+            mMultiToMonoConverter = std::make_unique<MultiToMonoConverter>(sourceChannelCount);
+            lastOutput->connect(&mMultiToMonoConverter->input);
+            lastOutput = &mMultiToMonoConverter->output;
+        } else {
+            mChannelCountConverter = std::make_unique<ChannelCountConverter>(
+                    sourceChannelCount,
+                    sinkChannelCount);
+            lastOutput->connect(&mChannelCountConverter->input);
+            lastOutput = &mChannelCountConverter->output;
+        }
+    }
+
+    // Sample Rate conversion
+    if (sourceSampleRate != sinkSampleRate) {
+        // Create a resampler to do the math.
+        mResampler.reset(MultiChannelResampler::make(lastOutput->getSamplesPerFrame(),
+                                                     sourceSampleRate,
+                                                     sinkSampleRate,
+                                                     convertOboeSRQualityToMCR(
+                                                             sourceStream->getSampleRateConversionQuality())));
+        // Make a flowgraph node that uses the resampler.
+        mRateConverter = std::make_unique<SampleRateConverter>(lastOutput->getSamplesPerFrame(),
+                                                               *mResampler.get());
+        lastOutput->connect(&mRateConverter->input);
+        lastOutput = &mRateConverter->output;
+    }
+
+    // Expand the number of channels if required.
+    if (sourceChannelCount < sinkChannelCount) {
+        if (sourceChannelCount == 1) {
+            mMonoToMultiConverter = std::make_unique<MonoToMultiConverter>(sinkChannelCount);
+            lastOutput->connect(&mMonoToMultiConverter->input);
+            lastOutput = &mMonoToMultiConverter->output;
+        } else {
+            mChannelCountConverter = std::make_unique<ChannelCountConverter>(
+                    sourceChannelCount,
+                    sinkChannelCount);
+            lastOutput->connect(&mChannelCountConverter->input);
+            lastOutput = &mChannelCountConverter->output;
+        }
+    }
+
+    // Sink
+    switch (sinkFormat) {
+        case AudioFormat::Float:
+            mSink = std::make_unique<SinkFloat>(sinkChannelCount);
+            break;
+        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;;
+    }
+    lastOutput->connect(&mSink->input);
+
+    return Result::OK;
+}
+
+int32_t DataConversionFlowGraph::read(void *buffer, int32_t numFrames, int64_t timeoutNanos) {
+    if (mSourceCaller) {
+        mSourceCaller->setTimeoutNanos(timeoutNanos);
+    }
+    int32_t numRead = mSink->read(buffer, numFrames);
+    return numRead;
+}
+
+// This is similar to pushing data through the flowgraph.
+int32_t DataConversionFlowGraph::write(void *inputBuffer, int32_t numFrames) {
+    // Put the data from the input at the head of the flowgraph.
+    mSource->setData(inputBuffer, numFrames);
+    while (true) {
+        // Pull and read some data in app format into a small buffer.
+        int32_t framesRead = mSink->read(mAppBuffer.get(), flowgraph::kDefaultBufferSize);
+        if (framesRead <= 0) break;
+        // Write to a block adapter, which will call the destination whenever it has enough data.
+        int32_t bytesRead = mBlockWriter.write(mAppBuffer.get(),
+                                               framesRead * mFilterStream->getBytesPerFrame());
+        if (bytesRead < 0) return bytesRead; // TODO review
+    }
+    return numFrames;
+}
+
+int32_t DataConversionFlowGraph::onProcessFixedBlock(uint8_t *buffer, int32_t numBytes) {
+    int32_t numFrames = numBytes / mFilterStream->getBytesPerFrame();
+    mCallbackResult = mFilterStream->getDataCallback()->onAudioReady(mFilterStream, buffer, numFrames);
+    // TODO handle STOP from callback, process data remaining in the block adapter
+    return numBytes;
+}

package/ios/juce_modules/juce_audio_devices/native/oboe/src/common/DataConversionFlowGraph.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 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_OBOE_FLOW_GRAPH_H
+#define OBOE_OBOE_FLOW_GRAPH_H
+
+#include <memory>
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <flowgraph/ChannelCountConverter.h>
+#include <flowgraph/MonoToMultiConverter.h>
+#include <flowgraph/MultiToMonoConverter.h>
+#include <flowgraph/SampleRateConverter.h>
+#include <oboe/Definitions.h>
+#include "AudioSourceCaller.h"
+#include "FixedBlockWriter.h"
+
+namespace oboe {
+
+class AudioStream;
+class AudioSourceCaller;
+
+/**
+ * Convert PCM channels, format and sample rate for optimal latency.
+ */
+class DataConversionFlowGraph : public FixedBlockProcessor {
+public:
+
+    DataConversionFlowGraph()
+    : mBlockWriter(*this) {}
+
+    void setSource(const void *buffer, int32_t numFrames);
+
+    /** Connect several modules together to convert from source to sink.
+     * This should only be called once for each instance.
+     *
+     * @param sourceFormat
+     * @param sourceChannelCount
+     * @param sinkFormat
+     * @param sinkChannelCount
+     * @return
+     */
+    oboe::Result configure(oboe::AudioStream *sourceStream, oboe::AudioStream *sinkStream);
+
+    int32_t read(void *buffer, int32_t numFrames, int64_t timeoutNanos);
+
+    int32_t write(void *buffer, int32_t numFrames);
+
+    int32_t onProcessFixedBlock(uint8_t *buffer, int32_t numBytes) override;
+
+    DataCallbackResult getDataCallbackResult() {
+        return mCallbackResult;
+    }
+
+private:
+    std::unique_ptr<flowgraph::FlowGraphSourceBuffered>    mSource;
+    std::unique_ptr<AudioSourceCaller>                 mSourceCaller;
+    std::unique_ptr<flowgraph::MonoToMultiConverter>   mMonoToMultiConverter;
+    std::unique_ptr<flowgraph::MultiToMonoConverter>   mMultiToMonoConverter;
+    std::unique_ptr<flowgraph::ChannelCountConverter>  mChannelCountConverter;
+    std::unique_ptr<resampler::MultiChannelResampler>  mResampler;
+    std::unique_ptr<flowgraph::SampleRateConverter>    mRateConverter;
+    std::unique_ptr<flowgraph::FlowGraphSink>              mSink;
+
+    FixedBlockWriter                                   mBlockWriter;
+    DataCallbackResult                                 mCallbackResult = DataCallbackResult::Continue;
+    AudioStream                                       *mFilterStream = nullptr;
+    std::unique_ptr<uint8_t[]>                         mAppBuffer;
+};
+
+}
+#endif //OBOE_OBOE_FLOW_GRAPH_H

package/ios/juce_modules/juce_audio_devices/native/oboe/src/common/FilterAudioStream.cpp

@@ -0,0 +1,106 @@
+/*
+ * 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 <memory>
+
+#include "OboeDebug.h"
+#include "FilterAudioStream.h"
+
+using namespace oboe;
+using namespace flowgraph;
+
+// Output callback uses FixedBlockReader::read()
+//                <= SourceFloatCaller::onProcess()
+//                <=== DataConversionFlowGraph::read()
+//                <== FilterAudioStream::onAudioReady()
+//
+// Output blocking uses no block adapter because AAudio can accept
+// writes of any size. It uses DataConversionFlowGraph::read() <== FilterAudioStream::write() <= app
+//
+// Input callback uses FixedBlockWriter::write()
+//                <= DataConversionFlowGraph::write()
+//                <= FilterAudioStream::onAudioReady()
+//
+// Input blocking uses FixedBlockReader::read() // TODO may not need block adapter
+//                <= SourceFloatCaller::onProcess()
+//                <=== SinkFloat::read()
+//                <= DataConversionFlowGraph::read()
+//                <== FilterAudioStream::read()
+//                <= app
+
+Result FilterAudioStream::configureFlowGraph() {
+    mFlowGraph = std::make_unique<DataConversionFlowGraph>();
+    bool isOutput = getDirection() == Direction::Output;
+
+    AudioStream *sourceStream =  isOutput ? this : mChildStream.get();
+    AudioStream *sinkStream =  isOutput ? mChildStream.get() : this;
+
+    mRateScaler = ((double) getSampleRate()) / mChildStream->getSampleRate();
+
+    return mFlowGraph->configure(sourceStream, sinkStream);
+}
+
+// Put the data to be written at the source end of the flowgraph.
+// Then read (pull) the data from the flowgraph and write it to the
+// child stream.
+ResultWithValue<int32_t> FilterAudioStream::write(const void *buffer,
+                               int32_t numFrames,
+                               int64_t timeoutNanoseconds) {
+    int32_t framesWritten = 0;
+    mFlowGraph->setSource(buffer, numFrames);
+    while (true) {
+        int32_t numRead = mFlowGraph->read(mBlockingBuffer.get(),
+                getFramesPerBurst(),
+                timeoutNanoseconds);
+        if (numRead < 0) {
+            return ResultWithValue<int32_t>::createBasedOnSign(numRead);
+        }
+        if (numRead == 0) {
+            break; // finished processing the source buffer
+        }
+        auto writeResult = mChildStream->write(mBlockingBuffer.get(),
+                                               numRead,
+                                               timeoutNanoseconds);
+        if (!writeResult) {
+            return writeResult;
+        }
+        framesWritten += writeResult.value();
+    }
+    return ResultWithValue<int32_t>::createBasedOnSign(framesWritten);
+}
+
+// Read (pull) the data we want from the sink end of the flowgraph.
+// The necessary data will be read from the child stream using a flowgraph callback.
+ResultWithValue<int32_t> FilterAudioStream::read(void *buffer,
+                                                  int32_t numFrames,
+                                                  int64_t timeoutNanoseconds) {
+    int32_t framesRead = mFlowGraph->read(buffer, numFrames, timeoutNanoseconds);
+    return ResultWithValue<int32_t>::createBasedOnSign(framesRead);
+}
+
+DataCallbackResult FilterAudioStream::onAudioReady(AudioStream *oboeStream,
+                                void *audioData,
+                                int32_t numFrames) {
+    int32_t framesProcessed;
+    if (oboeStream->getDirection() == Direction::Output) {
+        framesProcessed = mFlowGraph->read(audioData, numFrames, 0 /* timeout */);
+    } else {
+        framesProcessed = mFlowGraph->write(audioData, numFrames);
+    }
+    return (framesProcessed < numFrames)
+           ? DataCallbackResult::Stop
+           : mFlowGraph->getDataCallbackResult();
+}

package/ios/juce_modules/juce_audio_devices/native/oboe/src/common/FilterAudioStream.h

@@ -0,0 +1,227 @@
+/*
+ * 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_FILTER_AUDIO_STREAM_H
+#define OBOE_FILTER_AUDIO_STREAM_H
+
+#include <memory>
+#include <oboe/AudioStream.h>
+#include "DataConversionFlowGraph.h"
+
+namespace oboe {
+
+/**
+ * An AudioStream that wraps another AudioStream and provides audio data conversion.
+ * Operations may include channel conversion, data format conversion and/or sample rate conversion.
+ */
+class FilterAudioStream : public AudioStream, AudioStreamCallback {
+public:
+
+    /**
+     * Construct an `AudioStream` using the given `AudioStreamBuilder` and a child AudioStream.
+     *
+     * This should only be called internally by AudioStreamBuilder.
+     * Ownership of childStream will be passed to this object.
+     *
+     * @param builder containing all the stream's attributes
+     */
+    FilterAudioStream(const AudioStreamBuilder &builder, AudioStream *childStream)
+    : AudioStream(builder)
+    , mChildStream(childStream) {
+        // Intercept the callback if used.
+        if (builder.isErrorCallbackSpecified()) {
+            mErrorCallback = mChildStream->swapErrorCallback(this);
+        }
+        if (builder.isDataCallbackSpecified()) {
+            mDataCallback = mChildStream->swapDataCallback(this);
+        } else {
+            const int size = childStream->getFramesPerBurst() * childStream->getBytesPerFrame();
+            mBlockingBuffer = std::make_unique<uint8_t[]>(size);
+        }
+
+        // Copy parameters that may not match builder.
+        mBufferCapacityInFrames = mChildStream->getBufferCapacityInFrames();
+        mPerformanceMode = mChildStream->getPerformanceMode();
+        mSharingMode = mChildStream->getSharingMode();
+        mInputPreset = mChildStream->getInputPreset();
+        mFramesPerBurst = mChildStream->getFramesPerBurst();
+        mDeviceId = mChildStream->getDeviceId();
+        mHardwareSampleRate = mChildStream->getHardwareSampleRate();
+        mHardwareChannelCount = mChildStream->getHardwareChannelCount();
+        mHardwareFormat = mChildStream->getHardwareFormat();
+    }
+
+    virtual ~FilterAudioStream() = default;
+
+    AudioStream *getChildStream() const {
+        return mChildStream.get();
+    }
+
+    Result configureFlowGraph();
+
+    // Close child and parent.
+    Result close()  override {
+        const Result result1 = mChildStream->close();
+        const Result result2 = AudioStream::close();
+        return (result1 != Result::OK ? result1 : result2);
+    }
+
+    /**
+     * Start the stream asynchronously. Returns immediately (does not block). Equivalent to calling
+     * `start(0)`.
+     */
+    Result requestStart() override {
+        return mChildStream->requestStart();
+    }
+
+    /**
+     * Pause the stream asynchronously. Returns immediately (does not block). Equivalent to calling
+     * `pause(0)`.
+     */
+    Result requestPause() override {
+        return mChildStream->requestPause();
+    }
+
+    /**
+     * Flush the stream asynchronously. Returns immediately (does not block). Equivalent to calling
+     * `flush(0)`.
+     */
+    Result requestFlush() override {
+        return mChildStream->requestFlush();
+    }
+
+    /**
+     * Stop the stream asynchronously. Returns immediately (does not block). Equivalent to calling
+     * `stop(0)`.
+     */
+    Result requestStop() override {
+        return mChildStream->requestStop();
+    }
+
+    ResultWithValue<int32_t> read(void *buffer,
+            int32_t numFrames,
+            int64_t timeoutNanoseconds) override;
+
+    ResultWithValue<int32_t> write(const void *buffer,
+            int32_t numFrames,
+            int64_t timeoutNanoseconds) override;
+
+    StreamState getState() override {
+        return mChildStream->getState();
+    }
+
+    Result waitForStateChange(
+            StreamState inputState,
+            StreamState *nextState,
+            int64_t timeoutNanoseconds) override {
+        return mChildStream->waitForStateChange(inputState, nextState, timeoutNanoseconds);
+    }
+
+    bool isXRunCountSupported() const override {
+        return mChildStream->isXRunCountSupported();
+    }
+
+    AudioApi getAudioApi() const override {
+        return mChildStream->getAudioApi();
+    }
+
+    void updateFramesWritten() override {
+        // TODO for output, just count local writes?
+        mFramesWritten = static_cast<int64_t>(mChildStream->getFramesWritten() * mRateScaler);
+    }
+
+    void updateFramesRead() override {
+        // TODO for input, just count local reads?
+        mFramesRead = static_cast<int64_t>(mChildStream->getFramesRead() * mRateScaler);
+    }
+
+    void *getUnderlyingStream() const  override {
+        return mChildStream->getUnderlyingStream();
+    }
+
+    ResultWithValue<int32_t> setBufferSizeInFrames(int32_t requestedFrames) override {
+        return mChildStream->setBufferSizeInFrames(requestedFrames);
+    }
+
+    int32_t getBufferSizeInFrames() override {
+        mBufferSizeInFrames = mChildStream->getBufferSizeInFrames();
+        return mBufferSizeInFrames;
+    }
+
+    ResultWithValue<int32_t> getXRunCount() override {
+        return mChildStream->getXRunCount();
+    }
+
+    ResultWithValue<double> calculateLatencyMillis() override {
+        // This will automatically include the latency of the flowgraph?
+        return mChildStream->calculateLatencyMillis();
+    }
+
+    Result getTimestamp(clockid_t clockId,
+            int64_t *framePosition,
+            int64_t *timeNanoseconds) override {
+        int64_t childPosition = 0;
+        Result result = mChildStream->getTimestamp(clockId, &childPosition, timeNanoseconds);
+        // It is OK if framePosition is null.
+        if (framePosition) {
+            *framePosition = childPosition * mRateScaler;
+        }
+        return result;
+    }
+
+    DataCallbackResult onAudioReady(AudioStream *oboeStream,
+            void *audioData,
+            int32_t numFrames) override;
+
+    bool onError(AudioStream * /*audioStream*/, Result error) override {
+        if (mErrorCallback != nullptr) {
+            return mErrorCallback->onError(this, error);
+        }
+        return false;
+    }
+
+    void onErrorBeforeClose(AudioStream * /*oboeStream*/, Result error) override {
+        if (mErrorCallback != nullptr) {
+            mErrorCallback->onErrorBeforeClose(this, error);
+        }
+    }
+
+    void onErrorAfterClose(AudioStream * /*oboeStream*/, Result error) override {
+        // Close this parent stream because the callback will only close the child.
+        AudioStream::close();
+        if (mErrorCallback != nullptr) {
+            mErrorCallback->onErrorAfterClose(this, error);
+        }
+    }
+
+    /**
+     * @return last result passed from an error callback
+     */
+    oboe::Result getLastErrorCallbackResult() const override {
+        return mChildStream->getLastErrorCallbackResult();
+    }
+
+private:
+
+    std::unique_ptr<AudioStream>             mChildStream; // this stream wraps the child stream
+    std::unique_ptr<DataConversionFlowGraph> mFlowGraph; // for converting data
+    std::unique_ptr<uint8_t[]>               mBlockingBuffer; // temp buffer for write()
+    double                                   mRateScaler = 1.0; // ratio parent/child sample rates
+};
+
+} // oboe
+
+#endif //OBOE_FILTER_AUDIO_STREAM_H