mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
218 lines
7.5 KiB
C++
218 lines
7.5 KiB
C++
|
/* -*- 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 "AudioSegment.h"
|
||
|
|
||
|
#include "AudioMixer.h"
|
||
|
#include "AudioChannelFormat.h"
|
||
|
#include "Latency.h"
|
||
|
#include <speex/speex_resampler.h>
|
||
|
|
||
|
namespace mozilla {
|
||
|
|
||
|
const uint8_t SilentChannel::gZeroChannel[MAX_AUDIO_SAMPLE_SIZE*SilentChannel::AUDIO_PROCESSING_FRAMES] = {0};
|
||
|
|
||
|
template<>
|
||
|
const float* SilentChannel::ZeroChannel<float>()
|
||
|
{
|
||
|
return reinterpret_cast<const float*>(SilentChannel::gZeroChannel);
|
||
|
}
|
||
|
|
||
|
template<>
|
||
|
const int16_t* SilentChannel::ZeroChannel<int16_t>()
|
||
|
{
|
||
|
return reinterpret_cast<const int16_t*>(SilentChannel::gZeroChannel);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
AudioSegment::ApplyVolume(float aVolume)
|
||
|
{
|
||
|
for (ChunkIterator ci(*this); !ci.IsEnded(); ci.Next()) {
|
||
|
ci->mVolume *= aVolume;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void AudioSegment::ResampleChunks(SpeexResamplerState* aResampler, uint32_t aInRate, uint32_t aOutRate)
|
||
|
{
|
||
|
if (mChunks.IsEmpty()) {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
MOZ_ASSERT(aResampler || IsNull(), "We can only be here without a resampler if this segment is null.");
|
||
|
|
||
|
AudioSampleFormat format = AUDIO_FORMAT_SILENCE;
|
||
|
for (ChunkIterator ci(*this); !ci.IsEnded(); ci.Next()) {
|
||
|
if (ci->mBufferFormat != AUDIO_FORMAT_SILENCE) {
|
||
|
format = ci->mBufferFormat;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
switch (format) {
|
||
|
// If the format is silence at this point, all the chunks are silent. The
|
||
|
// actual function we use does not matter, it's just a matter of changing
|
||
|
// the chunks duration.
|
||
|
case AUDIO_FORMAT_SILENCE:
|
||
|
case AUDIO_FORMAT_FLOAT32:
|
||
|
Resample<float>(aResampler, aInRate, aOutRate);
|
||
|
break;
|
||
|
case AUDIO_FORMAT_S16:
|
||
|
Resample<int16_t>(aResampler, aInRate, aOutRate);
|
||
|
break;
|
||
|
default:
|
||
|
MOZ_ASSERT(false);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// This helps to to safely get a pointer to the position we want to start
|
||
|
// writing a planar audio buffer, depending on the channel and the offset in the
|
||
|
// buffer.
|
||
|
static AudioDataValue*
|
||
|
PointerForOffsetInChannel(AudioDataValue* aData, size_t aLengthSamples,
|
||
|
uint32_t aChannelCount, uint32_t aChannel,
|
||
|
uint32_t aOffsetSamples)
|
||
|
{
|
||
|
size_t samplesPerChannel = aLengthSamples / aChannelCount;
|
||
|
size_t beginningOfChannel = samplesPerChannel * aChannel;
|
||
|
MOZ_ASSERT(aChannel * samplesPerChannel + aOffsetSamples < aLengthSamples,
|
||
|
"Offset request out of bounds.");
|
||
|
return aData + beginningOfChannel + aOffsetSamples;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
AudioSegment::Mix(AudioMixer& aMixer, uint32_t aOutputChannels,
|
||
|
uint32_t aSampleRate)
|
||
|
{
|
||
|
nsAutoTArray<AudioDataValue, SilentChannel::AUDIO_PROCESSING_FRAMES* GUESS_AUDIO_CHANNELS>
|
||
|
buf;
|
||
|
nsAutoTArray<const AudioDataValue*, GUESS_AUDIO_CHANNELS> channelData;
|
||
|
uint32_t offsetSamples = 0;
|
||
|
uint32_t duration = GetDuration();
|
||
|
|
||
|
if (duration <= 0) {
|
||
|
MOZ_ASSERT(duration == 0);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
uint32_t outBufferLength = duration * aOutputChannels;
|
||
|
buf.SetLength(outBufferLength);
|
||
|
|
||
|
for (ChunkIterator ci(*this); !ci.IsEnded(); ci.Next()) {
|
||
|
AudioChunk& c = *ci;
|
||
|
uint32_t frames = c.mDuration;
|
||
|
|
||
|
// If the chunk is silent, simply write the right number of silence in the
|
||
|
// buffers.
|
||
|
if (c.mBufferFormat == AUDIO_FORMAT_SILENCE) {
|
||
|
for (uint32_t channel = 0; channel < aOutputChannels; channel++) {
|
||
|
AudioDataValue* ptr =
|
||
|
PointerForOffsetInChannel(buf.Elements(), outBufferLength,
|
||
|
aOutputChannels, channel, offsetSamples);
|
||
|
PodZero(ptr, frames);
|
||
|
}
|
||
|
} else {
|
||
|
// Othewise, we need to upmix or downmix appropriately, depending on the
|
||
|
// desired input and output channels.
|
||
|
channelData.SetLength(c.mChannelData.Length());
|
||
|
for (uint32_t i = 0; i < channelData.Length(); ++i) {
|
||
|
channelData[i] = static_cast<const AudioDataValue*>(c.mChannelData[i]);
|
||
|
}
|
||
|
if (channelData.Length() < aOutputChannels) {
|
||
|
// Up-mix.
|
||
|
AudioChannelsUpMix(&channelData, aOutputChannels, SilentChannel::ZeroChannel<AudioDataValue>());
|
||
|
for (uint32_t channel = 0; channel < aOutputChannels; channel++) {
|
||
|
AudioDataValue* ptr =
|
||
|
PointerForOffsetInChannel(buf.Elements(), outBufferLength,
|
||
|
aOutputChannels, channel, offsetSamples);
|
||
|
PodCopy(ptr, reinterpret_cast<const AudioDataValue*>(channelData[channel]),
|
||
|
frames);
|
||
|
}
|
||
|
MOZ_ASSERT(channelData.Length() == aOutputChannels);
|
||
|
} else if (channelData.Length() > aOutputChannels) {
|
||
|
// Down mix.
|
||
|
nsAutoTArray<AudioDataValue*, GUESS_AUDIO_CHANNELS> outChannelPtrs;
|
||
|
outChannelPtrs.SetLength(aOutputChannels);
|
||
|
uint32_t offsetSamples = 0;
|
||
|
for (uint32_t channel = 0; channel < aOutputChannels; channel++) {
|
||
|
outChannelPtrs[channel] =
|
||
|
PointerForOffsetInChannel(buf.Elements(), outBufferLength,
|
||
|
aOutputChannels, channel, offsetSamples);
|
||
|
}
|
||
|
AudioChannelsDownMix(channelData, outChannelPtrs.Elements(),
|
||
|
aOutputChannels, frames);
|
||
|
} else {
|
||
|
// The channel count is already what we want, just copy it over.
|
||
|
for (uint32_t channel = 0; channel < aOutputChannels; channel++) {
|
||
|
AudioDataValue* ptr =
|
||
|
PointerForOffsetInChannel(buf.Elements(), outBufferLength,
|
||
|
aOutputChannels, channel, offsetSamples);
|
||
|
PodCopy(ptr, reinterpret_cast<const AudioDataValue*>(channelData[channel]),
|
||
|
frames);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
offsetSamples += frames;
|
||
|
}
|
||
|
|
||
|
if (offsetSamples) {
|
||
|
MOZ_ASSERT(offsetSamples == outBufferLength / aOutputChannels,
|
||
|
"We forgot to write some samples?");
|
||
|
aMixer.Mix(buf.Elements(), aOutputChannels, offsetSamples, aSampleRate);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
AudioSegment::WriteTo(uint64_t aID, AudioMixer& aMixer, uint32_t aOutputChannels, uint32_t aSampleRate)
|
||
|
{
|
||
|
nsAutoTArray<AudioDataValue,SilentChannel::AUDIO_PROCESSING_FRAMES*GUESS_AUDIO_CHANNELS> buf;
|
||
|
// Offset in the buffer that will be written to the mixer, in samples.
|
||
|
uint32_t offset = 0;
|
||
|
|
||
|
if (GetDuration() <= 0) {
|
||
|
MOZ_ASSERT(GetDuration() == 0);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
uint32_t outBufferLength = GetDuration() * aOutputChannels;
|
||
|
buf.SetLength(outBufferLength);
|
||
|
|
||
|
|
||
|
for (ChunkIterator ci(*this); !ci.IsEnded(); ci.Next()) {
|
||
|
AudioChunk& c = *ci;
|
||
|
|
||
|
switch (c.mBufferFormat) {
|
||
|
case AUDIO_FORMAT_S16:
|
||
|
WriteChunk<int16_t>(c, aOutputChannels, buf.Elements() + offset);
|
||
|
break;
|
||
|
case AUDIO_FORMAT_FLOAT32:
|
||
|
WriteChunk<float>(c, aOutputChannels, buf.Elements() + offset);
|
||
|
break;
|
||
|
case AUDIO_FORMAT_SILENCE:
|
||
|
// The mixer is expecting interleaved data, so this is ok.
|
||
|
PodZero(buf.Elements() + offset, c.mDuration * aOutputChannels);
|
||
|
break;
|
||
|
default:
|
||
|
MOZ_ASSERT(false, "Not handled");
|
||
|
}
|
||
|
|
||
|
offset += c.mDuration * aOutputChannels;
|
||
|
|
||
|
#if !defined(MOZILLA_XPCOMRT_API)
|
||
|
if (!c.mTimeStamp.IsNull()) {
|
||
|
TimeStamp now = TimeStamp::Now();
|
||
|
// would be more efficient to c.mTimeStamp to ms on create time then pass here
|
||
|
LogTime(AsyncLatencyLogger::AudioMediaStreamTrack, aID,
|
||
|
(now - c.mTimeStamp).ToMilliseconds(), c.mTimeStamp);
|
||
|
}
|
||
|
#endif // !defined(MOZILLA_XPCOMRT_API)
|
||
|
}
|
||
|
|
||
|
if (offset) {
|
||
|
aMixer.Mix(buf.Elements(), aOutputChannels, offset / aOutputChannels, aSampleRate);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
} // namespace mozilla
|