DynamicsCompressor.reduction is a float not an AudioParam

third_party/WebKit/Source/modules/webaudio/DynamicsCompressorNode.cpp

 /*
  * Copyright (C) 2011, 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 15 matching lines @@
 #include "modules/webaudio/AudioNodeInput.h"
 #include "modules/webaudio/AudioNodeOutput.h"
 #include "platform/audio/DynamicsCompressor.h"
 
 // Set output to stereo by default.
 static const unsigned defaultNumberOfOutputChannels = 2;
 
 namespace blink {
 
 DynamicsCompressorHandler::DynamicsCompressorHandler(
-    AudioNode& node, float sampleRate,
-    AudioParamHandler& threshold, AudioParamHandler& knee,
-    AudioParamHandler& ratio, AudioParamHandler& reduction,
-    AudioParamHandler& attack, AudioParamHandler& release)
+    AudioNode& node,
+    float sampleRate,
+    AudioParamHandler& threshold,
+    AudioParamHandler& knee,
+    AudioParamHandler& ratio,
+    AudioParamHandler& attack,
+    AudioParamHandler& release)
     : AudioHandler(NodeTypeDynamicsCompressor, node, sampleRate)
     , m_threshold(threshold)
     , m_knee(knee)
     , m_ratio(ratio)
-    , m_reduction(reduction)
+    , m_reduction(0)
     , m_attack(attack)
     , m_release(release)
 {
     addInput();
     addOutput(defaultNumberOfOutputChannels);
     initialize();
 }
 
 PassRefPtr<DynamicsCompressorHandler> DynamicsCompressorHandler::create(
-    AudioNode& node, float sampleRate,
-    AudioParamHandler& threshold, AudioParamHandler& knee,
-    AudioParamHandler& ratio, AudioParamHandler& reduction,
-    AudioParamHandler& attack, AudioParamHandler& release)
+    AudioNode& node,
+    float sampleRate,
+    AudioParamHandler& threshold,
+    AudioParamHandler& knee,
+    AudioParamHandler& ratio,
+    AudioParamHandler& attack,
+    AudioParamHandler& release)
 {
-    return adoptRef(new DynamicsCompressorHandler(node, sampleRate, threshold, knee, ratio, reduction, attack, release));
+    return adoptRef(new DynamicsCompressorHandler(
+        node,
+        sampleRate,
+        threshold,
+        knee,
+        ratio,
+        attack,
+        release));
 }
 
 DynamicsCompressorHandler::~DynamicsCompressorHandler()
 {
     uninitialize();
 }
 
 void DynamicsCompressorHandler::process(size_t framesToProcess)
 {
     AudioBus* outputBus = output(0).bus();
     ASSERT(outputBus);
 
     float threshold = m_threshold->value();
     float knee = m_knee->value();
     float ratio = m_ratio->value();
     float attack = m_attack->value();
     float release = m_release->value();
 
     m_dynamicsCompressor->setParameterValue(DynamicsCompressor::ParamThreshold, threshold);
     m_dynamicsCompressor->setParameterValue(DynamicsCompressor::ParamKnee, knee);
     m_dynamicsCompressor->setParameterValue(DynamicsCompressor::ParamRatio, ratio);
     m_dynamicsCompressor->setParameterValue(DynamicsCompressor::ParamAttack, attack);
     m_dynamicsCompressor->setParameterValue(DynamicsCompressor::ParamRelease, release);
 
     m_dynamicsCompressor->process(input(0).bus(), outputBus, framesToProcess);
 
-    float reduction = m_dynamicsCompressor->parameterValue(DynamicsCompressor::ParamReduction);
-    m_reduction->setValue(reduction);
+    m_reduction = m_dynamicsCompressor->parameterValue(DynamicsCompressor::ParamReduction);
 }
 
 void DynamicsCompressorHandler::initialize()
 {
     if (isInitialized())
         return;
 
     AudioHandler::initialize();
     m_dynamicsCompressor = adoptPtr(new DynamicsCompressor(sampleRate(), defaultNumberOfOutputChannels));
 }
 
 void DynamicsCompressorHandler::clearInternalStateWhenDisabled()
 {
-    m_reduction->setValue(0);
+    m_reduction = 0;
 }
 
 double DynamicsCompressorHandler::tailTime() const
 {
     return m_dynamicsCompressor->tailTime();
 }
 
 double DynamicsCompressorHandler::latencyTime() const
 {
     return m_dynamicsCompressor->latencyTime();
 }
 
 // ----------------------------------------------------------------
 
 DynamicsCompressorNode::DynamicsCompressorNode(AbstractAudioContext& context, float sampleRate)
     : AudioNode(context)
     , m_threshold(AudioParam::create(context, -24))
     , m_knee(AudioParam::create(context, 30))
     , m_ratio(AudioParam::create(context, 12))
-    , m_reduction(AudioParam::create(context, 0))
     , m_attack(AudioParam::create(context, 0.003))
     , m_release(AudioParam::create(context, 0.250))
 {
-    setHandler(DynamicsCompressorHandler::create(*this, sampleRate, m_threshold->handler(), m_knee->handler(), m_ratio->handler(), m_reduction->handler(), m_attack->handler(), m_release->handler()));
+    setHandler(DynamicsCompressorHandler::create(
+        *this,
+        sampleRate,
+        m_threshold->handler(),
+        m_knee->handler(),
+        m_ratio->handler(),
+        m_attack->handler(),
+        m_release->handler()));
 }
 
 DynamicsCompressorNode* DynamicsCompressorNode::create(AbstractAudioContext& context, float sampleRate)
 {
     return new DynamicsCompressorNode(context, sampleRate);
 }
 
 DEFINE_TRACE(DynamicsCompressorNode)
 {
     visitor->trace(m_threshold);
     visitor->trace(m_knee);
     visitor->trace(m_ratio);
-    visitor->trace(m_reduction);
     visitor->trace(m_attack);
     visitor->trace(m_release);
     AudioNode::trace(visitor);
 }
 
 DynamicsCompressorHandler& DynamicsCompressorNode::dynamicsCompressorHandler() const
 {
     return static_cast<DynamicsCompressorHandler&>(handler());
 }
 
 AudioParam* DynamicsCompressorNode::threshold() const
 {
     return m_threshold;
 }
 
 AudioParam* DynamicsCompressorNode::knee() const
 {
     return m_knee;
 }
 
 AudioParam* DynamicsCompressorNode::ratio() const
 {
     return m_ratio;
 }
 
-AudioParam* DynamicsCompressorNode::reduction() const
+float DynamicsCompressorNode::reduction() const
 {
-    return m_reduction;
+    return dynamicsCompressorHandler().reductionValue();
 }
 
 AudioParam* DynamicsCompressorNode::attack() const
 {
     return m_attack;
 }
 
 AudioParam* DynamicsCompressorNode::release() const
 {
     return m_release;
 }
 
 } // namespace blink