Tests that we do not crash when using a very large sample rate

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

PASS context.sampleRate is 384000

PASS context.state is "running"

PASS successfullyParsed is true

TEST COMPLETE

<script src="../resources/js-test.js"></script>

jsTestIsAsync = true;

context = new AudioContext({ sampleRate: 384000 });

shouldBe("context.sampleRate", "384000");

node = new ConstantSourceNode(context, { offset: 0.5 });

setTimeout(() => {

shouldBeEqualToString("context.state", "running");

finishJSTest();

}, 100);

Tests that we do not crash when using a very low sample rate

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

PASS context.sampleRate is 3000

PASS context.state is "running"

PASS successfullyParsed is true

TEST COMPLETE

<script src="../resources/js-test.js"></script>

jsTestIsAsync = true;

context = new AudioContext({ sampleRate: 3000 });

shouldBe("context.sampleRate", "3000");

node = new ConstantSourceNode(context, { offset: 0.5 });

setTimeout(() => {

shouldBeEqualToString("context.state", "running");

finishJSTest();

}, 100);

2020-11-20 Chris Dumez <cdumez@apple.com>

Poor resampling quality when using AudioContext sampleRate parameter

https://bugs.webkit.org/show_bug.cgi?id=219201

Reviewed by Geoff Garen.

MultiChannelResampler uses a SincResampler per audio channel. In MultiChannelResampler::process(),

it was calling SincResampler::process() for each channel, which would potentially end up calling

MultiChannelResampler::ChannelProvider::provideInput() to provide channel data used for resampling.

The issue was that MultiChannelResampler::ChannelProvider::provideInput() is implemented in such

a way that things will break if provideInput() gets called more than once per channel. When using

an AudioContext's sample rate larger than the hardware sample rate, provideInput() was getting

called more than once per channel and this resulted in very poor resampling quality.

To address the issue, MultiChannelResampler::process() now processes the data in chunks that

are small enough to guarantee that MultiChannelResampler::ChannelProvider::provideInput() will

never get called more than once per audio channel.

The fix is based on the corresponding MultiChannelResampler / SincResampler implementation in

Chrome:

- https://github.com/chromium/chromium/blob/master/media/base/multi_channel_resampler.cc

- https://github.com/chromium/chromium/blob/master/media/base/sinc_resampler.cc

Tests: webaudio/audiocontext-large-samplerate.html

webaudio/audiocontext-low-samplerate.html

* platform/audio/MultiChannelResampler.cpp:

(WebCore::MultiChannelResampler::ChannelProvider::setProvider):

(WebCore::MultiChannelResampler::ChannelProvider::setCurrentChannel):

(WebCore::MultiChannelResampler::process):

* platform/audio/MultiChannelResampler.h:

* platform/audio/SincResampler.cpp:

(WebCore::calculateChunkSize):

(WebCore::SincResampler::updateRegions):

* platform/audio/SincResampler.h:

#include "AudioUtilities.h"

class MultiChannelResampler::ChannelProvider {

: m_multiChannelBus(AudioBus::create(numberOfChannels, AudioUtilities::renderQuantumSize))

void provideInputForChannel(AudioBus* bus, size_t framesToProcess, unsigned channelIndex)

ASSERT(channelIndex < m_multiChannelBus->numberOfChannels());

ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);

if (framesToProcess > AudioUtilities::renderQuantumSize)

return;

if (!channelIndex) {

bool isGood = framesToProcess == m_framesToProcess;

memcpy(bus->channel(0)->mutableData(), m_multiChannelBus->channel(channelIndex)->data(), sizeof(float) * framesToProcess);

// We need to ensure that SincResampler only calls provideInput() once for each channel or it will confuse the logic

// inside ChannelProvider. To ensure this, we chunk the number of requested frames into SincResampler::chunkSize()

// sized chunks. SincResampler guarantees it will only call provideInput() once once we resample this way.

m_outputFramesReady = 0;

while (m_outputFramesReady < framesToProcess) {

size_t chunkSize = m_kernels[0]->chunkSize();

size_t framesThisTime = std::min(framesToProcess - m_outputFramesReady, chunkSize);

for (unsigned channelIndex = 0; channelIndex < m_numberOfChannels; ++channelIndex) {

ASSERT(chunkSize == m_kernels[channelIndex]->chunkSize());

bool wasProvideInputCalled = false;

m_kernels[channelIndex]->process(destination->channel(channelIndex)->mutableData() + m_outputFramesReady, framesThisTime, [this, channelIndex, &wasProvideInputCalled](AudioBus* bus, size_t framesToProcess) {

ASSERT_WITH_MESSAGE(!wasProvideInputCalled, "provideInputForChannel should only be called once");

wasProvideInputCalled = true;

m_channelProvider->provideInputForChannel(bus, framesToProcess, channelIndex);

});

}

m_outputFramesReady += framesThisTime;

size_t m_outputFramesReady { 0 };

static size_t calculateChunkSize(unsigned blockSize, double scaleFactor)

{

return blockSize / scaleFactor;

}

m_chunkSize = calculateChunkSize(m_blockSize, m_scaleFactor);

void SincResampler::consumeSource(float* buffer, unsigned numberOfSourceFrames, const Function<void(AudioBus* bus, size_t framesToProcess)>& provideInput)

ASSERT(provideInput);

if (!provideInput)

provideInput(m_internalBus.get(), numberOfSourceFrames);

class BufferSourceProvider {

void provideInput(AudioBus* bus, size_t framesToProcess)

process(destination, framesThisTime, [&sourceProvider](AudioBus* bus, size_t framesToProcess) {

sourceProvider.provideInput(bus, framesToProcess);

});

void SincResampler::process(float* destination, size_t framesToProcess, const Function<void(AudioBus* bus, size_t framesToProcess)>& provideInput)

ASSERT(provideInput);

if (!provideInput)

consumeSource(m_r0, m_requestFrames, provideInput);

consumeSource(m_r0, m_requestFrames, provideInput);

size_t chunkSize() const { return m_chunkSize; }

// Process with provideInput callback function for streaming applications.

void process(float* destination, size_t framesToProcess, const Function<void(AudioBus* bus, size_t framesToProcess)>& provideInput);

void consumeSource(float* buffer, unsigned numberOfSourceFrames, const Function<void(AudioBus* bus, size_t framesToProcess)>& provideInput);

size_t m_chunkSize { 0 };