Adds support for 16kHz input sample rate and mono channel config. in WebRTC.

content/renderer/media/webrtc_audio_device_unittest.cc

 // Copyright (c) 2011 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/environment.h"
 #include "base/test/test_timeouts.h"
 #include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/test/webrtc_audio_device_test.h"
 #include "media/audio/audio_manager.h"
@@ skipping 20 matching lines @@
 class AudioUtil : public AudioUtilInterface {
  public:
   AudioUtil() {}
 
   virtual double GetAudioHardwareSampleRate() OVERRIDE {
     return media::GetAudioHardwareSampleRate();
   }
   virtual double GetAudioInputHardwareSampleRate() OVERRIDE {
     return media::GetAudioInputHardwareSampleRate();
   }
+  virtual uint32 GetAudioInputHardwareChannelCount() OVERRIDE {
+    return media::GetAudioInputHardwareChannelCount();
+  }
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioUtil);
 };
 
 class AudioUtilNoHardware : public AudioUtilInterface {
  public:
-  AudioUtilNoHardware(double output_rate, double input_rate)
-    : output_rate_(output_rate), input_rate_(input_rate) {
+  AudioUtilNoHardware(double output_rate, double input_rate,
+                      uint32 input_channels)
+      : output_rate_(output_rate),
+        input_rate_(input_rate),
+        input_channels_(input_channels) {
   }
 
   virtual double GetAudioHardwareSampleRate() OVERRIDE {
     return output_rate_;
   }
   virtual double GetAudioInputHardwareSampleRate() OVERRIDE {
     return input_rate_;
   }
+  virtual uint32 GetAudioInputHardwareChannelCount() OVERRIDE {
+    return input_channels_;
+  }
 
  private:
   double output_rate_;
   double input_rate_;
+  uint32 input_channels_;
   DISALLOW_COPY_AND_ASSIGN(AudioUtilNoHardware);
 };
 
 bool IsRunningHeadless() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->HasVar("CHROME_HEADLESS"))
     return true;
   return false;
 }
 
 // The WebRTC audio client only supports 44.1 and 48.0 kHz.
 // This method returns false if a non-supported rate is detected on the
 // input or output side.
 // TODO(henrika): add support for automatic fallback to Windows Wave audio
 // if a non-supported rate is detected. It is probably better to detect
 // invalid audio settings by actually trying to open the audio streams instead
 // of relying on hard coded conditions.
 bool HardwareSampleRatesAreValid() {
   int output_sample_rate =
       static_cast<int>(audio_hardware::GetOutputSampleRate());
   int input_sample_rate =
       static_cast<int>(audio_hardware::GetInputSampleRate());
   bool rates_are_valid =
       ((output_sample_rate == 44100 || output_sample_rate == 48000) &&
-       (input_sample_rate == 44100 || input_sample_rate == 48000));
+       (input_sample_rate == 44100 || input_sample_rate == 48000 ||
+        input_sample_rate == 16000 || input_sample_rate == 32000));
   DLOG_IF(WARNING, !rates_are_valid) << "Non-supported sample rate detected.";
   return rates_are_valid;
 }
 
 
 class WebRTCMediaProcessImpl : public webrtc::VoEMediaProcess {
  public:
   explicit WebRTCMediaProcessImpl(base::WaitableEvent* event)
       : event_(event),
         channel_id_(-1),
@@ skipping 57 matching lines @@
   int channels_;
   mutable base::Lock lock_;
   DISALLOW_COPY_AND_ASSIGN(WebRTCMediaProcessImpl);
 };
 
 }  // end namespace
 
 // Basic test that instantiates and initializes an instance of
 // WebRtcAudioDeviceImpl.
 TEST_F(WebRTCAudioDeviceTest, Construct) {
-  AudioUtilNoHardware audio_util(48000.0, 48000.0);
+  AudioUtilNoHardware audio_util(48000.0, 48000.0, 1);
   SetAudioUtilCallback(&audio_util);
   scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
       new WebRtcAudioDeviceImpl());
+
   audio_device->SetSessionId(1);
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   int err = base->Init(audio_device);
   EXPECT_EQ(0, err);
   EXPECT_EQ(0, base->Terminate());
 }
@@ skipping 256 matching lines @@
                                 MessageLoop::QuitClosure(),
                                 TestTimeouts::action_timeout_ms());
   message_loop_.Run();
 
   EXPECT_EQ(0, base->StopSend(ch));
   EXPECT_EQ(0, base->StopPlayout(ch));
 
   EXPECT_EQ(0, base->DeleteChannel(ch));
   EXPECT_EQ(0, base->Terminate());
 }