Setting convolver buffer needs to update number of output channels

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 123 matching lines @@
                                 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,
       context() && context()->hasRealtimeConstraint(), m_normalize));
 
   {
+    // The context must be locked since changing the buffer can
+    // re-configure the number of channels that are output.
+    BaseAudioContext::AutoLocker contextLocker(context());
+
     // Synchronize with process().
     MutexLocker locker(m_processLock);
     m_reverb = std::move(reverb);
     m_buffer = buffer;
+    if (buffer) {
+      // This will propagate the channel count to any nodes connected further
+      // downstream in the graph.
+      output(0).setNumberOfChannels(computeNumberOfOutputChannels(
+          input(0).numberOfChannels(), m_buffer->numberOfChannels()));
+    }
   }
 }
 
 AudioBuffer* ConvolverHandler::buffer() {
   DCHECK(isMainThread());
   return m_buffer.get();
 }
 
 double ConvolverHandler::tailTime() const {
   MutexTryLocker tryLocker(m_processLock);
@@ skipping 12 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();
 }
 
+unsigned ConvolverHandler::computeNumberOfOutputChannels(
+    unsigned inputChannels,
+    unsigned responseChannels) const {
+  // The number of output channels for a Convolver must be one or two.
+  // And can only be one if there's a mono source and a mono response
+  // buffer.
+  return clampTo(std::max(inputChannels, responseChannels), 1, 2);
+}
+
 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");
@@ skipping 18 matching lines @@
 #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));
+    unsigned numberOfOutputChannels = computeNumberOfOutputChannels(
+        input->numberOfChannels(), m_buffer->numberOfChannels());
 
     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.
@@ skipping 56 matching lines @@
 
 bool ConvolverNode::normalize() const {
   return convolverHandler().normalize();
 }
 
 void ConvolverNode::setNormalize(bool normalize) {
   convolverHandler().setNormalize(normalize);
 }
 
 }  // namespace blink