Make ConvolverNode conform to spec

third_party/WebKit/Source/platform/audio/Reverb.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
@@ skipping 72 matching lines @@
   // True-stereo compensation
   if (response->numberOfChannels() == 4)
     scale *= 0.5f;
 
   return scale;
 }
 
 Reverb::Reverb(AudioBus* impulseResponse,
                size_t renderSliceSize,
                size_t maxFFTSize,
-               size_t numberOfChannels,
                bool useBackgroundThreads,
                bool normalize) {
   float scale = 1;
 
   if (normalize) {
     scale = calculateNormalizationScale(impulseResponse);
 
     if (scale)
       impulseResponse->scale(scale);
   }
 
-  initialize(impulseResponse, renderSliceSize, maxFFTSize, numberOfChannels,
+  initialize(impulseResponse, renderSliceSize, maxFFTSize,
              useBackgroundThreads);
 
   // Undo scaling since this shouldn't be a destructive operation on
   // impulseResponse.
   // FIXME: What about roundoff? Perhaps consider making a temporary scaled copy
   // instead of scaling and unscaling in place.
   if (normalize && scale)
     impulseResponse->scale(1 / scale);
 }
 
 void Reverb::initialize(AudioBus* impulseResponseBuffer,
                         size_t renderSliceSize,
                         size_t maxFFTSize,
-                        size_t numberOfChannels,
                         bool useBackgroundThreads) {
   m_impulseResponseLength = impulseResponseBuffer->length();
+  m_numberOfResponseChannels = impulseResponseBuffer->numberOfChannels();
 
   // The reverb can handle a mono impulse response and still do stereo
-  // processing
-  size_t numResponseChannels = impulseResponseBuffer->numberOfChannels();
-  m_convolvers.reserveCapacity(numberOfChannels);
+  // processing.
+  unsigned numConvolvers = std::max(m_numberOfResponseChannels, 2u);
+  m_convolvers.reserveCapacity(numConvolvers);
 
   int convolverRenderPhase = 0;
-  for (size_t i = 0; i < numResponseChannels; ++i) {
-    AudioChannel* channel = impulseResponseBuffer->channel(i);
+  for (unsigned i = 0; i < numConvolvers; ++i) {
+    AudioChannel* channel = impulseResponseBuffer->channel(
+        std::min(i, m_numberOfResponseChannels - 1));
 
     std::unique_ptr<ReverbConvolver> convolver = WTF::wrapUnique(
         new ReverbConvolver(channel, renderSliceSize, maxFFTSize,
                             convolverRenderPhase, useBackgroundThreads));
     m_convolvers.push_back(std::move(convolver));
 
     convolverRenderPhase += renderSliceSize;
   }
 
   // For "True" stereo processing we allocate a temporary buffer to avoid
   // repeatedly allocating it in the process() method.  It can be bad to
   // allocate memory in a real-time thread.
-  if (numResponseChannels == 4)
+  if (m_numberOfResponseChannels == 4)
     m_tempBuffer = AudioBus::create(2, MaxFrameSize);
 }
 
 void Reverb::process(const AudioBus* sourceBus,
                      AudioBus* destinationBus,
                      size_t framesToProcess) {
   // Do a fairly comprehensive sanity check.
   // If these conditions are satisfied, all of the source and destination
   // pointers will be valid for the various matrixing cases.
   bool isSafeToProcess = sourceBus && destinationBus &&
@@ skipping 12 matching lines @@
     destinationBus->zero();
     return;
   }
 
   AudioChannel* destinationChannelL = destinationBus->channel(0);
   const AudioChannel* sourceChannelL = sourceBus->channel(0);
 
   // Handle input -> output matrixing...
   size_t numInputChannels = sourceBus->numberOfChannels();
   size_t numOutputChannels = destinationBus->numberOfChannels();
-  size_t numReverbChannels = m_convolvers.size();
+  size_t numberOfResponseChannels = m_numberOfResponseChannels;
 
-  if (numInputChannels == 2 && numReverbChannels == 2 &&
+  DCHECK_LE(numInputChannels, 2ul);
+  DCHECK_LE(numOutputChannels, 2ul);
+  DCHECK(numberOfResponseChannels == 1 || numberOfResponseChannels == 2 ||
+         numberOfResponseChannels == 4);
+
+  // These are the possible combinations of number inputs, response
+  // channels and outputs channels that need to be supported:
+  //
+  //   numInputChannels:         1 or 2
+  //   numberOfResponseChannels: 1, 2, or 4
+  //   numOutputChannels:        1 or 2
+  //
+  // Not all possible combinations are valid.  numOutputChannels is
+  // one only if both numInputChannels and numberOfResponseChannels are 1.
+  // Otherwise numOutputChannels MUST be 2.
+  //
+  // The valid combinations are
+  //
+  //   Case     in -> resp -> out
+  //   1        1 -> 1 -> 1
+  //   2        1 -> 2 -> 2
+  //   3        1 -> 4 -> 2
+  //   4        2 -> 1 -> 2
+  //   5        2 -> 2 -> 2
+  //   6        2 -> 4 -> 2
+
+  if (numInputChannels == 2 &&
+      (numberOfResponseChannels == 1 || numberOfResponseChannels == 2) &&
       numOutputChannels == 2) {
-    // 2 -> 2 -> 2
+    // Case 4 and 5: 2 -> 2 -> 2 or 2 -> 1 -> 2.
+    //
+    // These can be handled in the same way because in the latter
+    // case, two connvolvers are still created with the second being a
+    // copy of the first.
     const AudioChannel* sourceChannelR = sourceBus->channel(1);
     AudioChannel* destinationChannelR = destinationBus->channel(1);
     m_convolvers[0]->process(sourceChannelL, destinationChannelL,
                              framesToProcess);
     m_convolvers[1]->process(sourceChannelR, destinationChannelR,
                              framesToProcess);
   } else if (numInputChannels == 1 && numOutputChannels == 2 &&
-             numReverbChannels == 2) {
-    // 1 -> 2 -> 2
+             numberOfResponseChannels == 2) {
+    // Case 2: 1 -> 2 -> 2
     for (int i = 0; i < 2; ++i) {
       AudioChannel* destinationChannel = destinationBus->channel(i);
       m_convolvers[i]->process(sourceChannelL, destinationChannel,
                                framesToProcess);
     }
-  } else if (numInputChannels == 1 && numReverbChannels == 1 &&
-             numOutputChannels == 2) {
-    // 1 -> 1 -> 2
+  } else if (numInputChannels == 1 && numberOfResponseChannels == 1) {
+    // Case 1: 1 -> 1 -> 1
+    DCHECK_EQ(numOutputChannels, 1ul);
     m_convolvers[0]->process(sourceChannelL, destinationChannelL,
                              framesToProcess);
-
-    // simply copy L -> R
-    AudioChannel* destinationChannelR = destinationBus->channel(1);
-    bool isCopySafe = destinationChannelL->data() &&
-                      destinationChannelR->data() &&
-                      destinationChannelL->length() >= framesToProcess &&
-                      destinationChannelR->length() >= framesToProcess;
-    ASSERT(isCopySafe);
-    if (!isCopySafe)
-      return;
-    memcpy(destinationChannelR->mutableData(), destinationChannelL->data(),
-           sizeof(float) * framesToProcess);
-  } else if (numInputChannels == 1 && numReverbChannels == 1 &&
-             numOutputChannels == 1) {
-    // 1 -> 1 -> 1
-    m_convolvers[0]->process(sourceChannelL, destinationChannelL,
-                             framesToProcess);
-  } else if (numInputChannels == 2 && numReverbChannels == 4 &&
+  } else if (numInputChannels == 2 && numberOfResponseChannels == 4 &&
              numOutputChannels == 2) {
-    // 2 -> 4 -> 2 ("True" stereo)
+    // Case 6: 2 -> 4 -> 2 ("True" stereo)
     const AudioChannel* sourceChannelR = sourceBus->channel(1);
     AudioChannel* destinationChannelR = destinationBus->channel(1);
 
     AudioChannel* tempChannelL = m_tempBuffer->channel(0);
     AudioChannel* tempChannelR = m_tempBuffer->channel(1);
 
     // Process left virtual source
     m_convolvers[0]->process(sourceChannelL, destinationChannelL,
                              framesToProcess);
     m_convolvers[1]->process(sourceChannelL, destinationChannelR,
                              framesToProcess);
 
     // Process right virtual source
     m_convolvers[2]->process(sourceChannelR, tempChannelL, framesToProcess);
     m_convolvers[3]->process(sourceChannelR, tempChannelR, framesToProcess);
 
     destinationBus->sumFrom(*m_tempBuffer);
-  } else if (numInputChannels == 1 && numReverbChannels == 4 &&
+  } else if (numInputChannels == 1 && numberOfResponseChannels == 4 &&
              numOutputChannels == 2) {
-    // 1 -> 4 -> 2 (Processing mono with "True" stereo impulse response)
-    // This is an inefficient use of a four-channel impulse response, but we
-    // should handle the case.
+    // Case 3: 1 -> 4 -> 2 (Processing mono with "True" stereo impulse
+    // response) This is an inefficient use of a four-channel impulse
+    // response, but we should handle the case.
     AudioChannel* destinationChannelR = destinationBus->channel(1);
 
     AudioChannel* tempChannelL = m_tempBuffer->channel(0);
     AudioChannel* tempChannelR = m_tempBuffer->channel(1);
 
     // Process left virtual source
     m_convolvers[0]->process(sourceChannelL, destinationChannelL,
                              framesToProcess);
     m_convolvers[1]->process(sourceChannelL, destinationChannelR,
                              framesToProcess);
 
     // Process right virtual source
     m_convolvers[2]->process(sourceChannelL, tempChannelL, framesToProcess);
     m_convolvers[3]->process(sourceChannelL, tempChannelR, framesToProcess);
 
     destinationBus->sumFrom(*m_tempBuffer);
   } else {
-    // Handle gracefully any unexpected / unsupported matrixing
-    // FIXME: add code for 5.1 support...
+    NOTREACHED();
     destinationBus->zero();
   }
 }
 
 void Reverb::reset() {
   for (size_t i = 0; i < m_convolvers.size(); ++i)
     m_convolvers[i]->reset();
 }
 
 size_t Reverb::latencyFrames() const {
   return !m_convolvers.isEmpty() ? m_convolvers.front()->latencyFrames() : 0;
 }
 
 }  // namespace blink