Enable platform echo cancellation through the AudioRecord path.

media/audio/audio_parameters.h

 // Copyright (c) 2012 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_PARAMETERS_H_
 #define MEDIA_AUDIO_AUDIO_PARAMETERS_H_
 
 #include "base/basictypes.h"
 #include "base/time/time.h"
 #include "media/base/channel_layout.h"
@@ skipping 26 matching lines @@
     AUDIO_LAST_FORMAT         // Only used for validation of format.
   };
 
   enum {
     // Telephone quality sample rate, mostly for speech-only audio.
     kTelephoneSampleRate = 8000,
     // CD sampling rate is 44.1 KHz or conveniently 2x2x3x3x5x5x7x7.
     kAudioCDSampleRate = 44100,
   };
 
+  // Used to carry whether certin platform (typically hardware) audio effects
+  // should be enabled.
+  struct PlatformEffects {
+    PlatformEffects() : echo_canceller(false) {}
+    bool operator==(const PlatformEffects& other) const {

[tommi (sloooow) - chröme, 2013/12/11 12:14:36]

document why you need the comparison operator. Usually we don't override
operators unless there's a specific need to (it goes against the style guide).
If you don't need it, you can still have an IsEqual method.

[ajm, 2013/12/11 17:46:49]

It was only to support the AudioParameters comparison operator, but I could just
as well call an IsEqual there.

+      return echo_canceller == other.echo_canceller;
+    }
+    bool echo_canceller;
+  };
+
   AudioParameters();
   AudioParameters(Format format, ChannelLayout channel_layout,
                   int sample_rate, int bits_per_sample,
                   int frames_per_buffer);
   AudioParameters(Format format, ChannelLayout channel_layout,
                   int input_channels,
                   int sample_rate, int bits_per_sample,
                   int frames_per_buffer);
   void Reset(Format format, ChannelLayout channel_layout,
              int channels, int input_channels,
@@ skipping 17 matching lines @@
   // and sample_rate().
   base::TimeDelta GetBufferDuration() const;
 
   Format format() const { return format_; }
   ChannelLayout channel_layout() const { return channel_layout_; }
   int sample_rate() const { return sample_rate_; }
   int bits_per_sample() const { return bits_per_sample_; }
   int frames_per_buffer() const { return frames_per_buffer_; }
   int channels() const { return channels_; }
   int input_channels() const { return input_channels_; }
+  const PlatformEffects& effects() const { return effects_; }
 
   // Set to CHANNEL_LAYOUT_DISCRETE with given number of channels.
   void SetDiscreteChannels(int channels);
+  void SetPlatformEffects(const PlatformEffects& effects);
 
   // Comparison with other AudioParams.
   bool operator==(const AudioParameters& other) const {
     return format_ == other.format() &&
            sample_rate_ == other.sample_rate() &&
            channel_layout_ == other.channel_layout() &&
            channels_ == other.channels() &&
            input_channels_ == other.input_channels() &&
            bits_per_sample_ == other.bits_per_sample() &&
-           frames_per_buffer_ == other.frames_per_buffer();
+           frames_per_buffer_ == other.frames_per_buffer() &&
+           effects_ == other.effects();
   }
 
  private:
   Format format_;                 // Format of the stream.
   ChannelLayout channel_layout_;  // Order of surround sound channels.
   int sample_rate_;               // Sampling frequency/rate.
   int bits_per_sample_;           // Number of bits per sample.
   int frames_per_buffer_;         // Number of frames in a buffer.
 
   int channels_;                  // Number of channels. Value set based on
                                   // |channel_layout|.
   int input_channels_;            // Optional number of input channels.
                                   // Normally 0, but can be set to specify
                                   // synchronized I/O.
+  PlatformEffects effects_;       // See PlatformEffects.
 };
 
 // Comparison is useful when AudioParameters is used with std structures.
 inline bool operator<(const AudioParameters& a, const AudioParameters& b) {
   if (a.format() != b.format())
     return a.format() < b.format();
   if (a.channels() != b.channels())
     return a.channels() < b.channels();
   if (a.input_channels() != b.input_channels())
     return a.input_channels() < b.input_channels();
   if (a.sample_rate() != b.sample_rate())
     return a.sample_rate() < b.sample_rate();
   if (a.bits_per_sample() != b.bits_per_sample())
     return a.bits_per_sample() < b.bits_per_sample();
   return a.frames_per_buffer() < b.frames_per_buffer();
 }
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_PARAMETERS_H_