Collapse AudioRendererMixer and OnMoreDataResampler into AudioTransform.

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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 59 matching lines @@
     return mixer_.get();
   }
 
   MOCK_METHOD1(RemoveMixer, void(const AudioParameters&));
 
   void InitializeInputs(int count) {
     mixer_inputs_.reserve(count);
     fake_callbacks_.reserve(count);
 
     // Setup FakeAudioRenderCallback step to compensate for resampling.
-    double scale_factor = input_parameters_.sample_rate()
-        / static_cast<double>(output_parameters_.sample_rate());
+    double scale_factor = input_parameters_.sample_rate() /
+        static_cast<double>(output_parameters_.sample_rate());
     double step = kSineCycles / (scale_factor *
         static_cast<double>(output_parameters_.frames_per_buffer()));
 
     for (int i = 0; i < count; ++i) {
       fake_callbacks_.push_back(new FakeAudioRenderCallback(step));
       mixer_inputs_.push_back(new AudioRendererMixerInput(
           base::Bind(&AudioRendererMixerTest::GetMixer,
                      base::Unretained(this)),
           base::Bind(&AudioRendererMixerTest::RemoveMixer,
                      base::Unretained(this))));
       mixer_inputs_[i]->Initialize(input_parameters_, fake_callbacks_[i]);
       mixer_inputs_[i]->SetVolume(1.0f);
     }
     EXPECT_CALL(*this, RemoveMixer(testing::_)).Times(count);
   }
 
-  bool ValidateAudioData(int index, int frames, float scale) {
+  bool ValidateAudioData(int index, int frames, float scale, double epsilon) {
     for (int i = 0; i < audio_bus_->channels(); ++i) {
       for (int j = index; j < frames; j++) {
         double error = fabs(audio_bus_->channel(i)[j] -
             expected_audio_bus_->channel(i)[j] * scale);
-        if (error > epsilon_) {
+        if (error > epsilon) {
           EXPECT_NEAR(expected_audio_bus_->channel(i)[j] * scale,
-                      audio_bus_->channel(i)[j], epsilon_)
+                      audio_bus_->channel(i)[j], epsilon)
               << " i=" << i << ", j=" << j;
           return false;
         }
       }
     }
     return true;
   }
 
+  bool ValidateAudioData(int index, int frames, float scale) {
+    return ValidateAudioData(index, frames, scale, epsilon_);
+  }
+
   bool RenderAndValidateAudioData(float scale) {
-    // Half fill won't be exactly half when resampling since the resampler
-    // will have enough data to fill out more of the buffer based on its
-    // internal buffer and kernel size.  So special case some of the checks.
-    bool resampling = input_parameters_.sample_rate()
-        != output_parameters_.sample_rate();
-
     if (half_fill_) {
       for (size_t i = 0; i < fake_callbacks_.size(); ++i)
         fake_callbacks_[i]->set_half_fill(true);
       expected_callback_->set_half_fill(true);
-      expected_audio_bus_->Zero();
     }
 
     // Render actual audio data.
     int frames = mixer_callback_->Render(audio_bus_.get(), 0);
     if (frames != audio_bus_->frames())
       return false;
 
     // Render expected audio data (without scaling).
     expected_callback_->Render(expected_audio_bus_.get(), 0);
 
     if (half_fill_) {
-      // Verify first half of audio data for both resampling and non-resampling.
-      if (!ValidateAudioData(0, frames / 2, scale))
-        return false;
-      // Verify silence in the second half if we're not resampling.
-      if (!resampling)
-        return ValidateAudioData(frames / 2, frames, 0);
-      return true;
+      // In this case, just verify that every frame was initialized, this will
+      // only fail under tooling such as valgrind.
+      return ValidateAudioData(
+          0, frames, 0, std::numeric_limits<double>::max());
     } else {
       return ValidateAudioData(0, frames, scale);
     }
   }
 
   // Fill |audio_bus_| fully with |value|.
   void FillAudioData(float value) {
     for (int i = 0; i < audio_bus_->channels(); ++i) {
       std::fill(audio_bus_->channel(i),
                 audio_bus_->channel(i) + audio_bus_->frames(), value);
@@ skipping 227 matching lines @@
   for (size_t i = 0; i < mixer_inputs_.size(); ++i) {
     mixer_inputs_[i]->Start();
     EXPECT_CALL(*fake_callbacks_[i], OnRenderError()).Times(1);
   }
 
   mixer_callback_->OnRenderError();
   for (size_t i = 0; i < mixer_inputs_.size(); ++i)
     mixer_inputs_[i]->Stop();
 }
 
-// Verify that audio delay information is scaled to the input parameters.
-TEST_P(AudioRendererMixerTest, DelayTest) {
-  InitializeInputs(1);
-  static const int kAudioDelayMilliseconds = 100;
-  ASSERT_EQ(mixer_inputs_.size(), 1u);
-
-  // Start the input and issue a single render callback.
-  mixer_inputs_[0]->Start();
-  mixer_inputs_[0]->Play();
-  mixer_callback_->Render(audio_bus_.get(), kAudioDelayMilliseconds);
-
-  // The input to output ratio should only include the sample rate difference.
-  double io_ratio = input_parameters_.sample_rate() /
-      static_cast<double>(output_parameters_.sample_rate());
-
-  EXPECT_EQ(static_cast<int>(kAudioDelayMilliseconds / io_ratio),
-            fake_callbacks_[0]->last_audio_delay_milliseconds());
-  mixer_inputs_[0]->Stop();
-}
-
 // Ensure constructing an AudioRendererMixerInput, but not initializing it does
 // not call RemoveMixer().
 TEST_P(AudioRendererMixerTest, NoInitialize) {
   EXPECT_CALL(*this, RemoveMixer(testing::_)).Times(0);
   scoped_refptr<AudioRendererMixerInput> audio_renderer_mixer =
       new AudioRendererMixerInput(
           base::Bind(&AudioRendererMixerTest::GetMixer,
                      base::Unretained(this)),
           base::Bind(&AudioRendererMixerTest::RemoveMixer,
                      base::Unretained(this)));
 }
 
 INSTANTIATE_TEST_CASE_P(
     AudioRendererMixerTest, AudioRendererMixerTest, testing::Values(
         // No resampling.
         std::tr1::make_tuple(44100, 44100, 0.00000048),
 
         // Upsampling.
         std::tr1::make_tuple(44100, 48000, 0.033),
 
         // Downsampling.
         std::tr1::make_tuple(48000, 41000, 0.042)));
 
 }  // namespace media