changed MSAP to work with 96000KHZ

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/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/time/time.h"
@@ skipping 51 matching lines @@
                 media::CHANNEL_LAYOUT_STEREO, 48000, 16, 512) {
   }
 
  protected:
   // Helper method to save duplicated code.
   void ProcessDataAndVerifyFormat(MediaStreamAudioProcessor* audio_processor,
                                   int expected_output_sample_rate,
                                   int expected_output_channels,
                                   int expected_output_buffer_size) {
     // 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();
+        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());
+        params.channels(), params.frames_per_buffer());
     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(),
+        audio_processor->OnPlayoutData(data_bus.get(), 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);
         EXPECT_EQ(audio_processor->OutputFormat().channels(),
                   expected_output_channels);
         EXPECT_EQ(audio_processor->OutputFormat().frames_per_buffer(),
                   expected_output_buffer_size);
       }
 
-      data_ptr += params_.frames_per_buffer() * params_.channels();
+      data_ptr += params.frames_per_buffer() * params.channels();
     }
   }
 
   void VerifyDefaultComponents(MediaStreamAudioProcessor* audio_processor) {
     webrtc::AudioProcessing* audio_processing =
         audio_processor->audio_processing_.get();
 #if defined(OS_ANDROID)
     EXPECT_TRUE(audio_processing->echo_control_mobile()->is_enabled());
     EXPECT_TRUE(audio_processing->echo_control_mobile()->routing_mode() ==
         webrtc::EchoControlMobile::kSpeakerphone);
@@ skipping 219 matching lines @@
 
 TEST_F(MediaStreamAudioProcessorTest, ValidateConstraints) {
   MockMediaConstraintFactory constraint_factory;
   const std::string dummy_constraint = "dummy";
   constraint_factory.AddMandatory(dummy_constraint, true);
   MediaAudioConstraints audio_constraints(
       constraint_factory.CreateWebMediaConstraints(), 0);
   EXPECT_FALSE(audio_constraints.IsValid());
 }
 
+TEST_F(MediaStreamAudioProcessorTest, TestAllSampleRates) {
+  MockMediaConstraintFactory constraint_factory;
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
+      new WebRtcAudioDeviceImpl());
+  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
+      new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
+          constraint_factory.CreateWebMediaConstraints(), 0,
+          webrtc_audio_device.get()));
+  EXPECT_TRUE(audio_processor->has_audio_processing());
+
+  static const int kSupportedSampleRates[] =
+      { 8000, 16000, 22050, 32000, 44100, 48000, 88200, 96000 };
+  for (size_t i = 0; i < arraysize(kSupportedSampleRates); ++i) {
+    int buffer_size = (kSupportedSampleRates[i] / 100)  < 128 ?
+        kSupportedSampleRates[i] / 100 : 128;
+    media::AudioParameters params(
+        media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+        media::CHANNEL_LAYOUT_STEREO, kSupportedSampleRates[i], 16,
+        buffer_size);
+    audio_processor->OnCaptureFormatChanged(params);
+    VerifyDefaultComponents(audio_processor);
+
+    ProcessDataAndVerifyFormat(audio_processor,
+                               kAudioProcessingSampleRate,
+                               kAudioProcessingNumberOfChannel,
+                               kAudioProcessingSampleRate / 100);
+  }
+
+  // Set |audio_processor| to NULL to make sure |webrtc_audio_device|
+  // outlives |audio_processor|.
+  audio_processor = NULL;
+}
+
 }  // namespace content