⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 267541 in webkit


Ignore:
Timestamp:
Sep 24, 2020, 11:32:53 AM (6 years ago)
Author:
Chris Dumez
Message:

Declare render quantum size constant in AudioUtilities.h
​https://bugs.webkit.org/show_bug.cgi?id=216935

Reviewed by Eric Carlson.

Declare render quantum size [1] constant in AudioUtilities.h so that it can be used in both
platform/ and Modules/webaudio/. Also update the code so that we have a single constant
instead of many.

[1] ​https://www.w3.org/TR/webaudio/#render-quantum-size

  • Modules/webaudio/AudioListener.cpp:

(WebCore::AudioListener::AudioListener):

  • Modules/webaudio/AudioNode.h:
  • Modules/webaudio/AudioNodeInput.cpp:

(WebCore::AudioNodeInput::AudioNodeInput):
(WebCore::AudioNodeInput::updateInternalBus):

  • Modules/webaudio/AudioNodeOutput.cpp:

(WebCore::AudioNodeOutput::AudioNodeOutput):
(WebCore::AudioNodeOutput::updateInternalBus):

  • Modules/webaudio/AudioParam.cpp:

(WebCore::AudioParam::calculateFinalValues):
(WebCore::AudioParam::calculateTimelineValues):

  • Modules/webaudio/AudioParamTimeline.cpp:

(WebCore::AudioParamTimeline::valueForContextTime):

  • Modules/webaudio/AudioScheduledSourceNode.cpp:

(WebCore::AudioScheduledSourceNode::updateSchedulingInfo):

  • Modules/webaudio/BiquadDSPKernel.cpp:

(WebCore::BiquadDSPKernel::updateCoefficientsIfNecessary):

  • Modules/webaudio/BiquadProcessor.cpp:

(WebCore::BiquadProcessor::processOnlyAudioParams):

  • Modules/webaudio/ConstantSourceNode.cpp:

(WebCore::ConstantSourceNode::ConstantSourceNode):

  • Modules/webaudio/ConstantSourceNode.h:
  • Modules/webaudio/ConvolverNode.cpp:

(WebCore::ConvolverNode::setBuffer):

  • Modules/webaudio/DelayDSPKernel.cpp:

(WebCore::DelayDSPKernel::DelayDSPKernel):
(WebCore::DelayDSPKernel::processOnlyAudioParams):

  • Modules/webaudio/DynamicsCompressorNode.cpp:

(WebCore::DynamicsCompressorNode::processOnlyAudioParams):

  • Modules/webaudio/GainNode.cpp:

(WebCore::GainNode::GainNode):
(WebCore::GainNode::processOnlyAudioParams):

  • Modules/webaudio/OfflineAudioContext.cpp:

(WebCore::OfflineAudioContext::suspendOfflineRendering):

  • Modules/webaudio/OfflineAudioDestinationNode.cpp:

(WebCore::OfflineAudioDestinationNode::OfflineAudioDestinationNode):
(WebCore::OfflineAudioDestinationNode::offlineRender):

  • Modules/webaudio/OfflineAudioDestinationNode.h:
  • Modules/webaudio/OscillatorNode.cpp:

(WebCore::OscillatorNode::OscillatorNode):

  • Modules/webaudio/OscillatorNode.h:
  • Modules/webaudio/PannerNode.cpp:

(WebCore::PannerNode::processOnlyAudioParams):
(WebCore::PannerNode::processSampleAccurateValues):

  • Modules/webaudio/RealtimeAnalyser.cpp:

(WebCore::RealtimeAnalyser::RealtimeAnalyser):

  • Modules/webaudio/ScriptProcessorNode.cpp:

(WebCore::ScriptProcessorNode::ScriptProcessorNode):

  • Modules/webaudio/StereoPannerNode.cpp:

(WebCore::StereoPannerNode::StereoPannerNode):
(WebCore::StereoPannerNode::processOnlyAudioParams):

  • Modules/webaudio/StereoPannerNode.h:
  • Modules/webaudio/WaveShaperDSPKernel.cpp:

(WebCore::WaveShaperDSPKernel::lazyInitializeOversampling):
(WebCore::WaveShaperDSPKernel::processCurve2x):
(WebCore::WaveShaperDSPKernel::processCurve4x):

  • platform/audio/AudioResamplerKernel.cpp:

(WebCore::AudioResamplerKernel::AudioResamplerKernel):
(WebCore::AudioResamplerKernel::getSourcePointer):
(WebCore::AudioResamplerKernel::process):

  • platform/audio/AudioResamplerKernel.h:
  • platform/audio/AudioUtilities.h:
  • platform/audio/Biquad.cpp:

(WebCore::Biquad::Biquad):

  • platform/audio/Biquad.h:
  • platform/audio/HRTFPanner.cpp:

(WebCore::HRTFPanner::HRTFPanner):
(WebCore::HRTFPanner::pan):

  • platform/audio/IIRFilter.cpp:

(WebCore::IIRFilter::tailTime):

  • platform/audio/cocoa/AudioDestinationCocoa.cpp:

(WebCore::AudioDestinationCocoa::AudioDestinationCocoa):
(WebCore::AudioDestinationCocoa::render):
(WebCore::AudioDestinationCocoa::provideInput):

  • platform/audio/cocoa/MediaSessionManagerCocoa.mm:

(WebCore::MediaSessionManagerCocoa::updateSessionState):

  • platform/audio/gstreamer/AudioDestinationGStreamer.cpp:

(WebCore::AudioDestinationGStreamer::AudioDestinationGStreamer):
(WebCore::AudioDestinationGStreamer::framesPerBuffer const):

  • platform/audio/gstreamer/WebKitWebAudioSourceGStreamer.cpp:

(webkit_web_audio_src_class_init):

