Make ConvolverNode conform to spec

third_party/WebKit/Source/modules/webaudio/ConvolverNode.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 30 matching lines @@
 // a good value.  But, the Reverb object is multi-threaded, so we want this as
 // high as possible without losing too much accuracy.  Very large FFTs will have
 // worse phase errors. Given these constraints 32768 is a good compromise.
 const size_t MaxFFTSize = 32768;
 
 namespace blink {
 
 ConvolverHandler::ConvolverHandler(AudioNode& node, float sampleRate)
     : AudioHandler(NodeTypeConvolver, node, sampleRate), m_normalize(true) {
   addInput();
-  addOutput(2);
+  addOutput(1);
 
   // Node-specific default mixing rules.
   m_channelCount = 2;
   setInternalChannelCountMode(ClampedMax);
   setInternalChannelInterpretation(AudioBus::Speakers);
 
   initialize();
 }
 
 PassRefPtr<ConvolverHandler> ConvolverHandler::create(AudioNode& node,
@@ skipping 68 matching lines @@
   RefPtr<AudioBus> bufferBus =
       AudioBus::create(numberOfChannels, bufferLength, false);
   for (unsigned i = 0; i < numberOfChannels; ++i)
     bufferBus->setChannelMemory(i, buffer->getChannelData(i)->data(),
                                 bufferLength);
 
   bufferBus->setSampleRate(buffer->sampleRate());
 
   // Create the reverb with the given impulse response.
   std::unique_ptr<Reverb> reverb = WTF::wrapUnique(new Reverb(
-      bufferBus.get(), AudioUtilities::kRenderQuantumFrames, MaxFFTSize, 2,
+      bufferBus.get(), AudioUtilities::kRenderQuantumFrames, MaxFFTSize,
       context() && context()->hasRealtimeConstraint(), m_normalize));
 
   {
     // Synchronize with process().
     MutexLocker locker(m_processLock);
     m_reverb = std::move(reverb);
     m_buffer = buffer;
   }
 }
 
@@ skipping 19 matching lines @@
   if (tryLocker.locked())
     return m_reverb
                ? m_reverb->latencyFrames() /
                      static_cast<double>(context()->sampleRate())
                : 0;
   // Since we don't want to block the Audio Device thread, we return a large
   // value instead of trying to acquire the lock.
   return std::numeric_limits<double>::infinity();
 }
 
+void ConvolverHandler::setChannelCount(unsigned long channelCount,
+                                       ExceptionState& exceptionState) {
+  DCHECK(isMainThread());
+  BaseAudioContext::AutoLocker locker(context());
+
+  // channelCount must be 2.
+  if (channelCount != 2) {
+    exceptionState.throwDOMException(
+        NotSupportedError,
+        "ConvolverNode: channelCount cannot be changed from 2");
+  }
+}
+
+void ConvolverHandler::setChannelCountMode(const String& mode,
+                                           ExceptionState& exceptionState) {
+  DCHECK(isMainThread());
+  BaseAudioContext::AutoLocker locker(context());
+
+  // channcelCountMode must be 'clamped-max'.
+  if (mode != "clamped-max") {
+    exceptionState.throwDOMException(
+        NotSupportedError,
+        "ConvolverNode: channelCountMode cannot be changed from 'clamped-max'");
+  }
+}
+
+void ConvolverHandler::checkNumberOfChannelsForInput(AudioNodeInput* input) {
+  DCHECK(context()->isAudioThread());
+#if DCHECK_IS_ON()
+  DCHECK(context()->isGraphOwner());
+#endif
+
+  DCHECK(input);
+  DCHECK_EQ(input, &this->input(0));
+  if (input != &this->input(0))
+    return;
+
+  if (m_buffer) {
+    unsigned numberOfChannels = input->numberOfChannels();
+    unsigned numberOfReverbeChannels = m_buffer->numberOfChannels();
+    unsigned numberOfOutputChannels =
+        std::min(2u, std::max(numberOfChannels, numberOfReverbeChannels));
+
+    if (isInitialized() &&
+        numberOfOutputChannels != output(0).numberOfChannels()) {
+      // We're already initialized but the channel count has changed.
+      uninitialize();
+    }
+
+    if (!isInitialized()) {
+      // This will propagate the channel count to any nodes connected further
+      // downstream in the graph.
+      output(0).setNumberOfChannels(numberOfOutputChannels);
+      initialize();
+    }
+  }
+
+  // Update the input's internal bus if needed.
+  AudioHandler::checkNumberOfChannelsForInput(input);
+}
 // ----------------------------------------------------------------
 
 ConvolverNode::ConvolverNode(BaseAudioContext& context) : AudioNode(context) {
   setHandler(ConvolverHandler::create(*this, context.sampleRate()));
 }
 
 ConvolverNode* ConvolverNode::create(BaseAudioContext& context,
                                      ExceptionState& exceptionState) {
   DCHECK(isMainThread());
 
@@ skipping 38 matching lines @@
 
 bool ConvolverNode::normalize() const {
   return convolverHandler().normalize();
 }
 
 void ConvolverNode::setNormalize(bool normalize) {
   convolverHandler().setNormalize(normalize);
 }
 
 }  // namespace blink