Switch to pcm_low_latency and enable resampling.

media/base/audio_renderer_mixer_unittest.cc

 // 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.
 
 #include <cmath>
 
 #include "base/memory/scoped_ptr.h"
 #include "media/audio/audio_util.h"
 #include "media/base/audio_renderer_mixer.h"
 #include "media/base/audio_renderer_mixer_input.h"
 #include "media/base/fake_audio_render_callback.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // Parameters which control the many input case tests.
 static const int kMixerInputs = 64;
 static const int kMixerCycles = 32;
 
 static const int kBitsPerChannel = 16;
-static const int kSampleRate = 48000;
+static const int kSampleRate = GetAudioHardwareSampleRate();
 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
 
 // Multiple rounds of addition result in precision loss with float values, so we
 // need an epsilon such that if for all x f(x) = sum(x, m) and g(x) = m * x then
 // fabs(f - g) < kEpsilon.  The kEpsilon below has been tested with m < 128.
 static const float kEpsilon = 0.00015f;
 
 class MockAudioRendererSink : public AudioRendererSink {
  public:
   MOCK_METHOD0(Start, void());
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD1(Pause, void(bool flush));
   MOCK_METHOD0(Play, void());
   MOCK_METHOD1(SetPlaybackRate, void(float rate));
   MOCK_METHOD1(SetVolume, bool(double volume));
   MOCK_METHOD1(GetVolume, void(double* volume));
 
-  void Initialize(const media::AudioParameters& params,
+  void Initialize(const AudioParameters& params,
                   AudioRendererSink::RenderCallback* renderer) OVERRIDE {
     // TODO(dalecurtis): Once we have resampling we need to ensure we are given
     // an AudioParameters which reflects the hardware settings.
     callback_ = renderer;
+    params_ = params;
   };
 
   AudioRendererSink::RenderCallback* callback() {
     return callback_;
   }
 
+  const AudioParameters& params() {
+    return params_;
+  }
+
   void SimulateRenderError() {
     callback_->OnRenderError();
   }
 
  protected:
   virtual ~MockAudioRendererSink() {}
 
   AudioRendererSink::RenderCallback* callback_;
+  AudioParameters params_;
 };
 
 class AudioRendererMixerTest : public ::testing::Test {
  public:
   AudioRendererMixerTest() {
-    audio_parameters_ = AudioParameters(
+    input_parameters_ = AudioParameters(
         AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
         kBitsPerChannel, GetHighLatencyOutputBufferSize(kSampleRate));
     sink_ = new MockAudioRendererSink();
     EXPECT_CALL(*sink_, Start());
     EXPECT_CALL(*sink_, Stop());
 
-    mixer_ = new AudioRendererMixer(audio_parameters_, sink_);
+    mixer_ = new AudioRendererMixer(input_parameters_, sink_);
     mixer_callback_ = sink_->callback();
+    output_parameters_ = sink_->params();
 
     // TODO(dalecurtis): If we switch to AVX/SSE optimization, we'll need to
     // allocate these on 32-byte boundaries and ensure they're sized % 32 bytes.
-    audio_data_.reserve(audio_parameters_.channels());
-    for (int i = 0; i < audio_parameters_.channels(); ++i)
-      audio_data_.push_back(new float[audio_parameters_.frames_per_buffer()]);
+    audio_data_.reserve(output_parameters_.channels());
+    for (int i = 0; i < output_parameters_.channels(); ++i)
+      audio_data_.push_back(new float[output_parameters_.frames_per_buffer()]);
 
-    fake_callback_.reset(new FakeAudioRenderCallback(audio_parameters_));
+    fake_callback_.reset(new FakeAudioRenderCallback(output_parameters_));
   }
 
   void InitializeInputs(int count) {
     for (int i = 0; i < count; ++i) {
       scoped_refptr<AudioRendererMixerInput> mixer_input(
           new AudioRendererMixerInput(mixer_));
-      mixer_input->Initialize(audio_parameters_, fake_callback_.get());
+      mixer_input->Initialize(input_parameters_, fake_callback_.get());
       mixer_input->SetVolume(1.0f);
       mixer_inputs_.push_back(mixer_input);
     }
   }
 
   bool ValidateAudioData(int start_index, int frames, float check_value) {
     for (size_t i = 0; i < audio_data_.size(); ++i) {
       for (int j = start_index; j < frames; j++) {
         if (fabs(audio_data_[i][j] - check_value) > kEpsilon) {
           EXPECT_NEAR(check_value, audio_data_[i][j], kEpsilon)
               << " i=" << i << ", j=" << j;
           return false;
         }
       }
     }
     return true;
   }
 
-  // Render audio_parameters_.frames_per_buffer() frames into |audio_data_| and
+  // Render input_parameters_.frames_per_buffer() frames into |audio_data_| and
   // verify the result against |check_value|.
   bool RenderAndValidateAudioData(float check_value) {
-    int frames = mixer_callback_->Render(
-        audio_data_, audio_parameters_.frames_per_buffer(), 0);
-    return frames == audio_parameters_.frames_per_buffer() && ValidateAudioData(
-        0, audio_parameters_.frames_per_buffer(), check_value);
+    int request_frames = output_parameters_.frames_per_buffer();
+    int frames = mixer_callback_->Render(audio_data_, request_frames, 0);
+    return frames == request_frames && ValidateAudioData(
+        0, request_frames, check_value);
   }
 
   // Fill |audio_data_| fully with |value|.
   void FillAudioData(float value) {
     for (size_t i = 0; i < audio_data_.size(); ++i)
       std::fill(audio_data_[i],
-                audio_data_[i] + audio_parameters_.frames_per_buffer(), value);
+                audio_data_[i] + output_parameters_.frames_per_buffer(), value);
   }
 
   // Verify silence when mixer inputs are in pre-Start() and post-Start().
   void StartTest(int inputs) {
     InitializeInputs(inputs);
 
     // Verify silence before any inputs have been started.  Fill the buffer
     // before hand with non-zero data to ensure we get zeros back.
     FillAudioData(1.0f);
     EXPECT_TRUE(RenderAndValidateAudioData(0.0f));
@@ skipping 66 matching lines @@
           fake_callback_->fill_value() * total_scale));
     }
 
     for (size_t i = 0; i < mixer_inputs_.size(); ++i)
       mixer_inputs_[i]->Stop();
   }
 
   // Verify output when mixer inputs can only partially fulfill a Render().
   void PlayPartialRenderTest(int inputs) {
     InitializeInputs(inputs);
-    int frames = audio_parameters_.frames_per_buffer();
+    int frames = output_parameters_.frames_per_buffer();
 
     for (size_t i = 0; i < mixer_inputs_.size(); ++i) {
       mixer_inputs_[i]->Start();
       mixer_inputs_[i]->Play();
     }
 
     // Verify a properly filled buffer when half filled (remainder zeroed).
     fake_callback_->set_half_fill(true);
     for (int i = 0; i < kMixerCycles; ++i) {
       fake_callback_->NextFillValue();
@@ skipping 55 matching lines @@
  protected:
   virtual ~AudioRendererMixerTest() {
     for (size_t i = 0; i < audio_data_.size(); ++i)
       delete [] audio_data_[i];
   }
 
   scoped_refptr<MockAudioRendererSink> sink_;
   scoped_refptr<AudioRendererMixer> mixer_;
   AudioRendererSink::RenderCallback* mixer_callback_;
   scoped_ptr<FakeAudioRenderCallback> fake_callback_;
-  AudioParameters audio_parameters_;
+  AudioParameters input_parameters_;
+  AudioParameters output_parameters_;
   std::vector<float*> audio_data_;
   std::vector< scoped_refptr<AudioRendererMixerInput> > mixer_inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererMixerTest);
 };
 
 // Verify a mixer with no inputs returns silence for all requested frames.
 TEST_F(AudioRendererMixerTest, NoInputs) {
   FillAudioData(1.0f);
   EXPECT_TRUE(RenderAndValidateAudioData(0.0f));
@@ skipping 82 matching lines @@
 
   for (size_t i = 1; i < mixer_inputs_.size(); i += 2)
     mixer_inputs_[i]->Stop();
 }
 
 TEST_F(AudioRendererMixerTest, OnRenderError) {
   std::vector< scoped_refptr<AudioRendererMixerInput> > mixer_inputs;
   for (int i = 0; i < kMixerInputs; ++i) {
     scoped_refptr<AudioRendererMixerInput> mixer_input(
         new AudioRendererMixerInput(mixer_));
-    mixer_input->Initialize(audio_parameters_, fake_callback_.get());
+    mixer_input->Initialize(input_parameters_, fake_callback_.get());
     mixer_input->SetVolume(1.0f);
     mixer_input->Start();
     mixer_inputs_.push_back(mixer_input);
   }
 
   EXPECT_CALL(*fake_callback_, OnRenderError()).Times(kMixerInputs);
   sink_->SimulateRenderError();
   for (int i = 0; i < kMixerInputs; ++i)
     mixer_inputs_[i]->Stop();
 }
 
 }  // namespace media