Location:
trunk/Source/WebCore
Files:
38 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r267539 r267541  
     12020-09-24  Chris Dumez  <cdumez@apple.com>
     2
     3        Declare render quantum size constant in AudioUtilities.h
     4        https://bugs.webkit.org/show_bug.cgi?id=216935
     5
     6        Reviewed by Eric Carlson.
     7
     8        Declare render quantum size [1] constant in AudioUtilities.h so that it can be used in both
     9        platform/ and Modules/webaudio/. Also update the code so that we have a single constant
     10        instead of many.
     11
     12        [1] https://www.w3.org/TR/webaudio/#render-quantum-size
     13
     14        * Modules/webaudio/AudioListener.cpp:
     15        (WebCore::AudioListener::AudioListener):
     16        * Modules/webaudio/AudioNode.h:
     17        * Modules/webaudio/AudioNodeInput.cpp:
     18        (WebCore::AudioNodeInput::AudioNodeInput):
     19        (WebCore::AudioNodeInput::updateInternalBus):
     20        * Modules/webaudio/AudioNodeOutput.cpp:
     21        (WebCore::AudioNodeOutput::AudioNodeOutput):
     22        (WebCore::AudioNodeOutput::updateInternalBus):
     23        * Modules/webaudio/AudioParam.cpp:
     24        (WebCore::AudioParam::calculateFinalValues):
     25        (WebCore::AudioParam::calculateTimelineValues):
     26        * Modules/webaudio/AudioParamTimeline.cpp:
     27        (WebCore::AudioParamTimeline::valueForContextTime):
     28        * Modules/webaudio/AudioScheduledSourceNode.cpp:
     29        (WebCore::AudioScheduledSourceNode::updateSchedulingInfo):
     30        * Modules/webaudio/BiquadDSPKernel.cpp:
     31        (WebCore::BiquadDSPKernel::updateCoefficientsIfNecessary):
     32        * Modules/webaudio/BiquadProcessor.cpp:
     33        (WebCore::BiquadProcessor::processOnlyAudioParams):
     34        * Modules/webaudio/ConstantSourceNode.cpp:
     35        (WebCore::ConstantSourceNode::ConstantSourceNode):
     36        * Modules/webaudio/ConstantSourceNode.h:
     37        * Modules/webaudio/ConvolverNode.cpp:
     38        (WebCore::ConvolverNode::setBuffer):
     39        * Modules/webaudio/DelayDSPKernel.cpp:
     40        (WebCore::DelayDSPKernel::DelayDSPKernel):
     41        (WebCore::DelayDSPKernel::processOnlyAudioParams):
     42        * Modules/webaudio/DynamicsCompressorNode.cpp:
     43        (WebCore::DynamicsCompressorNode::processOnlyAudioParams):
     44        * Modules/webaudio/GainNode.cpp:
     45        (WebCore::GainNode::GainNode):
     46        (WebCore::GainNode::processOnlyAudioParams):
     47        * Modules/webaudio/OfflineAudioContext.cpp:
     48        (WebCore::OfflineAudioContext::suspendOfflineRendering):
     49        * Modules/webaudio/OfflineAudioDestinationNode.cpp:
     50        (WebCore::OfflineAudioDestinationNode::OfflineAudioDestinationNode):
     51        (WebCore::OfflineAudioDestinationNode::offlineRender):
     52        * Modules/webaudio/OfflineAudioDestinationNode.h:
     53        * Modules/webaudio/OscillatorNode.cpp:
     54        (WebCore::OscillatorNode::OscillatorNode):
     55        * Modules/webaudio/OscillatorNode.h:
     56        * Modules/webaudio/PannerNode.cpp:
     57        (WebCore::PannerNode::processOnlyAudioParams):
     58        (WebCore::PannerNode::processSampleAccurateValues):
     59        * Modules/webaudio/RealtimeAnalyser.cpp:
     60        (WebCore::RealtimeAnalyser::RealtimeAnalyser):
     61        * Modules/webaudio/ScriptProcessorNode.cpp:
     62        (WebCore::ScriptProcessorNode::ScriptProcessorNode):
     63        * Modules/webaudio/StereoPannerNode.cpp:
     64        (WebCore::StereoPannerNode::StereoPannerNode):
     65        (WebCore::StereoPannerNode::processOnlyAudioParams):
     66        * Modules/webaudio/StereoPannerNode.h:
     67        * Modules/webaudio/WaveShaperDSPKernel.cpp:
     68        (WebCore::WaveShaperDSPKernel::lazyInitializeOversampling):
     69        (WebCore::WaveShaperDSPKernel::processCurve2x):
     70        (WebCore::WaveShaperDSPKernel::processCurve4x):
     71        * platform/audio/AudioResamplerKernel.cpp:
     72        (WebCore::AudioResamplerKernel::AudioResamplerKernel):
     73        (WebCore::AudioResamplerKernel::getSourcePointer):
     74        (WebCore::AudioResamplerKernel::process):
     75        * platform/audio/AudioResamplerKernel.h:
     76        * platform/audio/AudioUtilities.h:
     77        * platform/audio/Biquad.cpp:
     78        (WebCore::Biquad::Biquad):
     79        * platform/audio/Biquad.h:
     80        * platform/audio/HRTFPanner.cpp:
     81        (WebCore::HRTFPanner::HRTFPanner):
     82        (WebCore::HRTFPanner::pan):
     83        * platform/audio/IIRFilter.cpp:
     84        (WebCore::IIRFilter::tailTime):
     85        * platform/audio/cocoa/AudioDestinationCocoa.cpp:
     86        (WebCore::AudioDestinationCocoa::AudioDestinationCocoa):
     87        (WebCore::AudioDestinationCocoa::render):
     88        (WebCore::AudioDestinationCocoa::provideInput):
     89        * platform/audio/cocoa/MediaSessionManagerCocoa.mm:
     90        (WebCore::MediaSessionManagerCocoa::updateSessionState):
     91        * platform/audio/gstreamer/AudioDestinationGStreamer.cpp:
     92        (WebCore::AudioDestinationGStreamer::AudioDestinationGStreamer):
     93        (WebCore::AudioDestinationGStreamer::framesPerBuffer const):
     94        * platform/audio/gstreamer/WebKitWebAudioSourceGStreamer.cpp:
     95        (webkit_web_audio_src_class_init):
     96
    1972020-09-24  Youenn Fablet  <youenn@apple.com>
    298

  • trunk/Source/WebCore/Modules/webaudio/AudioListener.cpp

    r266319 r267541  
    3636#include "AudioBus.h"
    3737#include "AudioParam.h"
     38#include "AudioUtilities.h"
    3839
    3940namespace WebCore {
    … …  
    4950    , m_upY(AudioParam::create(context, "upY", 1.0, -FLT_MAX, FLT_MAX, AutomationRate::ARate))
    5051    , m_upZ(AudioParam::create(context, "upZ", 0.0, -FLT_MAX, FLT_MAX, AutomationRate::ARate))
    51     , m_positionXValues(AudioNode::ProcessingSizeInFrames)
    52     , m_positionYValues(AudioNode::ProcessingSizeInFrames)
    53     , m_positionZValues(AudioNode::ProcessingSizeInFrames)
    54     , m_forwardXValues(AudioNode::ProcessingSizeInFrames)
    55     , m_forwardYValues(AudioNode::ProcessingSizeInFrames)
    56     , m_forwardZValues(AudioNode::ProcessingSizeInFrames)
    57     , m_upXValues(AudioNode::ProcessingSizeInFrames)
    58     , m_upYValues(AudioNode::ProcessingSizeInFrames)
    59     , m_upZValues(AudioNode::ProcessingSizeInFrames)
     52    , m_positionXValues(AudioUtilities::renderQuantumSize)
     53    , m_positionYValues(AudioUtilities::renderQuantumSize)
     54    , m_positionZValues(AudioUtilities::renderQuantumSize)
     55    , m_forwardXValues(AudioUtilities::renderQuantumSize)
     56    , m_forwardYValues(AudioUtilities::renderQuantumSize)
     57    , m_forwardZValues(AudioUtilities::renderQuantumSize)
     58    , m_upXValues(AudioUtilities::renderQuantumSize)
     59    , m_upYValues(AudioUtilities::renderQuantumSize)
     60    , m_upZValues(AudioUtilities::renderQuantumSize)
    6061{
    6162}

  • trunk/Source/WebCore/Modules/webaudio/AudioNode.h

    r267537 r267541  
    6060    WTF_MAKE_ISO_ALLOCATED(AudioNode);
    6161public:
    62     enum { ProcessingSizeInFrames = 128 };
    63 
    6462    explicit AudioNode(BaseAudioContext&);
    6563    virtual ~AudioNode();

  • trunk/Source/WebCore/Modules/webaudio/AudioNodeInput.cpp

    r266518 r267541  
    4242{
    4343    // Set to mono by default.
    44     m_internalSummingBus = AudioBus::create(1, AudioNode::ProcessingSizeInFrames);
     44    m_internalSummingBus = AudioBus::create(1, AudioUtilities::renderQuantumSize);
    4545}
    4646
    … …  
    142142        return;
    143143
    144     m_internalSummingBus = AudioBus::create(numberOfInputChannels, AudioNode::ProcessingSizeInFrames);
     144    m_internalSummingBus = AudioBus::create(numberOfInputChannels, AudioUtilities::renderQuantumSize);
    145145}
    146146

  • trunk/Source/WebCore/Modules/webaudio/AudioNodeOutput.cpp

    r196603 r267541  
    4848    ASSERT(numberOfChannels <= AudioContext::maxNumberOfChannels());
    4949
    50     m_internalBus = AudioBus::create(numberOfChannels, AudioNode::ProcessingSizeInFrames);
     50    m_internalBus = AudioBus::create(numberOfChannels, AudioUtilities::renderQuantumSize);
    5151}
    5252
    … …  
    7272        return;
    7373
    74     m_internalBus = AudioBus::create(numberOfChannels(), AudioNode::ProcessingSizeInFrames);
     74    m_internalBus = AudioBus::create(numberOfChannels(), AudioUtilities::renderQuantumSize);
    7575}
    7676

  • trunk/Source/WebCore/Modules/webaudio/AudioParam.cpp

    r266788 r267541  
    280280
    281281        // Render audio from this output.
    282         AudioBus* connectionBus = output->pull(0, AudioNode::ProcessingSizeInFrames);
     282        AudioBus* connectionBus = output->pull(0, AudioUtilities::renderQuantumSize);
    283283
    284284        // Sum, with unity-gain.
    … …  
    301301{
    302302    // Calculate values for this render quantum.
    303     // Normally numberOfValues will equal AudioNode::ProcessingSizeInFrames (the render quantum size).
     303    // Normally numberOfValues will equal AudioUtilities::renderQuantumSize (the render quantum size).
    304304    double sampleRate = context().sampleRate();
    305305    size_t startFrame = context().currentSampleFrame();

  • trunk/Source/WebCore/Modules/webaudio/AudioParamTimeline.cpp

    r267435 r267541  
    330330    size_t startFrame = context.currentSampleFrame();
    331331    size_t endFrame = startFrame + 1;
    332     double controlRate = sampleRate / AudioNode::ProcessingSizeInFrames; // one parameter change per render quantum
     332    double controlRate = sampleRate / AudioUtilities::renderQuantumSize; // one parameter change per render quantum
    333333    value = valuesForTimeRange(startFrame, endFrame, defaultValue, minValue, maxValue, &value, 1, sampleRate, controlRate);
    334334    return value;

  • trunk/Source/WebCore/Modules/webaudio/AudioScheduledSourceNode.cpp

    r267443 r267541  
    6565    startFrameOffset = 0;
    6666
    67     ASSERT(quantumFrameSize == AudioNode::ProcessingSizeInFrames);
    68     if (quantumFrameSize != AudioNode::ProcessingSizeInFrames)
     67    ASSERT(quantumFrameSize == AudioUtilities::renderQuantumSize);
     68    if (quantumFrameSize != AudioUtilities::renderQuantumSize)
    6969        return;
    7070

  • trunk/Source/WebCore/Modules/webaudio/BiquadDSPKernel.cpp

    r266417 r267541  
    2929#include "BiquadDSPKernel.h"
    3030
     31#include "AudioUtilities.h"
    3132#include "Biquad.h"
    3233#include "BiquadProcessor.h"
    … …  
    5960    if (biquadProcessor()->filterCoefficientsDirty()) {
    6061        if (biquadProcessor()->hasSampleAccurateValues() && biquadProcessor()->shouldUseARate()) {
    61             float cutoffFrequency[Biquad::MaxFramesToProcess];
    62             float q[Biquad::MaxFramesToProcess];
    63             float gain[Biquad::MaxFramesToProcess];
    64             float detune[Biquad::MaxFramesToProcess]; // in Cents
    65 
    66             ASSERT(framesToProcess <= Biquad::MaxFramesToProcess);
     62            float cutoffFrequency[AudioUtilities::renderQuantumSize];
     63            float q[AudioUtilities::renderQuantumSize];
     64            float gain[AudioUtilities::renderQuantumSize];
     65            float detune[AudioUtilities::renderQuantumSize]; // in Cents
     66
     67            ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    6768
    6869            biquadProcessor()->parameter1().calculateSampleAccurateValues(cutoffFrequency, framesToProcess);

  • trunk/Source/WebCore/Modules/webaudio/BiquadProcessor.cpp

    r267432 r267541  
    111111void BiquadProcessor::processOnlyAudioParams(size_t framesToProcess)
    112112{
    113     float values[AudioNode::ProcessingSizeInFrames];
    114     ASSERT(framesToProcess <= AudioNode::ProcessingSizeInFrames);
     113    float values[AudioUtilities::renderQuantumSize];
     114    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    115115
    116116    m_parameter1->calculateSampleAccurateValues(values, framesToProcess);

  • trunk/Source/WebCore/Modules/webaudio/ConstantSourceNode.cpp

    r266221 r267541  
    3232#include "AudioNodeOutput.h"
    3333#include "AudioParam.h"
     34#include "AudioUtilities.h"
    3435#include "ConstantSourceOptions.h"
    3536#include <wtf/IsoMallocInlines.h>
    … …  
    5657    : AudioScheduledSourceNode(context)
    5758    , m_offset(AudioParam::create(context, "offset"_s, offset, -FLT_MAX, FLT_MAX, AutomationRate::ARate))
     59    , m_sampleAccurateValues(AudioUtilities::renderQuantumSize)
    5860{
    5961    setNodeType(NodeTypeConstant);

  • trunk/Source/WebCore/Modules/webaudio/ConstantSourceNode.h

    r267537 r267541  
    5858   
    5959    // Stores sample-accurate values calculated.
    60     AudioFloatArray m_sampleAccurateValues { AudioNode::ProcessingSizeInFrames };
     60    AudioFloatArray m_sampleAccurateValues;
    6161};
    6262

  • trunk/Source/WebCore/Modules/webaudio/ConvolverNode.cpp

    r267537 r267541  
    3333#include "AudioNodeInput.h"
    3434#include "AudioNodeOutput.h"
     35#include "AudioUtilities.h"
    3536#include "Reverb.h"
    3637#include <wtf/IsoMallocInlines.h>
    … …  
    147148    // Create the reverb with the given impulse response.
    148149    bool useBackgroundThreads = !context().isOfflineContext();
    149     auto reverb = makeUnique<Reverb>(bufferBus.get(), AudioNode::ProcessingSizeInFrames, MaxFFTSize, useBackgroundThreads, m_normalize);
     150    auto reverb = makeUnique<Reverb>(bufferBus.get(), AudioUtilities::renderQuantumSize, MaxFFTSize, useBackgroundThreads, m_normalize);
    150151
    151152    {

  • trunk/Source/WebCore/Modules/webaudio/DelayDSPKernel.cpp

    r267432 r267541  
    3636DelayDSPKernel::DelayDSPKernel(DelayProcessor* processor)
    3737    : AudioDSPKernel(processor)
    38     , m_delayTimes(AudioNode::ProcessingSizeInFrames)
     38    , m_delayTimes(AudioUtilities::renderQuantumSize)
    3939{
    4040    ASSERT(processor && processor->sampleRate() > 0);
    … …  
    139139        return;
    140140
    141     float values[AudioNode::ProcessingSizeInFrames];
    142     ASSERT(framesToProcess <= AudioNode::ProcessingSizeInFrames);
     141    float values[AudioUtilities::renderQuantumSize];
     142    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    143143
    144144    delayProcessor()->delayTime().calculateSampleAccurateValues(values, framesToProcess);

  • trunk/Source/WebCore/Modules/webaudio/DynamicsCompressorNode.cpp

    r267537 r267541  
    3333#include "AudioNodeInput.h"
    3434#include "AudioNodeOutput.h"
     35#include "AudioUtilities.h"
    3536#include "DynamicsCompressor.h"
    3637#include "WebKitDynamicsCompressorNode.h"
    … …  
    106107void DynamicsCompressorNode::processOnlyAudioParams(size_t framesToProcess)
    107108{
    108     float values[AudioNode::ProcessingSizeInFrames];
    109     ASSERT(framesToProcess <= AudioNode::ProcessingSizeInFrames);
     109    float values[AudioUtilities::renderQuantumSize];
     110    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    110111
    111112    m_threshold->calculateSampleAccurateValues(values, framesToProcess);

  • trunk/Source/WebCore/Modules/webaudio/GainNode.cpp

    r267537 r267541  
    5858GainNode::GainNode(BaseAudioContext& context)
    5959    : AudioNode(context)
    60     , m_sampleAccurateGainValues(AudioNode::ProcessingSizeInFrames) // FIXME: can probably share temp buffer in context
     60    , m_sampleAccurateGainValues(AudioUtilities::renderQuantumSize) // FIXME: can probably share temp buffer in context
    6161    , m_gain(AudioParam::create(context, "gain"_s, 1.0, -FLT_MAX, FLT_MAX, AutomationRate::ARate))
    6262{
    … …  
    105105void GainNode::processOnlyAudioParams(size_t framesToProcess)
    106106{
    107     float values[AudioNode::ProcessingSizeInFrames];
    108     ASSERT(framesToProcess <= AudioNode::ProcessingSizeInFrames);
     107    float values[AudioUtilities::renderQuantumSize];
     108    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    109109
    110110    m_gain->calculateSampleAccurateValues(values, framesToProcess);

  • trunk/Source/WebCore/Modules/webaudio/OfflineAudioContext.cpp

    r267151 r267541  
    143143
    144144    size_t frame = AudioUtilities::timeToSampleFrame(suspendTime, sampleRate());
    145     frame = OfflineAudioDestinationNode::renderQuantumSize * ((frame + OfflineAudioDestinationNode::renderQuantumSize - 1) / OfflineAudioDestinationNode::renderQuantumSize);
     145    frame = AudioUtilities::renderQuantumSize * ((frame + AudioUtilities::renderQuantumSize - 1) / AudioUtilities::renderQuantumSize);
    146146    if (frame < currentSampleFrame()) {
    147147        promise->reject(Exception { InvalidStateError, "Suspension frame is earlier than current frame"_s });

  • trunk/Source/WebCore/Modules/webaudio/OfflineAudioDestinationNode.cpp

    r267505 r267541  
    3131#include "AudioBus.h"
    3232#include "AudioContext.h"
     33#include "AudioUtilities.h"
    3334#include "HRTFDatabaseLoader.h"
    3435#include <algorithm>
    … …  
    3940
    4041WTF_MAKE_ISO_ALLOCATED_IMPL(OfflineAudioDestinationNode);
    41    
    42 const size_t OfflineAudioDestinationNode::renderQuantumSize = 128;
    4342
    4443OfflineAudioDestinationNode::OfflineAudioDestinationNode(BaseAudioContext& context, unsigned numberOfChannels, RefPtr<AudioBuffer>&& renderTarget)
    … …  
    4847    , m_framesToProcess(m_renderTarget ? m_renderTarget->length() : 0)
    4948{
    50     m_renderBus = AudioBus::create(numberOfChannels, renderQuantumSize);
     49    m_renderBus = AudioBus::create(numberOfChannels, AudioUtilities::renderQuantumSize);
    5150    initializeDefaultNodeOptions(numberOfChannels, ChannelCountMode::Explicit, ChannelInterpretation::Speakers);
    5251}
    … …  
    135134        return OfflineRenderResult::Failure;
    136135
    137     bool isRenderBusAllocated = m_renderBus->length() >= renderQuantumSize;
     136    bool isRenderBusAllocated = m_renderBus->length() >= AudioUtilities::renderQuantumSize;
    138137    ASSERT(isRenderBusAllocated);
    139138    if (!isRenderBusAllocated)
    … …  
    149148
    150149        // Render one render quantum.
    151         render(0, m_renderBus.get(), renderQuantumSize, { });
     150        render(0, m_renderBus.get(), AudioUtilities::renderQuantumSize, { });
    152151       
    153         size_t framesAvailableToCopy = std::min(m_framesToProcess, renderQuantumSize);
     152        size_t framesAvailableToCopy = std::min(m_framesToProcess, AudioUtilities::renderQuantumSize);
    154153       
    155154        for (unsigned channelIndex = 0; channelIndex < numberOfChannels; ++channelIndex) {

  • trunk/Source/WebCore/Modules/webaudio/OfflineAudioDestinationNode.h

    r267147 r267541  
    5555    float sampleRate() const final { return m_renderTarget->sampleRate(); }
    5656
    57     static const size_t renderQuantumSize;
    58 
    5957private:
    6058    OfflineAudioDestinationNode(BaseAudioContext&, unsigned numberOfChannels, RefPtr<AudioBuffer>&& renderTarget);

  • trunk/Source/WebCore/Modules/webaudio/OscillatorNode.cpp

    r267537 r267541  
    3131#include "AudioNodeOutput.h"
    3232#include "AudioParam.h"
     33#include "AudioUtilities.h"
    3334#include "PeriodicWave.h"
    3435#include "VectorMath.h"
    … …  
    9596    , m_frequency(AudioParam::create(context, "frequency"_s, options.frequency, -context.sampleRate() / 2, context.sampleRate() / 2, AutomationRate::ARate))
    9697    , m_detune(AudioParam::create(context, "detune"_s, options.detune, -1200 * log2f(std::numeric_limits<float>::max()), 1200 * log2f(std::numeric_limits<float>::max()), AutomationRate::ARate))
     98    , m_phaseIncrements(AudioUtilities::renderQuantumSize)
     99    , m_detuneValues(AudioUtilities::renderQuantumSize)
    97100{
    98101    setNodeType(NodeTypeOscillator);

  • trunk/Source/WebCore/Modules/webaudio/OscillatorNode.h

    r267537 r267541  
    8989
    9090    // Stores sample-accurate values calculated according to frequency and detune.
    91     AudioFloatArray m_phaseIncrements { AudioNode::ProcessingSizeInFrames };
    92     AudioFloatArray m_detuneValues { AudioNode::ProcessingSizeInFrames };
     91    AudioFloatArray m_phaseIncrements;
     92    AudioFloatArray m_detuneValues;
    9393   
    9494    RefPtr<PeriodicWave> m_periodicWave;

  • trunk/Source/WebCore/Modules/webaudio/PannerNode.cpp

    r267537 r267541  
    184184void PannerNode::processOnlyAudioParams(size_t framesToProcess)
    185185{
    186     float values[AudioNode::ProcessingSizeInFrames];
    187     ASSERT(framesToProcess <= AudioNode::ProcessingSizeInFrames);
     186    float values[AudioUtilities::renderQuantumSize];
     187    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    188188
    189189    m_positionX->calculateSampleAccurateValues(values, framesToProcess);
    … …  
    202202    // Get the sample accurate values from all of the AudioParams, including the
    203203    // values from the AudioListener.
    204     float pannerX[AudioNode::ProcessingSizeInFrames];
    205     float pannerY[AudioNode::ProcessingSizeInFrames];
    206     float pannerZ[AudioNode::ProcessingSizeInFrames];
    207 
    208     float orientationX[AudioNode::ProcessingSizeInFrames];
    209     float orientationY[AudioNode::ProcessingSizeInFrames];
    210     float orientationZ[AudioNode::ProcessingSizeInFrames];
     204    float pannerX[AudioUtilities::renderQuantumSize];
     205    float pannerY[AudioUtilities::renderQuantumSize];
     206    float pannerZ[AudioUtilities::renderQuantumSize];
     207
     208    float orientationX[AudioUtilities::renderQuantumSize];
     209    float orientationY[AudioUtilities::renderQuantumSize];
     210    float orientationZ[AudioUtilities::renderQuantumSize];
    211211
    212212    m_positionX->calculateSampleAccurateValues(pannerX, framesToProcess);
    … …  
    218218
    219219    // Get the automation values from the listener.
    220     const float* listenerX = listener().positionXValues(AudioNode::ProcessingSizeInFrames);
    221     const float* listenerY = listener().positionYValues(AudioNode::ProcessingSizeInFrames);
    222     const float* listenerZ = listener().positionZValues(AudioNode::ProcessingSizeInFrames);
    223 
    224     const float* forwardX = listener().forwardXValues(AudioNode::ProcessingSizeInFrames);
    225     const float* forwardY = listener().forwardYValues(AudioNode::ProcessingSizeInFrames);
    226     const float* forwardZ = listener().forwardZValues(AudioNode::ProcessingSizeInFrames);
    227 
    228     const float* upX = listener().upXValues(AudioNode::ProcessingSizeInFrames);
    229     const float* upY = listener().upYValues(AudioNode::ProcessingSizeInFrames);
    230     const float* upZ = listener().upZValues(AudioNode::ProcessingSizeInFrames);
     220    const float* listenerX = listener().positionXValues(AudioUtilities::renderQuantumSize);
     221    const float* listenerY = listener().positionYValues(AudioUtilities::renderQuantumSize);
     222    const float* listenerZ = listener().positionZValues(AudioUtilities::renderQuantumSize);
     223
     224    const float* forwardX = listener().forwardXValues(AudioUtilities::renderQuantumSize);
     225    const float* forwardY = listener().forwardYValues(AudioUtilities::renderQuantumSize);
     226    const float* forwardZ = listener().forwardZValues(AudioUtilities::renderQuantumSize);
     227
     228    const float* upX = listener().upXValues(AudioUtilities::renderQuantumSize);
     229    const float* upY = listener().upYValues(AudioUtilities::renderQuantumSize);
     230    const float* upZ = listener().upZValues(AudioUtilities::renderQuantumSize);
    231231
    232232    // Compute the azimuth, elevation, and total gains for each position.
    233     double azimuth[AudioNode::ProcessingSizeInFrames];
    234     double elevation[AudioNode::ProcessingSizeInFrames];
    235     float totalGain[AudioNode::ProcessingSizeInFrames];
     233    double azimuth[AudioUtilities::renderQuantumSize];
     234    double elevation[AudioUtilities::renderQuantumSize];
     235    float totalGain[AudioUtilities::renderQuantumSize];
    236236
    237237    for (size_t k = 0; k < framesToProcess; ++k) {

  • trunk/Source/WebCore/Modules/webaudio/RealtimeAnalyser.cpp

    r267537 r267541  
    5656    : m_inputBuffer(InputBufferSize)
    5757    , m_writeIndex(0)
    58     , m_downmixBus(AudioBus::create(1, AudioNode::ProcessingSizeInFrames))
     58    , m_downmixBus(AudioBus::create(1, AudioUtilities::renderQuantumSize))
    5959    , m_fftSize(DefaultFFTSize)
    6060    , m_magnitudeBuffer(DefaultFFTSize / 2)

  • trunk/Source/WebCore/Modules/webaudio/ScriptProcessorNode.cpp

    r267537 r267541  
    3535#include "AudioNodeOutput.h"
    3636#include "AudioProcessingEvent.h"
     37#include "AudioUtilities.h"
    3738#include "Document.h"
    3839#include "EventNames.h"
    … …  
    5960    , m_numberOfInputChannels(numberOfInputChannels)
    6061    , m_numberOfOutputChannels(numberOfOutputChannels)
    61     , m_internalInputBus(AudioBus::create(numberOfInputChannels, AudioNode::ProcessingSizeInFrames, false))
     62    , m_internalInputBus(AudioBus::create(numberOfInputChannels, AudioUtilities::renderQuantumSize, false))
    6263{
    6364    // Regardless of the allowed buffer sizes, we still need to process at the granularity of the AudioNode.
    64     if (m_bufferSize < AudioNode::ProcessingSizeInFrames)
    65         m_bufferSize = AudioNode::ProcessingSizeInFrames;
     65    if (m_bufferSize < AudioUtilities::renderQuantumSize)
     66        m_bufferSize = AudioUtilities::renderQuantumSize;
    6667
    6768    ASSERT(numberOfInputChannels <= AudioContext::maxNumberOfChannels());

  • trunk/Source/WebCore/Modules/webaudio/StereoPannerNode.cpp

    r267432 r267541  
    3333#include "AudioNodeInput.h"
    3434#include "AudioNodeOutput.h"
     35#include "AudioUtilities.h"
    3536#include <wtf/IsoMallocInlines.h>
    3637
    … …  
    5859    : AudioNode(context)
    5960    , m_pan(AudioParam::create(context, "pan"_s, pan, -1, 1, AutomationRate::ARate))
     61    , m_sampleAccurateValues(AudioUtilities::renderQuantumSize)
    6062{
    6163    setNodeType(NodeTypeStereo);
    … …  
    103105void StereoPannerNode::processOnlyAudioParams(size_t framesToProcess)
    104106{
    105     float values[AudioNode::ProcessingSizeInFrames];
    106     ASSERT(framesToProcess <= AudioNode::ProcessingSizeInFrames);
     107    float values[AudioUtilities::renderQuantumSize];
     108    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    107109
    108110    m_pan->calculateSampleAccurateValues(values, framesToProcess);

  • trunk/Source/WebCore/Modules/webaudio/StereoPannerNode.h

    r267537 r267541  
    6262   
    6363    Ref<AudioParam> m_pan;
    64     AudioFloatArray m_sampleAccurateValues { AudioNode::ProcessingSizeInFrames };
     64    AudioFloatArray m_sampleAccurateValues;
    6565};
    6666

  • trunk/Source/WebCore/Modules/webaudio/WaveShaperDSPKernel.cpp

    r266417 r267541  
    2929#include "WaveShaperDSPKernel.h"
    3030
     31#include "AudioUtilities.h"
    3132#include "WaveShaperProcessor.h"
    3233#include <algorithm>
    … …  
    3435#include <wtf/Threading.h>
    3536
    36 const unsigned RenderingQuantum = 128;
    37 
    3837namespace WebCore {
    3938
    … …  
    5049
    5150    if (!m_tempBuffer) {
    52         m_tempBuffer = makeUnique<AudioFloatArray>(RenderingQuantum * 2);
    53         m_tempBuffer2 = makeUnique<AudioFloatArray>(RenderingQuantum * 4);
    54         m_upSampler = makeUnique<UpSampler>(RenderingQuantum);
    55         m_downSampler = makeUnique<DownSampler>(RenderingQuantum * 2);
    56         m_upSampler2 = makeUnique<UpSampler>(RenderingQuantum * 2);
    57         m_downSampler2 = makeUnique<DownSampler>(RenderingQuantum * 4);
     51        m_tempBuffer = makeUnique<AudioFloatArray>(AudioUtilities::renderQuantumSize * 2);
     52        m_tempBuffer2 = makeUnique<AudioFloatArray>(AudioUtilities::renderQuantumSize * 4);
     53        m_upSampler = makeUnique<UpSampler>(AudioUtilities::renderQuantumSize);
     54        m_downSampler = makeUnique<DownSampler>(AudioUtilities::renderQuantumSize * 2);
     55        m_upSampler2 = makeUnique<UpSampler>(AudioUtilities::renderQuantumSize * 2);
     56        m_downSampler2 = makeUnique<DownSampler>(AudioUtilities::renderQuantumSize * 4);
    5857    }
    5958}
    … …  
    118117void WaveShaperDSPKernel::processCurve2x(const float* source, float* destination, size_t framesToProcess)
    119118{
    120     bool isSafe = framesToProcess == RenderingQuantum;
     119    bool isSafe = framesToProcess == AudioUtilities::renderQuantumSize;
    121120    ASSERT(isSafe);
    122121    if (!isSafe)
    … …  
    135134void WaveShaperDSPKernel::processCurve4x(const float* source, float* destination, size_t framesToProcess)
    136135{
    137     bool isSafe = framesToProcess == RenderingQuantum;
     136    bool isSafe = framesToProcess == AudioUtilities::renderQuantumSize;
    138137    ASSERT(isSafe);
    139138    if (!isSafe)

  • trunk/Source/WebCore/platform/audio/AudioResamplerKernel.cpp

    r159027 r267541  
    3030
    3131#include "AudioResampler.h"
     32#include "AudioUtilities.h"
    3233#include <algorithm>
    3334
    3435namespace WebCore {
    35    
    36 const size_t AudioResamplerKernel::MaxFramesToProcess = 128;
    3736
    3837AudioResamplerKernel::AudioResamplerKernel(AudioResampler* resampler)
    3938    : m_resampler(resampler)
    4039    // The buffer size must be large enough to hold up to two extra sample frames for the linear interpolation.
    41     , m_sourceBuffer(2 + static_cast<int>(MaxFramesToProcess * AudioResampler::MaxRate))
     40    , m_sourceBuffer(2 + static_cast<int>(AudioUtilities::renderQuantumSize * AudioResampler::MaxRate))
    4241    , m_virtualReadIndex(0.0)
    4342    , m_fillIndex(0)
    … …  
    4948float* AudioResamplerKernel::getSourcePointer(size_t framesToProcess, size_t* numberOfSourceFramesNeededP)
    5049{
    51     ASSERT(framesToProcess <= MaxFramesToProcess);
     50    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    5251   
    5352    // Calculate the next "virtual" index.  After process() is called, m_virtualReadIndex will equal this value.
    … …  
    7473void AudioResamplerKernel::process(float* destination, size_t framesToProcess)
    7574{
    76     ASSERT(framesToProcess <= MaxFramesToProcess);
     75    ASSERT(framesToProcess <= AudioUtilities::renderQuantumSize);
    7776
    7877    float* source = m_sourceBuffer.data();

  • trunk/Source/WebCore/platform/audio/AudioResamplerKernel.h

    r249022 r267541  
    4646    // Given a number of frames to process (for subsequent call to process()), it returns a pointer and numberOfSourceFramesNeeded
    4747    // where sample data should be copied. This sample data provides the input to the resampler when process() is called.
    48     // framesToProcess must be less than or equal to MaxFramesToProcess.
     48    // framesToProcess must be less than or equal to AudioUtilities::renderQuantumSize.
    4949    float* getSourcePointer(size_t framesToProcess, size_t* numberOfSourceFramesNeeded);
    5050
    5151    // process() resamples framesToProcess frames from the source into destination.
    5252    // Each call to process() must be preceded by a call to getSourcePointer() so that source input may be supplied.
    53     // framesToProcess must be less than or equal to MaxFramesToProcess.
     53    // framesToProcess must be less than or equal to AudioUtilities::renderQuantumSize.
    5454    void process(float* destination, size_t framesToProcess);
    5555
    5656    // Resets the processing state.
    5757    void reset();
    58 
    59     static const size_t MaxFramesToProcess;
    6058
    6159private:

  • trunk/Source/WebCore/platform/audio/AudioUtilities.h

    r267202 r267541  
    2929
    3030namespace AudioUtilities {
     31
     32// https://www.w3.org/TR/webaudio/#render-quantum-size
     33constexpr size_t renderQuantumSize = 128;
    3134
    3235// Standard functions for converting to and from decibel values from linear.

  • trunk/Source/WebCore/platform/audio/Biquad.cpp

    r267444 r267541  
    3333#include "Biquad.h"
    3434
     35#include "AudioUtilities.h"
    3536#include "DenormalDisabler.h"
    3637#include <algorithm>
    … …  
    6061    // Allocate enough space for the a-rate filter coefficients to handle a
    6162    // rendering quantum of 128 frames.
    62     m_b0.allocate(MaxFramesToProcess);
    63     m_b1.allocate(MaxFramesToProcess);
    64     m_b2.allocate(MaxFramesToProcess);
    65     m_a1.allocate(MaxFramesToProcess);
    66     m_a2.allocate(MaxFramesToProcess);
     63    m_b0.allocate(AudioUtilities::renderQuantumSize);
     64    m_b1.allocate(AudioUtilities::renderQuantumSize);
     65    m_b2.allocate(AudioUtilities::renderQuantumSize);
     66    m_a1.allocate(AudioUtilities::renderQuantumSize);
     67    m_a2.allocate(AudioUtilities::renderQuantumSize);
    6768
    6869    // Initialize as pass-thru (straight-wire, no filter effect)

  • trunk/Source/WebCore/platform/audio/Biquad.h

    r266398 r267541  
    4646    Biquad();
    4747    ~Biquad();
    48 
    49     static constexpr size_t MaxFramesToProcess = 128;
    5048
    5149    void process(const float* sourceP, float* destP, size_t framesToProcess);

  • trunk/Source/WebCore/platform/audio/HRTFPanner.cpp

    r266417 r267541  
    3030
    3131#include "AudioBus.h"
     32#include "AudioUtilities.h"
    3233#include "FFTConvolver.h"
    3334#include "HRTFDatabase.h"
    … …  
    4344
    4445const int UninitializedAzimuth = -1;
    45 const unsigned RenderingQuantum = 128;
    4646
    4747HRTFPanner::HRTFPanner(float sampleRate, HRTFDatabaseLoader* databaseLoader)
    … …  
    6262    , m_delayLineL(MaxDelayTimeSeconds, sampleRate)
    6363    , m_delayLineR(MaxDelayTimeSeconds, sampleRate)
    64     , m_tempL1(RenderingQuantum)
    65     , m_tempR1(RenderingQuantum)
    66     , m_tempL2(RenderingQuantum)
    67     , m_tempR2(RenderingQuantum)
     64    , m_tempL1(AudioUtilities::renderQuantumSize)
     65    , m_tempR1(AudioUtilities::renderQuantumSize)
     66    , m_tempL2(AudioUtilities::renderQuantumSize)
     67    , m_tempR2(AudioUtilities::renderQuantumSize)
    6868{
    6969    ASSERT(databaseLoader);
    … …  
    219219    }
    220220
    221     // This algorithm currently requires that we process in power-of-two size chunks at least RenderingQuantum.
     221    // This algorithm currently requires that we process in power-of-two size chunks at least AudioUtilities::renderQuantumSize.
    222222    ASSERT(1UL << static_cast<int>(log2(framesToProcess)) == framesToProcess);
    223     ASSERT(framesToProcess >= RenderingQuantum);
    224 
    225     const unsigned framesPerSegment = RenderingQuantum;
     223    ASSERT(framesToProcess >= AudioUtilities::renderQuantumSize);
     224
     225    const unsigned framesPerSegment = AudioUtilities::renderQuantumSize;
    226226    const unsigned numberOfSegments = framesToProcess / framesPerSegment;
    227227

  • trunk/Source/WebCore/platform/audio/IIRFilter.cpp

    r266186 r267541  
    3030
    3131#include "AudioArray.h"
     32#include "AudioUtilities.h"
    3233#include "VectorMath.h"
    3334#include <algorithm>
    … …  
    3637
    3738namespace WebCore {
    38 
    39 constexpr unsigned iirRenderingQuantum = 128;
    4039
    4140// The length of the memory buffers for the IIR filter. This MUST be a power of
    … …  
    189188
    190189    // Number of render quanta needed to reach the max tail time.
    191     int numberOfBlocks = std::ceil(sampleRate * maxTailTime / iirRenderingQuantum);
     190    int numberOfBlocks = std::ceil(sampleRate * maxTailTime / AudioUtilities::renderQuantumSize);
    192191
    193192    // Input and output buffers for filtering.
    194     AudioFloatArray input(iirRenderingQuantum);
    195     AudioFloatArray output(iirRenderingQuantum);
     193    AudioFloatArray input(AudioUtilities::renderQuantumSize);
     194    AudioFloatArray output(AudioUtilities::renderQuantumSize);
    196195
    197196    // Array to hold the max magnitudes
    … …  
    202201
    203202    // Process the first block and get the max magnitude of the output.
    204     process(input.data(), output.data(), iirRenderingQuantum);
    205     VectorMath::vmaxmgv(output.data(), 1, &magnitudes[0], iirRenderingQuantum);
     203    process(input.data(), output.data(), AudioUtilities::renderQuantumSize);
     204    VectorMath::vmaxmgv(output.data(), 1, &magnitudes[0], AudioUtilities::renderQuantumSize);
    206205
    207206    // Process the rest of the signal, getting the max magnitude of the
    … …  
    210209
    211210    for (int k = 1; k < numberOfBlocks; ++k) {
    212         process(input.data(), output.data(), iirRenderingQuantum);
    213         VectorMath::vmaxmgv(output.data(), 1, &magnitudes[k], iirRenderingQuantum);
     211        process(input.data(), output.data(), AudioUtilities::renderQuantumSize);
     212        VectorMath::vmaxmgv(output.data(), 1, &magnitudes[k], AudioUtilities::renderQuantumSize);
    214213    }
    215214
    … …  
    229228    // The magnitude first become lower than the threshold at the next block.
    230229    // Compute the corresponding time value value; that's the tail time.
    231     return (index + 1) * iirRenderingQuantum / sampleRate;
     230    return (index + 1) * AudioUtilities::renderQuantumSize / sampleRate;
    232231}
    233232

  • trunk/Source/WebCore/platform/audio/cocoa/AudioDestinationCocoa.cpp

    r267036 r267541  
    3131#include "AudioBus.h"
    3232#include "AudioSession.h"
     33#include "AudioUtilities.h"
    3334#include "Logging.h"
    3435#include "MultiChannelResampler.h"
    … …  
    3738namespace WebCore {
    3839
    39 constexpr size_t kRenderBufferSize = 128;
    40 
    41 constexpr size_t fifoSize = 96 * kRenderBufferSize;
     40constexpr size_t fifoSize = 96 * AudioUtilities::renderQuantumSize;
    4241
    4342CreateAudioDestinationCocoaOverride AudioDestinationCocoa::createOverride = nullptr;
    … …  
    7574    : m_outputUnit(0)
    7675    , m_callback(callback)
    77     , m_outputBus(AudioBus::create(numberOfOutputChannels, kRenderBufferSize, false).releaseNonNull())
    78     , m_renderBus(AudioBus::create(numberOfOutputChannels, kRenderBufferSize).releaseNonNull())
     76    , m_outputBus(AudioBus::create(numberOfOutputChannels, AudioUtilities::renderQuantumSize, false).releaseNonNull())
     77    , m_renderBus(AudioBus::create(numberOfOutputChannels, AudioUtilities::renderQuantumSize).releaseNonNull())
    7978    , m_fifo(makeUniqueRef<PushPullFIFO>(numberOfOutputChannels, fifoSize))
    8079    , m_contextSampleRate(sampleRate)
    … …  
    8584    if (sampleRate != hardwareSampleRate) {
    8685        double scaleFactor = static_cast<double>(sampleRate) / hardwareSampleRate;
    87         m_resampler = makeUnique<MultiChannelResampler>(scaleFactor, numberOfOutputChannels, kRenderBufferSize);
     86        m_resampler = makeUnique<MultiChannelResampler>(scaleFactor, numberOfOutputChannels, AudioUtilities::renderQuantumSize);
    8887    }
    8988}
    … …  
    177176    size_t framesToRender = m_fifo->pull(m_outputBus.ptr(), numberOfFrames);
    178177
    179     for (size_t pushedFrames = 0; pushedFrames < framesToRender; pushedFrames += kRenderBufferSize) {
     178    for (size_t pushedFrames = 0; pushedFrames < framesToRender; pushedFrames += AudioUtilities::renderQuantumSize) {
    180179        if (m_resampler)
    181             m_resampler->process(this, m_renderBus.ptr(), kRenderBufferSize);
     180            m_resampler->process(this, m_renderBus.ptr(), AudioUtilities::renderQuantumSize);
    182181        else
    183             m_callback.render(0, m_renderBus.ptr(), kRenderBufferSize, m_outputTimestamp);
     182            m_callback.render(0, m_renderBus.ptr(), AudioUtilities::renderQuantumSize, m_outputTimestamp);
    184183
    185184        m_fifo->push(m_renderBus.ptr());
    … …  
    198197void AudioDestinationCocoa::provideInput(AudioBus* bus, size_t framesToProcess)
    199198{
    200     ASSERT_UNUSED(framesToProcess, framesToProcess == kRenderBufferSize);
    201     m_callback.render(0, bus, kRenderBufferSize, m_outputTimestamp);
     199    ASSERT_UNUSED(framesToProcess, framesToProcess == AudioUtilities::renderQuantumSize);
     200    m_callback.render(0, bus, AudioUtilities::renderQuantumSize, m_outputTimestamp);
    202201}
    203202

  • trunk/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm

    r266121 r267541  
    3030
    3131#import "AudioSession.h"
     32#import "AudioUtilities.h"
    3233#import "DeprecatedGlobalSettings.h"
    3334#import "HTMLMediaElement.h"
    … …  
    4344#import "MediaRemoteSoftLink.h"
    4445
    45 static const size_t kWebAudioBufferSize = 128;
    4646static const size_t kLowPowerVideoBufferSize = 4096;
    4747
    … …  
    103103
    104104    if (webAudioCount)
    105         AudioSession::sharedSession().setPreferredBufferSize(kWebAudioBufferSize);
     105        AudioSession::sharedSession().setPreferredBufferSize(AudioUtilities::renderQuantumSize);
    106106    // In case of audio capture, we want to grab 20 ms chunks to limit the latency so that it is not noticeable by users
    107107    // while having a large enough buffer so that the audio rendering remains stable, hence a computation based on sample rate.
    … …  
    113113            bufferSize = kLowPowerVideoBufferSize;
    114114        else
    115             bufferSize = kWebAudioBufferSize;
     115            bufferSize = AudioUtilities::renderQuantumSize;
    116116
    117117        AudioSession::sharedSession().setPreferredBufferSize(bufferSize);

  • trunk/Source/WebCore/platform/audio/gstreamer/AudioDestinationGStreamer.cpp

    r266895 r267541  
    2626#include "AudioChannel.h"
    2727#include "AudioSourceProvider.h"
     28#include "AudioUtilities.h"
    2829#include "GRefPtrGStreamer.h"
    2930#include "Logging.h"
    … …  
    3536
    3637namespace WebCore {
    37 
    38 // Size of the AudioBus for playback. The webkitwebaudiosrc element
    39 // needs to handle this number of frames per cycle as well.
    40 const unsigned framesToPull = 128;
    4138
    4239gboolean messageCallback(GstBus*, GstMessage* message, AudioDestinationGStreamer* destination)
    … …  
    8077AudioDestinationGStreamer::AudioDestinationGStreamer(AudioIOCallback& callback, float sampleRate)
    8178    : m_callback(callback)
    82     , m_renderBus(AudioBus::create(2, framesToPull, false))
     79    , m_renderBus(AudioBus::create(2, AudioUtilities::renderQuantumSize, false))
    8380    , m_sampleRate(sampleRate)
    8481    , m_isPlaying(false)
    … …  
    9491                                                                            "bus", m_renderBus.get(),
    9592                                                                            "provider", &m_callback,
    96                                                                             "frames", framesToPull, nullptr));
     93                                                                            "frames", AudioUtilities::renderQuantumSize, nullptr));
    9794
    9895    GRefPtr<GstElement> audioSink = gst_element_factory_make("autoaudiosink", nullptr);
    … …  
    139136unsigned AudioDestinationGStreamer::framesPerBuffer() const
    140137{
    141     return framesToPull;
     138    return AudioUtilities::renderQuantumSize;
    142139}
    143140

  • trunk/Source/WebCore/platform/audio/gstreamer/WebKitWebAudioSourceGStreamer.cpp

    r266721 r267541  
    2626#include "AudioBus.h"
    2727#include "AudioIOCallback.h"
     28#include "AudioUtilities.h"
    2829#include "GStreamerCommon.h"
    2930#include <gst/app/gstappsrc.h>
    … …  
    187188                                    g_param_spec_uint("frames", "frames",
    188189                                                      "Number of audio frames to pull at each iteration",
    189                                                       0, G_MAXUINT8, 128, flags));
     190                                                      0, G_MAXUINT8, AudioUtilities::renderQuantumSize, flags));
    190191}
    191192
Note: See TracChangeset for help on using the changeset viewer.