Strip away the keyboard mic channel if no audio processing.

content/renderer/media/media_stream_audio_processor_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/aligned_memory.h"
 #include "base/path_service.h"
@@ skipping 22 matching lines @@
 #if defined(ANDROID)
 const int kAudioProcessingSampleRate = 16000;
 #else
 const int kAudioProcessingSampleRate = 32000;
 #endif
 const int kAudioProcessingNumberOfChannel = 1;
 
 // The number of packers used for testing.
 const int kNumberOfPacketsForTest = 100;
 
+const int kMaxNumberOfPlayoutDataChannels = 2;
+
 void ReadDataFromSpeechFile(char* data, int length) {
   base::FilePath file;
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &file));
   file = file.Append(FILE_PATH_LITERAL("media"))
              .Append(FILE_PATH_LITERAL("test"))
              .Append(FILE_PATH_LITERAL("data"))
              .Append(FILE_PATH_LITERAL("speech_16b_stereo_48kHz.raw"));
   DCHECK(base::PathExists(file));
   int64 data_file_size64 = 0;
   DCHECK(base::GetFileSize(file, &data_file_size64));
@@ skipping 19 matching lines @@
     // Read the audio data from a file.
     const media::AudioParameters& params = audio_processor->InputFormat();
     const int packet_size =
         params.frames_per_buffer() * 2 * params.channels();
     const size_t length = packet_size * kNumberOfPacketsForTest;
     scoped_ptr<char[]> capture_data(new char[length]);
     ReadDataFromSpeechFile(capture_data.get(), length);
     const int16* data_ptr = reinterpret_cast<const int16*>(capture_data.get());
     scoped_ptr<media::AudioBus> data_bus = media::AudioBus::Create(
         params.channels(), params.frames_per_buffer());
+
+    // |data_bus_playout| is used if the number of capture channels is larger
+    // that max allowed playout channels. |data_bus_playout_to_use| points to
+    // the AudioBus to use, either |data_bus| or |data_bus_playout|.
+    scoped_ptr<media::AudioBus> data_bus_playout;
+    media::AudioBus* data_bus_playout_to_use = data_bus.get();
+    if (params.channels() > kMaxNumberOfPlayoutDataChannels) {
+      data_bus_playout =
+          media::AudioBus::CreateWrapper(kMaxNumberOfPlayoutDataChannels);
+      data_bus_playout->set_frames(params.frames_per_buffer());
+      data_bus_playout_to_use = data_bus_playout.get();
+    }
+
     for (int i = 0; i < kNumberOfPacketsForTest; ++i) {
       data_bus->FromInterleaved(data_ptr, data_bus->frames(), 2);
       audio_processor->PushCaptureData(data_bus.get());
 
       // |audio_processor| does nothing when the audio processing is off in
       // the processor.
       webrtc::AudioProcessing* ap = audio_processor->audio_processing_.get();
 #if defined(OS_ANDROID) || defined(OS_IOS)
       const bool is_aec_enabled = ap && ap->echo_control_mobile()->is_enabled();
       // AEC should be turned off for mobiles.
       DCHECK(!ap || !ap->echo_cancellation()->is_enabled());
 #else
       const bool is_aec_enabled = ap && ap->echo_cancellation()->is_enabled();
 #endif
       if (is_aec_enabled) {
-        audio_processor->OnPlayoutData(data_bus.get(), params.sample_rate(),
-                                       10);
+        if (params.channels() > kMaxNumberOfPlayoutDataChannels) {
+          for (int i = 0; i < kMaxNumberOfPlayoutDataChannels; ++i) {
+            data_bus_playout->SetChannelData(
+                i, const_cast<float*>(data_bus->channel(i)));
+          }
+        }
+        audio_processor->OnPlayoutData(data_bus_playout_to_use,
+                                       params.sample_rate(), 10);
       }
 
       int16* output = NULL;
       int new_volume = 0;
       while(audio_processor->ProcessAndConsumeData(
           base::TimeDelta::FromMilliseconds(10), 255, false, &new_volume,
           &output)) {
         EXPECT_TRUE(output != NULL);
         EXPECT_EQ(audio_processor->OutputFormat().sample_rate(),
                   expected_output_sample_rate);
@@ skipping 353 matching lines @@
     EXPECT_TRUE(output != NULL);
     EXPECT_EQ(output_bus->channel(0)[0], 0);
     EXPECT_NE(output_bus->channel(1)[0], 0);
   }
 
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
+TEST_F(MediaStreamAudioProcessorTest, TestWithKeyboardMicChannel) {
+  MockMediaConstraintFactory constraint_factory;
+  constraint_factory.AddMandatory(
+      MediaAudioConstraints::kGoogExperimentalNoiseSuppression, true);
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
+      new WebRtcAudioDeviceImpl());
+  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
+      new rtc::RefCountedObject<MediaStreamAudioProcessor>(
+          constraint_factory.CreateWebMediaConstraints(), 0,
+          webrtc_audio_device.get()));
+  EXPECT_TRUE(audio_processor->has_audio_processing());
+
+  media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                                media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC,
+                                48000, 16, 512);
+  audio_processor->OnCaptureFormatChanged(params);
+
+  ProcessDataAndVerifyFormat(audio_processor.get(),
+                             kAudioProcessingSampleRate,
+                             kAudioProcessingNumberOfChannel,
+                             kAudioProcessingSampleRate / 100);
+  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
+  // |audio_processor|.
+  audio_processor = NULL;
+}
+
+TEST_F(MediaStreamAudioProcessorTest,
+       TestWithKeyboardMicChannelWithoutProcessing) {
+  // Setup the audio processor with disabled flag on.
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kDisableAudioTrackProcessing);
+  MockMediaConstraintFactory constraint_factory;
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
+      new WebRtcAudioDeviceImpl());
+  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
+      new rtc::RefCountedObject<MediaStreamAudioProcessor>(
+          constraint_factory.CreateWebMediaConstraints(), 0,
+          webrtc_audio_device.get()));
+  EXPECT_FALSE(audio_processor->has_audio_processing());
+
+  media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                                media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC,
+                                48000, 16, 512);
+  audio_processor->OnCaptureFormatChanged(params);
+
+  ProcessDataAndVerifyFormat(
+      audio_processor.get(),
+      params.sample_rate(),
+      media::ChannelLayoutToChannelCount(media::CHANNEL_LAYOUT_STEREO),
+      params.sample_rate() / 100);
+  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
+  // |audio_processor|.
+  audio_processor = NULL;
+}
+
 }  // namespace content