Add min/max values for AudioParams

third_party/WebKit/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
  *     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 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 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 "modules/webaudio/AudioParam.h"
+
+#include "core/inspector/ConsoleMessage.h"
 #include "modules/webaudio/AudioNode.h"
 #include "modules/webaudio/AudioNodeOutput.h"
 #include "platform/FloatConversion.h"
 #include "platform/Histogram.h"
 #include "platform/audio/AudioUtilities.h"
+#include "platform/v8_inspector/public/ConsoleTypes.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 const double AudioParamHandler::DefaultSmoothingConstant = 0.05;
 const double AudioParamHandler::SnapThreshold = 0.001;
 
-AudioParamHandler::AudioParamHandler(AbstractAudioContext& context, AudioParamType paramType, double defaultValue)
+AudioParamHandler::AudioParamHandler(AbstractAudioContext& context, AudioParamType paramType, double defaultValue, float minValue, float maxValue)
     : AudioSummingJunction(context.deferredTaskHandler())
     , m_paramType(paramType)
     , m_intrinsicValue(defaultValue)
     , m_defaultValue(defaultValue)
+    , m_minValue(minValue)
+    , m_maxValue(maxValue)
     , m_smoothedValue(defaultValue)
 {
     // The destination MUST exist because we need the destination handler for the AudioParam.
     RELEASE_ASSERT(context.destination());
 
     m_destinationHandler = &context.destination()->audioDestinationHandler();
 }
 
 AudioDestinationHandler& AudioParamHandler::destinationHandler() const
 {
@@ skipping 61 matching lines @@
         float timelineValue = m_timeline.valueForContextTime(destinationHandler(), v, hasValue);
 
         if (hasValue)
             v = timelineValue;
     }
 
     setIntrinsicValue(v);
     return v;
 }
 
+void AudioParamHandler::setIntrinsicValue(float newValue)
+{
+    newValue = clampTo(newValue, m_minValue, m_maxValue);
+    noBarrierStore(&m_intrinsicValue, newValue);
+}
+
 void AudioParamHandler::setValue(float value)
 {
     setIntrinsicValue(value);
     updateHistograms(value);
 }
 
 float AudioParamHandler::smoothedValue()
 {
     return m_smoothedValue;
 }
@@ skipping 152 matching lines @@
         }
         break;
     default:
         // Nothing to do for all other types.
         break;
     }
 }
 
 // ----------------------------------------------------------------
 
-AudioParam::AudioParam(AbstractAudioContext& context, AudioParamType paramType, double defaultValue)
-    : m_handler(AudioParamHandler::create(context, paramType, defaultValue))
+AudioParam::AudioParam(AbstractAudioContext& context, AudioParamType paramType, double defaultValue, float minValue, float maxValue)
+    : m_handler(AudioParamHandler::create(context, paramType, defaultValue, minValue, maxValue))
     , m_context(context)
 {
 }
 
 AudioParam* AudioParam::create(AbstractAudioContext& context, AudioParamType paramType, double defaultValue)
 {
-    return new AudioParam(context, paramType, defaultValue);
+    // Default nominal range is most negative float to most positive.  This basically means any
+    // value is valid, except that floating-point infinities are excluded.
+    float limit = std::numeric_limits<float>::max();
+    return new AudioParam(context, paramType, defaultValue, -limit, limit);
+}
+
+AudioParam* AudioParam::create(AbstractAudioContext& context, AudioParamType paramType, double defaultValue, float minValue, float maxValue)
+{
+    DCHECK(minValue <= maxValue);

[tkent, 2016/05/15 23:50:10]

DCHECK -> DCHECK_LE

+    return new AudioParam(context, paramType, defaultValue, minValue, maxValue);
 }
 
 DEFINE_TRACE(AudioParam)
 {
     visitor->trace(m_context);
 }
 
 float AudioParam::value() const
 {
     return handler().value();
 }
 
