Use AudioUtilities::kRenderQuantumFrames everywhere

third_party/WebKit/Source/modules/webaudio/PannerNode.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 148 matching lines @@
   } else {
     // Too bad - The tryLock() failed.  We must be in the middle of changing the
     // properties of the panner or the listener.
     destination->zero();
   }
 }
 
 void PannerHandler::processSampleAccurateValues(AudioBus* destination,
                                                 const AudioBus* source,
                                                 size_t framesToProcess) {
-  RELEASE_ASSERT(framesToProcess <= ProcessingSizeInFrames);
+  RELEASE_ASSERT(framesToProcess <= AudioUtilities::kRenderQuantumFrames);
 
   // Get the sample accurate values from all of the AudioParams, including the
   // values from the AudioListener.
-  float pannerX[ProcessingSizeInFrames];
-  float pannerY[ProcessingSizeInFrames];
-  float pannerZ[ProcessingSizeInFrames];
+  float pannerX[AudioUtilities::kRenderQuantumFrames];
+  float pannerY[AudioUtilities::kRenderQuantumFrames];
+  float pannerZ[AudioUtilities::kRenderQuantumFrames];
 
-  float orientationX[ProcessingSizeInFrames];
-  float orientationY[ProcessingSizeInFrames];
-  float orientationZ[ProcessingSizeInFrames];
+  float orientationX[AudioUtilities::kRenderQuantumFrames];
+  float orientationY[AudioUtilities::kRenderQuantumFrames];
+  float orientationZ[AudioUtilities::kRenderQuantumFrames];
 
   m_positionX->calculateSampleAccurateValues(pannerX, framesToProcess);
   m_positionY->calculateSampleAccurateValues(pannerY, framesToProcess);
   m_positionZ->calculateSampleAccurateValues(pannerZ, framesToProcess);
   m_orientationX->calculateSampleAccurateValues(orientationX, framesToProcess);
   m_orientationY->calculateSampleAccurateValues(orientationY, framesToProcess);
   m_orientationZ->calculateSampleAccurateValues(orientationZ, framesToProcess);
 
   // Get the automation values from the listener.
   const float* listenerX =
-      listener()->getPositionXValues(ProcessingSizeInFrames);
+      listener()->getPositionXValues(AudioUtilities::kRenderQuantumFrames);
   const float* listenerY =
-      listener()->getPositionYValues(ProcessingSizeInFrames);
+      listener()->getPositionYValues(AudioUtilities::kRenderQuantumFrames);
   const float* listenerZ =
-      listener()->getPositionZValues(ProcessingSizeInFrames);
+      listener()->getPositionZValues(AudioUtilities::kRenderQuantumFrames);
 
-  const float* forwardX = listener()->getForwardXValues(ProcessingSizeInFrames);
-  const float* forwardY = listener()->getForwardYValues(ProcessingSizeInFrames);
-  const float* forwardZ = listener()->getForwardZValues(ProcessingSizeInFrames);
+  const float* forwardX =
+      listener()->getForwardXValues(AudioUtilities::kRenderQuantumFrames);
+  const float* forwardY =
+      listener()->getForwardYValues(AudioUtilities::kRenderQuantumFrames);
+  const float* forwardZ =
+      listener()->getForwardZValues(AudioUtilities::kRenderQuantumFrames);
 
-  const float* upX = listener()->getUpXValues(ProcessingSizeInFrames);
-  const float* upY = listener()->getUpYValues(ProcessingSizeInFrames);
-  const float* upZ = listener()->getUpZValues(ProcessingSizeInFrames);
+  const float* upX =
+      listener()->getUpXValues(AudioUtilities::kRenderQuantumFrames);
+  const float* upY =
+      listener()->getUpYValues(AudioUtilities::kRenderQuantumFrames);
+  const float* upZ =
+      listener()->getUpZValues(AudioUtilities::kRenderQuantumFrames);
 
   // Compute the azimuth, elevation, and total gains for each position.
-  double azimuth[ProcessingSizeInFrames];
-  double elevation[ProcessingSizeInFrames];
-  float totalGain[ProcessingSizeInFrames];
+  double azimuth[AudioUtilities::kRenderQuantumFrames];
+  double elevation[AudioUtilities::kRenderQuantumFrames];
+  float totalGain[AudioUtilities::kRenderQuantumFrames];
 
   for (unsigned k = 0; k < framesToProcess; ++k) {
     FloatPoint3D pannerPosition(pannerX[k], pannerY[k], pannerZ[k]);
     FloatPoint3D orientation(orientationX[k], orientationY[k], orientationZ[k]);
     FloatPoint3D listenerPosition(listenerX[k], listenerY[k], listenerZ[k]);
     FloatPoint3D listenerForward(forwardX[k], forwardY[k], forwardZ[k]);
     FloatPoint3D listenerUp(upX[k], upY[k], upZ[k]);
 
     calculateAzimuthElevation(&azimuth[k], &elevation[k], pannerPosition,
                               listenerPosition, listenerForward, listenerUp);
@@ skipping 551 matching lines @@
   visitor->trace(m_positionZ);
 
   visitor->trace(m_orientationX);
   visitor->trace(m_orientationY);
   visitor->trace(m_orientationZ);
 
   AudioNode::trace(visitor);
 }
 
 }  // namespace blink