#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "SincResampler.h"
#include "AudioBus.h"
#include "AudioUtilities.h"
#include <wtf/MathExtras.h>
#if USE(ACCELERATE)
#include <Accelerate/Accelerate.h>
#elif CPU(X86_SSE2)
#include <xmmintrin.h>
#elif HAVE(ARM_NEON_INTRINSICS)
#include <arm_neon.h>
#endif
namespace WebCore {
constexpr unsigned kernelSize { 32 };
constexpr unsigned numberOfKernelOffsets { 32 };
constexpr unsigned kernelStorageSize { kernelSize * (numberOfKernelOffsets + 1) };
static size_t calculateChunkSize(unsigned blockSize, double scaleFactor)
{
return blockSize / scaleFactor;
}
SincResampler::SincResampler(double scaleFactor, unsigned requestFrames, Function<void(float* buffer, size_t framesToProcess)>&& provideInput)
: m_scaleFactor(scaleFactor)
, m_kernelStorage(kernelStorageSize)
, m_requestFrames(requestFrames)
, m_provideInput(WTFMove(provideInput))
, m_inputBuffer(m_requestFrames + kernelSize) , m_r1(m_inputBuffer.data())
, m_r2(m_inputBuffer.data() + kernelSize / 2)
{
ASSERT(m_provideInput);
ASSERT(m_requestFrames > 0);
updateRegions(false);
ASSERT(m_blockSize > kernelSize);
initializeKernel();
}
void SincResampler::updateRegions(bool isSecondLoad)
{
m_r0 = m_inputBuffer.data() + (isSecondLoad ? kernelSize : kernelSize / 2);
m_r3 = m_r0 + m_requestFrames - kernelSize;
m_r4 = m_r0 + m_requestFrames - kernelSize / 2;
m_blockSize = m_r4 - m_r2;
m_chunkSize = calculateChunkSize(m_blockSize, m_scaleFactor);
ASSERT(m_r1 == m_inputBuffer.data());
ASSERT((m_r2 - m_r1) == (m_r4 - m_r3));
ASSERT(m_r2 <= m_r3);
}
void SincResampler::initializeKernel()
{
double alpha = 0.16;
double a0 = 0.5 * (1.0 - alpha);
double a1 = 0.5;
double a2 = 0.5 * alpha;
double sincScaleFactor = m_scaleFactor > 1.0 ? 1.0 / m_scaleFactor : 1.0;
sincScaleFactor *= 0.9;
int n = kernelSize;
int halfSize = n / 2;
for (unsigned offsetIndex = 0; offsetIndex <= numberOfKernelOffsets; ++offsetIndex) {
double subsampleOffset = static_cast<double>(offsetIndex) / numberOfKernelOffsets;
for (int i = 0; i < n; ++i) {
double s = sincScaleFactor * piDouble * (i - halfSize - subsampleOffset);
double sinc = !s ? 1.0 : sin(s) / s;
sinc *= sincScaleFactor;
double x = (i - subsampleOffset) / n;
double window = a0 - a1 * cos(2.0 * piDouble * x) + a2 * cos(4.0 * piDouble * x);
m_kernelStorage[i + offsetIndex * kernelSize] = sinc * window;
}
}
}
void SincResampler::processBuffer(const float* source, float* destination, unsigned numberOfSourceFrames, double scaleFactor)
{
SincResampler resampler(scaleFactor, AudioUtilities::renderQuantumSize, [source, numberOfSourceFrames](float* buffer, size_t framesToProcess) mutable {
size_t framesToCopy = std::min<size_t>(numberOfSourceFrames, framesToProcess);
memcpy(buffer, source, sizeof(float) * framesToCopy);
if (framesToCopy < framesToProcess)
memset(buffer + framesToCopy, 0, sizeof(float) * (framesToProcess - framesToCopy));
numberOfSourceFrames -= framesToCopy;
source += framesToCopy;
});
unsigned numberOfDestinationFrames = static_cast<unsigned>(numberOfSourceFrames / scaleFactor);
unsigned remaining = numberOfDestinationFrames;
while (remaining) {
unsigned framesThisTime = std::min<unsigned>(remaining, AudioUtilities::renderQuantumSize);
resampler.process(destination, framesThisTime);
destination += framesThisTime;
remaining -= framesThisTime;
}
}
void SincResampler::process(float* destination, size_t framesToProcess)
{
unsigned numberOfDestinationFrames = framesToProcess;
if (!m_isBufferPrimed) {
m_provideInput(m_r0, m_requestFrames);
m_isBufferPrimed = true;
}
while (numberOfDestinationFrames) {
while (m_virtualSourceIndex < m_blockSize) {
int sourceIndexI = static_cast<int>(m_virtualSourceIndex);
double subsampleRemainder = m_virtualSourceIndex - sourceIndexI;
double virtualOffsetIndex = subsampleRemainder * numberOfKernelOffsets;
int offsetIndex = static_cast<int>(virtualOffsetIndex);
float* k1 = m_kernelStorage.data() + offsetIndex * kernelSize;
float* k2 = k1 + kernelSize;
ASSERT(!(reinterpret_cast<uintptr_t>(k1) & 0x0F));
ASSERT(!(reinterpret_cast<uintptr_t>(k2) & 0x0F));
float* inputP = m_r1 + sourceIndexI;
double kernelInterpolationFactor = virtualOffsetIndex - offsetIndex;
*destination++ = convolve(inputP, k1, k2, kernelInterpolationFactor);
m_virtualSourceIndex += m_scaleFactor;
--numberOfDestinationFrames;
if (!numberOfDestinationFrames)
return;
}
ASSERT(m_virtualSourceIndex >= m_blockSize);
m_virtualSourceIndex -= m_blockSize;
memcpy(m_r1, m_r3, sizeof(float) * kernelSize);
if (m_r0 == m_r2)
updateRegions(true);
m_provideInput(m_r0, m_requestFrames);
}
}
float SincResampler::convolve(const float* inputP, const float* k1, const float* k2, float kernelInterpolationFactor)
{
#if USE(ACCELERATE)
float sum1;
float sum2;
vDSP_dotpr(inputP, 1, k1, 1, &sum1, kernelSize);
vDSP_dotpr(inputP, 1, k2, 1, &sum2, kernelSize);
return (1.0f - kernelInterpolationFactor) * sum1 + kernelInterpolationFactor * sum2;
#elif CPU(X86_SSE2)
__m128 m_input;
__m128 m_sums1 = _mm_setzero_ps();
__m128 m_sums2 = _mm_setzero_ps();
if (reinterpret_cast<uintptr_t>(inputP) & 0x0F) {
for (unsigned i = 0; i < kernelSize; i += 4) {
m_input = _mm_loadu_ps(inputP + i);
m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
}
} else {
for (unsigned i = 0; i < kernelSize; i += 4) {
m_input = _mm_load_ps(inputP + i);
m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
}
}
m_sums1 = _mm_mul_ps(m_sums1, _mm_set_ps1(1.0f - kernelInterpolationFactor));
m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1(kernelInterpolationFactor));
m_sums1 = _mm_add_ps(m_sums1, m_sums2);
float result;
m_sums2 = _mm_add_ps(_mm_movehl_ps(m_sums1, m_sums1), m_sums1);
_mm_store_ss(&result, _mm_add_ss(m_sums2, _mm_shuffle_ps(m_sums2, m_sums2, 1)));
return result;
#elif HAVE(ARM_NEON_INTRINSICS)
float32x4_t m_input;
float32x4_t m_sums1 = vmovq_n_f32(0);
float32x4_t m_sums2 = vmovq_n_f32(0);
const float* upper = inputP + kernelSize;
for (; inputP < upper; ) {
m_input = vld1q_f32(inputP);
inputP += 4;
m_sums1 = vmlaq_f32(m_sums1, m_input, vld1q_f32(k1));
k1 += 4;
m_sums2 = vmlaq_f32(m_sums2, m_input, vld1q_f32(k2));
k2 += 4;
}
m_sums1 = vmlaq_f32(vmulq_f32(m_sums1, vmovq_n_f32(1.0 - kernelInterpolationFactor)), m_sums2, vmovq_n_f32(kernelInterpolationFactor));
float32x2_t m_half = vadd_f32(vget_high_f32(m_sums1), vget_low_f32(m_sums1));
return vget_lane_f32(vpadd_f32(m_half, m_half), 0);
#else
float sum1 = 0;
float sum2 = 0;
int n = kernelSize;
while (n--) {
sum1 += *inputP * *k1++;
sum2 += *inputP++ * *k2++;
}
return (1.0f - kernelInterpolationFactor) * sum1 + kernelInterpolationFactor * sum2;
#endif
}
}
#endif // ENABLE(WEB_AUDIO)