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/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 52 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);
 }
 
 float AudioParamHandler::smoothedValue()
 {
     return m_smoothedValue;
 }
 
@@ skipping 117 matching lines @@
 
     if (m_outputs.contains(&output)) {
         m_outputs.remove(&output);
         changedOutputs();
         output.removeParam(*this);
     }
 }
 
 // ----------------------------------------------------------------
 
-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 min, float max)

[hongchan, 2016/05/13 01:30:15]

Here as well.

[Raymond Toy, 2016/05/13 18:40:32]

Done.

+{
+    DCHECK(min <= max);
+    return new AudioParam(context, paramType, defaultValue, min, max);
 }
 
 DEFINE_TRACE(AudioParam)
 {
     visitor->trace(m_context);
 }
 
 float AudioParam::value() const
 {
     return handler().value();
 }
 
+void AudioParam::warnIfOutsideRange(float value, float minValue, float maxValue)
+{
+    if (value < minValue || value > maxValue) {
+        context()->getExecutionContext()->addConsoleMessage(
+            ConsoleMessage::create(
+                JSMessageSource,
+                WarningMessageLevel,
+                handler().getParamName()
+                + " value "
+                + String::number(value)
+                + " outside nominal range ["
+                + String::number(minValue) + ", " + String::number(maxValue)
+                + "]; value will be clamped."));
+    }
+}
+
 void AudioParam::setValue(float value)
 {
+    warnIfOutsideRange(value, minValue(), maxValue());
     handler().setValue(value);
 }
 
 float AudioParam::defaultValue() const
 {
     return handler().defaultValue();
 }
 
+float AudioParam::minValue() const
+{
+    return handler().minValue();
+}
+
+float AudioParam::maxValue() const
+{
+    return handler().maxValue();
+}
+
 AudioParam* AudioParam::setValueAtTime(float value, double time, ExceptionState& exceptionState)
 {
     handler().timeline().setValueAtTime(value, time, exceptionState);
     return this;
 }
 
 AudioParam* AudioParam::linearRampToValueAtTime(float value, double time, ExceptionState& exceptionState)
 {
     handler().timeline().linearRampToValueAtTime(
         value, time, handler().intrinsicValue(), context()->currentTime(), exceptionState);
@@ skipping 19 matching lines @@
 }
 
 AudioParam* AudioParam::cancelScheduledValues(double startTime, ExceptionState& exceptionState)
 {
     handler().timeline().cancelScheduledValues(startTime, exceptionState);
     return this;
 }
 
 } // namespace blink