Sync AAudio flowgraph with Oboe
The flowgraph code in AAudio and Oboe should be kept in parity.
The code has diverged and this cl is meant to sync them again.
Bug: 208689965
Test: Build libaaudio/oboeservice and test changes
Change-Id: I1e0cf04120305ffcb1e64df1930ffa079d3c4a94
diff --git a/media/libaaudio/src/Android.bp b/media/libaaudio/src/Android.bp
index 01aaa2a..ddd3f97 100644
--- a/media/libaaudio/src/Android.bp
+++ b/media/libaaudio/src/Android.bp
@@ -207,10 +207,14 @@
"binding/RingBufferParcelable.cpp",
"binding/SharedMemoryParcelable.cpp",
"binding/SharedRegionParcelable.cpp",
- "flowgraph/AudioProcessorBase.cpp",
+ "flowgraph/ChannelCountConverter.cpp",
"flowgraph/ClipToRange.cpp",
+ "flowgraph/FlowGraphNode.cpp",
+ "flowgraph/ManyToMultiConverter.cpp",
"flowgraph/MonoToMultiConverter.cpp",
+ "flowgraph/MultiToMonoConverter.cpp",
"flowgraph/RampLinear.cpp",
+ "flowgraph/SampleRateConverter.cpp",
"flowgraph/SinkFloat.cpp",
"flowgraph/SinkI16.cpp",
"flowgraph/SinkI24.cpp",
@@ -219,6 +223,14 @@
"flowgraph/SourceI16.cpp",
"flowgraph/SourceI24.cpp",
"flowgraph/SourceI32.cpp",
+ "flowgraph/resampler/IntegerRatio.cpp",
+ "flowgraph/resampler/LinearResampler.cpp",
+ "flowgraph/resampler/MultiChannelResampler.cpp",
+ "flowgraph/resampler/PolyphaseResampler.cpp",
+ "flowgraph/resampler/PolyphaseResamplerMono.cpp",
+ "flowgraph/resampler/PolyphaseResamplerStereo.cpp",
+ "flowgraph/resampler/SincResampler.cpp",
+ "flowgraph/resampler/SincResamplerStereo.cpp",
],
sanitize: {
integer_overflow: true,
diff --git a/media/libaaudio/src/client/AAudioFlowGraph.cpp b/media/libaaudio/src/client/AAudioFlowGraph.cpp
index 61b50f3..68b84c8 100644
--- a/media/libaaudio/src/client/AAudioFlowGraph.cpp
+++ b/media/libaaudio/src/client/AAudioFlowGraph.cpp
@@ -38,7 +38,7 @@
int32_t sourceChannelCount,
audio_format_t sinkFormat,
int32_t sinkChannelCount) {
- AudioFloatOutputPort *lastOutput = nullptr;
+ FlowGraphPortFloatOutput *lastOutput = nullptr;
// TODO change back to ALOGD
ALOGI("%s() source format = 0x%08x, channels = %d, sink format = 0x%08x, channels = %d",
diff --git a/media/libaaudio/src/client/AAudioFlowGraph.h b/media/libaaudio/src/client/AAudioFlowGraph.h
index a49f64e..079328a 100644
--- a/media/libaaudio/src/client/AAudioFlowGraph.h
+++ b/media/libaaudio/src/client/AAudioFlowGraph.h
@@ -53,11 +53,11 @@
void setRampLengthInFrames(int32_t numFrames);
private:
- std::unique_ptr<flowgraph::AudioSource> mSource;
- std::unique_ptr<flowgraph::RampLinear> mVolumeRamp;
- std::unique_ptr<flowgraph::ClipToRange> mClipper;
- std::unique_ptr<flowgraph::MonoToMultiConverter> mChannelConverter;
- std::unique_ptr<flowgraph::AudioSink> mSink;
+ std::unique_ptr<flowgraph::FlowGraphSourceBuffered> mSource;
+ std::unique_ptr<flowgraph::RampLinear> mVolumeRamp;
+ std::unique_ptr<flowgraph::ClipToRange> mClipper;
+ std::unique_ptr<flowgraph::MonoToMultiConverter> mChannelConverter;
+ std::unique_ptr<flowgraph::FlowGraphSink> mSink;
};
diff --git a/media/libaaudio/src/flowgraph/AudioProcessorBase.cpp b/media/libaaudio/src/flowgraph/AudioProcessorBase.cpp
deleted file mode 100644
index d8ffd00..0000000
--- a/media/libaaudio/src/flowgraph/AudioProcessorBase.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright 2015 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 <sys/types.h>
-#include "AudioProcessorBase.h"
-
-using namespace flowgraph;
-
-/***************************************************************************/
-int32_t AudioProcessorBase::pullData(int64_t framePosition, int32_t numFrames) {
- if (framePosition > mLastFramePosition) {
- mLastFramePosition = framePosition;
- mFramesValid = onProcess(framePosition, numFrames);
- }
- return mFramesValid;
-}
-
-/***************************************************************************/
-AudioFloatBlockPort::AudioFloatBlockPort(AudioProcessorBase &parent,
- int32_t samplesPerFrame,
- int32_t framesPerBlock)
- : AudioPort(parent, samplesPerFrame)
- , mFramesPerBlock(framesPerBlock) {
- int32_t numFloats = framesPerBlock * getSamplesPerFrame();
- mSampleBlock = new float[numFloats]{0.0f};
-}
-
-AudioFloatBlockPort::~AudioFloatBlockPort() {
- delete[] mSampleBlock;
-}
-
-/***************************************************************************/
-int32_t AudioFloatOutputPort::pullData(int64_t framePosition, int32_t numFrames) {
- numFrames = std::min(getFramesPerBlock(), numFrames);
- return mParent.pullData(framePosition, numFrames);
-}
-
-// These need to be in the .cpp file because of forward cross references.
-void AudioFloatOutputPort::connect(AudioFloatInputPort *port) {
- port->connect(this);
-}
-
-void AudioFloatOutputPort::disconnect(AudioFloatInputPort *port) {
- port->disconnect(this);
-}
-
-/***************************************************************************/
-int32_t AudioFloatInputPort::pullData(int64_t framePosition, int32_t numFrames) {
- return (mConnected == nullptr)
- ? std::min(getFramesPerBlock(), numFrames)
- : mConnected->pullData(framePosition, numFrames);
-}
-
-float *AudioFloatInputPort::getBlock() {
- if (mConnected == nullptr) {
- return AudioFloatBlockPort::getBlock(); // loaded using setValue()
- } else {
- return mConnected->getBlock();
- }
-}
-
-/***************************************************************************/
-int32_t AudioSink::pull(int32_t numFrames) {
- int32_t actualFrames = input.pullData(mFramePosition, numFrames);
- mFramePosition += actualFrames;
- return actualFrames;
-}
\ No newline at end of file
diff --git a/media/libaaudio/src/flowgraph/AudioProcessorBase.h b/media/libaaudio/src/flowgraph/AudioProcessorBase.h
deleted file mode 100644
index 972932f..0000000
--- a/media/libaaudio/src/flowgraph/AudioProcessorBase.h
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Copyright 2015 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.
- */
-
-/*
- * AudioProcessorBase.h
- *
- * Audio processing node and ports that can be used in a simple data flow graph.
- */
-
-#ifndef FLOWGRAPH_AUDIO_PROCESSOR_BASE_H
-#define FLOWGRAPH_AUDIO_PROCESSOR_BASE_H
-
-#include <cassert>
-#include <cstring>
-#include <math.h>
-#include <sys/types.h>
-#include <time.h>
-#include <unistd.h>
-
-// TODO consider publishing all header files under "include/libaaudio/FlowGraph.h"
-
-namespace flowgraph {
-
-// Default block size that can be overridden when the AudioFloatBlockPort is created.
-// If it is too small then we will have too much overhead from switching between nodes.
-// If it is too high then we will thrash the caches.
-constexpr int kDefaultBlockSize = 8; // arbitrary
-
-class AudioFloatInputPort;
-
-/***************************************************************************/
-class AudioProcessorBase {
-public:
- virtual ~AudioProcessorBase() = default;
-
- /**
- * Perform custom function.
- *
- * @param framePosition index of first frame to be processed
- * @param numFrames maximum number of frames requested for processing
- * @return number of frames actually processed
- */
- virtual int32_t onProcess(int64_t framePosition, int32_t numFrames) = 0;
-
- /**
- * If the framePosition is at or after the last frame position then call onProcess().
- * This prevents infinite recursion in case of cyclic graphs.
- * It also prevents nodes upstream from a branch from being executed twice.
- *
- * @param framePosition
- * @param numFrames
- * @return
- */
- int32_t pullData(int64_t framePosition, int32_t numFrames);
-
-protected:
- int64_t mLastFramePosition = -1; // Start at -1 so that the first pull works.
-
-private:
- int32_t mFramesValid = 0; // num valid frames in the block
-};
-
-/***************************************************************************/
-/**
- * This is a connector that allows data to flow between modules.
- */
-class AudioPort {
-public:
- AudioPort(AudioProcessorBase &parent, int32_t samplesPerFrame)
- : mParent(parent)
- , mSamplesPerFrame(samplesPerFrame) {
- }
-
- // Ports are often declared public. So let's make them non-copyable.
- AudioPort(const AudioPort&) = delete;
- AudioPort& operator=(const AudioPort&) = delete;
-
- int32_t getSamplesPerFrame() const {
- return mSamplesPerFrame;
- }
-
-protected:
- AudioProcessorBase &mParent;
-
-private:
- const int32_t mSamplesPerFrame = 1;
-};
-
-/***************************************************************************/
-/**
- * This port contains a float type buffer.
- * The size is framesPerBlock * samplesPerFrame).
- */
-class AudioFloatBlockPort : public AudioPort {
-public:
- AudioFloatBlockPort(AudioProcessorBase &mParent,
- int32_t samplesPerFrame,
- int32_t framesPerBlock = kDefaultBlockSize
- );
-
- virtual ~AudioFloatBlockPort();
-
- int32_t getFramesPerBlock() const {
- return mFramesPerBlock;
- }
-
-protected:
-
- /**
- * @return buffer internal to the port or from a connected port
- */
- virtual float *getBlock() {
- return mSampleBlock;
- }
-
-
-private:
- const int32_t mFramesPerBlock = 1;
- float *mSampleBlock = nullptr; // allocated in constructor
-};
-
-/***************************************************************************/
-/**
- * The results of a module are stored in the buffer of the output ports.
- */
-class AudioFloatOutputPort : public AudioFloatBlockPort {
-public:
- AudioFloatOutputPort(AudioProcessorBase &parent, int32_t samplesPerFrame)
- : AudioFloatBlockPort(parent, samplesPerFrame) {
- }
-
- virtual ~AudioFloatOutputPort() = default;
-
- using AudioFloatBlockPort::getBlock;
-
- /**
- * Call the parent module's onProcess() method.
- * That may pull data from its inputs and recursively
- * process the entire graph.
- * @return number of frames actually pulled
- */
- int32_t pullData(int64_t framePosition, int32_t numFrames);
-
- /**
- * Connect to the input of another module.
- * An input port can only have one connection.
- * An output port can have multiple connections.
- * If you connect a second output port to an input port
- * then it overwrites the previous connection.
- *
- * This not thread safe. Do not modify the graph topology form another thread while running.
- */
- void connect(AudioFloatInputPort *port);
-
- /**
- * Disconnect from the input of another module.
- * This not thread safe.
- */
- void disconnect(AudioFloatInputPort *port);
-};
-
-/***************************************************************************/
-class AudioFloatInputPort : public AudioFloatBlockPort {
-public:
- AudioFloatInputPort(AudioProcessorBase &parent, int32_t samplesPerFrame)
- : AudioFloatBlockPort(parent, samplesPerFrame) {
- }
-
- virtual ~AudioFloatInputPort() = default;
-
- /**
- * If connected to an output port then this will return
- * that output ports buffers.
- * If not connected then it returns the input ports own buffer
- * which can be loaded using setValue().
- */
- float *getBlock() override;
-
- /**
- * Pull data from any output port that is connected.
- */
- int32_t pullData(int64_t framePosition, int32_t numFrames);
-
- /**
- * Write every value of the float buffer.
- * This value will be ignored if an output port is connected
- * to this port.
- */
- void setValue(float value) {
- int numFloats = kDefaultBlockSize * getSamplesPerFrame();
- float *buffer = getBlock();
- for (int i = 0; i < numFloats; i++) {
- *buffer++ = value;
- }
- }
-
- /**
- * Connect to the output of another module.
- * An input port can only have one connection.
- * An output port can have multiple connections.
- * This not thread safe.
- */
- void connect(AudioFloatOutputPort *port) {
- assert(getSamplesPerFrame() == port->getSamplesPerFrame());
- mConnected = port;
- }
-
- void disconnect(AudioFloatOutputPort *port) {
- assert(mConnected == port);
- (void) port;
- mConnected = nullptr;
- }
-
- void disconnect() {
- mConnected = nullptr;
- }
-
-private:
- AudioFloatOutputPort *mConnected = nullptr;
-};
-
-/***************************************************************************/
-class AudioSource : public AudioProcessorBase {
-public:
- explicit AudioSource(int32_t channelCount)
- : output(*this, channelCount) {
- }
-
- virtual ~AudioSource() = default;
-
- AudioFloatOutputPort output;
-
- void setData(const void *data, int32_t numFrames) {
- mData = data;
- mSizeInFrames = numFrames;
- mFrameIndex = 0;
- }
-
-protected:
- const void *mData = nullptr;
- int32_t mSizeInFrames = 0; // number of frames in mData
- int32_t mFrameIndex = 0; // index of next frame to be processed
-};
-
-/***************************************************************************/
-class AudioSink : public AudioProcessorBase {
-public:
- explicit AudioSink(int32_t channelCount)
- : input(*this, channelCount) {
- }
-
- virtual ~AudioSink() = default;
-
- AudioFloatInputPort input;
-
- /**
- * Do nothing. The work happens in the read() method.
- *
- * @param framePosition index of first frame to be processed
- * @param numFrames
- * @return number of frames actually processed
- */
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override {
- (void) framePosition;
- (void) numFrames;
- return 0;
- };
-
- virtual int32_t read(void *data, int32_t numFrames) = 0;
-
-protected:
- int32_t pull(int32_t numFrames);
-
-private:
- int64_t mFramePosition = 0;
-};
-
-} /* namespace flowgraph */
-
-#endif /* FLOWGRAPH_AUDIO_PROCESSOR_BASE_H */
diff --git a/media/libaaudio/src/flowgraph/ChannelCountConverter.cpp b/media/libaaudio/src/flowgraph/ChannelCountConverter.cpp
new file mode 100644
index 0000000..351def2
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/ChannelCountConverter.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2015 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 <unistd.h>
+#include "FlowGraphNode.h"
+#include "ChannelCountConverter.h"
+
+using namespace flowgraph;
+
+ChannelCountConverter::ChannelCountConverter(
+ int32_t inputChannelCount,
+ int32_t outputChannelCount)
+ : input(*this, inputChannelCount)
+ , output(*this, outputChannelCount) {
+}
+
+ChannelCountConverter::~ChannelCountConverter() = default;
+
+int32_t ChannelCountConverter::onProcess(int32_t numFrames) {
+ const float *inputBuffer = input.getBuffer();
+ float *outputBuffer = output.getBuffer();
+ int32_t inputChannelCount = input.getSamplesPerFrame();
+ int32_t outputChannelCount = output.getSamplesPerFrame();
+ for (int i = 0; i < numFrames; i++) {
+ int inputChannel = 0;
+ for (int outputChannel = 0; outputChannel < outputChannelCount; outputChannel++) {
+ // Copy input channels to output channels.
+ // Wrap if we run out of inputs.
+ // Discard if we run out of outputs.
+ outputBuffer[outputChannel] = inputBuffer[inputChannel];
+ inputChannel = (inputChannel == inputChannelCount)
+ ? 0 : inputChannel + 1;
+ }
+ inputBuffer += inputChannelCount;
+ outputBuffer += outputChannelCount;
+ }
+ return numFrames;
+}
+
diff --git a/media/libaaudio/src/flowgraph/ChannelCountConverter.h b/media/libaaudio/src/flowgraph/ChannelCountConverter.h
new file mode 100644
index 0000000..e4b6f4e
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/ChannelCountConverter.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2015 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_CHANNEL_COUNT_CONVERTER_H
+#define FLOWGRAPH_CHANNEL_COUNT_CONVERTER_H
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "FlowGraphNode.h"
+
+namespace flowgraph {
+
+/**
+ * Change the number of number of channels without mixing.
+ * When increasing the channel count, duplicate input channels.
+ * When decreasing the channel count, drop input channels.
+ */
+ class ChannelCountConverter : public FlowGraphNode {
+ public:
+ explicit ChannelCountConverter(
+ int32_t inputChannelCount,
+ int32_t outputChannelCount);
+
+ virtual ~ChannelCountConverter();
+
+ int32_t onProcess(int32_t numFrames) override;
+
+ const char *getName() override {
+ return "ChannelCountConverter";
+ }
+
+ FlowGraphPortFloatInput input;
+ FlowGraphPortFloatOutput output;
+ };
+
+} /* namespace flowgraph */
+
+#endif //FLOWGRAPH_CHANNEL_COUNT_CONVERTER_H
diff --git a/media/libaaudio/src/flowgraph/ClipToRange.cpp b/media/libaaudio/src/flowgraph/ClipToRange.cpp
index bd9c22a..d2f8a02 100644
--- a/media/libaaudio/src/flowgraph/ClipToRange.cpp
+++ b/media/libaaudio/src/flowgraph/ClipToRange.cpp
@@ -16,25 +16,23 @@
#include <algorithm>
#include <unistd.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "ClipToRange.h"
using namespace flowgraph;
ClipToRange::ClipToRange(int32_t channelCount)
- : input(*this, channelCount)
- , output(*this, channelCount) {
+ : FlowGraphFilter(channelCount) {
}
-int32_t ClipToRange::onProcess(int64_t framePosition, int32_t numFrames) {
- int32_t framesToProcess = input.pullData(framePosition, numFrames);
- const float *inputBuffer = input.getBlock();
- float *outputBuffer = output.getBlock();
+int32_t ClipToRange::onProcess(int32_t numFrames) {
+ const float *inputBuffer = input.getBuffer();
+ float *outputBuffer = output.getBuffer();
- int32_t numSamples = framesToProcess * output.getSamplesPerFrame();
+ int32_t numSamples = numFrames * output.getSamplesPerFrame();
for (int32_t i = 0; i < numSamples; i++) {
*outputBuffer++ = std::min(mMaximum, std::max(mMinimum, *inputBuffer++));
}
- return framesToProcess;
+ return numFrames;
}
diff --git a/media/libaaudio/src/flowgraph/ClipToRange.h b/media/libaaudio/src/flowgraph/ClipToRange.h
index 9eef254..22b7804 100644
--- a/media/libaaudio/src/flowgraph/ClipToRange.h
+++ b/media/libaaudio/src/flowgraph/ClipToRange.h
@@ -21,7 +21,7 @@
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
@@ -30,13 +30,13 @@
constexpr float kDefaultMaxHeadroom = 1.41253754f;
constexpr float kDefaultMinHeadroom = -kDefaultMaxHeadroom;
-class ClipToRange : public AudioProcessorBase {
+class ClipToRange : public FlowGraphFilter {
public:
explicit ClipToRange(int32_t channelCount);
virtual ~ClipToRange() = default;
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override;
+ int32_t onProcess(int32_t numFrames) override;
void setMinimum(float min) {
mMinimum = min;
@@ -54,8 +54,9 @@
return mMaximum;
}
- AudioFloatInputPort input;
- AudioFloatOutputPort output;
+ const char *getName() override {
+ return "ClipToRange";
+ }
private:
float mMinimum = kDefaultMinHeadroom;
diff --git a/media/libaaudio/src/flowgraph/FlowGraphNode.cpp b/media/libaaudio/src/flowgraph/FlowGraphNode.cpp
new file mode 100644
index 0000000..4c76e77
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/FlowGraphNode.cpp
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2015 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 "stdio.h"
+#include <algorithm>
+#include <sys/types.h>
+#include "FlowGraphNode.h"
+
+using namespace flowgraph;
+
+/***************************************************************************/
+int32_t FlowGraphNode::pullData(int32_t numFrames, int64_t callCount) {
+ int32_t frameCount = numFrames;
+ // Prevent recursion and multiple execution of nodes.
+ if (callCount > mLastCallCount) {
+ mLastCallCount = callCount;
+ if (mDataPulledAutomatically) {
+ // Pull from all the upstream nodes.
+ for (auto &port : mInputPorts) {
+ // TODO fix bug of leaving unused data in some ports if using multiple AudioSource
+ frameCount = port.get().pullData(callCount, frameCount);
+ }
+ }
+ if (frameCount > 0) {
+ frameCount = onProcess(frameCount);
+ }
+ mLastFrameCount = frameCount;
+ } else {
+ frameCount = mLastFrameCount;
+ }
+ return frameCount;
+}
+
+void FlowGraphNode::pullReset() {
+ if (!mBlockRecursion) {
+ mBlockRecursion = true; // for cyclic graphs
+ // Pull reset from all the upstream nodes.
+ for (auto &port : mInputPorts) {
+ port.get().pullReset();
+ }
+ mBlockRecursion = false;
+ reset();
+ }
+}
+
+void FlowGraphNode::reset() {
+ mLastFrameCount = 0;
+ mLastCallCount = kInitialCallCount;
+}
+
+/***************************************************************************/
+FlowGraphPortFloat::FlowGraphPortFloat(FlowGraphNode &parent,
+ int32_t samplesPerFrame,
+ int32_t framesPerBuffer)
+ : FlowGraphPort(parent, samplesPerFrame)
+ , mFramesPerBuffer(framesPerBuffer)
+ , mBuffer(nullptr) {
+ size_t numFloats = framesPerBuffer * getSamplesPerFrame();
+ mBuffer = std::make_unique<float[]>(numFloats);
+}
+
+/***************************************************************************/
+int32_t FlowGraphPortFloatOutput::pullData(int64_t callCount, int32_t numFrames) {
+ numFrames = std::min(getFramesPerBuffer(), numFrames);
+ return mContainingNode.pullData(numFrames, callCount);
+}
+
+void FlowGraphPortFloatOutput::pullReset() {
+ mContainingNode.pullReset();
+}
+
+// These need to be in the .cpp file because of forward cross references.
+void FlowGraphPortFloatOutput::connect(FlowGraphPortFloatInput *port) {
+ port->connect(this);
+}
+
+void FlowGraphPortFloatOutput::disconnect(FlowGraphPortFloatInput *port) {
+ port->disconnect(this);
+}
+
+/***************************************************************************/
+int32_t FlowGraphPortFloatInput::pullData(int64_t callCount, int32_t numFrames) {
+ return (mConnected == nullptr)
+ ? std::min(getFramesPerBuffer(), numFrames)
+ : mConnected->pullData(callCount, numFrames);
+}
+void FlowGraphPortFloatInput::pullReset() {
+ if (mConnected != nullptr) mConnected->pullReset();
+}
+
+float *FlowGraphPortFloatInput::getBuffer() {
+ if (mConnected == nullptr) {
+ return FlowGraphPortFloat::getBuffer(); // loaded using setValue()
+ } else {
+ return mConnected->getBuffer();
+ }
+}
+
+int32_t FlowGraphSink::pullData(int32_t numFrames) {
+ return FlowGraphNode::pullData(numFrames, getLastCallCount() + 1);
+}
diff --git a/media/libaaudio/src/flowgraph/FlowGraphNode.h b/media/libaaudio/src/flowgraph/FlowGraphNode.h
new file mode 100644
index 0000000..69c83dd
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/FlowGraphNode.h
@@ -0,0 +1,437 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/*
+ * FlowGraph.h
+ *
+ * Processing node and ports that can be used in a simple data flow graph.
+ * This was designed to work with audio but could be used for other
+ * types of data.
+ */
+
+#ifndef FLOWGRAPH_FLOW_GRAPH_NODE_H
+#define FLOWGRAPH_FLOW_GRAPH_NODE_H
+
+#include <cassert>
+#include <cstring>
+#include <math.h>
+#include <memory>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+#include <vector>
+
+// TODO Move these classes into separate files.
+// TODO Review use of raw pointers for connect(). Maybe use smart pointers but need to avoid
+// run-time deallocation in audio thread.
+
+// Set this to 1 if using it inside the Android framework.
+// This code is kept here so that it can be moved easily between Oboe and AAudio.
+#ifndef FLOWGRAPH_ANDROID_INTERNAL
+#define FLOWGRAPH_ANDROID_INTERNAL 0
+#endif
+
+namespace flowgraph {
+
+// Default block size that can be overridden when the FlowGraphPortFloat is created.
+// If it is too small then we will have too much overhead from switching between nodes.
+// If it is too high then we will thrash the caches.
+constexpr int kDefaultBufferSize = 8; // arbitrary
+
+class FlowGraphPort;
+class FlowGraphPortFloatInput;
+
+/***************************************************************************/
+/**
+ * Base class for all nodes in the flowgraph.
+ */
+class FlowGraphNode {
+public:
+ FlowGraphNode() = default;
+ virtual ~FlowGraphNode() = default;
+
+ /**
+ * Read from the input ports,
+ * generate multiple frames of data then write the results to the output ports.
+ *
+ * @param numFrames maximum number of frames requested for processing
+ * @return number of frames actually processed
+ */
+ virtual int32_t onProcess(int32_t numFrames) = 0;
+
+ /**
+ * If the callCount is at or after the previous callCount then call
+ * pullData on all of the upstreamNodes.
+ * Then call onProcess().
+ * This prevents infinite recursion in case of cyclic graphs.
+ * It also prevents nodes upstream from a branch from being executed twice.
+ *
+ * @param callCount
+ * @param numFrames
+ * @return number of frames valid
+ */
+ int32_t pullData(int32_t numFrames, int64_t callCount);
+
+ /**
+ * Recursively reset all the nodes in the graph, starting from a Sink.
+ *
+ * This must not be called at the same time as pullData!
+ */
+ void pullReset();
+
+ /**
+ * Reset framePosition counters.
+ */
+ virtual void reset();
+
+ void addInputPort(FlowGraphPort &port) {
+ mInputPorts.emplace_back(port);
+ }
+
+ bool isDataPulledAutomatically() const {
+ return mDataPulledAutomatically;
+ }
+
+ /**
+ * Set true if you want the data pulled through the graph automatically.
+ * This is the default.
+ *
+ * Set false if you want to pull the data from the input ports in the onProcess() method.
+ * You might do this, for example, in a sample rate converting node.
+ *
+ * @param automatic
+ */
+ void setDataPulledAutomatically(bool automatic) {
+ mDataPulledAutomatically = automatic;
+ }
+
+ virtual const char *getName() {
+ return "FlowGraph";
+ }
+
+ int64_t getLastCallCount() {
+ return mLastCallCount;
+ }
+
+protected:
+
+ static constexpr int64_t kInitialCallCount = -1;
+ int64_t mLastCallCount = kInitialCallCount;
+
+ std::vector<std::reference_wrapper<FlowGraphPort>> mInputPorts;
+
+private:
+ bool mDataPulledAutomatically = true;
+ bool mBlockRecursion = false;
+ int32_t mLastFrameCount = 0;
+
+};
+
+/***************************************************************************/
+/**
+ * This is a connector that allows data to flow between modules.
+ *
+ * The ports are the primary means of interacting with a module.
+ * So they are generally declared as public.
+ *
+ */
+class FlowGraphPort {
+public:
+ FlowGraphPort(FlowGraphNode &parent, int32_t samplesPerFrame)
+ : mContainingNode(parent)
+ , mSamplesPerFrame(samplesPerFrame) {
+ }
+
+ virtual ~FlowGraphPort() = default;
+
+ // Ports are often declared public. So let's make them non-copyable.
+ FlowGraphPort(const FlowGraphPort&) = delete;
+ FlowGraphPort& operator=(const FlowGraphPort&) = delete;
+
+ int32_t getSamplesPerFrame() const {
+ return mSamplesPerFrame;
+ }
+
+ virtual int32_t pullData(int64_t framePosition, int32_t numFrames) = 0;
+
+ virtual void pullReset() {}
+
+protected:
+ FlowGraphNode &mContainingNode;
+
+private:
+ const int32_t mSamplesPerFrame = 1;
+};
+
+/***************************************************************************/
+/**
+ * This port contains a 32-bit float buffer that can contain several frames of data.
+ * Processing the data in a block improves performance.
+ *
+ * The size is framesPerBuffer * samplesPerFrame).
+ */
+class FlowGraphPortFloat : public FlowGraphPort {
+public:
+ FlowGraphPortFloat(FlowGraphNode &parent,
+ int32_t samplesPerFrame,
+ int32_t framesPerBuffer = kDefaultBufferSize
+ );
+
+ virtual ~FlowGraphPortFloat() = default;
+
+ int32_t getFramesPerBuffer() const {
+ return mFramesPerBuffer;
+ }
+
+protected:
+
+ /**
+ * @return buffer internal to the port or from a connected port
+ */
+ virtual float *getBuffer() {
+ return mBuffer.get();
+ }
+
+private:
+ const int32_t mFramesPerBuffer = 1;
+ std::unique_ptr<float[]> mBuffer; // allocated in constructor
+};
+
+/***************************************************************************/
+/**
+ * The results of a node's processing are stored in the buffers of the output ports.
+ */
+class FlowGraphPortFloatOutput : public FlowGraphPortFloat {
+public:
+ FlowGraphPortFloatOutput(FlowGraphNode &parent, int32_t samplesPerFrame)
+ : FlowGraphPortFloat(parent, samplesPerFrame) {
+ }
+
+ virtual ~FlowGraphPortFloatOutput() = default;
+
+ using FlowGraphPortFloat::getBuffer;
+
+ /**
+ * Connect to the input of another module.
+ * An input port can only have one connection.
+ * An output port can have multiple connections.
+ * If you connect a second output port to an input port
+ * then it overwrites the previous connection.
+ *
+ * This not thread safe. Do not modify the graph topology from another thread while running.
+ * Also do not delete a module while it is connected to another port if the graph is running.
+ */
+ void connect(FlowGraphPortFloatInput *port);
+
+ /**
+ * Disconnect from the input of another module.
+ * This not thread safe.
+ */
+ void disconnect(FlowGraphPortFloatInput *port);
+
+ /**
+ * Call the parent module's onProcess() method.
+ * That may pull data from its inputs and recursively
+ * process the entire graph.
+ * @return number of frames actually pulled
+ */
+ int32_t pullData(int64_t framePosition, int32_t numFrames) override;
+
+
+ void pullReset() override;
+
+};
+
+/***************************************************************************/
+
+/**
+ * An input port for streaming audio data.
+ * You can set a value that will be used for processing.
+ * If you connect an output port to this port then its value will be used instead.
+ */
+class FlowGraphPortFloatInput : public FlowGraphPortFloat {
+public:
+ FlowGraphPortFloatInput(FlowGraphNode &parent, int32_t samplesPerFrame)
+ : FlowGraphPortFloat(parent, samplesPerFrame) {
+ // Add to parent so it can pull data from each input.
+ parent.addInputPort(*this);
+ }
+
+ virtual ~FlowGraphPortFloatInput() = default;
+
+ /**
+ * If connected to an output port then this will return
+ * that output ports buffers.
+ * If not connected then it returns the input ports own buffer
+ * which can be loaded using setValue().
+ */
+ float *getBuffer() override;
+
+ /**
+ * Write every value of the float buffer.
+ * This value will be ignored if an output port is connected
+ * to this port.
+ */
+ void setValue(float value) {
+ int numFloats = kDefaultBufferSize * getSamplesPerFrame();
+ float *buffer = getBuffer();
+ for (int i = 0; i < numFloats; i++) {
+ *buffer++ = value;
+ }
+ }
+
+ /**
+ * Connect to the output of another module.
+ * An input port can only have one connection.
+ * An output port can have multiple connections.
+ * This not thread safe.
+ */
+ void connect(FlowGraphPortFloatOutput *port) {
+ assert(getSamplesPerFrame() == port->getSamplesPerFrame());
+ mConnected = port;
+ }
+
+ void disconnect(FlowGraphPortFloatOutput *port) {
+ assert(mConnected == port);
+ (void) port;
+ mConnected = nullptr;
+ }
+
+ void disconnect() {
+ mConnected = nullptr;
+ }
+
+ /**
+ * Pull data from any output port that is connected.
+ */
+ int32_t pullData(int64_t framePosition, int32_t numFrames) override;
+
+ void pullReset() override;
+
+private:
+ FlowGraphPortFloatOutput *mConnected = nullptr;
+};
+
+/***************************************************************************/
+
+/**
+ * Base class for an edge node in a graph that has no upstream nodes.
+ * It outputs data but does not consume data.
+ * By default, it will read its data from an external buffer.
+ */
+class FlowGraphSource : public FlowGraphNode {
+public:
+ explicit FlowGraphSource(int32_t channelCount)
+ : output(*this, channelCount) {
+ }
+
+ virtual ~FlowGraphSource() = default;
+
+ FlowGraphPortFloatOutput output;
+};
+
+/***************************************************************************/
+
+/**
+ * Base class for an edge node in a graph that has no upstream nodes.
+ * It outputs data but does not consume data.
+ * By default, it will read its data from an external buffer.
+ */
+class FlowGraphSourceBuffered : public FlowGraphSource {
+public:
+ explicit FlowGraphSourceBuffered(int32_t channelCount)
+ : FlowGraphSource(channelCount) {}
+
+ virtual ~FlowGraphSourceBuffered() = default;
+
+ /**
+ * Specify buffer that the node will read from.
+ *
+ * @param data TODO Consider using std::shared_ptr.
+ * @param numFrames
+ */
+ void setData(const void *data, int32_t numFrames) {
+ mData = data;
+ mSizeInFrames = numFrames;
+ mFrameIndex = 0;
+ }
+
+protected:
+ const void *mData = nullptr;
+ int32_t mSizeInFrames = 0; // number of frames in mData
+ int32_t mFrameIndex = 0; // index of next frame to be processed
+};
+
+/***************************************************************************/
+/**
+ * Base class for an edge node in a graph that has no downstream nodes.
+ * It consumes data but does not output data.
+ * This graph will be executed when data is read() from this node
+ * by pulling data from upstream nodes.
+ */
+class FlowGraphSink : public FlowGraphNode {
+public:
+ explicit FlowGraphSink(int32_t channelCount)
+ : input(*this, channelCount) {
+ }
+
+ virtual ~FlowGraphSink() = default;
+
+ FlowGraphPortFloatInput input;
+
+ /**
+ * Do nothing. The work happens in the read() method.
+ *
+ * @param numFrames
+ * @return number of frames actually processed
+ */
+ int32_t onProcess(int32_t numFrames) override {
+ return numFrames;
+ }
+
+ virtual int32_t read(void *data, int32_t numFrames) = 0;
+
+protected:
+ /**
+ * Pull data through the graph using this nodes last callCount.
+ * @param numFrames
+ * @return
+ */
+ int32_t pullData(int32_t numFrames);
+};
+
+/***************************************************************************/
+/**
+ * Base class for a node that has an input and an output with the same number of channels.
+ * This may include traditional filters, eg. FIR, but also include
+ * any processing node that converts input to output.
+ */
+class FlowGraphFilter : public FlowGraphNode {
+public:
+ explicit FlowGraphFilter(int32_t channelCount)
+ : input(*this, channelCount)
+ , output(*this, channelCount) {
+ }
+
+ virtual ~FlowGraphFilter() = default;
+
+ FlowGraphPortFloatInput input;
+ FlowGraphPortFloatOutput output;
+};
+
+} /* namespace flowgraph */
+
+#endif /* FLOWGRAPH_FLOW_GRAPH_NODE_H */
diff --git a/media/libaaudio/src/flowgraph/ManyToMultiConverter.cpp b/media/libaaudio/src/flowgraph/ManyToMultiConverter.cpp
new file mode 100644
index 0000000..879685e
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/ManyToMultiConverter.cpp
@@ -0,0 +1,47 @@
+/*
+ * 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 <unistd.h>
+
+#include "ManyToMultiConverter.h"
+
+using namespace flowgraph;
+
+ManyToMultiConverter::ManyToMultiConverter(int32_t channelCount)
+ : inputs(channelCount)
+ , output(*this, channelCount) {
+ for (int i = 0; i < channelCount; i++) {
+ inputs[i] = std::make_unique<FlowGraphPortFloatInput>(*this, 1);
+ }
+}
+
+int32_t ManyToMultiConverter::onProcess(int32_t numFrames) {
+ int32_t channelCount = output.getSamplesPerFrame();
+
+ for (int ch = 0; ch < channelCount; ch++) {
+ const float *inputBuffer = inputs[ch]->getBuffer();
+ float *outputBuffer = output.getBuffer() + ch;
+
+ for (int i = 0; i < numFrames; i++) {
+ // read one, write into the proper interleaved output channel
+ float sample = *inputBuffer++;
+ *outputBuffer = sample;
+ outputBuffer += channelCount; // advance to next multichannel frame
+ }
+ }
+ return numFrames;
+}
+
diff --git a/media/libaaudio/src/flowgraph/ManyToMultiConverter.h b/media/libaaudio/src/flowgraph/ManyToMultiConverter.h
new file mode 100644
index 0000000..c7460ff
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/ManyToMultiConverter.h
@@ -0,0 +1,53 @@
+/*
+ * 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_MANY_TO_MULTI_CONVERTER_H
+#define FLOWGRAPH_MANY_TO_MULTI_CONVERTER_H
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <vector>
+
+#include "FlowGraphNode.h"
+
+namespace flowgraph {
+
+/**
+ * Combine multiple mono inputs into one interleaved multi-channel output.
+ */
+class ManyToMultiConverter : public flowgraph::FlowGraphNode {
+public:
+ explicit ManyToMultiConverter(int32_t channelCount);
+
+ virtual ~ManyToMultiConverter() = default;
+
+ int32_t onProcess(int numFrames) override;
+
+ void setEnabled(bool /*enabled*/) {}
+
+ std::vector<std::unique_ptr<flowgraph::FlowGraphPortFloatInput>> inputs;
+ flowgraph::FlowGraphPortFloatOutput output;
+
+ const char *getName() override {
+ return "ManyToMultiConverter";
+ }
+
+private:
+};
+
+} /* namespace flowgraph */
+
+#endif //FLOWGRAPH_MANY_TO_MULTI_CONVERTER_H
diff --git a/media/libaaudio/src/flowgraph/MonoToMultiConverter.cpp b/media/libaaudio/src/flowgraph/MonoToMultiConverter.cpp
index c6fcac6..c8d60b9 100644
--- a/media/libaaudio/src/flowgraph/MonoToMultiConverter.cpp
+++ b/media/libaaudio/src/flowgraph/MonoToMultiConverter.cpp
@@ -14,32 +14,28 @@
* limitations under the License.
*/
-
#include <unistd.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "MonoToMultiConverter.h"
using namespace flowgraph;
-MonoToMultiConverter::MonoToMultiConverter(int32_t channelCount)
+MonoToMultiConverter::MonoToMultiConverter(int32_t outputChannelCount)
: input(*this, 1)
- , output(*this, channelCount) {
+ , output(*this, outputChannelCount) {
}
-int32_t MonoToMultiConverter::onProcess(int64_t framePosition, int32_t numFrames) {
- int32_t framesToProcess = input.pullData(framePosition, numFrames);
-
- const float *inputBuffer = input.getBlock();
- float *outputBuffer = output.getBlock();
+int32_t MonoToMultiConverter::onProcess(int32_t numFrames) {
+ const float *inputBuffer = input.getBuffer();
+ float *outputBuffer = output.getBuffer();
int32_t channelCount = output.getSamplesPerFrame();
- // TODO maybe move to audio_util as audio_mono_to_multi()
- for (int i = 0; i < framesToProcess; i++) {
+ for (int i = 0; i < numFrames; i++) {
// read one, write many
float sample = *inputBuffer++;
for (int channel = 0; channel < channelCount; channel++) {
*outputBuffer++ = sample;
}
}
- return framesToProcess;
+ return numFrames;
}
diff --git a/media/libaaudio/src/flowgraph/MonoToMultiConverter.h b/media/libaaudio/src/flowgraph/MonoToMultiConverter.h
index 5058ae0..6e87ccb 100644
--- a/media/libaaudio/src/flowgraph/MonoToMultiConverter.h
+++ b/media/libaaudio/src/flowgraph/MonoToMultiConverter.h
@@ -14,27 +14,34 @@
* limitations under the License.
*/
-
#ifndef FLOWGRAPH_MONO_TO_MULTI_CONVERTER_H
#define FLOWGRAPH_MONO_TO_MULTI_CONVERTER_H
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class MonoToMultiConverter : public AudioProcessorBase {
+/**
+ * Convert a monophonic stream to a multi-channel interleaved stream
+ * with the same signal on each channel.
+ */
+class MonoToMultiConverter : public FlowGraphNode {
public:
- explicit MonoToMultiConverter(int32_t channelCount);
+ explicit MonoToMultiConverter(int32_t outputChannelCount);
virtual ~MonoToMultiConverter() = default;
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override;
+ int32_t onProcess(int32_t numFrames) override;
- AudioFloatInputPort input;
- AudioFloatOutputPort output;
+ const char *getName() override {
+ return "MonoToMultiConverter";
+ }
+
+ FlowGraphPortFloatInput input;
+ FlowGraphPortFloatOutput output;
};
} /* namespace flowgraph */
diff --git a/media/libaaudio/src/flowgraph/MultiToMonoConverter.cpp b/media/libaaudio/src/flowgraph/MultiToMonoConverter.cpp
new file mode 100644
index 0000000..c745108
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/MultiToMonoConverter.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2015 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 <unistd.h>
+#include "FlowGraphNode.h"
+#include "MultiToMonoConverter.h"
+
+using namespace flowgraph;
+
+MultiToMonoConverter::MultiToMonoConverter(int32_t inputChannelCount)
+ : input(*this, inputChannelCount)
+ , output(*this, 1) {
+}
+
+MultiToMonoConverter::~MultiToMonoConverter() = default;
+
+int32_t MultiToMonoConverter::onProcess(int32_t numFrames) {
+ const float *inputBuffer = input.getBuffer();
+ float *outputBuffer = output.getBuffer();
+ int32_t channelCount = input.getSamplesPerFrame();
+ for (int i = 0; i < numFrames; i++) {
+ // read first channel of multi stream, write many
+ *outputBuffer++ = *inputBuffer;
+ inputBuffer += channelCount;
+ }
+ return numFrames;
+}
+
diff --git a/media/libaaudio/src/flowgraph/MultiToMonoConverter.h b/media/libaaudio/src/flowgraph/MultiToMonoConverter.h
new file mode 100644
index 0000000..37c53bd
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/MultiToMonoConverter.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2015 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_MULTI_TO_MONO_CONVERTER_H
+#define FLOWGRAPH_MULTI_TO_MONO_CONVERTER_H
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "FlowGraphNode.h"
+
+namespace flowgraph {
+
+/**
+ * Convert a multi-channel interleaved stream to a monophonic stream
+ * by extracting channel[0].
+ */
+ class MultiToMonoConverter : public FlowGraphNode {
+ public:
+ explicit MultiToMonoConverter(int32_t inputChannelCount);
+
+ virtual ~MultiToMonoConverter();
+
+ int32_t onProcess(int32_t numFrames) override;
+
+ const char *getName() override {
+ return "MultiToMonoConverter";
+ }
+
+ FlowGraphPortFloatInput input;
+ FlowGraphPortFloatOutput output;
+ };
+
+} /* namespace flowgraph */
+
+#endif //FLOWGRAPH_MULTI_TO_MONO_CONVERTER_H
diff --git a/media/libaaudio/src/flowgraph/RampLinear.cpp b/media/libaaudio/src/flowgraph/RampLinear.cpp
index 0cc32e5..905ae07 100644
--- a/media/libaaudio/src/flowgraph/RampLinear.cpp
+++ b/media/libaaudio/src/flowgraph/RampLinear.cpp
@@ -14,20 +14,15 @@
* limitations under the License.
*/
-#define LOG_TAG "RampLinear"
-//#define LOG_NDEBUG 0
-#include <utils/Log.h>
-
#include <algorithm>
#include <unistd.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "RampLinear.h"
using namespace flowgraph;
RampLinear::RampLinear(int32_t channelCount)
- : input(*this, channelCount)
- , output(*this, channelCount) {
+ : FlowGraphFilter(channelCount) {
mTarget.store(1.0f);
}
@@ -38,7 +33,7 @@
void RampLinear::setTarget(float target) {
mTarget.store(target);
// If the ramp has not been used then start immediately at this level.
- if (mLastFramePosition < 0) {
+ if (mLastCallCount == kInitialCallCount) {
forceCurrent(target);
}
}
@@ -47,10 +42,9 @@
return mLevelTo - (mRemaining * mScaler);
}
-int32_t RampLinear::onProcess(int64_t framePosition, int32_t numFrames) {
- int32_t framesToProcess = input.pullData(framePosition, numFrames);
- const float *inputBuffer = input.getBlock();
- float *outputBuffer = output.getBlock();
+int32_t RampLinear::onProcess(int32_t numFrames) {
+ const float *inputBuffer = input.getBuffer();
+ float *outputBuffer = output.getBuffer();
int32_t channelCount = output.getSamplesPerFrame();
float target = getTarget();
@@ -59,12 +53,10 @@
mLevelFrom = interpolateCurrent();
mLevelTo = target;
mRemaining = mLengthInFrames;
- ALOGV("%s() mLevelFrom = %f, mLevelTo = %f, mRemaining = %d, mScaler = %f",
- __func__, mLevelFrom, mLevelTo, mRemaining, mScaler);
mScaler = (mLevelTo - mLevelFrom) / mLengthInFrames; // for interpolation
}
- int32_t framesLeft = framesToProcess;
+ int32_t framesLeft = numFrames;
if (mRemaining > 0) { // Ramping? This doesn't happen very often.
int32_t framesToRamp = std::min(framesLeft, mRemaining);
@@ -85,5 +77,5 @@
*outputBuffer++ = *inputBuffer++ * mLevelTo;
}
- return framesToProcess;
+ return numFrames;
}
diff --git a/media/libaaudio/src/flowgraph/RampLinear.h b/media/libaaudio/src/flowgraph/RampLinear.h
index bdc8f41..f285704 100644
--- a/media/libaaudio/src/flowgraph/RampLinear.h
+++ b/media/libaaudio/src/flowgraph/RampLinear.h
@@ -21,17 +21,25 @@
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class RampLinear : public AudioProcessorBase {
+/**
+ * When the target is modified then the output will ramp smoothly
+ * between the original and the new target value.
+ * This can be used to smooth out control values and reduce pops.
+ *
+ * The target may be updated while a ramp is in progress, which will trigger
+ * a new ramp from the current value.
+ */
+class RampLinear : public FlowGraphFilter {
public:
explicit RampLinear(int32_t channelCount);
virtual ~RampLinear() = default;
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override;
+ int32_t onProcess(int32_t numFrames) override;
/**
* This is used for the next ramp.
@@ -66,8 +74,9 @@
mLevelTo = level;
}
- AudioFloatInputPort input;
- AudioFloatOutputPort output;
+ const char *getName() override {
+ return "RampLinear";
+ }
private:
diff --git a/media/libaaudio/src/flowgraph/SampleRateConverter.cpp b/media/libaaudio/src/flowgraph/SampleRateConverter.cpp
new file mode 100644
index 0000000..5c3ed1f
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/SampleRateConverter.cpp
@@ -0,0 +1,70 @@
+/*
+ * 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 "SampleRateConverter.h"
+
+using namespace flowgraph;
+using namespace resampler;
+
+SampleRateConverter::SampleRateConverter(int32_t channelCount, MultiChannelResampler &resampler)
+ : FlowGraphFilter(channelCount)
+ , mResampler(resampler) {
+ setDataPulledAutomatically(false);
+}
+
+void SampleRateConverter::reset() {
+ FlowGraphNode::reset();
+ mInputCursor = kInitialCallCount;
+}
+
+// Return true if there is a sample available.
+bool SampleRateConverter::isInputAvailable() {
+ // If we have consumed all of the input data then go out and get some more.
+ if (mInputCursor >= mNumValidInputFrames) {
+ mInputCallCount++;
+ mNumValidInputFrames = input.pullData(mInputCallCount, input.getFramesPerBuffer());
+ mInputCursor = 0;
+ }
+ return (mInputCursor < mNumValidInputFrames);
+}
+
+const float *SampleRateConverter::getNextInputFrame() {
+ const float *inputBuffer = input.getBuffer();
+ return &inputBuffer[mInputCursor++ * input.getSamplesPerFrame()];
+}
+
+int32_t SampleRateConverter::onProcess(int32_t numFrames) {
+ float *outputBuffer = output.getBuffer();
+ int32_t channelCount = output.getSamplesPerFrame();
+ int framesLeft = numFrames;
+ while (framesLeft > 0) {
+ // Gather input samples as needed.
+ if(mResampler.isWriteNeeded()) {
+ if (isInputAvailable()) {
+ const float *frame = getNextInputFrame();
+ mResampler.writeNextFrame(frame);
+ } else {
+ break;
+ }
+ } else {
+ // Output frame is interpolated from input samples.
+ mResampler.readNextFrame(outputBuffer);
+ outputBuffer += channelCount;
+ framesLeft--;
+ }
+ }
+ return numFrames - framesLeft;
+}
diff --git a/media/libaaudio/src/flowgraph/SampleRateConverter.h b/media/libaaudio/src/flowgraph/SampleRateConverter.h
new file mode 100644
index 0000000..57d76a4
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/SampleRateConverter.h
@@ -0,0 +1,63 @@
+/*
+ * 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_SAMPLE_RATE_CONVERTER_H
+#define OBOE_SAMPLE_RATE_CONVERTER_H
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "FlowGraphNode.h"
+#include "resampler/MultiChannelResampler.h"
+
+namespace flowgraph {
+
+class SampleRateConverter : public FlowGraphFilter {
+public:
+ explicit SampleRateConverter(int32_t channelCount,
+ resampler::MultiChannelResampler &mResampler);
+
+ virtual ~SampleRateConverter() = default;
+
+ int32_t onProcess(int32_t numFrames) override;
+
+ const char *getName() override {
+ return "SampleRateConverter";
+ }
+
+ void reset() override;
+
+private:
+
+ // Return true if there is a sample available.
+ bool isInputAvailable();
+
+ // This assumes data is available. Only call after calling isInputAvailable().
+ const float *getNextInputFrame();
+
+ resampler::MultiChannelResampler &mResampler;
+
+ int32_t mInputCursor = 0; // offset into the input port buffer
+ int32_t mNumValidInputFrames = 0; // number of valid frames currently in the input port buffer
+ // We need our own callCount for upstream calls because calls occur at a different rate.
+ // This means we cannot have cyclic graphs or merges that contain an SRC.
+ int64_t mInputCallCount = 0;
+
+};
+
+} /* namespace flowgraph */
+
+#endif //OBOE_SAMPLE_RATE_CONVERTER_H
diff --git a/media/libaaudio/src/flowgraph/SinkFloat.cpp b/media/libaaudio/src/flowgraph/SinkFloat.cpp
index fb3dcbc..0588848 100644
--- a/media/libaaudio/src/flowgraph/SinkFloat.cpp
+++ b/media/libaaudio/src/flowgraph/SinkFloat.cpp
@@ -16,31 +16,31 @@
#include <algorithm>
#include <unistd.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "SinkFloat.h"
using namespace flowgraph;
SinkFloat::SinkFloat(int32_t channelCount)
- : AudioSink(channelCount) {
+ : FlowGraphSink(channelCount) {
}
int32_t SinkFloat::read(void *data, int32_t numFrames) {
float *floatData = (float *) data;
- int32_t channelCount = input.getSamplesPerFrame();
+ 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 = pull(framesLeft);
- if (framesRead <= 0) {
+ int32_t framesPulled = pullData(framesLeft);
+ if (framesPulled <= 0) {
break;
}
- const float *signal = input.getBlock();
- int32_t numSamples = framesRead * channelCount;
+ const float *signal = input.getBuffer();
+ int32_t numSamples = framesPulled * channelCount;
memcpy(floatData, signal, numSamples * sizeof(float));
floatData += numSamples;
- framesLeft -= framesRead;
+ framesLeft -= framesPulled;
}
return numFrames - framesLeft;
}
diff --git a/media/libaaudio/src/flowgraph/SinkFloat.h b/media/libaaudio/src/flowgraph/SinkFloat.h
index 7775c08..c812373 100644
--- a/media/libaaudio/src/flowgraph/SinkFloat.h
+++ b/media/libaaudio/src/flowgraph/SinkFloat.h
@@ -21,16 +21,23 @@
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class SinkFloat : public AudioSink {
+/**
+ * AudioSink that lets you read data as 32-bit floats.
+ */
+class SinkFloat : public FlowGraphSink {
public:
explicit SinkFloat(int32_t channelCount);
+ ~SinkFloat() override = default;
int32_t read(void *data, int32_t numFrames) override;
+ const char *getName() override {
+ return "SinkFloat";
+ }
};
} /* namespace flowgraph */
diff --git a/media/libaaudio/src/flowgraph/SinkI16.cpp b/media/libaaudio/src/flowgraph/SinkI16.cpp
index ffec8f5..da7fd6b 100644
--- a/media/libaaudio/src/flowgraph/SinkI16.cpp
+++ b/media/libaaudio/src/flowgraph/SinkI16.cpp
@@ -17,17 +17,16 @@
#include <algorithm>
#include <unistd.h>
-#ifdef __ANDROID__
+#include "SinkI16.h"
+
+#if FLOWGRAPH_ANDROID_INTERNAL
#include <audio_utils/primitives.h>
#endif
-#include "AudioProcessorBase.h"
-#include "SinkI16.h"
-
using namespace flowgraph;
SinkI16::SinkI16(int32_t channelCount)
- : AudioSink(channelCount) {}
+ : FlowGraphSink(channelCount) {}
int32_t SinkI16::read(void *data, int32_t numFrames) {
int16_t *shortData = (int16_t *) data;
@@ -36,13 +35,13 @@
int32_t framesLeft = numFrames;
while (framesLeft > 0) {
// Run the graph and pull data through the input port.
- int32_t framesRead = pull(framesLeft);
+ int32_t framesRead = pullData(framesLeft);
if (framesRead <= 0) {
break;
}
- const float *signal = input.getBlock();
+ const float *signal = input.getBuffer();
int32_t numSamples = framesRead * channelCount;
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
memcpy_to_i16_from_float(shortData, signal, numSamples);
shortData += numSamples;
signal += numSamples;
diff --git a/media/libaaudio/src/flowgraph/SinkI16.h b/media/libaaudio/src/flowgraph/SinkI16.h
index 6d86266..1e1ce3a 100644
--- a/media/libaaudio/src/flowgraph/SinkI16.h
+++ b/media/libaaudio/src/flowgraph/SinkI16.h
@@ -20,15 +20,22 @@
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class SinkI16 : public AudioSink {
+/**
+ * AudioSink that lets you read data as 16-bit signed integers.
+ */
+class SinkI16 : public FlowGraphSink {
public:
explicit SinkI16(int32_t channelCount);
int32_t read(void *data, int32_t numFrames) override;
+
+ const char *getName() override {
+ return "SinkI16";
+ }
};
} /* namespace flowgraph */
diff --git a/media/libaaudio/src/flowgraph/SinkI24.cpp b/media/libaaudio/src/flowgraph/SinkI24.cpp
index 0cb077d..a9fb5d2 100644
--- a/media/libaaudio/src/flowgraph/SinkI24.cpp
+++ b/media/libaaudio/src/flowgraph/SinkI24.cpp
@@ -15,19 +15,20 @@
*/
#include <algorithm>
-#include <stdint.h>
+#include <unistd.h>
-#ifdef __ANDROID__
+
+#include "FlowGraphNode.h"
+#include "SinkI24.h"
+
+#if FLOWGRAPH_ANDROID_INTERNAL
#include <audio_utils/primitives.h>
#endif
-#include "AudioProcessorBase.h"
-#include "SinkI24.h"
-
using namespace flowgraph;
SinkI24::SinkI24(int32_t channelCount)
- : AudioSink(channelCount) {}
+ : FlowGraphSink(channelCount) {}
int32_t SinkI24::read(void *data, int32_t numFrames) {
uint8_t *byteData = (uint8_t *) data;
@@ -36,13 +37,13 @@
int32_t framesLeft = numFrames;
while (framesLeft > 0) {
// Run the graph and pull data through the input port.
- int32_t framesRead = pull(framesLeft);
+ int32_t framesRead = pullData(framesLeft);
if (framesRead <= 0) {
break;
}
- const float *floatData = input.getBlock();
+ const float *floatData = input.getBuffer();
int32_t numSamples = framesRead * channelCount;
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
memcpy_to_p24_from_float(byteData, floatData, numSamples);
static const int kBytesPerI24Packed = 3;
byteData += numSamples * kBytesPerI24Packed;
diff --git a/media/libaaudio/src/flowgraph/SinkI24.h b/media/libaaudio/src/flowgraph/SinkI24.h
index 5b9b505..44078a9 100644
--- a/media/libaaudio/src/flowgraph/SinkI24.h
+++ b/media/libaaudio/src/flowgraph/SinkI24.h
@@ -20,15 +20,23 @@
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class SinkI24 : public AudioSink {
+/**
+ * AudioSink that lets you read data as packed 24-bit signed integers.
+ * The sample size is 3 bytes.
+ */
+class SinkI24 : public FlowGraphSink {
public:
explicit SinkI24(int32_t channelCount);
int32_t read(void *data, int32_t numFrames) override;
+
+ const char *getName() override {
+ return "SinkI24";
+ }
};
} /* namespace flowgraph */
diff --git a/media/libaaudio/src/flowgraph/SinkI32.cpp b/media/libaaudio/src/flowgraph/SinkI32.cpp
index eab863d..9fd4e96 100644
--- a/media/libaaudio/src/flowgraph/SinkI32.cpp
+++ b/media/libaaudio/src/flowgraph/SinkI32.cpp
@@ -14,18 +14,18 @@
* limitations under the License.
*/
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
#include <audio_utils/primitives.h>
#endif
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "FlowgraphUtilities.h"
#include "SinkI32.h"
using namespace flowgraph;
SinkI32::SinkI32(int32_t channelCount)
- : AudioSink(channelCount) {}
+ : FlowGraphSink(channelCount) {}
int32_t SinkI32::read(void *data, int32_t numFrames) {
int32_t *intData = (int32_t *) data;
@@ -34,13 +34,13 @@
int32_t framesLeft = numFrames;
while (framesLeft > 0) {
// Run the graph and pull data through the input port.
- int32_t framesRead = pull(framesLeft);
+ int32_t framesRead = pullData(framesLeft);
if (framesRead <= 0) {
break;
}
- const float *signal = input.getBlock();
+ const float *signal = input.getBuffer();
int32_t numSamples = framesRead * channelCount;
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
memcpy_to_i32_from_float(intData, signal, numSamples);
intData += numSamples;
signal += numSamples;
diff --git a/media/libaaudio/src/flowgraph/SinkI32.h b/media/libaaudio/src/flowgraph/SinkI32.h
index 09d23b7..7456d5f 100644
--- a/media/libaaudio/src/flowgraph/SinkI32.h
+++ b/media/libaaudio/src/flowgraph/SinkI32.h
@@ -19,16 +19,20 @@
#include <stdint.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class SinkI32 : public AudioSink {
+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 */
diff --git a/media/libaaudio/src/flowgraph/SourceFloat.cpp b/media/libaaudio/src/flowgraph/SourceFloat.cpp
index 5b3a51e..1b3daf1 100644
--- a/media/libaaudio/src/flowgraph/SourceFloat.cpp
+++ b/media/libaaudio/src/flowgraph/SourceFloat.cpp
@@ -16,23 +16,22 @@
#include <algorithm>
#include <unistd.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "SourceFloat.h"
using namespace flowgraph;
SourceFloat::SourceFloat(int32_t channelCount)
- : AudioSource(channelCount) {
+ : FlowGraphSourceBuffered(channelCount) {
}
-int32_t SourceFloat::onProcess(int64_t /*framePosition*/, int32_t numFrames) {
+int32_t SourceFloat::onProcess(int32_t numFrames) {
+ float *outputBuffer = output.getBuffer();
+ const int32_t channelCount = output.getSamplesPerFrame();
- float *outputBuffer = output.getBlock();
- 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];
diff --git a/media/libaaudio/src/flowgraph/SourceFloat.h b/media/libaaudio/src/flowgraph/SourceFloat.h
index e6eed9f..4719669 100644
--- a/media/libaaudio/src/flowgraph/SourceFloat.h
+++ b/media/libaaudio/src/flowgraph/SourceFloat.h
@@ -20,15 +20,23 @@
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class SourceFloat : public AudioSource {
+/**
+ * AudioSource that reads a block of pre-defined float data.
+ */
+class SourceFloat : public FlowGraphSourceBuffered {
public:
explicit SourceFloat(int32_t channelCount);
+ ~SourceFloat() override = default;
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override;
+ int32_t onProcess(int32_t numFrames) override;
+
+ const char *getName() override {
+ return "SourceFloat";
+ }
};
} /* namespace flowgraph */
diff --git a/media/libaaudio/src/flowgraph/SourceI16.cpp b/media/libaaudio/src/flowgraph/SourceI16.cpp
index a645cc2..8813023 100644
--- a/media/libaaudio/src/flowgraph/SourceI16.cpp
+++ b/media/libaaudio/src/flowgraph/SourceI16.cpp
@@ -17,21 +17,21 @@
#include <algorithm>
#include <unistd.h>
-#ifdef __ANDROID__
+#include "FlowGraphNode.h"
+#include "SourceI16.h"
+
+#if FLOWGRAPH_ANDROID_INTERNAL
#include <audio_utils/primitives.h>
#endif
-#include "AudioProcessorBase.h"
-#include "SourceI16.h"
-
using namespace flowgraph;
SourceI16::SourceI16(int32_t channelCount)
- : AudioSource(channelCount) {
+ : FlowGraphSourceBuffered(channelCount) {
}
-int32_t SourceI16::onProcess(int64_t /*framePosition*/, int32_t numFrames) {
- float *floatData = output.getBlock();
+int32_t SourceI16::onProcess(int32_t numFrames) {
+ float *floatData = output.getBuffer();
int32_t channelCount = output.getSamplesPerFrame();
int32_t framesLeft = mSizeInFrames - mFrameIndex;
@@ -41,7 +41,7 @@
const int16_t *shortBase = static_cast<const int16_t *>(mData);
const int16_t *shortData = &shortBase[mFrameIndex * channelCount];
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
memcpy_to_float_from_i16(floatData, shortData, numSamples);
#else
for (int i = 0; i < numSamples; i++) {
diff --git a/media/libaaudio/src/flowgraph/SourceI16.h b/media/libaaudio/src/flowgraph/SourceI16.h
index 2b116cf..fe440b2 100644
--- a/media/libaaudio/src/flowgraph/SourceI16.h
+++ b/media/libaaudio/src/flowgraph/SourceI16.h
@@ -20,15 +20,21 @@
#include <unistd.h>
#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-
-class SourceI16 : public AudioSource {
+/**
+ * AudioSource that reads a block of pre-defined 16-bit integer data.
+ */
+class SourceI16 : public FlowGraphSourceBuffered {
public:
explicit SourceI16(int32_t channelCount);
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override;
+ int32_t onProcess(int32_t numFrames) override;
+
+ const char *getName() override {
+ return "SourceI16";
+ }
};
} /* namespace flowgraph */
diff --git a/media/libaaudio/src/flowgraph/SourceI24.cpp b/media/libaaudio/src/flowgraph/SourceI24.cpp
index 50fb98e..1975878 100644
--- a/media/libaaudio/src/flowgraph/SourceI24.cpp
+++ b/media/libaaudio/src/flowgraph/SourceI24.cpp
@@ -15,13 +15,13 @@
*/
#include <algorithm>
-#include <stdint.h>
+#include <unistd.h>
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
#include <audio_utils/primitives.h>
#endif
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "SourceI24.h"
using namespace flowgraph;
@@ -29,11 +29,11 @@
constexpr int kBytesPerI24Packed = 3;
SourceI24::SourceI24(int32_t channelCount)
- : AudioSource(channelCount) {
+ : FlowGraphSourceBuffered(channelCount) {
}
-int32_t SourceI24::onProcess(int64_t /*framePosition*/, int32_t numFrames) {
- float *floatData = output.getBlock();
+int32_t SourceI24::onProcess(int32_t numFrames) {
+ float *floatData = output.getBuffer();
int32_t channelCount = output.getSamplesPerFrame();
int32_t framesLeft = mSizeInFrames - mFrameIndex;
@@ -43,7 +43,7 @@
const uint8_t *byteBase = (uint8_t *) mData;
const uint8_t *byteData = &byteBase[mFrameIndex * channelCount * kBytesPerI24Packed];
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
memcpy_to_float_from_p24(floatData, byteData, numSamples);
#else
static const float scale = 1. / (float)(1UL << 31);
diff --git a/media/libaaudio/src/flowgraph/SourceI24.h b/media/libaaudio/src/flowgraph/SourceI24.h
index 2ed6f18..3779534 100644
--- a/media/libaaudio/src/flowgraph/SourceI24.h
+++ b/media/libaaudio/src/flowgraph/SourceI24.h
@@ -17,17 +17,25 @@
#ifndef FLOWGRAPH_SOURCE_I24_H
#define FLOWGRAPH_SOURCE_I24_H
-#include <stdint.h>
+#include <unistd.h>
+#include <sys/types.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class SourceI24 : public AudioSource {
+/**
+ * AudioSource that reads a block of pre-defined 24-bit packed integer data.
+ */
+class SourceI24 : public FlowGraphSourceBuffered {
public:
explicit SourceI24(int32_t channelCount);
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override;
+ int32_t onProcess(int32_t numFrames) override;
+
+ const char *getName() override {
+ return "SourceI24";
+ }
};
} /* namespace flowgraph */
diff --git a/media/libaaudio/src/flowgraph/SourceI32.cpp b/media/libaaudio/src/flowgraph/SourceI32.cpp
index 95bfd8f..4b2e8c4 100644
--- a/media/libaaudio/src/flowgraph/SourceI32.cpp
+++ b/media/libaaudio/src/flowgraph/SourceI32.cpp
@@ -17,31 +17,31 @@
#include <algorithm>
#include <unistd.h>
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
#include <audio_utils/primitives.h>
#endif
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
#include "SourceI32.h"
using namespace flowgraph;
SourceI32::SourceI32(int32_t channelCount)
- : AudioSource(channelCount) {
+ : FlowGraphSourceBuffered(channelCount) {
}
-int32_t SourceI32::onProcess(int64_t /*framePosition*/, int32_t numFrames) {
- float *floatData = output.getBlock();
- int32_t channelCount = output.getSamplesPerFrame();
+int32_t SourceI32::onProcess(int32_t numFrames) {
+ float *floatData = output.getBuffer();
+ 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 int32_t *intBase = static_cast<const int32_t *>(mData);
const int32_t *intData = &intBase[mFrameIndex * channelCount];
-#ifdef __ANDROID__
+#if FLOWGRAPH_ANDROID_INTERNAL
memcpy_to_float_from_i32(floatData, intData, numSamples);
#else
for (int i = 0; i < numSamples; i++) {
diff --git a/media/libaaudio/src/flowgraph/SourceI32.h b/media/libaaudio/src/flowgraph/SourceI32.h
index e50f9be..b4e0d7b 100644
--- a/media/libaaudio/src/flowgraph/SourceI32.h
+++ b/media/libaaudio/src/flowgraph/SourceI32.h
@@ -19,17 +19,20 @@
#include <stdint.h>
-#include "AudioProcessorBase.h"
+#include "FlowGraphNode.h"
namespace flowgraph {
-class SourceI32 : public AudioSource {
+class SourceI32 : public FlowGraphSourceBuffered {
public:
explicit SourceI32(int32_t channelCount);
~SourceI32() override = default;
- int32_t onProcess(int64_t framePosition, int32_t numFrames) override;
+ int32_t onProcess(int32_t numFrames) override;
+ const char *getName() override {
+ return "SourceI32";
+ }
private:
static constexpr float kScale = 1.0 / (1UL << 31);
};
diff --git a/media/libaaudio/src/flowgraph/resampler/HyperbolicCosineWindow.h b/media/libaaudio/src/flowgraph/resampler/HyperbolicCosineWindow.h
new file mode 100644
index 0000000..f6479ae
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/HyperbolicCosineWindow.h
@@ -0,0 +1,68 @@
+/*
+ * 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 RESAMPLER_HYPERBOLIC_COSINE_WINDOW_H
+#define RESAMPLER_HYPERBOLIC_COSINE_WINDOW_H
+
+#include <math.h>
+
+namespace resampler {
+
+/**
+ * Calculate a HyperbolicCosineWindow window centered at 0.
+ * This can be used in place of a Kaiser window.
+ *
+ * The code is based on an anonymous contribution by "a concerned citizen":
+ * https://dsp.stackexchange.com/questions/37714/kaiser-window-approximation
+ */
+class HyperbolicCosineWindow {
+public:
+ HyperbolicCosineWindow() {
+ setStopBandAttenuation(60);
+ }
+
+ /**
+ * @param attenuation typical values range from 30 to 90 dB
+ * @return beta
+ */
+ double setStopBandAttenuation(double attenuation) {
+ double alpha = ((-325.1e-6 * attenuation + 0.1677) * attenuation) - 3.149;
+ setAlpha(alpha);
+ return alpha;
+ }
+
+ void setAlpha(double alpha) {
+ mAlpha = alpha;
+ mInverseCoshAlpha = 1.0 / cosh(alpha);
+ }
+
+ /**
+ * @param x ranges from -1.0 to +1.0
+ */
+ double operator()(double x) {
+ double x2 = x * x;
+ if (x2 >= 1.0) return 0.0;
+ double w = mAlpha * sqrt(1.0 - x2);
+ return cosh(w) * mInverseCoshAlpha;
+ }
+
+private:
+ double mAlpha = 0.0;
+ double mInverseCoshAlpha = 1.0;
+};
+
+} // namespace resampler
+#endif //RESAMPLER_HYPERBOLIC_COSINE_WINDOW_H
diff --git a/media/libaaudio/src/flowgraph/resampler/IntegerRatio.cpp b/media/libaaudio/src/flowgraph/resampler/IntegerRatio.cpp
new file mode 100644
index 0000000..4bd75b3
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/IntegerRatio.cpp
@@ -0,0 +1,50 @@
+/*
+ * 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 "IntegerRatio.h"
+
+using namespace resampler;
+
+// Enough primes to cover the common sample rates.
+static const int kPrimes[] = {
+ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
+ 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
+ 101, 103, 107, 109, 113, 127, 131, 137, 139, 149,
+ 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199};
+
+void IntegerRatio::reduce() {
+ for (int prime : kPrimes) {
+ if (mNumerator < prime || mDenominator < prime) {
+ break;
+ }
+
+ // Find biggest prime factor for numerator.
+ while (true) {
+ int top = mNumerator / prime;
+ int bottom = mDenominator / prime;
+ if ((top >= 1)
+ && (bottom >= 1)
+ && (top * prime == mNumerator) // divided evenly?
+ && (bottom * prime == mDenominator)) {
+ mNumerator = top;
+ mDenominator = bottom;
+ } else {
+ break;
+ }
+ }
+
+ }
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/IntegerRatio.h b/media/libaaudio/src/flowgraph/resampler/IntegerRatio.h
new file mode 100644
index 0000000..8c044d8
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/IntegerRatio.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_INTEGER_RATIO_H
+#define OBOE_INTEGER_RATIO_H
+
+#include <sys/types.h>
+
+namespace resampler {
+
+/**
+ * Represent the ratio of two integers.
+ */
+class IntegerRatio {
+public:
+ IntegerRatio(int32_t numerator, int32_t denominator)
+ : mNumerator(numerator), mDenominator(denominator) {}
+
+ /**
+ * Reduce by removing common prime factors.
+ */
+ void reduce();
+
+ int32_t getNumerator() {
+ return mNumerator;
+ }
+
+ int32_t getDenominator() {
+ return mDenominator;
+ }
+
+private:
+ int32_t mNumerator;
+ int32_t mDenominator;
+};
+
+} // namespace resampler
+
+#endif //OBOE_INTEGER_RATIO_H
diff --git a/media/libaaudio/src/flowgraph/resampler/KaiserWindow.h b/media/libaaudio/src/flowgraph/resampler/KaiserWindow.h
new file mode 100644
index 0000000..73dbc41
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/KaiserWindow.h
@@ -0,0 +1,87 @@
+/*
+ * 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 RESAMPLER_KAISER_WINDOW_H
+#define RESAMPLER_KAISER_WINDOW_H
+
+#include <math.h>
+
+namespace resampler {
+
+/**
+ * Calculate a Kaiser window centered at 0.
+ */
+class KaiserWindow {
+public:
+ KaiserWindow() {
+ setStopBandAttenuation(60);
+ }
+
+ /**
+ * @param attenuation typical values range from 30 to 90 dB
+ * @return beta
+ */
+ double setStopBandAttenuation(double attenuation) {
+ double beta = 0.0;
+ if (attenuation > 50) {
+ beta = 0.1102 * (attenuation - 8.7);
+ } else if (attenuation >= 21) {
+ double a21 = attenuation - 21;
+ beta = 0.5842 * pow(a21, 0.4) + (0.07886 * a21);
+ }
+ setBeta(beta);
+ return beta;
+ }
+
+ void setBeta(double beta) {
+ mBeta = beta;
+ mInverseBesselBeta = 1.0 / bessel(beta);
+ }
+
+ /**
+ * @param x ranges from -1.0 to +1.0
+ */
+ double operator()(double x) {
+ double x2 = x * x;
+ if (x2 >= 1.0) return 0.0;
+ double w = mBeta * sqrt(1.0 - x2);
+ return bessel(w) * mInverseBesselBeta;
+ }
+
+ // Approximation of a
+ // modified zero order Bessel function of the first kind.
+ // Based on a discussion at:
+ // https://dsp.stackexchange.com/questions/37714/kaiser-window-approximation
+ static double bessel(double x) {
+ double y = cosh(0.970941817426052 * x);
+ y += cosh(0.8854560256532099 * x);
+ y += cosh(0.7485107481711011 * x);
+ y += cosh(0.5680647467311558 * x);
+ y += cosh(0.3546048870425356 * x);
+ y += cosh(0.120536680255323 * x);
+ y *= 2;
+ y += cosh(x);
+ y /= 13;
+ return y;
+ }
+
+private:
+ double mBeta = 0.0;
+ double mInverseBesselBeta = 1.0;
+};
+
+} // namespace resampler
+#endif //RESAMPLER_KAISER_WINDOW_H
diff --git a/media/libaaudio/src/flowgraph/resampler/LinearResampler.cpp b/media/libaaudio/src/flowgraph/resampler/LinearResampler.cpp
new file mode 100644
index 0000000..a7748c1
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/LinearResampler.cpp
@@ -0,0 +1,42 @@
+/*
+ * 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 "LinearResampler.h"
+
+using namespace resampler;
+
+LinearResampler::LinearResampler(const MultiChannelResampler::Builder &builder)
+ : MultiChannelResampler(builder) {
+ mPreviousFrame = std::make_unique<float[]>(getChannelCount());
+ mCurrentFrame = std::make_unique<float[]>(getChannelCount());
+}
+
+void LinearResampler::writeFrame(const float *frame) {
+ memcpy(mPreviousFrame.get(), mCurrentFrame.get(), sizeof(float) * getChannelCount());
+ memcpy(mCurrentFrame.get(), frame, sizeof(float) * getChannelCount());
+}
+
+void LinearResampler::readFrame(float *frame) {
+ float *previous = mPreviousFrame.get();
+ float *current = mCurrentFrame.get();
+ float phase = (float) getIntegerPhase() / mDenominator;
+ // iterate across samples in the frame
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ float f0 = *previous++;
+ float f1 = *current++;
+ *frame++ = f0 + (phase * (f1 - f0));
+ }
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/LinearResampler.h b/media/libaaudio/src/flowgraph/resampler/LinearResampler.h
new file mode 100644
index 0000000..6bde81d
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/LinearResampler.h
@@ -0,0 +1,44 @@
+/*
+ * 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_LINEAR_RESAMPLER_H
+#define OBOE_LINEAR_RESAMPLER_H
+
+#include <memory>
+#include <sys/types.h>
+#include <unistd.h>
+#include "MultiChannelResampler.h"
+
+namespace resampler {
+
+/**
+ * Simple resampler that uses bi-linear interpolation.
+ */
+class LinearResampler : public MultiChannelResampler {
+public:
+ explicit LinearResampler(const MultiChannelResampler::Builder &builder);
+
+ void writeFrame(const float *frame) override;
+
+ void readFrame(float *frame) override;
+
+private:
+ std::unique_ptr<float[]> mPreviousFrame;
+ std::unique_ptr<float[]> mCurrentFrame;
+};
+
+} // namespace resampler
+#endif //OBOE_LINEAR_RESAMPLER_H
diff --git a/media/libaaudio/src/flowgraph/resampler/MultiChannelResampler.cpp b/media/libaaudio/src/flowgraph/resampler/MultiChannelResampler.cpp
new file mode 100644
index 0000000..d630520
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/MultiChannelResampler.cpp
@@ -0,0 +1,171 @@
+/*
+ * 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 <math.h>
+
+#include "IntegerRatio.h"
+#include "LinearResampler.h"
+#include "MultiChannelResampler.h"
+#include "PolyphaseResampler.h"
+#include "PolyphaseResamplerMono.h"
+#include "PolyphaseResamplerStereo.h"
+#include "SincResampler.h"
+#include "SincResamplerStereo.h"
+
+using namespace resampler;
+
+MultiChannelResampler::MultiChannelResampler(const MultiChannelResampler::Builder &builder)
+ : mNumTaps(builder.getNumTaps())
+ , mX(builder.getChannelCount() * builder.getNumTaps() * 2)
+ , mSingleFrame(builder.getChannelCount())
+ , mChannelCount(builder.getChannelCount())
+ {
+ // Reduce sample rates to the smallest ratio.
+ // For example 44100/48000 would become 147/160.
+ IntegerRatio ratio(builder.getInputRate(), builder.getOutputRate());
+ ratio.reduce();
+ mNumerator = ratio.getNumerator();
+ mDenominator = ratio.getDenominator();
+ mIntegerPhase = mDenominator;
+}
+
+// static factory method
+MultiChannelResampler *MultiChannelResampler::make(int32_t channelCount,
+ int32_t inputRate,
+ int32_t outputRate,
+ Quality quality) {
+ Builder builder;
+ builder.setInputRate(inputRate);
+ builder.setOutputRate(outputRate);
+ builder.setChannelCount(channelCount);
+
+ switch (quality) {
+ case Quality::Fastest:
+ builder.setNumTaps(2);
+ break;
+ case Quality::Low:
+ builder.setNumTaps(4);
+ break;
+ case Quality::Medium:
+ default:
+ builder.setNumTaps(8);
+ break;
+ case Quality::High:
+ builder.setNumTaps(16);
+ break;
+ case Quality::Best:
+ builder.setNumTaps(32);
+ break;
+ }
+
+ // Set the cutoff frequency so that we do not get aliasing when down-sampling.
+ if (inputRate > outputRate) {
+ builder.setNormalizedCutoff(kDefaultNormalizedCutoff);
+ }
+ return builder.build();
+}
+
+MultiChannelResampler *MultiChannelResampler::Builder::build() {
+ if (getNumTaps() == 2) {
+ // Note that this does not do low pass filteringh.
+ return new LinearResampler(*this);
+ }
+ IntegerRatio ratio(getInputRate(), getOutputRate());
+ ratio.reduce();
+ bool usePolyphase = (getNumTaps() * ratio.getDenominator()) <= kMaxCoefficients;
+ if (usePolyphase) {
+ if (getChannelCount() == 1) {
+ return new PolyphaseResamplerMono(*this);
+ } else if (getChannelCount() == 2) {
+ return new PolyphaseResamplerStereo(*this);
+ } else {
+ return new PolyphaseResampler(*this);
+ }
+ } else {
+ // Use less optimized resampler that uses a float phaseIncrement.
+ // TODO mono resampler
+ if (getChannelCount() == 2) {
+ return new SincResamplerStereo(*this);
+ } else {
+ return new SincResampler(*this);
+ }
+ }
+}
+
+void MultiChannelResampler::writeFrame(const float *frame) {
+ // Move cursor before write so that cursor points to last written frame in read.
+ if (--mCursor < 0) {
+ mCursor = getNumTaps() - 1;
+ }
+ float *dest = &mX[mCursor * getChannelCount()];
+ int offset = getNumTaps() * getChannelCount();
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ // Write twice so we avoid having to wrap when reading.
+ dest[channel] = dest[channel + offset] = frame[channel];
+ }
+}
+
+float MultiChannelResampler::sinc(float radians) {
+ if (abs(radians) < 1.0e-9) return 1.0f; // avoid divide by zero
+ return sinf(radians) / radians; // Sinc function
+}
+
+// Generate coefficients in the order they will be used by readFrame().
+// This is more complicated but readFrame() is called repeatedly and should be optimized.
+void MultiChannelResampler::generateCoefficients(int32_t inputRate,
+ int32_t outputRate,
+ int32_t numRows,
+ double phaseIncrement,
+ float normalizedCutoff) {
+ mCoefficients.resize(getNumTaps() * numRows);
+ int coefficientIndex = 0;
+ double phase = 0.0; // ranges from 0.0 to 1.0, fraction between samples
+ // Stretch the sinc function for low pass filtering.
+ const float cutoffScaler = normalizedCutoff *
+ ((outputRate < inputRate)
+ ? ((float)outputRate / inputRate)
+ : ((float)inputRate / outputRate));
+ const int numTapsHalf = getNumTaps() / 2; // numTaps must be even.
+ const float numTapsHalfInverse = 1.0f / numTapsHalf;
+ for (int i = 0; i < numRows; i++) {
+ float tapPhase = phase - numTapsHalf;
+ float gain = 0.0; // sum of raw coefficients
+ int gainCursor = coefficientIndex;
+ for (int tap = 0; tap < getNumTaps(); tap++) {
+ float radians = tapPhase * M_PI;
+
+#if MCR_USE_KAISER
+ float window = mKaiserWindow(tapPhase * numTapsHalfInverse);
+#else
+ float window = mCoshWindow(tapPhase * numTapsHalfInverse);
+#endif
+ float coefficient = sinc(radians * cutoffScaler) * window;
+ mCoefficients.at(coefficientIndex++) = coefficient;
+ gain += coefficient;
+ tapPhase += 1.0;
+ }
+ phase += phaseIncrement;
+ while (phase >= 1.0) {
+ phase -= 1.0;
+ }
+
+ // Correct for gain variations.
+ float gainCorrection = 1.0 / gain; // normalize the gain
+ for (int tap = 0; tap < getNumTaps(); tap++) {
+ mCoefficients.at(gainCursor + tap) *= gainCorrection;
+ }
+ }
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/MultiChannelResampler.h b/media/libaaudio/src/flowgraph/resampler/MultiChannelResampler.h
new file mode 100644
index 0000000..da79cad
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/MultiChannelResampler.h
@@ -0,0 +1,271 @@
+/*
+ * 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_MULTICHANNEL_RESAMPLER_H
+#define OBOE_MULTICHANNEL_RESAMPLER_H
+
+#include <memory>
+#include <vector>
+#include <sys/types.h>
+#include <unistd.h>
+
+#ifndef MCR_USE_KAISER
+// It appears from the spectrogram that the HyperbolicCosine window leads to fewer artifacts.
+// And it is faster to calculate.
+#define MCR_USE_KAISER 0
+#endif
+
+#if MCR_USE_KAISER
+#include "KaiserWindow.h"
+#else
+#include "HyperbolicCosineWindow.h"
+#endif
+
+namespace resampler {
+
+class MultiChannelResampler {
+
+public:
+
+ enum class Quality : int32_t {
+ Fastest,
+ Low,
+ Medium,
+ High,
+ Best,
+ };
+
+ class Builder {
+ public:
+ /**
+ * Construct an optimal resampler based on the specified parameters.
+ * @return address of a resampler
+ */
+ MultiChannelResampler *build();
+
+ /**
+ * The number of taps in the resampling filter.
+ * More taps gives better quality but uses more CPU time.
+ * This typically ranges from 4 to 64. Default is 16.
+ *
+ * For polyphase filters, numTaps must be a multiple of four for loop unrolling.
+ * @param numTaps number of taps for the filter
+ * @return address of this builder for chaining calls
+ */
+ Builder *setNumTaps(int32_t numTaps) {
+ mNumTaps = numTaps;
+ return this;
+ }
+
+ /**
+ * Use 1 for mono, 2 for stereo, etc. Default is 1.
+ *
+ * @param channelCount number of channels
+ * @return address of this builder for chaining calls
+ */
+ Builder *setChannelCount(int32_t channelCount) {
+ mChannelCount = channelCount;
+ return this;
+ }
+
+ /**
+ * Default is 48000.
+ *
+ * @param inputRate sample rate of the input stream
+ * @return address of this builder for chaining calls
+ */
+ Builder *setInputRate(int32_t inputRate) {
+ mInputRate = inputRate;
+ return this;
+ }
+
+ /**
+ * Default is 48000.
+ *
+ * @param outputRate sample rate of the output stream
+ * @return address of this builder for chaining calls
+ */
+ Builder *setOutputRate(int32_t outputRate) {
+ mOutputRate = outputRate;
+ return this;
+ }
+
+ /**
+ * Set cutoff frequency relative to the Nyquist rate of the output sample rate.
+ * Set to 1.0 to match the Nyquist frequency.
+ * Set lower to reduce aliasing.
+ * Default is 0.70.
+ *
+ * @param normalizedCutoff anti-aliasing filter cutoff
+ * @return address of this builder for chaining calls
+ */
+ Builder *setNormalizedCutoff(float normalizedCutoff) {
+ mNormalizedCutoff = normalizedCutoff;
+ return this;
+ }
+
+ int32_t getNumTaps() const {
+ return mNumTaps;
+ }
+
+ int32_t getChannelCount() const {
+ return mChannelCount;
+ }
+
+ int32_t getInputRate() const {
+ return mInputRate;
+ }
+
+ int32_t getOutputRate() const {
+ return mOutputRate;
+ }
+
+ float getNormalizedCutoff() const {
+ return mNormalizedCutoff;
+ }
+
+ protected:
+ int32_t mChannelCount = 1;
+ int32_t mNumTaps = 16;
+ int32_t mInputRate = 48000;
+ int32_t mOutputRate = 48000;
+ float mNormalizedCutoff = kDefaultNormalizedCutoff;
+ };
+
+ virtual ~MultiChannelResampler() = default;
+
+ /**
+ * Factory method for making a resampler that is optimal for the given inputs.
+ *
+ * @param channelCount number of channels, 2 for stereo
+ * @param inputRate sample rate of the input stream
+ * @param outputRate sample rate of the output stream
+ * @param quality higher quality sounds better but uses more CPU
+ * @return an optimal resampler
+ */
+ static MultiChannelResampler *make(int32_t channelCount,
+ int32_t inputRate,
+ int32_t outputRate,
+ Quality quality);
+
+ bool isWriteNeeded() const {
+ return mIntegerPhase >= mDenominator;
+ }
+
+ /**
+ * Write a frame containing N samples.
+ *
+ * @param frame pointer to the first sample in a frame
+ */
+ void writeNextFrame(const float *frame) {
+ writeFrame(frame);
+ advanceWrite();
+ }
+
+ /**
+ * Read a frame containing N samples.
+ *
+ * @param frame pointer to the first sample in a frame
+ */
+ void readNextFrame(float *frame) {
+ readFrame(frame);
+ advanceRead();
+ }
+
+ int getNumTaps() const {
+ return mNumTaps;
+ }
+
+ int getChannelCount() const {
+ return mChannelCount;
+ }
+
+ static float hammingWindow(float radians, float spread);
+
+ static float sinc(float radians);
+
+protected:
+
+ explicit MultiChannelResampler(const MultiChannelResampler::Builder &builder);
+
+ /**
+ * Write a frame containing N samples.
+ * Call advanceWrite() after calling this.
+ * @param frame pointer to the first sample in a frame
+ */
+ virtual void writeFrame(const float *frame);
+
+ /**
+ * Read a frame containing N samples using interpolation.
+ * Call advanceRead() after calling this.
+ * @param frame pointer to the first sample in a frame
+ */
+ virtual void readFrame(float *frame) = 0;
+
+ void advanceWrite() {
+ mIntegerPhase -= mDenominator;
+ }
+
+ void advanceRead() {
+ mIntegerPhase += mNumerator;
+ }
+
+ /**
+ * Generate the filter coefficients in optimal order.
+ * @param inputRate sample rate of the input stream
+ * @param outputRate sample rate of the output stream
+ * @param numRows number of rows in the array that contain a set of tap coefficients
+ * @param phaseIncrement how much to increment the phase between rows
+ * @param normalizedCutoff filter cutoff frequency normalized to Nyquist rate of output
+ */
+ void generateCoefficients(int32_t inputRate,
+ int32_t outputRate,
+ int32_t numRows,
+ double phaseIncrement,
+ float normalizedCutoff);
+
+
+ int32_t getIntegerPhase() {
+ return mIntegerPhase;
+ }
+
+ static constexpr int kMaxCoefficients = 8 * 1024;
+ std::vector<float> mCoefficients;
+
+ const int mNumTaps;
+ int mCursor = 0;
+ std::vector<float> mX; // delayed input values for the FIR
+ std::vector<float> mSingleFrame; // one frame for temporary use
+ int32_t mIntegerPhase = 0;
+ int32_t mNumerator = 0;
+ int32_t mDenominator = 0;
+
+
+private:
+
+#if MCR_USE_KAISER
+ KaiserWindow mKaiserWindow;
+#else
+ HyperbolicCosineWindow mCoshWindow;
+#endif
+
+ static constexpr float kDefaultNormalizedCutoff = 0.70f;
+
+ const int mChannelCount;
+};
+
+} // namespace resampler
+#endif //OBOE_MULTICHANNEL_RESAMPLER_H
diff --git a/media/libaaudio/src/flowgraph/resampler/PolyphaseResampler.cpp b/media/libaaudio/src/flowgraph/resampler/PolyphaseResampler.cpp
new file mode 100644
index 0000000..aa4ffd9
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/PolyphaseResampler.cpp
@@ -0,0 +1,60 @@
+/*
+ * 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 <cassert>
+#include <math.h>
+#include "IntegerRatio.h"
+#include "PolyphaseResampler.h"
+
+using namespace resampler;
+
+PolyphaseResampler::PolyphaseResampler(const MultiChannelResampler::Builder &builder)
+ : MultiChannelResampler(builder)
+ {
+ assert((getNumTaps() % 4) == 0); // Required for loop unrolling.
+
+ int32_t inputRate = builder.getInputRate();
+ int32_t outputRate = builder.getOutputRate();
+
+ int32_t numRows = mDenominator;
+ double phaseIncrement = (double) inputRate / (double) outputRate;
+ generateCoefficients(inputRate, outputRate,
+ numRows, phaseIncrement,
+ builder.getNormalizedCutoff());
+}
+
+void PolyphaseResampler::readFrame(float *frame) {
+ // Clear accumulator for mixing.
+ std::fill(mSingleFrame.begin(), mSingleFrame.end(), 0.0);
+
+ // Multiply input times windowed sinc function.
+ float *coefficients = &mCoefficients[mCoefficientCursor];
+ float *xFrame = &mX[mCursor * getChannelCount()];
+ for (int i = 0; i < mNumTaps; i++) {
+ float coefficient = *coefficients++;
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ mSingleFrame[channel] += *xFrame++ * coefficient;
+ }
+ }
+
+ // Advance and wrap through coefficients.
+ mCoefficientCursor = (mCoefficientCursor + mNumTaps) % mCoefficients.size();
+
+ // Copy accumulator to output.
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ frame[channel] = mSingleFrame[channel];
+ }
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/PolyphaseResampler.h b/media/libaaudio/src/flowgraph/resampler/PolyphaseResampler.h
new file mode 100644
index 0000000..1aeb680
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/PolyphaseResampler.h
@@ -0,0 +1,51 @@
+/*
+ * 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_POLYPHASE_RESAMPLER_H
+#define OBOE_POLYPHASE_RESAMPLER_H
+
+#include <memory>
+#include <vector>
+#include <sys/types.h>
+#include <unistd.h>
+#include "MultiChannelResampler.h"
+
+namespace resampler {
+/**
+ * Resampler that is optimized for a reduced ratio of sample rates.
+ * All of the coefficients for each possible phase value are pre-calculated.
+ */
+class PolyphaseResampler : public MultiChannelResampler {
+public:
+ /**
+ *
+ * @param builder containing lots of parameters
+ */
+ explicit PolyphaseResampler(const MultiChannelResampler::Builder &builder);
+
+ virtual ~PolyphaseResampler() = default;
+
+ void readFrame(float *frame) override;
+
+protected:
+
+ int32_t mCoefficientCursor = 0;
+
+};
+
+} // namespace resampler
+
+#endif //OBOE_POLYPHASE_RESAMPLER_H
diff --git a/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerMono.cpp b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerMono.cpp
new file mode 100644
index 0000000..c0e29b7
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerMono.cpp
@@ -0,0 +1,63 @@
+/*
+ * 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 <cassert>
+#include "PolyphaseResamplerMono.h"
+
+using namespace resampler;
+
+#define MONO 1
+
+PolyphaseResamplerMono::PolyphaseResamplerMono(const MultiChannelResampler::Builder &builder)
+ : PolyphaseResampler(builder) {
+ assert(builder.getChannelCount() == MONO);
+}
+
+void PolyphaseResamplerMono::writeFrame(const float *frame) {
+ // Move cursor before write so that cursor points to last written frame in read.
+ if (--mCursor < 0) {
+ mCursor = getNumTaps() - 1;
+ }
+ float *dest = &mX[mCursor * MONO];
+ const int offset = mNumTaps * MONO;
+ // Write each channel twice so we avoid having to wrap when running the FIR.
+ const float sample = frame[0];
+ // Put ordered writes together.
+ dest[0] = sample;
+ dest[offset] = sample;
+}
+
+void PolyphaseResamplerMono::readFrame(float *frame) {
+ // Clear accumulator.
+ float sum = 0.0;
+
+ // Multiply input times precomputed windowed sinc function.
+ const float *coefficients = &mCoefficients[mCoefficientCursor];
+ float *xFrame = &mX[mCursor * MONO];
+ const int numLoops = mNumTaps >> 2; // n/4
+ for (int i = 0; i < numLoops; i++) {
+ // Manual loop unrolling, might get converted to SIMD.
+ sum += *xFrame++ * *coefficients++;
+ sum += *xFrame++ * *coefficients++;
+ sum += *xFrame++ * *coefficients++;
+ sum += *xFrame++ * *coefficients++;
+ }
+
+ mCoefficientCursor = (mCoefficientCursor + mNumTaps) % mCoefficients.size();
+
+ // Copy accumulator to output.
+ frame[0] = sum;
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerMono.h b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerMono.h
new file mode 100644
index 0000000..0a691a3
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerMono.h
@@ -0,0 +1,39 @@
+/*
+ * 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_POLYPHASE_RESAMPLER_MONO_H
+#define OBOE_POLYPHASE_RESAMPLER_MONO_H
+
+#include <sys/types.h>
+#include <unistd.h>
+#include "PolyphaseResampler.h"
+
+namespace resampler {
+
+class PolyphaseResamplerMono : public PolyphaseResampler {
+public:
+ explicit PolyphaseResamplerMono(const MultiChannelResampler::Builder &builder);
+
+ virtual ~PolyphaseResamplerMono() = default;
+
+ void writeFrame(const float *frame) override;
+
+ void readFrame(float *frame) override;
+};
+
+} // namespace resampler
+
+#endif //OBOE_POLYPHASE_RESAMPLER_MONO_H
diff --git a/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerStereo.cpp b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerStereo.cpp
new file mode 100644
index 0000000..e4bef74
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerStereo.cpp
@@ -0,0 +1,79 @@
+/*
+ * 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 <cassert>
+#include "PolyphaseResamplerStereo.h"
+
+using namespace resampler;
+
+#define STEREO 2
+
+PolyphaseResamplerStereo::PolyphaseResamplerStereo(const MultiChannelResampler::Builder &builder)
+ : PolyphaseResampler(builder) {
+ assert(builder.getChannelCount() == STEREO);
+}
+
+void PolyphaseResamplerStereo::writeFrame(const float *frame) {
+ // Move cursor before write so that cursor points to last written frame in read.
+ if (--mCursor < 0) {
+ mCursor = getNumTaps() - 1;
+ }
+ float *dest = &mX[mCursor * STEREO];
+ const int offset = mNumTaps * STEREO;
+ // Write each channel twice so we avoid having to wrap when running the FIR.
+ const float left = frame[0];
+ const float right = frame[1];
+ // Put ordered writes together.
+ dest[0] = left;
+ dest[1] = right;
+ dest[offset] = left;
+ dest[1 + offset] = right;
+}
+
+void PolyphaseResamplerStereo::readFrame(float *frame) {
+ // Clear accumulators.
+ float left = 0.0;
+ float right = 0.0;
+
+ // Multiply input times precomputed windowed sinc function.
+ const float *coefficients = &mCoefficients[mCoefficientCursor];
+ float *xFrame = &mX[mCursor * STEREO];
+ const int numLoops = mNumTaps >> 2; // n/4
+ for (int i = 0; i < numLoops; i++) {
+ // Manual loop unrolling, might get converted to SIMD.
+ float coefficient = *coefficients++;
+ left += *xFrame++ * coefficient;
+ right += *xFrame++ * coefficient;
+
+ coefficient = *coefficients++; // next tap
+ left += *xFrame++ * coefficient;
+ right += *xFrame++ * coefficient;
+
+ coefficient = *coefficients++; // next tap
+ left += *xFrame++ * coefficient;
+ right += *xFrame++ * coefficient;
+
+ coefficient = *coefficients++; // next tap
+ left += *xFrame++ * coefficient;
+ right += *xFrame++ * coefficient;
+ }
+
+ mCoefficientCursor = (mCoefficientCursor + mNumTaps) % mCoefficients.size();
+
+ // Copy accumulators to output.
+ frame[0] = left;
+ frame[1] = right;
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerStereo.h b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerStereo.h
new file mode 100644
index 0000000..e608483
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/PolyphaseResamplerStereo.h
@@ -0,0 +1,39 @@
+/*
+ * 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_POLYPHASE_RESAMPLER_STEREO_H
+#define OBOE_POLYPHASE_RESAMPLER_STEREO_H
+
+#include <sys/types.h>
+#include <unistd.h>
+#include "PolyphaseResampler.h"
+
+namespace resampler {
+
+class PolyphaseResamplerStereo : public PolyphaseResampler {
+public:
+ explicit PolyphaseResamplerStereo(const MultiChannelResampler::Builder &builder);
+
+ virtual ~PolyphaseResamplerStereo() = default;
+
+ void writeFrame(const float *frame) override;
+
+ void readFrame(float *frame) override;
+};
+
+} // namespace resampler
+
+#endif //OBOE_POLYPHASE_RESAMPLER_STEREO_H
diff --git a/media/libaaudio/src/flowgraph/resampler/README.md b/media/libaaudio/src/flowgraph/resampler/README.md
new file mode 100644
index 0000000..05d8a89
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/README.md
@@ -0,0 +1,91 @@
+# Sample Rate Converter
+
+This folder contains a sample rate converter, or "resampler".
+
+The converter is based on a sinc function that has been windowed by a hyperbolic cosine.
+We found this had fewer artifacts than the more traditional Kaiser window.
+
+## Creating a Resampler
+
+Include the [main header](MultiChannelResampler.h) for the resampler.
+
+ #include "resampler/MultiChannelResampler.h"
+
+Here is an example of creating a stereo resampler that will convert from 44100 to 48000 Hz.
+Only do this once, when you open your stream. Then use the sample resampler to process multiple buffers.
+
+ MultiChannelResampler *resampler = MultiChannelResampler::make(
+ 2, // channel count
+ 44100, // input sampleRate
+ 48000, // output sampleRate
+ MultiChannelResampler::Quality::Medium); // conversion quality
+
+Possible values for quality include { Fastest, Low, Medium, High, Best }.
+Higher quality levels will sound better but consume more CPU because they have more taps in the filter.
+
+## Fractional Frame Counts
+
+Note that the number of output frames generated for a given number of input frames can vary.
+
+For example, suppose you are converting from 44100 Hz to 48000 Hz and using an input buffer with 960 frames. If you calculate the number of output frames you get:
+
+ 960 * 48000 * 44100 = 1044.897959...
+
+You cannot generate a fractional number of frames. So the resampler will sometimes generate 1044 frames and sometimes 1045 frames. On average it will generate 1044.897959 frames. The resampler stores the fraction internally and keeps track of when to consume or generate a frame.
+
+You can either use a fixed number of input frames or a fixed number of output frames. The other frame count will vary.
+
+## Calling the Resampler with a fixed number of OUTPUT frames
+
+In this example, suppose we have a fixed number of output frames and a variable number of input frames.
+
+Assume you start with these variables and a method that returns the next input frame:
+
+ float *outputBuffer; // multi-channel buffer to be filled
+ int numOutputFrames; // number of frames of output
+
+The resampler has a method isWriteNeeded() that tells you whether to write to or read from the resampler.
+
+ int outputFramesLeft = numOutputFrames;
+ while (outputFramesLeft > 0) {
+ if(resampler->isWriteNeeded()) {
+ const float *frame = getNextInputFrame(); // you provide this
+ resampler->writeNextFrame(frame);
+ } else {
+ resampler->readNextFrame(outputBuffer);
+ outputBuffer += channelCount;
+ outputFramesLeft--;
+ }
+ }
+
+## Calling the Resampler with a fixed number of INPUT frames
+
+In this example, suppose we have a fixed number of input frames and a variable number of output frames.
+
+Assume you start with these variables:
+
+ float *inputBuffer; // multi-channel buffer to be consumed
+ float *outputBuffer; // multi-channel buffer to be filled
+ int numInputFrames; // number of frames of input
+ int numOutputFrames = 0;
+ int channelCount; // 1 for mono, 2 for stereo
+
+ int inputFramesLeft = numInputFrames;
+ while (inputFramesLeft > 0) {
+ if(resampler->isWriteNeeded()) {
+ resampler->writeNextFrame(inputBuffer);
+ inputBuffer += channelCount;
+ inputFramesLeft--;
+ } else {
+ resampler->readNextFrame(outputBuffer);
+ outputBuffer += channelCount;
+ numOutputFrames++;
+ }
+ }
+
+## Deleting the Resampler
+
+When you are done, you should delete the Resampler to avoid a memory leak.
+
+ delete resampler;
+
diff --git a/media/libaaudio/src/flowgraph/resampler/SincResampler.cpp b/media/libaaudio/src/flowgraph/resampler/SincResampler.cpp
new file mode 100644
index 0000000..5e8a9e0
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/SincResampler.cpp
@@ -0,0 +1,76 @@
+/*
+ * 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 <cassert>
+#include <math.h>
+#include "SincResampler.h"
+
+using namespace resampler;
+
+SincResampler::SincResampler(const MultiChannelResampler::Builder &builder)
+ : MultiChannelResampler(builder)
+ , mSingleFrame2(builder.getChannelCount()) {
+ assert((getNumTaps() % 4) == 0); // Required for loop unrolling.
+ mNumRows = kMaxCoefficients / getNumTaps(); // no guard row needed
+ mPhaseScaler = (double) mNumRows / mDenominator;
+ double phaseIncrement = 1.0 / mNumRows;
+ generateCoefficients(builder.getInputRate(),
+ builder.getOutputRate(),
+ mNumRows,
+ phaseIncrement,
+ builder.getNormalizedCutoff());
+}
+
+void SincResampler::readFrame(float *frame) {
+ // Clear accumulator for mixing.
+ std::fill(mSingleFrame.begin(), mSingleFrame.end(), 0.0);
+ std::fill(mSingleFrame2.begin(), mSingleFrame2.end(), 0.0);
+
+ // Determine indices into coefficients table.
+ double tablePhase = getIntegerPhase() * mPhaseScaler;
+ int index1 = static_cast<int>(floor(tablePhase));
+ if (index1 >= mNumRows) { // no guard row needed because we wrap the indices
+ tablePhase -= mNumRows;
+ index1 -= mNumRows;
+ }
+
+ int index2 = index1 + 1;
+ if (index2 >= mNumRows) { // no guard row needed because we wrap the indices
+ index2 -= mNumRows;
+ }
+
+ float *coefficients1 = &mCoefficients[index1 * getNumTaps()];
+ float *coefficients2 = &mCoefficients[index2 * getNumTaps()];
+
+ float *xFrame = &mX[mCursor * getChannelCount()];
+ for (int i = 0; i < mNumTaps; i++) {
+ float coefficient1 = *coefficients1++;
+ float coefficient2 = *coefficients2++;
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ float sample = *xFrame++;
+ mSingleFrame[channel] += sample * coefficient1;
+ mSingleFrame2[channel] += sample * coefficient2;
+ }
+ }
+
+ // Interpolate and copy to output.
+ float fraction = tablePhase - index1;
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ float low = mSingleFrame[channel];
+ float high = mSingleFrame2[channel];
+ frame[channel] = low + (fraction * (high - low));
+ }
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/SincResampler.h b/media/libaaudio/src/flowgraph/resampler/SincResampler.h
new file mode 100644
index 0000000..b235188
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/SincResampler.h
@@ -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.
+ */
+
+#ifndef OBOE_SINC_RESAMPLER_H
+#define OBOE_SINC_RESAMPLER_H
+
+#include <memory>
+#include <sys/types.h>
+#include <unistd.h>
+#include "MultiChannelResampler.h"
+
+namespace resampler {
+
+/**
+ * Resampler that can interpolate between coefficients.
+ * This can be used to support arbitrary ratios.
+ */
+class SincResampler : public MultiChannelResampler {
+public:
+ explicit SincResampler(const MultiChannelResampler::Builder &builder);
+
+ virtual ~SincResampler() = default;
+
+ void readFrame(float *frame) override;
+
+protected:
+
+ std::vector<float> mSingleFrame2; // for interpolation
+ int32_t mNumRows = 0;
+ double mPhaseScaler = 1.0;
+};
+
+} // namespace resampler
+#endif //OBOE_SINC_RESAMPLER_H
diff --git a/media/libaaudio/src/flowgraph/resampler/SincResamplerStereo.cpp b/media/libaaudio/src/flowgraph/resampler/SincResamplerStereo.cpp
new file mode 100644
index 0000000..ce00302
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/SincResamplerStereo.cpp
@@ -0,0 +1,81 @@
+/*
+ * 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 <cassert>
+#include <math.h>
+
+#include "SincResamplerStereo.h"
+
+using namespace resampler;
+
+#define STEREO 2
+
+SincResamplerStereo::SincResamplerStereo(const MultiChannelResampler::Builder &builder)
+ : SincResampler(builder) {
+ assert(builder.getChannelCount() == STEREO);
+}
+
+void SincResamplerStereo::writeFrame(const float *frame) {
+ // Move cursor before write so that cursor points to last written frame in read.
+ if (--mCursor < 0) {
+ mCursor = getNumTaps() - 1;
+ }
+ float *dest = &mX[mCursor * STEREO];
+ const int offset = mNumTaps * STEREO;
+ // Write each channel twice so we avoid having to wrap when running the FIR.
+ const float left = frame[0];
+ const float right = frame[1];
+ // Put ordered writes together.
+ dest[0] = left;
+ dest[1] = right;
+ dest[offset] = left;
+ dest[1 + offset] = right;
+}
+
+// Multiply input times windowed sinc function.
+void SincResamplerStereo::readFrame(float *frame) {
+ // Clear accumulator for mixing.
+ std::fill(mSingleFrame.begin(), mSingleFrame.end(), 0.0);
+ std::fill(mSingleFrame2.begin(), mSingleFrame2.end(), 0.0);
+
+ // Determine indices into coefficients table.
+ double tablePhase = getIntegerPhase() * mPhaseScaler;
+ int index1 = static_cast<int>(floor(tablePhase));
+ float *coefficients1 = &mCoefficients[index1 * getNumTaps()];
+ int index2 = (index1 + 1);
+ if (index2 >= mNumRows) { // no guard row needed because we wrap the indices
+ index2 = 0;
+ }
+ float *coefficients2 = &mCoefficients[index2 * getNumTaps()];
+ float *xFrame = &mX[mCursor * getChannelCount()];
+ for (int i = 0; i < mNumTaps; i++) {
+ float coefficient1 = *coefficients1++;
+ float coefficient2 = *coefficients2++;
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ float sample = *xFrame++;
+ mSingleFrame[channel] += sample * coefficient1;
+ mSingleFrame2[channel] += sample * coefficient2;
+ }
+ }
+
+ // Interpolate and copy to output.
+ float fraction = tablePhase - index1;
+ for (int channel = 0; channel < getChannelCount(); channel++) {
+ float low = mSingleFrame[channel];
+ float high = mSingleFrame2[channel];
+ frame[channel] = low + (fraction * (high - low));
+ }
+}
diff --git a/media/libaaudio/src/flowgraph/resampler/SincResamplerStereo.h b/media/libaaudio/src/flowgraph/resampler/SincResamplerStereo.h
new file mode 100644
index 0000000..7d49ec7
--- /dev/null
+++ b/media/libaaudio/src/flowgraph/resampler/SincResamplerStereo.h
@@ -0,0 +1,39 @@
+/*
+ * 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_SINC_RESAMPLER_STEREO_H
+#define OBOE_SINC_RESAMPLER_STEREO_H
+
+#include <sys/types.h>
+#include <unistd.h>
+#include "SincResampler.h"
+
+namespace resampler {
+
+class SincResamplerStereo : public SincResampler {
+public:
+ explicit SincResamplerStereo(const MultiChannelResampler::Builder &builder);
+
+ virtual ~SincResamplerStereo() = default;
+
+ void writeFrame(const float *frame) override;
+
+ void readFrame(float *frame) override;
+
+};
+
+} // namespace resampler
+#endif //OBOE_SINC_RESAMPLER_STEREO_H