#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "AudioBus.h"
#include "DenormalDisabler.h"
#include "SincResampler.h"
#include "VectorMath.h"
#include <algorithm>
#include <assert.h>
#include <math.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
namespace WebCore {
using namespace VectorMath;
AudioBus::AudioBus(unsigned numberOfChannels, size_t length, bool allocate)
: m_length(length)
, m_busGain(1)
, m_isFirstTime(true)
, m_sampleRate(0)
{
m_channels.reserveInitialCapacity(numberOfChannels);
for (unsigned i = 0; i < numberOfChannels; ++i) {
PassOwnPtr<AudioChannel> channel = allocate ? adoptPtr(new AudioChannel(length)) : adoptPtr(new AudioChannel(0, length));
m_channels.append(channel);
}
m_layout = LayoutCanonical; }
void AudioBus::setChannelMemory(unsigned channelIndex, float* storage, size_t length)
{
if (channelIndex < m_channels.size()) {
channel(channelIndex)->set(storage, length);
m_length = length; }
}
void AudioBus::zero()
{
for (unsigned i = 0; i < m_channels.size(); ++i)
m_channels[i]->zero();
}
AudioChannel* AudioBus::channelByType(unsigned channelType)
{
if (m_layout != LayoutCanonical)
return 0;
switch (numberOfChannels()) {
case 1: if (channelType == ChannelMono || channelType == ChannelLeft)
return channel(0);
return 0;
case 2: switch (channelType) {
case ChannelLeft: return channel(0);
case ChannelRight: return channel(1);
default: return 0;
}
case 4: switch (channelType) {
case ChannelLeft: return channel(0);
case ChannelRight: return channel(1);
case ChannelSurroundLeft: return channel(2);
case ChannelSurroundRight: return channel(3);
default: return 0;
}
case 5: switch (channelType) {
case ChannelLeft: return channel(0);
case ChannelRight: return channel(1);
case ChannelCenter: return channel(2);
case ChannelSurroundLeft: return channel(3);
case ChannelSurroundRight: return channel(4);
default: return 0;
}
case 6: switch (channelType) {
case ChannelLeft: return channel(0);
case ChannelRight: return channel(1);
case ChannelCenter: return channel(2);
case ChannelLFE: return channel(3);
case ChannelSurroundLeft: return channel(4);
case ChannelSurroundRight: return channel(5);
default: return 0;
}
}
ASSERT_NOT_REACHED();
return 0;
}
const AudioChannel* AudioBus::channelByType(unsigned type) const
{
return const_cast<AudioBus*>(this)->channelByType(type);
}
bool AudioBus::topologyMatches(const AudioBus& bus) const
{
if (numberOfChannels() != bus.numberOfChannels())
return false;
if (length() > bus.length())
return false;
return true;
}
PassOwnPtr<AudioBus> AudioBus::createBufferFromRange(const AudioBus* sourceBuffer, unsigned startFrame, unsigned endFrame)
{
size_t numberOfSourceFrames = sourceBuffer->length();
unsigned numberOfChannels = sourceBuffer->numberOfChannels();
bool isRangeSafe = startFrame < endFrame && endFrame <= numberOfSourceFrames;
ASSERT(isRangeSafe);
if (!isRangeSafe)
return nullptr;
size_t rangeLength = endFrame - startFrame;
OwnPtr<AudioBus> audioBus = adoptPtr(new AudioBus(numberOfChannels, rangeLength));
audioBus->setSampleRate(sourceBuffer->sampleRate());
for (unsigned i = 0; i < numberOfChannels; ++i)
audioBus->channel(i)->copyFromRange(sourceBuffer->channel(i), startFrame, endFrame);
return audioBus.release();
}
float AudioBus::maxAbsValue() const
{
float max = 0.0f;
for (unsigned i = 0; i < numberOfChannels(); ++i) {
const AudioChannel* channel = this->channel(i);
max = std::max(max, channel->maxAbsValue());
}
return max;
}
void AudioBus::normalize()
{
float max = maxAbsValue();
if (max)
scale(1.0f / max);
}
void AudioBus::scale(float scale)
{
for (unsigned i = 0; i < numberOfChannels(); ++i)
channel(i)->scale(scale);
}
void AudioBus::copyFrom(const AudioBus& sourceBus)
{
if (&sourceBus == this)
return;
unsigned numberOfSourceChannels = sourceBus.numberOfChannels();
unsigned numberOfDestinationChannels = numberOfChannels();
if (numberOfDestinationChannels == numberOfSourceChannels) {
for (unsigned i = 0; i < numberOfSourceChannels; ++i)
channel(i)->copyFrom(sourceBus.channel(i));
} else if (numberOfDestinationChannels == 2 && numberOfSourceChannels == 1) {
const AudioChannel* sourceChannel = sourceBus.channel(0);
channel(0)->copyFrom(sourceChannel);
channel(1)->copyFrom(sourceChannel);
} else if (numberOfDestinationChannels == 1 && numberOfSourceChannels == 2) {
AudioBus& sourceBusSafe = const_cast<AudioBus&>(sourceBus);
const float* sourceL = sourceBusSafe.channelByType(ChannelLeft)->data();
const float* sourceR = sourceBusSafe.channelByType(ChannelRight)->data();
float* destination = channelByType(ChannelLeft)->mutableData();
vadd(sourceL, 1, sourceR, 1, destination, 1, length());
float scale = 0.5;
vsmul(destination, 1, &scale, destination, 1, length());
} else if (numberOfDestinationChannels == 6 && numberOfSourceChannels == 1) {
channel(2)->copyFrom(sourceBus.channel(0));
channel(0)->zero();
channel(1)->zero();
channel(3)->zero();
channel(4)->zero();
channel(5)->zero();
} else if (numberOfDestinationChannels == 1 && numberOfSourceChannels == 6) {
channel(0)->copyFrom(sourceBus.channel(2));
} else if (numberOfDestinationChannels < numberOfSourceChannels) {
for (unsigned i = 0; i < numberOfDestinationChannels; ++i)
channel(i)->copyFrom(sourceBus.channel(i));
} else if (numberOfDestinationChannels > numberOfSourceChannels) {
for (unsigned i = 0; i < numberOfSourceChannels; ++i)
channel(i)->copyFrom(sourceBus.channel(i));
for (unsigned i = numberOfSourceChannels; i < numberOfDestinationChannels; ++i)
channel(i)->zero();
} else {
ASSERT_NOT_REACHED();
}
}
void AudioBus::sumFrom(const AudioBus &sourceBus)
{
unsigned numberOfSourceChannels = sourceBus.numberOfChannels();
unsigned numberOfDestinationChannels = numberOfChannels();
if (numberOfDestinationChannels == numberOfSourceChannels) {
for (unsigned i = 0; i < numberOfChannels(); ++i)
channel(i)->sumFrom(sourceBus.channel(i));
} else if (numberOfDestinationChannels == 2 && numberOfSourceChannels == 1) {
const AudioChannel* sourceChannel = sourceBus.channel(0);
channel(0)->sumFrom(sourceChannel);
channel(1)->sumFrom(sourceChannel);
} else if (numberOfDestinationChannels == 1 && numberOfSourceChannels == 2) {
AudioBus& sourceBusSafe = const_cast<AudioBus&>(sourceBus);
const float* sourceL = sourceBusSafe.channelByType(ChannelLeft)->data();
const float* sourceR = sourceBusSafe.channelByType(ChannelRight)->data();
float* destination = channelByType(ChannelLeft)->mutableData();
float scale = 0.5;
vsma(sourceL, 1, &scale, destination, 1, length());
vsma(sourceR, 1, &scale, destination, 1, length());
} else if (numberOfDestinationChannels == 6 && numberOfSourceChannels == 1) {
channel(2)->sumFrom(sourceBus.channel(0));
} else if (numberOfDestinationChannels == 1 && numberOfSourceChannels == 6) {
channel(0)->sumFrom(sourceBus.channel(2));
} else if (numberOfDestinationChannels < numberOfSourceChannels) {
for (unsigned i = 0; i < numberOfDestinationChannels; ++i)
channel(i)->sumFrom(sourceBus.channel(i));
} else if (numberOfDestinationChannels > numberOfSourceChannels) {
for (unsigned i = 0; i < numberOfSourceChannels; ++i)
channel(i)->sumFrom(sourceBus.channel(i));
} else {
ASSERT_NOT_REACHED();
}
}
#define GAIN_DEZIPPER \
gain += (totalDesiredGain - gain) * DezipperRate; \
gain = DenormalDisabler::flushDenormalFloatToZero(gain);
#define PROCESS_WITH_GAIN(OP) \
for (k = 0; k < framesToDezipper; ++k) { \
OP \
GAIN_DEZIPPER \
} \
if (!framesToDezipper) \
gain = totalDesiredGain; \
OP##_V
#define STEREO_SUM \
{ \
float sumL = DenormalDisabler::flushDenormalFloatToZero(*destinationL + gain * *sourceL++); \
float sumR = DenormalDisabler::flushDenormalFloatToZero(*destinationR + gain * *sourceR++); \
*destinationL++ = sumL; \
*destinationR++ = sumR; \
}
#define STEREO_SUM_V \
{ \
vsma(sourceL, 1, &gain, destinationL, 1, framesToProcess - k); \
vsma(sourceR, 1, &gain, destinationR, 1, framesToProcess - k); \
}
#define MONO2STEREO_SUM \
{ \
float scaled = gain * *sourceL++; \
float sumL = DenormalDisabler::flushDenormalFloatToZero(*destinationL + scaled); \
float sumR = DenormalDisabler::flushDenormalFloatToZero(*destinationR + scaled); \
*destinationL++ = sumL; \
*destinationR++ = sumR; \
}
#define MONO2STEREO_SUM_V \
{ \
vsma(sourceL, 1, &gain, destinationL, 1, framesToProcess - k); \
vsma(sourceL, 1, &gain, destinationR, 1, framesToProcess - k); \
}
#define MONO_SUM \
{ \
float sum = DenormalDisabler::flushDenormalFloatToZero(*destinationL + gain * *sourceL++); \
*destinationL++ = sum; \
}
#define MONO_SUM_V \
{ \
vsma(sourceL, 1, &gain, destinationL, 1, framesToProcess - k); \
}
#define STEREO_NO_SUM \
{ \
float sampleL = *sourceL++; \
float sampleR = *sourceR++; \
*destinationL++ = DenormalDisabler::flushDenormalFloatToZero(gain * sampleL); \
*destinationR++ = DenormalDisabler::flushDenormalFloatToZero(gain * sampleR); \
}
#define STEREO_NO_SUM_V \
{ \
vsmul(sourceL, 1, &gain, destinationL, 1, framesToProcess - k); \
vsmul(sourceR, 1, &gain, destinationR, 1, framesToProcess - k); \
}
#define MONO2STEREO_NO_SUM \
{ \
float sample = *sourceL++; \
*destinationL++ = DenormalDisabler::flushDenormalFloatToZero(gain * sample); \
*destinationR++ = DenormalDisabler::flushDenormalFloatToZero(gain * sample); \
}
#define MONO2STEREO_NO_SUM_V \
{ \
vsmul(sourceL, 1, &gain, destinationL, 1, framesToProcess - k); \
vsmul(sourceL, 1, &gain, destinationR, 1, framesToProcess - k); \
}
#define MONO_NO_SUM \
{ \
float sampleL = *sourceL++; \
*destinationL++ = DenormalDisabler::flushDenormalFloatToZero(gain * sampleL); \
}
#define MONO_NO_SUM_V \
{ \
vsmul(sourceL, 1, &gain, destinationL, 1, framesToProcess - k); \
}
void AudioBus::processWithGainFromMonoStereo(const AudioBus &sourceBus, float* lastMixGain, float targetGain, bool sumToBus)
{
float totalDesiredGain = static_cast<float>(m_busGain * targetGain);
float gain = static_cast<float>(m_isFirstTime ? totalDesiredGain : *lastMixGain);
m_isFirstTime = false;
int numberOfSourceChannels = sourceBus.numberOfChannels();
int numberOfDestinationChannels = numberOfChannels();
AudioBus& sourceBusSafe = const_cast<AudioBus&>(sourceBus);
const float* sourceL = sourceBusSafe.channelByType(ChannelLeft)->data();
const float* sourceR = numberOfSourceChannels > 1 ? sourceBusSafe.channelByType(ChannelRight)->data() : 0;
if (sourceBusSafe.isSilent()) {
if (!sumToBus)
zero();
return;
}
float* destinationL = channelByType(ChannelLeft)->mutableData();
float* destinationR = numberOfDestinationChannels > 1 ? channelByType(ChannelRight)->mutableData() : 0;
const float DezipperRate = 0.005f;
int framesToProcess = length();
const float epsilon = 0.001f;
float gainDiff = fabs(totalDesiredGain - gain);
int framesToDezipper = (gainDiff < epsilon) ? 0 : framesToProcess;
int k = 0;
if (sumToBus) {
if (sourceR && destinationR) {
PROCESS_WITH_GAIN(STEREO_SUM)
} else if (destinationR) {
PROCESS_WITH_GAIN(MONO2STEREO_SUM)
} else {
PROCESS_WITH_GAIN(MONO_SUM)
}
} else {
if (sourceR && destinationR) {
PROCESS_WITH_GAIN(STEREO_NO_SUM)
} else if (destinationR) {
PROCESS_WITH_GAIN(MONO2STEREO_NO_SUM)
} else {
PROCESS_WITH_GAIN(MONO_NO_SUM)
}
}
*lastMixGain = gain;
}
void AudioBus::processWithGainFrom(const AudioBus &sourceBus, float* lastMixGain, float targetGain, bool sumToBus)
{
if (sourceBus.numberOfChannels() != 1 && !topologyMatches(sourceBus)) {
ASSERT_NOT_REACHED();
return;
}
if (!sumToBus && this == &sourceBus && *lastMixGain == targetGain && targetGain == 1.0)
return;
switch (numberOfChannels()) {
case 1: case 2: processWithGainFromMonoStereo(sourceBus, lastMixGain, targetGain, sumToBus);
break;
case 4: case 5: default:
ASSERT_NOT_REACHED();
break;
}
}
void AudioBus::copyWithSampleAccurateGainValuesFrom(const AudioBus &sourceBus, float* gainValues, unsigned numberOfGainValues)
{
if (sourceBus.numberOfChannels() != 1 && !topologyMatches(sourceBus)) {
ASSERT_NOT_REACHED();
return;
}
if (!gainValues || numberOfGainValues > sourceBus.length()) {
ASSERT_NOT_REACHED();
return;
}
if (sourceBus.length() == numberOfGainValues && sourceBus.length() == length() && sourceBus.isSilent()) {
zero();
return;
}
const float* source = sourceBus.channel(0)->data();
for (unsigned channelIndex = 0; channelIndex < numberOfChannels(); ++channelIndex) {
if (sourceBus.numberOfChannels() == numberOfChannels())
source = sourceBus.channel(channelIndex)->data();
float* destination = channel(channelIndex)->mutableData();
vmul(source, 1, gainValues, 1, destination, 1, numberOfGainValues);
}
}
void AudioBus::copyWithGainFrom(const AudioBus &sourceBus, float* lastMixGain, float targetGain)
{
processWithGainFrom(sourceBus, lastMixGain, targetGain, false);
}
void AudioBus::sumWithGainFrom(const AudioBus &sourceBus, float* lastMixGain, float targetGain)
{
processWithGainFrom(sourceBus, lastMixGain, targetGain, true);
}
PassOwnPtr<AudioBus> AudioBus::createBySampleRateConverting(const AudioBus* sourceBus, bool mixToMono, double newSampleRate)
{
ASSERT(sourceBus && sourceBus->sampleRate());
if (!sourceBus || !sourceBus->sampleRate())
return nullptr;
double sourceSampleRate = sourceBus->sampleRate();
double destinationSampleRate = newSampleRate;
double sampleRateRatio = sourceSampleRate / destinationSampleRate;
unsigned numberOfSourceChannels = sourceBus->numberOfChannels();
if (numberOfSourceChannels == 1)
mixToMono = false;
if (sourceSampleRate == destinationSampleRate) {
if (mixToMono)
return AudioBus::createByMixingToMono(sourceBus);
return AudioBus::createBufferFromRange(sourceBus, 0, sourceBus->length());
}
if (sourceBus->isSilent()) {
OwnPtr<AudioBus> silentBus = adoptPtr(new AudioBus(numberOfSourceChannels, sourceBus->length() / sampleRateRatio));
silentBus->setSampleRate(newSampleRate);
return silentBus.release();
}
const AudioBus* resamplerSourceBus;
OwnPtr<AudioBus> mixedMonoBus;
if (mixToMono) {
mixedMonoBus = AudioBus::createByMixingToMono(sourceBus);
resamplerSourceBus = mixedMonoBus.get();
} else {
resamplerSourceBus = sourceBus;
}
int sourceLength = resamplerSourceBus->length();
int destinationLength = sourceLength / sampleRateRatio;
unsigned numberOfDestinationChannels = resamplerSourceBus->numberOfChannels();
OwnPtr<AudioBus> destinationBus(adoptPtr(new AudioBus(numberOfDestinationChannels, destinationLength)));
for (unsigned i = 0; i < numberOfDestinationChannels; ++i) {
const float* source = resamplerSourceBus->channel(i)->data();
float* destination = destinationBus->channel(i)->mutableData();
SincResampler resampler(sampleRateRatio);
resampler.process(source, destination, sourceLength);
}
destinationBus->clearSilentFlag();
destinationBus->setSampleRate(newSampleRate);
return destinationBus.release();
}
PassOwnPtr<AudioBus> AudioBus::createByMixingToMono(const AudioBus* sourceBus)
{
if (sourceBus->isSilent())
return adoptPtr(new AudioBus(1, sourceBus->length()));
switch (sourceBus->numberOfChannels()) {
case 1:
return AudioBus::createBufferFromRange(sourceBus, 0, sourceBus->length());
case 2:
{
unsigned n = sourceBus->length();
OwnPtr<AudioBus> destinationBus(adoptPtr(new AudioBus(1, n)));
const float* sourceL = sourceBus->channel(0)->data();
const float* sourceR = sourceBus->channel(1)->data();
float* destination = destinationBus->channel(0)->mutableData();
for (unsigned i = 0; i < n; ++i)
destination[i] = (sourceL[i] + sourceR[i]) / 2;
destinationBus->clearSilentFlag();
destinationBus->setSampleRate(sourceBus->sampleRate());
return destinationBus.release();
}
}
ASSERT_NOT_REACHED();
return nullptr;
}
bool AudioBus::isSilent() const
{
for (size_t i = 0; i < m_channels.size(); ++i) {
if (!m_channels[i]->isSilent())
return false;
}
return true;
}
void AudioBus::clearSilentFlag()
{
for (size_t i = 0; i < m_channels.size(); ++i)
m_channels[i]->clearSilentFlag();
}
}
#endif // ENABLE(WEB_AUDIO)