Allow more than 2 input channels in AudioProcessing.

webrtc/modules/audio_processing/audio_buffer.h

 /*
  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 12 matching lines @@
 
 class PushSincResampler;
 class IFChannelBuffer;
 
 enum Band {
   kBand0To8kHz = 0,
   kBand8To16kHz = 1,
   kBand16To24kHz = 2
 };
 
+template <typename T, typename Intermediate>

[aluebs-webrtc, 2015/07/14 23:12:43]

What do you think about adding these to audio_util.h?

[mgraczyk, 2015/07/15 01:12:46]

Done.

+void DownmixStereoToMono(int num_frames,

[aluebs-webrtc, 2015/07/14 23:12:42]

Is it worth it to specialize for the stereo case?

[mgraczyk, 2015/07/15 01:12:46]

Probably, although I didn't benchmark it. I figured the stereo case would be
extremely common.

[aluebs-webrtc, 2015/07/15 18:04:05]

Yes, common, but do you gain anything? It definitively adds an extra if
statement to all cases. Plus more code to maintain.

[mgraczyk, 2015/07/15 20:03:19]

The if statement is basically free because it's at the beginning of the function
and will be consistently true or false, so calls to the function will either be
icache misses (in which case the branch penalty will not matter) or icache hits
(in which case the branch will be correctly predicted and incur no cost).

I agree it's probably not worth the extra code though.  Removed.

+                         T* out,
+                         const T* left,
+                         const T* right) {

[aluebs-webrtc, 2015/07/14 23:12:42]

Inputs before outputs?

[mgraczyk, 2015/07/15 01:12:46]

Done.

+  for (int i = 0; i < num_frames; ++i) {
+    out[i] = (static_cast<Intermediate>(left[i]) + right[i]) / 2;
+  }
+}
+
+template <typename T, typename Intermediate>
+void DownmixToMono(int num_frames,
+                   T* out,
+                   const T* const* input_channels,
+                   int num_channels) {

[aluebs-webrtc, 2015/07/14 23:12:42]

Inputs before outputs?

[mgraczyk, 2015/07/15 01:12:46]

Done.

+  if (num_channels == 2) {
+    DownmixStereoToMono<T, Intermediate>(num_frames, out, input_channels[0],
+                                         input_channels[1]);
+  } else {
+    for (int i = 0; i < num_frames; ++i) {
+      Intermediate value = input_channels[0][i];
+      for (int j = 1; j < num_channels; ++j) {
+        value += input_channels[j][i];
+      }
+      out[i] = value / num_channels;
+    }
+  }
+}
+
+// Downmixes an interleaved multichannel signal to a single channel by averaging
+// all channels.
+template <typename T, typename Intermediate>
+void DownmixInterleavedToMonoImpl(const T* interleaved,
+                                  T* deinterleaved,
+                                  int num_multichannel_frames,
+                                  int num_channels) {

[aluebs-webrtc, 2015/07/14 23:12:43]

Inputs before outputs?

[mgraczyk, 2015/07/15 01:12:46]

Done.

+  assert(num_channels > 0);
+  assert(num_multichannel_frames > 0);
+
+  const T* const end = interleaved + num_multichannel_frames * num_channels;
+
+  if (num_channels == 1) {
+    std::memmove(
+        deinterleaved, interleaved,
+        num_channels * num_multichannel_frames * sizeof(*deinterleaved));

[aluebs-webrtc, 2015/07/14 23:12:42]

You don't need to multiply by num_channels since you know it is 1 in this case.

[mgraczyk, 2015/07/15 01:12:46]

Done.

+  } else if (num_channels == 2) {

[aluebs-webrtc, 2015/07/14 23:12:42]

Is it worth it to specialize for the stereo case?

[mgraczyk, 2015/07/15 01:12:46]

Same answer, although here the savings is not going to be as much.

[aluebs-webrtc, 2015/07/15 21:29:16]

So, should this be removed as well following the same logic as above? How about
the 1 channel case?

[mgraczyk, 2015/07/15 21:53:55]

Done.

+    // Explicitly unroll for the common stereo case.
+    while (interleaved < end) {
+      *deinterleaved++ =
+          (static_cast<Intermediate>(*interleaved) + *(interleaved + 1)) / 2;
+      interleaved += 2;
+    }
+  } else {
+    while (interleaved < end) {

[aluebs-webrtc, 2015/07/14 23:12:43]

I find for with indexes easier to follow, but I leave it up to you.

[mgraczyk, 2015/07/15 01:12:46]

Acknowledged.

+      const T* const frame_end = interleaved + num_channels;
+
+      Intermediate value = *interleaved++;
+      while (interleaved < frame_end) {
+        value += *interleaved++;
+      }
+
+      *deinterleaved++ = value / num_channels;
+    }
+  }
+}
+
 class AudioBuffer {
  public:
   // TODO(ajm): Switch to take ChannelLayouts.
   AudioBuffer(int input_num_frames,
               int num_input_channels,
               int process_num_frames,
               int num_process_channels,
               int output_num_frames);
   virtual ~AudioBuffer();
 
@@ skipping 62 matching lines @@
   void set_activity(AudioFrame::VADActivity activity);
   AudioFrame::VADActivity activity() const;
 
   // Use for int16 interleaved data.
   void DeinterleaveFrom(AudioFrame* audioFrame);
   // If |data_changed| is false, only the non-audio data members will be copied
   // to |frame|.
   void InterleaveTo(AudioFrame* frame, bool data_changed) const;
 
   // Use for float deinterleaved data.
-  void CopyFrom(const float* const* data,
-                int num_frames,
-                AudioProcessing::ChannelLayout layout);
-  void CopyTo(int num_frames,
-              AudioProcessing::ChannelLayout layout,
-              float* const* data);
+  void CopyFrom(const float* const* data, const StreamConfig& stream_config);
+  void CopyTo(const StreamConfig& stream_config, float* const* data);
   void CopyLowPassToReference();
 
   // Splits the signal into different bands.
   void SplitIntoFrequencyBands();
   // Recombine the different bands into one signal.
   void MergeFrequencyBands();
 
  private:
   // Called from DeinterleaveFrom() and CopyFrom().
   void InitForNewData();
@@ skipping 26 matching lines @@
   rtc::scoped_ptr<ChannelBuffer<int16_t> > low_pass_reference_channels_;
   rtc::scoped_ptr<IFChannelBuffer> input_buffer_;
   rtc::scoped_ptr<ChannelBuffer<float> > process_buffer_;
   ScopedVector<PushSincResampler> input_resamplers_;
   ScopedVector<PushSincResampler> output_resamplers_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_BUFFER_H_