Allow more than 2 input channels in AudioProcessing.

webrtc/modules/audio_processing/test/audio_processing_unittest.cc

 /*
  *  Copyright (c) 2012 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 336 matching lines @@
   void Init(AudioProcessing* ap);
   void EnableAllComponents();
   bool ReadFrame(FILE* file, AudioFrame* frame);
   bool ReadFrame(FILE* file, AudioFrame* frame, ChannelBuffer<float>* cb);
   void ReadFrameWithRewind(FILE* file, AudioFrame* frame);
   void ReadFrameWithRewind(FILE* file, AudioFrame* frame,
                            ChannelBuffer<float>* cb);
   void ProcessWithDefaultStreamParameters(AudioFrame* frame);
   void ProcessDelayVerificationTest(int delay_ms, int system_delay_ms,
                                     int delay_min, int delay_max);
-  void TestChangingChannels(int num_channels,
-                            AudioProcessing::Error expected_return);
+  void TestChangingChannelsInt16Interface(
+      int num_channels,
+      AudioProcessing::Error expected_return);
+  void TestChangingForwardChannels(int num_in_channels,
+                                   int num_out_channels,
+                                   AudioProcessing::Error expected_return);
+  void TestChangingReverseChannels(int num_rev_channels,
+                                   AudioProcessing::Error expected_return);
   void RunQuantizedVolumeDoesNotGetStuckTest(int sample_rate);
   void RunManualVolumeChangeIsPossibleTest(int sample_rate);
   void StreamParametersTest(Format format);
   int ProcessStreamChooser(Format format);
   int AnalyzeReverseStreamChooser(Format format);
   void ProcessDebugDump(const std::string& in_filename,
                         const std::string& out_filename,
                         Format format);
   void VerifyDebugDumpTest(Format format);
 
@@ skipping 73 matching lines @@
   near_file_ = NULL;
 
   if (out_file_) {
     ASSERT_EQ(0, fclose(out_file_));
   }
   out_file_ = NULL;
 }
 
 void ApmTest::Init(AudioProcessing* ap) {
   ASSERT_EQ(kNoErr,
-            ap->Initialize(frame_->sample_rate_hz_,
-                           output_sample_rate_hz_,
-                           revframe_->sample_rate_hz_,
-                           LayoutFromChannels(frame_->num_channels_),
-                           LayoutFromChannels(num_output_channels_),
-                           LayoutFromChannels(revframe_->num_channels_)));
+            ap->Initialize(
+                {{{frame_->sample_rate_hz_, frame_->num_channels_},
+                  {output_sample_rate_hz_, num_output_channels_},
+                  {revframe_->sample_rate_hz_, revframe_->num_channels_}}}));
 }
 
 void ApmTest::Init(int sample_rate_hz,
                    int output_sample_rate_hz,
                    int reverse_sample_rate_hz,
                    int num_input_channels,
                    int num_output_channels,
                    int num_reverse_channels,
                    bool open_output_file) {
   SetContainerFormat(sample_rate_hz, num_input_channels, frame_, &float_cb_);
@@ skipping 316 matching lines @@
 
   // Low limit of 0 ms.
   apm_->set_delay_offset_ms(-50);
   EXPECT_EQ(-50, apm_->delay_offset_ms());
   EXPECT_EQ(apm_->kBadStreamParameterWarning, apm_->set_stream_delay_ms(20));
   EXPECT_EQ(0, apm_->stream_delay_ms());
   EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));
   EXPECT_EQ(50, apm_->stream_delay_ms());
 }
 
-void ApmTest::TestChangingChannels(int num_channels,
-                                   AudioProcessing::Error expected_return) {
+void ApmTest::TestChangingChannelsInt16Interface(
+    int num_channels,
+    AudioProcessing::Error expected_return) {
   frame_->num_channels_ = num_channels;
   EXPECT_EQ(expected_return, apm_->ProcessStream(frame_));
   EXPECT_EQ(expected_return, apm_->AnalyzeReverseStream(frame_));
 }
 
-TEST_F(ApmTest, Channels) {
-  // Testing number of invalid channels.
-  TestChangingChannels(0, apm_->kBadNumberChannelsError);
-  TestChangingChannels(3, apm_->kBadNumberChannelsError);
-  // Testing number of valid channels.
-  for (int i = 1; i < 3; i++) {
-    TestChangingChannels(i, kNoErr);
+void ApmTest::TestChangingForwardChannels(
+    int num_in_channels,
+    int num_out_channels,
+    AudioProcessing::Error expected_return) {
+  const StreamConfig input_stream = {frame_->sample_rate_hz_, num_in_channels};
+  const StreamConfig output_stream = {output_sample_rate_hz_, num_out_channels};
+
+  EXPECT_EQ(expected_return,
+            apm_->ProcessStream(float_cb_->channels(), input_stream,
+                                output_stream, float_cb_->channels()));
+}
+
+void ApmTest::TestChangingReverseChannels(
+    int num_rev_channels,
+    AudioProcessing::Error expected_return) {
+  const ProcessingConfig processing_config = {
+      {{ frame_->sample_rate_hz_, apm_->num_input_channels() },
+       { output_sample_rate_hz_, apm_->num_output_channels() },
+       { frame_->sample_rate_hz_, num_rev_channels }}};
+
+  EXPECT_EQ(expected_return,
+            apm_->AnalyzeReverseStream(float_cb_->channels(),
+                                       processing_config.reverse_stream()));
+}
+
+TEST_F(ApmTest, ChannelsInt16Interface) {
+  // Testing number of invalid and valid channels.
+  Init(16000, 16000, 16000, 4, 4, 4, false);
+
+  TestChangingChannelsInt16Interface(0, apm_->kBadNumberChannelsError);
+
+  for (int i = 1; i < 4; i++) {
+    TestChangingChannelsInt16Interface(i, kNoErr);
     EXPECT_EQ(i, apm_->num_input_channels());
     // We always force the number of reverse channels used for processing to 1.
     EXPECT_EQ(1, apm_->num_reverse_channels());
   }
 }
 
+TEST_F(ApmTest, Channels) {
+  // Testing number of invalid and valid channels.
+  Init(16000, 16000, 16000, 4, 4, 4, false);
+
+  TestChangingForwardChannels(0, 1, apm_->kBadNumberChannelsError);
+  TestChangingReverseChannels(0, apm_->kBadNumberChannelsError);
+
+  for (int i = 1; i < 4; ++i) {
+    for (int j = 0; j < 1; ++j) {
+      // Output channels much be one or match input channels.
+      if (j == 1 || i == j) {
+        TestChangingForwardChannels(i, j, kNoErr);
+        TestChangingReverseChannels(i, kNoErr);
+
+        EXPECT_EQ(i, apm_->num_input_channels());
+        EXPECT_EQ(j, apm_->num_output_channels());
+        // The number of reverse channels used for processing to is always 1.
+        EXPECT_EQ(1, apm_->num_reverse_channels());
+      } else {
+        TestChangingForwardChannels(i, j,
+                                    AudioProcessing::kBadNumberChannelsError);
+      }
+    }
+  }
+}
+
 TEST_F(ApmTest, SampleRatesInt) {
   // Testing invalid sample rates
   SetContainerFormat(10000, 2, frame_, &float_cb_);
   EXPECT_EQ(apm_->kBadSampleRateError, ProcessStreamChooser(kIntFormat));
   // Testing valid sample rates
   int fs[] = {8000, 16000, 32000, 48000};
   for (size_t i = 0; i < sizeof(fs) / sizeof(*fs); i++) {
     SetContainerFormat(fs[i], 2, frame_, &float_cb_);
     EXPECT_NOERR(ProcessStreamChooser(kIntFormat));
     EXPECT_EQ(fs[i], apm_->input_sample_rate_hz());
@@ skipping 1463 matching lines @@
                             int output_rate,
                             int reverse_rate,
                             int num_input_channels,
                             int num_output_channels,
                             int num_reverse_channels,
                             std::string output_file_prefix) {
     Config config;
     config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
     rtc::scoped_ptr<AudioProcessing> ap(AudioProcessing::Create(config));
     EnableAllAPComponents(ap.get());
-    ap->Initialize(input_rate,
-                   output_rate,
-                   reverse_rate,
-                   LayoutFromChannels(num_input_channels),
-                   LayoutFromChannels(num_output_channels),
-                   LayoutFromChannels(num_reverse_channels));
+    ap->Initialize({{{input_rate, num_input_channels},
+                     {output_rate, num_output_channels},
+                     {reverse_rate, num_reverse_channels}}});
 
     FILE* far_file = fopen(ResourceFilePath("far", reverse_rate).c_str(), "rb");
     FILE* near_file = fopen(ResourceFilePath("near", input_rate).c_str(), "rb");
     FILE* out_file = fopen(OutputFilePath(output_file_prefix,
                                           input_rate,
                                           output_rate,
                                           reverse_rate,
                                           num_input_channels,
                                           num_output_channels,
                                           num_reverse_channels).c_str(), "wb");
@@ skipping 307 matching lines @@
         std::tr1::make_tuple(16000, 16000, 32000, 40),
         std::tr1::make_tuple(16000, 16000, 16000, 0)));
 #endif
 
 // TODO(henrike): re-implement functionality lost when removing the old main
 //                function. See
 //                https://code.google.com/p/webrtc/issues/detail?id=1981
 
 }  // namespace
 }  // namespace webrtc