+void AudioParam::warnIfOutsideRange(const String& paramMethod, float value)
+{
+    if (value < minValue() || value > maxValue()) {
+        context()->getExecutionContext()->addConsoleMessage(
+            ConsoleMessage::create(
+                JSMessageSource,
+                WarningMessageLevel,
+                handler().getParamName()
+                + "."
+                + paramMethod
+                + " "
+                + String::number(value)
+                + " outside nominal range ["
+                + String::number(minValue()) + ", " + String::number(maxValue())
+                + "]; value will be clamped."));
+    }
+}
+
 void AudioParam::setValue(float value)
 {
+    warnIfOutsideRange("value", value);
     handler().setValue(value);
 }
 
 float AudioParam::defaultValue() const
 {
     return handler().defaultValue();
 }
 
+float AudioParam::minValue() const
+{
+    return handler().minValue();
+}
+
+float AudioParam::maxValue() const
+{
+    return handler().maxValue();
+}
+
 void AudioParam::setParamType(AudioParamType paramType)
 {
     handler().setParamType(paramType);
 }
 
 AudioParam* AudioParam::setValueAtTime(float value, double time, ExceptionState& exceptionState)
 {
+    warnIfOutsideRange("setValueAtTime value", value);
     handler().timeline().setValueAtTime(value, time, exceptionState);
     handler().updateHistograms(value);
     return this;
 }
 
 AudioParam* AudioParam::linearRampToValueAtTime(float value, double time, ExceptionState& exceptionState)
 {
+    warnIfOutsideRange("linearRampToValueAtTime value", value);
     handler().timeline().linearRampToValueAtTime(
         value, time, handler().intrinsicValue(), context()->currentTime(), exceptionState);
 
     // This is probably the best we can do for the histogram.  We don't want to run the automation
     // to get all the values and use them to update the histogram.
     handler().updateHistograms(value);
 
     return this;
 }
 
 AudioParam* AudioParam::exponentialRampToValueAtTime(float value, double time, ExceptionState& exceptionState)
 {
+    warnIfOutsideRange("exponentialRampToValue value", value);
     handler().timeline().exponentialRampToValueAtTime(value, time, handler().intrinsicValue(), context()->currentTime(), exceptionState);
 
     // This is probably the best we can do for the histogram.  We don't want to run the automation
     // to get all the values and use them to update the histogram.
     handler().updateHistograms(value);
 
     return this;
 }
 
 AudioParam* AudioParam::setTargetAtTime(float target, double time, double timeConstant, ExceptionState& exceptionState)
 {
+    warnIfOutsideRange("setTargetAtTime value", target);
     handler().timeline().setTargetAtTime(target, time, timeConstant, exceptionState);
 
     // Don't update the histogram here.  It's not clear in normal usage if the parameter value will
     // actually reach |target|.
     return this;
 }
 
 AudioParam* AudioParam::setValueCurveAtTime(DOMFloat32Array* curve, double time, double duration, ExceptionState& exceptionState)
 {
+    // Just find the first value in the curve (if any) that is outside the nominal range.  It's
+    // probably not necessary to produce a warning on every value outside the nominal range.
+    float* curveData = curve->data();
+    float min = minValue();
+    float max = maxValue();
+
+    for (unsigned k = 0; k < curve->length(); ++k) {
+        if (curveData[k] < min || curveData[k] > max) {
+            warnIfOutsideRange("setValueCurveAtTime value", curveData[k]);
+            break;
+        }
+    }
+
     handler().timeline().setValueCurveAtTime(curve, time, duration, exceptionState);
 
     // We could update the histogram with every value in the curve, due to interpolation, we'll
     // probably be missing many values.  So we don't update the histogram.  setValueCurveAtTime is
     // probably a fairly rare method anyway.
     return this;
 }
 
 AudioParam* AudioParam::cancelScheduledValues(double startTime, ExceptionState& exceptionState)
 {
     handler().timeline().cancelScheduledValues(startTime, exceptionState);
     return this;
 }
 
 } // namespace blink