/* * Copyright (C) 2010, Google Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" #if ENABLE(WEB_AUDIO) #include "BiquadDSPKernel.h" #include "AudioArray.h" #include "AudioUtilities.h" #include "Biquad.h" #include "BiquadProcessor.h" #include "FloatConversion.h" #include #include namespace WebCore { static bool hasConstantValue(float* values, size_t framesToProcess) { if (framesToProcess <= 1) return true; float constant = values[0]; for (size_t i = 1; i < framesToProcess; ++i) { if (values[i] != constant) return false; } return true; } void BiquadDSPKernel::updateCoefficientsIfNecessary(size_t framesToProcess) { if (biquadProcessor()->filterCoefficientsDirty()) { if (biquadProcessor()->hasSampleAccurateValues() && biquadProcessor()->shouldUseARate()) { // Use float arrays instead of AudioFloatArray to avoid heap allocations on the audio thread. float cutoffFrequency[AudioUtilities::renderQuantumSize]; float q[AudioUtilities::renderQuantumSize]; float gain[AudioUtilities::renderQuantumSize]; float detune[AudioUtilities::renderQuantumSize]; // in Cents RELEASE_ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize); biquadProcessor()->parameter1().calculateSampleAccurateValues(cutoffFrequency, framesToProcess); biquadProcessor()->parameter2().calculateSampleAccurateValues(q, framesToProcess); biquadProcessor()->parameter3().calculateSampleAccurateValues(gain, framesToProcess); biquadProcessor()->parameter4().calculateSampleAccurateValues(detune, framesToProcess); // If all the values are actually constant for this render (or the // automation rate is "k-rate" for all of the AudioParams), we don't need // to compute filter coefficients for each frame since they would be the // same as the first. bool isConstant = hasConstantValue(cutoffFrequency, framesToProcess) && hasConstantValue(q, framesToProcess) && hasConstantValue(gain, framesToProcess) && hasConstantValue(detune, framesToProcess); updateCoefficients(isConstant ? 1 : framesToProcess, cutoffFrequency, q, gain, detune); } else { float cutoffFrequency = biquadProcessor()->parameter1().finalValue(); float q = biquadProcessor()->parameter2().finalValue(); float gain = biquadProcessor()->parameter3().finalValue(); float detune = biquadProcessor()->parameter4().finalValue(); updateCoefficients(1, &cutoffFrequency, &q, &gain, &detune); } } } void BiquadDSPKernel::updateCoefficients(size_t numberOfFrames, const float* cutoffFrequency, const float* q, const float* gain, const float* detune) { // Convert from Hertz to normalized frequency 0 -> 1. double nyquist = this->nyquist(); m_biquad.setHasSampleAccurateValues(numberOfFrames > 1); for (size_t k = 0; k < numberOfFrames; ++k) { double normalizedFrequency = cutoffFrequency[k] / nyquist; // Offset frequency by detune. if (detune[k]) { // Detune multiplies the frequency by 2^(detune[k] / 1200). normalizedFrequency *= std::exp2(detune[k] / 1200); } // Configure the biquad with the new filter parameters for the appropriate // type of filter. switch (biquadProcessor()->type()) { case BiquadFilterType::Lowpass: m_biquad.setLowpassParams(k, normalizedFrequency, q[k]); break; case BiquadFilterType::Highpass: m_biquad.setHighpassParams(k, normalizedFrequency, q[k]); break; case BiquadFilterType::Bandpass: m_biquad.setBandpassParams(k, normalizedFrequency, q[k]); break; case BiquadFilterType::Lowshelf: m_biquad.setLowShelfParams(k, normalizedFrequency, gain[k]); break; case BiquadFilterType::Highshelf: m_biquad.setHighShelfParams(k, normalizedFrequency, gain[k]); break; case BiquadFilterType::Peaking: m_biquad.setPeakingParams(k, normalizedFrequency, q[k], gain[k]); break; case BiquadFilterType::Notch: m_biquad.setNotchParams(k, normalizedFrequency, q[k]); break; case BiquadFilterType::Allpass: m_biquad.setAllpassParams(k, normalizedFrequency, q[k]); break; } } ASSERT(numberOfFrames); updateTailTime(numberOfFrames - 1); } void BiquadDSPKernel::process(const float* source, float* destination, size_t framesToProcess) { ASSERT(source && destination && biquadProcessor()); // Recompute filter coefficients if any of the parameters have changed. // FIXME: as an optimization, implement a way that a Biquad object can simply copy its internal filter coefficients from another Biquad object. // Then re-factor this code to only run for the first BiquadDSPKernel of each BiquadProcessor. updateCoefficientsIfNecessary(framesToProcess); m_biquad.process(source, destination, framesToProcess); } void BiquadDSPKernel::getFrequencyResponse(unsigned nFrequencies, const float* frequencyHz, float* magResponse, float* phaseResponse) { bool isGood = nFrequencies > 0 && frequencyHz && magResponse && phaseResponse; ASSERT(isGood); if (!isGood) return; Vector frequency(nFrequencies); double nyquist = this->nyquist(); // Convert from frequency in Hz to normalized frequency (0 -> 1), // with 1 equal to the Nyquist frequency. for (unsigned k = 0; k < nFrequencies; ++k) frequency[k] = frequencyHz[k] / nyquist; m_biquad.getFrequencyResponse(nFrequencies, frequency.data(), magResponse, phaseResponse); } double BiquadDSPKernel::tailTime() const { return m_tailTime; } double BiquadDSPKernel::latencyTime() const { return 0; } void BiquadDSPKernel::updateTailTime(size_t coefIndex) { // A reasonable upper limit for the tail time. While it's easy to // create biquad filters whose tail time can be much larger than // this, limit the maximum to this value so that we don't keep such // nodes alive "forever". // TODO: What is a reasonable upper limit? constexpr double maxTailTime = 30; double sampleRate = this->sampleRate(); double tail = m_biquad.tailFrame(coefIndex, maxTailTime * sampleRate) / sampleRate; m_tailTime = std::clamp(tail, 0.0, maxTailTime); } bool BiquadDSPKernel::requiresTailProcessing() const { // Always return true even if the tail time and latency might both // be zero. This is for simplicity and because TailTime() is 0 // basically only when the filter response H(z) = 0 or H(z) = 1. And // it's ok to return true. It just means the node lives a little // longer than strictly necessary. return true; } } // namespace WebCore #endif // ENABLE(WEB_AUDIO)