Web Audio: Rename AudioParam class to AudioParamHandler.

Source/modules/webaudio/AudioParam.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
@@ skipping 17 matching lines @@
 #include "modules/webaudio/AudioParam.h"
 
 #include "modules/webaudio/AudioNode.h"
 #include "modules/webaudio/AudioNodeOutput.h"
 #include "platform/FloatConversion.h"
 #include "platform/audio/AudioUtilities.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
-const double AudioParam::DefaultSmoothingConstant = 0.05;
-const double AudioParam::SnapThreshold = 0.001;
+const double AudioParamHandler::DefaultSmoothingConstant = 0.05;
+const double AudioParamHandler::SnapThreshold = 0.001;
 
-float AudioParam::value()
+float AudioParamHandler::value()
 {
     // Update value for timeline.
     if (context() && context()->isAudioThread()) {
         bool hasValue;
         float timelineValue = m_timeline.valueForContextTime(context(), narrowPrecisionToFloat(m_value), hasValue);
 
         if (hasValue)
             m_value = timelineValue;
     }
 
     return narrowPrecisionToFloat(m_value);
 }
 
-void AudioParam::setValue(float value)
+void AudioParamHandler::setValue(float value)
 {
     m_value = value;
 }
 
-float AudioParam::smoothedValue()
+float AudioParamHandler::smoothedValue()
 {
     return narrowPrecisionToFloat(m_smoothedValue);
 }
 
-bool AudioParam::smooth()
+bool AudioParamHandler::smooth()
 {
     // If values have been explicitly scheduled on the timeline, then use the exact value.
     // Smoothing effectively is performed by the timeline.
     bool useTimelineValue = false;
     if (context())
         m_value = m_timeline.valueForContextTime(context(), narrowPrecisionToFloat(m_value), useTimelineValue);
 
     if (m_smoothedValue == m_value) {
         // Smoothed value has already approached and snapped to value.
         return true;
     }
 
     if (useTimelineValue) {
         m_smoothedValue = m_value;
     } else {
         // Dezipper - exponential approach.
         m_smoothedValue += (m_value - m_smoothedValue) * DefaultSmoothingConstant;
 
         // If we get close enough then snap to actual value.
         // FIXME: the threshold needs to be adjustable depending on range - but
         // this is OK general purpose value.
         if (fabs(m_smoothedValue - m_value) < SnapThreshold)
             m_smoothedValue = m_value;
     }
 
     return false;
 }
 
-float AudioParam::finalValue()
+float AudioParamHandler::finalValue()
 {
     float value = m_value;
     calculateFinalValues(&value, 1, false);
     return value;
 }
 
-void AudioParam::calculateSampleAccurateValues(float* values, unsigned numberOfValues)
+void AudioParamHandler::calculateSampleAccurateValues(float* values, unsigned numberOfValues)
 {
     bool isSafe = context() && context()->isAudioThread() && values && numberOfValues;
     ASSERT(isSafe);
     if (!isSafe)
         return;
 
     calculateFinalValues(values, numberOfValues, true);
 }
 
-void AudioParam::calculateFinalValues(float* values, unsigned numberOfValues, bool sampleAccurate)
+void AudioParamHandler::calculateFinalValues(float* values, unsigned numberOfValues, bool sampleAccurate)
 {
     bool isGood = context() && context()->isAudioThread() && values && numberOfValues;
     ASSERT(isGood);
     if (!isGood)
         return;
 
     // The calculated result will be the "intrinsic" value summed with all audio-rate connections.
 
     if (sampleAccurate) {
         // Calculate sample-accurate (a-rate) intrinsic values.
@@ skipping 19 matching lines @@
         ASSERT(output);
 
         // Render audio from this output.
         AudioBus* connectionBus = output->pull(0, AudioNode::ProcessingSizeInFrames);
 
         // Sum, with unity-gain.
         summingBus->sumFrom(*connectionBus);
     }
 }
 
-void AudioParam::calculateTimelineValues(float* values, unsigned numberOfValues)
+void AudioParamHandler::calculateTimelineValues(float* values, unsigned numberOfValues)
 {
     // Calculate values for this render quantum.
     // Normally numberOfValues will equal AudioNode::ProcessingSizeInFrames (the render quantum size).
     double sampleRate = context()->sampleRate();
     double startTime = context()->currentTime();
     double endTime = startTime + numberOfValues / sampleRate;
 
     // Note we're running control rate at the sample-rate.
     // Pass in the current value as default value.
     m_value = m_timeline.valuesForTimeRange(startTime, endTime, narrowPrecisionToFloat(m_value), values, numberOfValues, sampleRate, sampleRate);
 }
 
-void AudioParam::connect(AudioNodeOutput& output)
+void AudioParamHandler::connect(AudioNodeOutput& output)
 {
     ASSERT(context()->isGraphOwner());
 
     if (m_outputs.contains(&output))
         return;
 
     output.addParam(*this);
     m_outputs.add(&output);
     changedOutputs();
 }
 
-void AudioParam::disconnect(AudioNodeOutput& output)
+void AudioParamHandler::disconnect(AudioNodeOutput& output)
 {
     ASSERT(context()->isGraphOwner());
 
     if (m_outputs.contains(&output)) {
         m_outputs.remove(&output);
         changedOutputs();
         output.removeParam(*this);
     }
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)