Strip away the keyboard mic channel if no audio processing.

content/renderer/media/media_stream_audio_processor.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 "content/renderer/media/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #if defined(OS_MACOSX)
 #include "base/metrics/field_trial.h"
@@ skipping 209 matching lines @@
 
   // Reset the |capture_thread_checker_| since the capture data will come from
   // a new capture thread.
   capture_thread_checker_.DetachFromThread();
 }
 
 void MediaStreamAudioProcessor::PushCaptureData(
     const media::AudioBus* audio_source) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
 
-  capture_fifo_->Push(audio_source);
+  // If we don't use audio processing we strip any keyboard mic channel before
+  // putting it in the fifo.
+  if (input_format_.channel_layout() ==

[no longer working on chromium, 2014/09/24 12:41:27]

you should move these code to MediaStreamAudioFifo

[Henrik Grunell, 2014/09/24 20:01:29]

Yep, but I need the additional info about layout and audio processing enabled.

[Henrik Grunell, 2014/09/26 10:04:27]

Changed to what I proposed offline: take source and destination channels in the
fifo ctor, use that info to possibly strip away channels.

+          media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC &&
+      !audio_processing_) {
+    scoped_ptr<media::AudioBus> audio_source_stereo =

[no longer working on chromium, 2014/09/24 12:41:27]

use a member in MediaStreamAudioFifo, and set it up when MediaStreamAudioFifo is
created.

[Henrik Grunell, 2014/09/26 10:04:27]

Done.

+        media::AudioBus::CreateWrapper(2);
+    audio_source_stereo->SetChannelData(
+        0, const_cast<float*>(audio_source->channel(0)));
+    audio_source_stereo->SetChannelData(
+        1, const_cast<float*>(audio_source->channel(1)));
+    audio_source_stereo->set_frames(audio_source->frames());
+    capture_fifo_->Push(audio_source_stereo.get());
+  } else {
+    capture_fifo_->Push(audio_source);
+  }
 }
 
 bool MediaStreamAudioProcessor::ProcessAndConsumeData(
     base::TimeDelta capture_delay, int volume, bool key_pressed,
     int* new_volume, int16** out) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("audio", "MediaStreamAudioProcessor::ProcessAndConsumeData");
 
   MediaStreamAudioBus* process_bus;
   if (!capture_fifo_->Consume(&process_bus))
@@ skipping 218 matching lines @@
   DCHECK(input_format.IsValid());
   input_format_ = input_format;
 
   // TODO(ajm): For now, we assume fixed parameters for the output when audio
   // processing is enabled, to match the previous behavior. We should either
   // use the input parameters (in which case, audio processing will convert
   // at output) or ideally, have a backchannel from the sink to know what
   // format it would prefer.
   const int output_sample_rate = audio_processing_ ?
       kAudioProcessingSampleRate : input_format.sample_rate();
-  const media::ChannelLayout output_channel_layout = audio_processing_ ?
+  media::ChannelLayout output_channel_layout = audio_processing_ ?
       media::GuessChannelLayout(kAudioProcessingNumberOfChannels) :
       input_format.channel_layout();

[no longer working on chromium, 2014/09/24 12:41:27]

can the output_channel_layout be media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC
at all?

[Henrik Grunell, 2014/09/24 20:01:29]

No.

 
   // webrtc::AudioProcessing requires a 10 ms chunk size. We use this native
   // size when processing is enabled. When disabled we use the same size as
   // the source if less than 10 ms.
   //
   // TODO(ajm): This conditional buffer size appears to be assuming knowledge of
   // the sink based on the source parameters. PeerConnection sinks seem to want
   // 10 ms chunks regardless, while WebAudio sinks want less, and we're assuming
   // we can identify WebAudio sinks by the input chunk size. Less fragile would
   // be to have the sink actually tell us how much it wants (as in the above
   // TODO).
   int processing_frames = input_format.sample_rate() / 100;
   int output_frames = output_sample_rate / 100;
   if (!audio_processing_ && input_format.frames_per_buffer() < output_frames) {
     processing_frames = input_format.frames_per_buffer();
     output_frames = processing_frames;
   }
 
+  int capture_fifo_channels = input_format.channels();
+
+  // Special cases for if we have a keyboard mic channel on the input and no
+  // audio processing is used. We will then strip away that channel before
+  // putting it in the fifo. We keep the layout in |input_format_| since that's
+  // what we expect as input to this class.
+  if (input_format.channel_layout() ==
+          media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC &&
+      !audio_processing_) {
+    capture_fifo_channels = 2;
+    output_channel_layout = media::CHANNEL_LAYOUT_STEREO;
+  }
+
   output_format_ = media::AudioParameters(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       output_channel_layout,
       output_sample_rate,
       16,
       output_frames);
 
   capture_fifo_.reset(
-      new MediaStreamAudioFifo(input_format.channels(),
+      new MediaStreamAudioFifo(capture_fifo_channels,

[no longer working on chromium, 2014/09/24 12:41:27]

how about modify MediaStreamAudioFifo constructor and inject a boolean there to
indicate if audio processing is enabled or not, then all these channel layout
things will be handled internally in MediaStreamAudioFifo.

[Henrik Grunell, 2014/09/24 20:01:29]

Yes, but the fifo would need to know about the layout, since we can have 3
channels in other layouts as well.

                                input_format.frames_per_buffer(),
                                processing_frames));
 
   if (audio_processing_) {
     output_bus_.reset(new MediaStreamAudioBus(output_format_.channels(),
                                               output_frames));
   }
   output_data_.reset(new int16[output_format_.GetBytesPerBuffer() /
                                sizeof(int16)]);
 }
@@ skipping 71 matching lines @@
                                               vad->stream_has_voice());
     base::subtle::Release_Store(&typing_detected_, detected);
   }
 
   // Return 0 if the volume hasn't been changed, and otherwise the new volume.
   return (agc->stream_analog_level() == volume) ?
       0 : agc->stream_analog_level();
 }
 
 }  // namespace content