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 32 matching lines @@
     case media::CHANNEL_LAYOUT_STEREO:
       return AudioProcessing::kStereo;
     case media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC:
       return AudioProcessing::kStereoAndKeyboard;
     default:
       NOTREACHED() << "Layout not supported: " << media_layout;
       return AudioProcessing::kMono;
   }
 }
 
+// This is only used for playout data where only max two channels is supported.
 AudioProcessing::ChannelLayout ChannelsToLayout(int num_channels) {
   switch (num_channels) {
     case 1:
       return AudioProcessing::kMono;
     case 2:
       return AudioProcessing::kStereo;
     default:
       NOTREACHED() << "Channels not supported: " << num_channels;
       return AudioProcessing::kMono;
   }
@@ skipping 44 matching lines @@
   }
 
  private:
   base::ThreadChecker thread_checker_;
   scoped_ptr<media::AudioBus> bus_;
   scoped_ptr<float*[]> channel_ptrs_;
 };
 
 // Wraps AudioFifo to provide a cleaner interface to MediaStreamAudioProcessor.
 // It avoids the FIFO when the source and destination frames match. All methods
-// are called on one of the capture or render audio threads exclusively.
+// are called on one of the capture or render audio threads exclusively. If
+// |source_channels| is larger than |destination_channels|, only the first
+// |destination_channels| are kept from the source.
 class MediaStreamAudioFifo {
  public:
-  MediaStreamAudioFifo(int channels, int source_frames,
+  MediaStreamAudioFifo(int source_channels,
+                       int destination_channels,
+                       int source_frames,
                        int destination_frames)
-     : source_frames_(source_frames),
-       destination_(new MediaStreamAudioBus(channels, destination_frames)),
+     : source_channels_(source_channels),
+       source_frames_(source_frames),
+       destination_(
+           new MediaStreamAudioBus(destination_channels, destination_frames)),
        data_available_(false) {
+    DCHECK_GE(source_channels, destination_channels);
     if (source_frames != destination_frames) {
       // Since we require every Push to be followed by as many Consumes as
       // possible, twice the larger of the two is a (probably) loose upper bound
       // on the FIFO size.
       const int fifo_frames = 2 * std::max(source_frames, destination_frames);
-      fifo_.reset(new media::AudioFifo(channels, fifo_frames));
+      fifo_.reset(new media::AudioFifo(destination_channels, fifo_frames));
     }
 
     // May be created in the main render thread and used in the audio threads.
     thread_checker_.DetachFromThread();
   }
 
   void Push(const media::AudioBus* source) {
     DCHECK(thread_checker_.CalledOnValidThread());
-    DCHECK_EQ(source->channels(), destination_->bus()->channels());
+    DCHECK_EQ(source->channels(), source_channels_);
     DCHECK_EQ(source->frames(), source_frames_);
 
+    const media::AudioBus* source_to_push = source;
+
+    if (source->channels() > destination_->bus()->channels()) {
+      if (!audio_source_intermediate_) {
+        audio_source_intermediate_ =

[no longer working on chromium, 2014/09/26 11:20:41]

You can set up this audio_source_intermediate_ in the constructor, and in this
Push() call, do 
if (audio_source_intermediate_) {
  for (int i = 0; i < destination_->bus()->channels(); ++i) {
    audio_source_intermediate_->SetChannelData(
        i, const_cast<float*>(source->channel(i)));
  }
  audio_source_intermediate_->set_frames(source->frames());
  source_to_push = audio_source_intermediate_.get();
}

[Henrik Grunell, 2014/09/30 07:46:54]

Done.

+            media::AudioBus::CreateWrapper(destination_->bus()->channels());
+      }
+      for (int i = 0; i < destination_->bus()->channels(); ++i) {
+        audio_source_intermediate_->SetChannelData(
+            i,
+            const_cast<float*>(source->channel(i)));
+      }
+      audio_source_intermediate_->set_frames(source->frames());
+      source_to_push = audio_source_intermediate_.get();
+    }
+
     if (fifo_) {
-      fifo_->Push(source);
+      fifo_->Push(source_to_push);
     } else {
-      source->CopyTo(destination_->bus());
+      source_to_push->CopyTo(destination_->bus());
       data_available_ = true;
     }
   }
 
   // Returns true if there are destination_frames() of data available to be
   // consumed, and otherwise false.
   bool Consume(MediaStreamAudioBus** destination) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     if (fifo_) {
       if (fifo_->frames() < destination_->bus()->frames())
         return false;
 
       fifo_->Consume(destination_->bus(), 0, destination_->bus()->frames());
     } else {
       if (!data_available_)
         return false;
 
       // The data was already copied to |destination_| in this case.
       data_available_ = false;
     }
 
     *destination = destination_.get();
     return true;
   }
 
  private:
   base::ThreadChecker thread_checker_;
+  const int source_channels_;  // For a DCHECK.
   const int source_frames_;  // For a DCHECK.
+  scoped_ptr<media::AudioBus> audio_source_intermediate_;
   scoped_ptr<MediaStreamAudioBus> destination_;
   scoped_ptr<media::AudioFifo> fifo_;
   // Only used when the FIFO is disabled;
   bool data_available_;
 };
 
 bool MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled() {
   return !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableAudioTrackProcessing);
 }
@@ skipping 274 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();
 
+  // The output channels from the fifo is normally the same as input.
+  int fifo_output_channels = input_format.channels();
+
+  // Special case for if we have a keyboard mic channel on the input and no
+  // audio processing is used. We will then have the fifo strip away that
+  // channel. So we use stereo as output layout, and also change the output
+  // channels for the fifo.
+  if (input_format.channel_layout() ==
+          media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC &&
+      !audio_processing_) {
+    output_channel_layout = media::CHANNEL_LAYOUT_STEREO;
+    fifo_output_channels = ChannelLayoutToChannelCount(output_channel_layout);
+  }
+
   // 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;
   }
 
   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(),
+                               fifo_output_channels,
                                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 12 matching lines @@
   render_format_ = media::AudioParameters(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       media::GuessChannelLayout(number_of_channels),
       sample_rate,
       16,
       frames_per_buffer);
 
   const int analysis_frames = sample_rate / 100;  // 10 ms chunks.
   render_fifo_.reset(
       new MediaStreamAudioFifo(number_of_channels,
+                               number_of_channels,
                                frames_per_buffer,
                                analysis_frames));
 }
 
 int MediaStreamAudioProcessor::ProcessData(const float* const* process_ptrs,
                                            int process_frames,
                                            base::TimeDelta capture_delay,
                                            int volume,
                                            bool key_pressed,
                                            float* const* output_ptrs) {
@@ skipping 39 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