Use kRenderQuantumFrames in more places

third_party/WebKit/Source/platform/audio/HRTFPanner.cpp

 /*
  * 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
@@ skipping 20 matching lines @@
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 // The value of 2 milliseconds is larger than the largest delay which exists in
 // any HRTFKernel from the default HRTFDatabase (0.0136 seconds).
 // We ASSERT the delay values used in process() with this value.
 const double MaxDelayTimeSeconds = 0.002;
 
 const int UninitializedAzimuth = -1;
-const unsigned RenderingQuantum = 128;
 
 HRTFPanner::HRTFPanner(float sampleRate, HRTFDatabaseLoader* databaseLoader)
     : Panner(PanningModelHRTF),
       m_databaseLoader(databaseLoader),
       m_sampleRate(sampleRate),
       m_crossfadeSelection(CrossfadeSelection1),
       m_azimuthIndex1(UninitializedAzimuth),
       m_elevation1(0),
       m_azimuthIndex2(UninitializedAzimuth),
       m_elevation2(0),
       m_crossfadeX(0),
       m_crossfadeIncr(0),
       m_convolverL1(fftSizeForSampleRate(sampleRate)),
       m_convolverR1(fftSizeForSampleRate(sampleRate)),
       m_convolverL2(fftSizeForSampleRate(sampleRate)),
       m_convolverR2(fftSizeForSampleRate(sampleRate)),
       m_delayLineL(MaxDelayTimeSeconds, sampleRate),
       m_delayLineR(MaxDelayTimeSeconds, sampleRate),
-      m_tempL1(RenderingQuantum),
-      m_tempR1(RenderingQuantum),
-      m_tempL2(RenderingQuantum),
-      m_tempR2(RenderingQuantum) {
+      m_tempL1(AudioUtilities::kRenderQuantumFrames),
+      m_tempR1(AudioUtilities::kRenderQuantumFrames),
+      m_tempL2(AudioUtilities::kRenderQuantumFrames),
+      m_tempR2(AudioUtilities::kRenderQuantumFrames) {
   ASSERT(databaseLoader);
 }
 
 HRTFPanner::~HRTFPanner() {}
 
 size_t HRTFPanner::fftSizeForSampleRate(float sampleRate) {
   // The HRTF impulse responses (loaded as audio resources) are 512
   // sample-frames @44.1KHz.  Currently, we truncate the impulse responses to
   // half this size, but an FFT-size of twice impulse response size is needed
   // (for convolution).  So for sample rates around 44.1KHz an FFT size of 512
@@ skipping 129 matching lines @@
   if (m_crossfadeX == 1 && m_crossfadeSelection == CrossfadeSelection2) {
     if (desiredAzimuthIndex != m_azimuthIndex2 || elevation != m_elevation2) {
       // Cross-fade from 2 -> 1
       m_crossfadeIncr = -1 / fadeFrames;
       m_azimuthIndex1 = desiredAzimuthIndex;
       m_elevation1 = elevation;
     }
   }
 
   // This algorithm currently requires that we process in power-of-two size
-  // chunks at least RenderingQuantum.
+  // chunks at least AudioUtilities::kRenderQuantumFrames.
   ASSERT(1UL << static_cast<int>(log2(framesToProcess)) == framesToProcess);
-  ASSERT(framesToProcess >= RenderingQuantum);
+  DCHECK_GE(framesToProcess, AudioUtilities::kRenderQuantumFrames);
 
-  const unsigned framesPerSegment = RenderingQuantum;
+  const unsigned framesPerSegment = AudioUtilities::kRenderQuantumFrames;
   const unsigned numberOfSegments = framesToProcess / framesPerSegment;
 
   for (unsigned segment = 0; segment < numberOfSegments; ++segment) {
     // Get the HRTFKernels and interpolated delays.
     HRTFKernel* kernelL1;
     HRTFKernel* kernelR1;
     HRTFKernel* kernelL2;
     HRTFKernel* kernelR2;
     double frameDelayL1;
     double frameDelayR1;
@@ skipping 126 matching lines @@
          (fftSize() / 2) / static_cast<double>(sampleRate());
 }
 
 double HRTFPanner::latencyTime() const {
   // The latency of a FFTConvolver is also fftSize() / 2, and is in addition to
   // its tailTime of the same value.
   return (fftSize() / 2) / static_cast<double>(sampleRate());
 }
 
 }  // namespace blink