--- a/dom/media/AudioBufferUtils.h
+++ b/dom/media/AudioBufferUtils.h
@@ -24,55 +24,59 @@ static inline uint32_t SamplesToFrames(u
return aSamples / aChannels;
}
/**
* Class that gets a buffer pointer from an audio callback and provides a safe
* interface to manipulate this buffer, and to ensure we are not missing frames
* by the end of the callback.
*/
-template<typename T, uint32_t CHANNELS>
+template<typename T>
class AudioCallbackBufferWrapper
{
public:
- AudioCallbackBufferWrapper()
+ explicit AudioCallbackBufferWrapper(uint32_t aChannels)
: mBuffer(nullptr),
mSamples(0),
- mSampleWriteOffset(1)
- {}
+ mSampleWriteOffset(1),
+ mChannels(aChannels)
+
+ {
+ MOZ_ASSERT(aChannels);
+ }
/**
* Set the buffer in this wrapper. This is to be called at the beginning of
* the callback.
*/
void SetBuffer(T* aBuffer, uint32_t aFrames) {
MOZ_ASSERT(!mBuffer && !mSamples,
"SetBuffer called twice.");
mBuffer = aBuffer;
- mSamples = FramesToSamples(CHANNELS, aFrames);
+ mSamples = FramesToSamples(mChannels, aFrames);
mSampleWriteOffset = 0;
}
/**
* Write some frames to the internal buffer. Free space in the buffer should
* be check prior to calling this.
*/
void WriteFrames(T* aBuffer, uint32_t aFrames) {
MOZ_ASSERT(aFrames <= Available(),
"Writing more that we can in the audio buffer.");
- PodCopy(mBuffer + mSampleWriteOffset, aBuffer, FramesToSamples(CHANNELS,
+ PodCopy(mBuffer + mSampleWriteOffset, aBuffer, FramesToSamples(mChannels,
aFrames));
- mSampleWriteOffset += FramesToSamples(CHANNELS, aFrames);
+ mSampleWriteOffset += FramesToSamples(mChannels, aFrames);
}
/**
* Number of frames that can be written to the buffer.
*/
uint32_t Available() {
- return SamplesToFrames(CHANNELS, mSamples - mSampleWriteOffset);
+ return SamplesToFrames(mChannels, mSamples - mSampleWriteOffset);
}
/**
* Check that the buffer is completly filled, and reset internal state so this
* instance can be reused.
*/
void BufferFilled() {
// It's okay to have exactly zero samples here, it can happen we have an
@@ -83,84 +87,92 @@ public:
// all the streams were ended (no mixer callback occured).
// XXX Remove this warning, or find a way to avoid it if the mixer callback
// isn't called.
NS_WARNING_ASSERTION(
Available() == 0 || mSampleWriteOffset == 0,
"Audio Buffer is not full by the end of the callback.");
// Make sure the data returned is always set and not random!
if (Available()) {
- PodZero(mBuffer + mSampleWriteOffset, FramesToSamples(CHANNELS, Available()));
+ PodZero(mBuffer + mSampleWriteOffset, FramesToSamples(mChannels, Available()));
}
MOZ_ASSERT(mSamples, "Buffer not set.");
mSamples = 0;
mSampleWriteOffset = 0;
mBuffer = nullptr;
}
private:
/* This is not an owned pointer, but the pointer passed to use via the audio
* callback. */
T* mBuffer;
/* The number of samples of this audio buffer. */
uint32_t mSamples;
/* The position at which new samples should be written. We want to return to
* the audio callback iff this is equal to mSamples. */
uint32_t mSampleWriteOffset;
+ uint32_t const mChannels;
};
/**
* This is a class that interfaces with the AudioCallbackBufferWrapper, and is
* responsible for storing the excess of data produced by the MediaStreamGraph
* because of different rounding constraints, to be used the next time the audio
* backend calls back.
*/
-template<typename T, uint32_t BLOCK_SIZE, uint32_t CHANNELS>
+template<typename T, uint32_t BLOCK_SIZE>
class SpillBuffer
{
public:
- SpillBuffer()
+ explicit SpillBuffer(uint32_t aChannels)
: mPosition(0)
+ , mChannels(aChannels)
{
- PodArrayZero(mBuffer);
+ MOZ_ASSERT(aChannels);
+ mBuffer = MakeUnique<T[]>(BLOCK_SIZE * mChannels);
+ PodZero(mBuffer.get(), BLOCK_SIZE * mChannels);
}
+
/* Empty the spill buffer into the buffer of the audio callback. This returns
* the number of frames written. */
- uint32_t Empty(AudioCallbackBufferWrapper<T, CHANNELS>& aBuffer) {
+ uint32_t Empty(AudioCallbackBufferWrapper<T>& aBuffer) {
uint32_t framesToWrite = std::min(aBuffer.Available(),
- SamplesToFrames(CHANNELS, mPosition));
+ SamplesToFrames(mChannels, mPosition));
- aBuffer.WriteFrames(mBuffer, framesToWrite);
+ aBuffer.WriteFrames(mBuffer.get(), framesToWrite);
- mPosition -= FramesToSamples(CHANNELS, framesToWrite);
+ mPosition -= FramesToSamples(mChannels, framesToWrite);
// If we didn't empty the spill buffer for some reason, shift the remaining data down
if (mPosition > 0) {
- PodMove(mBuffer, mBuffer + FramesToSamples(CHANNELS, framesToWrite),
+ MOZ_ASSERT(FramesToSamples(mChannels, framesToWrite) + mPosition <= BLOCK_SIZE * mChannels);
+ PodMove(mBuffer.get(), mBuffer.get() + FramesToSamples(mChannels, framesToWrite),
mPosition);
}
return framesToWrite;
}
/* Fill the spill buffer from aInput, containing aFrames frames, return the
* number of frames written to the spill buffer */
uint32_t Fill(T* aInput, uint32_t aFrames) {
uint32_t framesToWrite = std::min(aFrames,
- BLOCK_SIZE - SamplesToFrames(CHANNELS,
+ BLOCK_SIZE - SamplesToFrames(mChannels,
mPosition));
- PodCopy(mBuffer + mPosition, aInput, FramesToSamples(CHANNELS,
+ MOZ_ASSERT(FramesToSamples(mChannels, framesToWrite) + mPosition <= BLOCK_SIZE * mChannels);
+ PodCopy(mBuffer.get() + mPosition, aInput, FramesToSamples(mChannels,
framesToWrite));
- mPosition += FramesToSamples(CHANNELS, framesToWrite);
+ mPosition += FramesToSamples(mChannels, framesToWrite);
return framesToWrite;
}
private:
/* The spilled data. */
- T mBuffer[BLOCK_SIZE * CHANNELS];
+ UniquePtr<T[]> mBuffer;
/* The current write position, in samples, in the buffer when filling, or the
* amount of buffer filled when emptying. */
uint32_t mPosition;
+ uint32_t const mChannels;
};
} // namespace mozilla
#endif // MOZILLA_SCRATCHBUFFER_H_--- a/dom/media/GraphDriver.cpp
+++ b/dom/media/GraphDriver.cpp
@@ -555,16 +555,19 @@ StreamAndPromiseForOperation::StreamAndP
, mPromise(aPromise)
, mOperation(aOperation)
{
// MOZ_ASSERT(aPromise);
}
AudioCallbackDriver::AudioCallbackDriver(MediaStreamGraphImpl* aGraphImpl)
: GraphDriver(aGraphImpl)
+ , mOuputChannels(mGraphImpl->AudioChannelCount())
+ , mScratchBuffer(mOuputChannels)
+ , mBuffer(mOuputChannels)
, mSampleRate(0)
, mInputChannels(1)
, mIterationDurationMS(MEDIA_GRAPH_TARGET_PERIOD_MS)
, mStarted(false)
, mAudioInput(nullptr)
, mAddedMixer(false)
, mInCallback(false)
, mMicrophoneActive(false)
@@ -621,25 +624,24 @@ AudioCallbackDriver::Init()
uint32_t latency_frames;
bool firstStream = CubebUtils::GetFirstStream();
MOZ_ASSERT(!NS_IsMainThread(),
"This is blocking and should never run on the main thread.");
mSampleRate = output.rate = CubebUtils::PreferredSampleRate();
- output.channels = mGraphImpl->AudioChannelCount();
if (AUDIO_OUTPUT_FORMAT == AUDIO_FORMAT_S16) {
output.format = CUBEB_SAMPLE_S16NE;
} else {
output.format = CUBEB_SAMPLE_FLOAT32NE;
}
- // Graphs are always stereo for now.
- output.layout = CUBEB_LAYOUT_STEREO;
+ output.channels = mOuputChannels;
+ output.layout = CUBEB_LAYOUT_UNDEFINED;
Maybe<uint32_t> latencyPref = CubebUtils::GetCubebMSGLatencyInFrames();
if (latencyPref) {
latency_frames = latencyPref.value();
} else {
if (cubeb_get_min_latency(cubebContext, &output, &latency_frames) != CUBEB_OK) {
NS_WARNING("Could not get minimal latency from cubeb.");
}
@@ -918,17 +920,17 @@ AudioCallbackDriver::DataCallback(const
GraphTime stateComputedTime = StateComputedTime();
if (stateComputedTime == 0) {
MonitorAutoLock mon(mGraphImpl->GetMonitor());
// Because this function is called during cubeb_stream_init (to prefill the
// audio buffers), it can be that we don't have a message here (because this
// driver is the first one for this graph), and the graph would exit. Simply
// return here until we have messages.
if (!mGraphImpl->MessagesQueued()) {
- PodZero(aOutputBuffer, aFrames * mGraphImpl->AudioChannelCount());
+ PodZero(aOutputBuffer, aFrames * mOuputChannels);
return aFrames;
}
mGraphImpl->SwapMessageQueues();
}
uint32_t durationMS = aFrames * 1000 / mSampleRate;
// For now, simply average the duration with the previous
@@ -1005,17 +1007,17 @@ AudioCallbackDriver::DataCallback(const
mBuffer.BufferFilled();
// Callback any observers for the AEC speaker data. Note that one
// (maybe) of these will be full-duplex, the others will get their input
// data off separate cubeb callbacks. Take care with how stuff is
// removed/added to this list and TSAN issues, but input and output will
// use separate callback methods.
mGraphImpl->NotifyOutputData(aOutputBuffer, static_cast<size_t>(aFrames),
- mSampleRate, ChannelCount);
+ mSampleRate, mOuputChannels);
bool switching = false;
{
MonitorAutoLock mon(mGraphImpl->GetMonitor());
switching = !!NextDriver();
}
if (switching && stillProcessing) {--- a/dom/media/GraphDriver.h
+++ b/dom/media/GraphDriver.h
@@ -465,28 +465,28 @@ private:
void PanOutputIfNeeded(bool aMicrophoneActive);
/**
* This is called when the output device used by the cubeb stream changes. */
void DeviceChangedCallback();
/* Start the cubeb stream */
bool StartStream();
friend class AsyncCubebTask;
bool Init();
- /* MediaStreamGraphs are always down/up mixed to stereo for now. */
- static const uint32_t ChannelCount = 2;
+ /* MediaStreamGraphs are always down/up mixed to output channels. */
+ uint32_t mOuputChannels;
/* The size of this buffer comes from the fact that some audio backends can
* call back with a number of frames lower than one block (128 frames), so we
* need to keep at most two block in the SpillBuffer, because we always round
* up to block boundaries during an iteration.
* This is only ever accessed on the audio callback thread. */
- SpillBuffer<AudioDataValue, WEBAUDIO_BLOCK_SIZE * 2, ChannelCount> mScratchBuffer;
+ SpillBuffer<AudioDataValue, WEBAUDIO_BLOCK_SIZE * 2> mScratchBuffer;
/* Wrapper to ensure we write exactly the number of frames we need in the
* audio buffer cubeb passes us. This is only ever accessed on the audio
* callback thread. */
- AudioCallbackBufferWrapper<AudioDataValue, ChannelCount> mBuffer;
+ AudioCallbackBufferWrapper<AudioDataValue> mBuffer;
/* cubeb stream for this graph. This is guaranteed to be non-null after Init()
* has been called, and is synchronized internaly. */
nsAutoRef<cubeb_stream> mAudioStream;
/* The sample rate for the aforementionned cubeb stream. This is set on
* initialization and can be read safely afterwards. */
uint32_t mSampleRate;
/* The number of input channels from cubeb. Should be set before opening cubeb
* and then be static. */--- a/dom/media/MediaStreamGraphImpl.h
+++ b/dom/media/MediaStreamGraphImpl.h
@@ -448,18 +448,20 @@ public:
/**
* Mark the media stream order as dirty.
*/
void SetStreamOrderDirty()
{
mStreamOrderDirty = true;
}
- // Always stereo for now.
- uint32_t AudioChannelCount() const { return 2; }
+ uint32_t AudioChannelCount() const
+ {
+ return std::min<uint32_t>(8, CubebUtils::MaxNumberOfChannels());
+ }
double MediaTimeToSeconds(GraphTime aTime) const
{
NS_ASSERTION(aTime > -STREAM_TIME_MAX && aTime <= STREAM_TIME_MAX,
"Bad time");
return static_cast<double>(aTime)/GraphRate();
}
--- a/dom/media/gtest/TestAudioBuffers.cpp
+++ b/dom/media/gtest/TestAudioBuffers.cpp
@@ -1,57 +1,60 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdint.h>
#include "AudioBufferUtils.h"
#include "gtest/gtest.h"
+#include <vector>
const uint32_t FRAMES = 256;
-const uint32_t CHANNELS = 2;
-const uint32_t SAMPLES = CHANNELS * FRAMES;
-TEST(AudioBuffers, Test)
+void test_for_number_of_channels(const uint32_t channels)
{
- mozilla::AudioCallbackBufferWrapper<float, CHANNELS> mBuffer;
- mozilla::SpillBuffer<float, 128, CHANNELS> b;
- float fromCallback[SAMPLES];
- float other[SAMPLES];
+ const uint32_t samples = channels * FRAMES;
- for (uint32_t i = 0; i < SAMPLES; i++) {
- other[i] = 1.0;
- fromCallback[i] = 0.0;
- }
+ mozilla::AudioCallbackBufferWrapper<float> mBuffer(channels);
+ mozilla::SpillBuffer<float, 128> b(channels);
+ std::vector<float> fromCallback(samples, 0.0);
+ std::vector<float> other(samples, 1.0);
// Set the buffer in the wrapper from the callback
- mBuffer.SetBuffer(fromCallback, FRAMES);
+ mBuffer.SetBuffer(fromCallback.data(), FRAMES);
// Fill the SpillBuffer with data.
- ASSERT_TRUE(b.Fill(other, 15) == 15);
- ASSERT_TRUE(b.Fill(other, 17) == 17);
- for (uint32_t i = 0; i < 32 * CHANNELS; i++) {
+ ASSERT_TRUE(b.Fill(other.data(), 15) == 15);
+ ASSERT_TRUE(b.Fill(other.data(), 17) == 17);
+ for (uint32_t i = 0; i < 32 * channels; i++) {
other[i] = 0.0;
}
// Empty it in the AudioCallbackBufferWrapper
ASSERT_TRUE(b.Empty(mBuffer) == 32);
// Check available return something reasonnable
ASSERT_TRUE(mBuffer.Available() == FRAMES - 32);
// Fill the buffer with the rest of the data
- mBuffer.WriteFrames(other + 32 * CHANNELS, FRAMES - 32);
+ mBuffer.WriteFrames(other.data() + 32 * channels, FRAMES - 32);
// Check the buffer is now full
ASSERT_TRUE(mBuffer.Available() == 0);
- for (uint32_t i = 0 ; i < SAMPLES; i++) {
+ for (uint32_t i = 0 ; i < samples; i++) {
ASSERT_TRUE(fromCallback[i] == 1.0) <<
"Difference at " << i << " (" << fromCallback[i] << " != " << 1.0 <<
")\n";
}
- ASSERT_TRUE(b.Fill(other, FRAMES) == 128);
- ASSERT_TRUE(b.Fill(other, FRAMES) == 0);
+ ASSERT_TRUE(b.Fill(other.data(), FRAMES) == 128);
+ ASSERT_TRUE(b.Fill(other.data(), FRAMES) == 0);
ASSERT_TRUE(b.Empty(mBuffer) == 0);
}
+
+TEST(AudioBuffers, Test)
+{
+ for (uint32_t ch = 1; ch <= 8; ++ch) {
+ test_for_number_of_channels(ch);
+ }
+}--- a/dom/media/webaudio/AudioContext.cpp
+++ b/dom/media/webaudio/AudioContext.cpp
@@ -200,18 +200,20 @@ AudioContext::Constructor(const GlobalOb
ErrorResult& aRv)
{
nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal.GetAsSupports());
if (!window) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
+ uint32_t maxChannelCount = std::min<uint32_t>(WebAudioUtils::MaxChannelCount,
+ CubebUtils::MaxNumberOfChannels());
RefPtr<AudioContext> object =
- new AudioContext(window, false);
+ new AudioContext(window, false,maxChannelCount);
aRv = object->Init();
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
RegisterWeakMemoryReporter(object);
return object.forget();
@@ -617,17 +619,18 @@ AudioContext::UpdatePannerSource()
for (auto iter = mPannerNodes.Iter(); !iter.Done(); iter.Next()) {
iter.Get()->GetKey()->FindConnectedSources();
}
}
uint32_t
AudioContext::MaxChannelCount() const
{
- return mIsOffline ? mNumberOfChannels : CubebUtils::MaxNumberOfChannels();
+ return std::min<uint32_t>(WebAudioUtils::MaxChannelCount,
+ mIsOffline ? mNumberOfChannels : CubebUtils::MaxNumberOfChannels());
}
uint32_t
AudioContext::ActiveNodeCount() const
{
return mActiveNodes.Count();
}
--- a/dom/media/webaudio/AudioDestinationNode.cpp
+++ b/dom/media/webaudio/AudioDestinationNode.cpp
@@ -320,17 +320,17 @@ NS_INTERFACE_MAP_END_INHERITING(AudioNod
NS_IMPL_ADDREF_INHERITED(AudioDestinationNode, AudioNode)
NS_IMPL_RELEASE_INHERITED(AudioDestinationNode, AudioNode)
AudioDestinationNode::AudioDestinationNode(AudioContext* aContext,
bool aIsOffline,
uint32_t aNumberOfChannels,
uint32_t aLength, float aSampleRate)
- : AudioNode(aContext, aIsOffline ? aNumberOfChannels : 2,
+ : AudioNode(aContext, aNumberOfChannels,
ChannelCountMode::Explicit, ChannelInterpretation::Speakers)
, mFramesToProduce(aLength)
, mIsOffline(aIsOffline)
, mAudioChannelSuspended(false)
, mCaptured(false)
, mAudible(AudioChannelService::AudibleState::eAudible)
{
nsPIDOMWindowInner* window = aContext->GetParentObject();--- a/dom/media/webrtc/AudioOutputObserver.h
+++ b/dom/media/webrtc/AudioOutputObserver.h
@@ -3,16 +3,17 @@
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef AUDIOOUTPUTOBSERVER_H_
#define AUDIOOUTPUTOBSERVER_H_
#include "mozilla/StaticPtr.h"
#include "nsAutoPtr.h"
#include "AudioMixer.h"
+#include "MediaData.h"
namespace webrtc {
class SingleRwFifo;
}
namespace mozilla {
typedef struct FarEndAudioChunk_ {
@@ -45,15 +46,16 @@ private:
uint32_t mPlayoutChannels;
nsAutoPtr<webrtc::SingleRwFifo> mPlayoutFifo;
uint32_t mChunkSize;
// chunking to 10ms support
FarEndAudioChunk *mSaved; // can't be nsAutoPtr since we need to use free(), not delete
uint32_t mSamplesSaved;
+ AlignedAudioBuffer mDownmixBuffer;
};
extern StaticRefPtr<AudioOutputObserver> gFarendObserver;
}
#endif--- a/dom/media/webrtc/MediaEngineWebRTCAudio.cpp
+++ b/dom/media/webrtc/MediaEngineWebRTCAudio.cpp
@@ -4,16 +4,17 @@
#include "MediaEngineWebRTC.h"
#include <stdio.h>
#include <algorithm>
#include "mozilla/Assertions.h"
#include "MediaTrackConstraints.h"
#include "mtransport/runnable_utils.h"
#include "nsAutoPtr.h"
+#include "AudioConverter.h"
// scoped_ptr.h uses FF
#ifdef FF
#undef FF
#endif
#include "webrtc/modules/audio_device/opensl/single_rw_fifo.h"
#define CHANNELS 1
@@ -58,16 +59,17 @@ ScopedCustomReleasePtr<webrtc::VoENetwor
ScopedCustomReleasePtr<webrtc::VoEAudioProcessing> MediaEngineWebRTCMicrophoneSource::mVoEProcessing;
AudioOutputObserver::AudioOutputObserver()
: mPlayoutFreq(0)
, mPlayoutChannels(0)
, mChunkSize(0)
, mSaved(nullptr)
, mSamplesSaved(0)
+ , mDownmixBuffer(MAX_SAMPLING_FREQ * MAX_CHANNELS / 100)
{
// Buffers of 10ms chunks
mPlayoutFifo = new webrtc::SingleRwFifo(MAX_AEC_FIFO_DEPTH/10);
}
AudioOutputObserver::~AudioOutputObserver()
{
Clear();
@@ -96,23 +98,29 @@ AudioOutputObserver::Size()
return mPlayoutFifo->size();
}
// static
void
AudioOutputObserver::InsertFarEnd(const AudioDataValue *aBuffer, uint32_t aFrames, bool aOverran,
int aFreq, int aChannels)
{
+ // Prepare for downmix if needed
+ int channels = aChannels;
+ if (aChannels > MAX_CHANNELS) {
+ channels = MAX_CHANNELS;
+ }
+
if (mPlayoutChannels != 0) {
- if (mPlayoutChannels != static_cast<uint32_t>(aChannels)) {
+ if (mPlayoutChannels != static_cast<uint32_t>(channels)) {
MOZ_CRASH();
}
} else {
- MOZ_ASSERT(aChannels <= MAX_CHANNELS);
- mPlayoutChannels = static_cast<uint32_t>(aChannels);
+ MOZ_ASSERT(channels <= MAX_CHANNELS);
+ mPlayoutChannels = static_cast<uint32_t>(channels);
}
if (mPlayoutFreq != 0) {
if (mPlayoutFreq != static_cast<uint32_t>(aFreq)) {
MOZ_CRASH();
}
} else {
MOZ_ASSERT(aFreq <= MAX_SAMPLING_FREQ);
MOZ_ASSERT(!(aFreq % 100), "Sampling rate for far end data should be multiple of 100.");
@@ -130,28 +138,34 @@ AudioOutputObserver::InsertFarEnd(const
aOverran = false;
}
// Rechunk to 10ms.
// The AnalyzeReverseStream() and WebRtcAec_BufferFarend() functions insist on 10ms
// samples per call. Annoying...
while (aFrames) {
if (!mSaved) {
mSaved = (FarEndAudioChunk *) moz_xmalloc(sizeof(FarEndAudioChunk) +
- (mChunkSize * aChannels - 1)*sizeof(int16_t));
+ (mChunkSize * channels - 1)*sizeof(int16_t));
mSaved->mSamples = mChunkSize;
mSaved->mOverrun = aOverran;
aOverran = false;
}
uint32_t to_copy = mChunkSize - mSamplesSaved;
if (to_copy > aFrames) {
to_copy = aFrames;
}
- int16_t *dest = &(mSaved->mData[mSamplesSaved * aChannels]);
- ConvertAudioSamples(aBuffer, dest, to_copy * aChannels);
+ int16_t* dest = &(mSaved->mData[mSamplesSaved * channels]);
+ if (aChannels > MAX_CHANNELS) {
+ AudioConverter converter(AudioConfig(aChannels, 0), AudioConfig(channels, 0));
+ converter.Process(mDownmixBuffer, aBuffer, to_copy);
+ ConvertAudioSamples(mDownmixBuffer.Data(), dest, to_copy * channels);
+ } else {
+ ConvertAudioSamples(aBuffer, dest, to_copy * channels);
+ }
#ifdef LOG_FAREND_INSERTION
if (fp) {
fwrite(&(mSaved->mData[mSamplesSaved * aChannels]), to_copy * aChannels, sizeof(int16_t), fp);
}
#endif
aFrames -= to_copy;
mSamplesSaved += to_copy;