Remove muted_ and playback_rate_ from media::AudioRendererAlgorithm.

media/filters/audio_renderer_algorithm_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.
 //
 // The format of these tests are to enqueue a known amount of data and then
 // request the exact amount we expect in order to dequeue the known amount of
 // data.  This ensures that for any rate we are consuming input data at the
 // correct rate.  We always pass in a very large destination buffer with the
 // expectation that FillBuffer() will fill as much as it can but no more.
 
@@ skipping 76 matching lines @@
     channels_ = ChannelLayoutToChannelCount(channel_layout);
     samples_per_second_ = samples_per_second;
     channel_layout_ = channel_layout;
     sample_format_ = sample_format;
     bytes_per_sample_ = SampleFormatToBytesPerChannel(sample_format);
     AudioParameters params(media::AudioParameters::AUDIO_PCM_LINEAR,
                            channel_layout,
                            samples_per_second,
                            bytes_per_sample_ * 8,
                            samples_per_second / 100);
-    algorithm_.Initialize(1, params);
+    algorithm_.Initialize(params);
     FillAlgorithmQueue();
   }
 
   void FillAlgorithmQueue() {
     // The value of the data is meaningless; we just want non-zero data to
     // differentiate it from muted data.
     scoped_refptr<AudioBuffer> buffer;
     while (!algorithm_.IsQueueFull()) {
       switch (sample_format_) {
         case kSampleFormatU8:
@@ skipping 30 matching lines @@
               kNoTimestamp());
           break;
         default:
           NOTREACHED() << "Unrecognized format " << sample_format_;
       }
       algorithm_.EnqueueBuffer(buffer);
       frames_enqueued_ += kFrameSize;
     }
   }
 
-  void CheckFakeData(AudioBus* audio_data, int frames_written) {

[scherkus (not reviewing), 2014/07/22 19:25:50]

I'm not sure what this was actually checking for ... but I tried to fix it up.

[DaleCurtis, 2014/07/22 19:32:56]

I think it was just trying to provide some extra context when debugging
failures.

-    // Check each channel individually.
+  bool AudioDataIsMuted(AudioBus* audio_data, int frames_written) {
     for (int ch = 0; ch < channels_; ++ch) {
-      bool all_zero = true;
-      for (int i = 0; i < frames_written && all_zero; ++i)
-        all_zero = audio_data->channel(ch)[i] == 0.0f;
-      ASSERT_EQ(algorithm_.is_muted(), all_zero) << " for channel " << ch;
+      for (int i = 0; i < frames_written; ++i) {
+        if (audio_data->channel(ch)[i] != 0.0f)
+          return false;
+      }
     }
+    return true;
   }
 
   int ComputeConsumedFrames(int initial_frames_enqueued,
                             int initial_frames_buffered) {
     int frame_delta = frames_enqueued_ - initial_frames_enqueued;
     int buffered_delta = algorithm_.frames_buffered() - initial_frames_buffered;
     int consumed = frame_delta - buffered_delta;
     CHECK_GE(consumed, 0);
     return consumed;
   }
 
   void TestPlaybackRate(double playback_rate) {
     const int kDefaultBufferSize = algorithm_.samples_per_second() / 100;
     const int kDefaultFramesRequested = kOutputDurationInSec *
         algorithm_.samples_per_second();
 
     TestPlaybackRate(
         playback_rate, kDefaultBufferSize, kDefaultFramesRequested);
   }
 
   void TestPlaybackRate(double playback_rate,
                         int buffer_size_in_frames,
                         int total_frames_requested) {
     int initial_frames_enqueued = frames_enqueued_;
     int initial_frames_buffered = algorithm_.frames_buffered();
-    algorithm_.SetPlaybackRate(static_cast<float>(playback_rate));
 
     scoped_ptr<AudioBus> bus =
         AudioBus::Create(channels_, buffer_size_in_frames);
     if (playback_rate == 0.0) {
-      int frames_written =
-          algorithm_.FillBuffer(bus.get(), buffer_size_in_frames);
+      int frames_written = algorithm_.FillBuffer(
+          bus.get(), buffer_size_in_frames, playback_rate);
       EXPECT_EQ(0, frames_written);
       return;
     }
 
+    bool expect_muted = (playback_rate < 0.5 || playback_rate > 4);
+
     int frames_remaining = total_frames_requested;
     bool first_fill_buffer = true;
     while (frames_remaining > 0) {
       int frames_requested = std::min(buffer_size_in_frames, frames_remaining);
-      int frames_written = algorithm_.FillBuffer(bus.get(), frames_requested);
+      int frames_written =
+          algorithm_.FillBuffer(bus.get(), frames_requested, playback_rate);
       ASSERT_GT(frames_written, 0) << "Requested: " << frames_requested
                                    << ", playing at " << playback_rate;
 
       // Do not check data if it is first pull out and only one frame written.
       // The very first frame out of WSOLA is always zero because of
       // overlap-and-add window, which is zero for the first sample. Therefore,
       // if at very first buffer-fill only one frame is written, that is zero
       // which might cause exception in CheckFakeData().
       if (!first_fill_buffer || frames_written > 1)
-        CheckFakeData(bus.get(), frames_written);
+        ASSERT_EQ(expect_muted, AudioDataIsMuted(bus.get(), frames_written));
       first_fill_buffer = false;
       frames_remaining -= frames_written;
 
       FillAlgorithmQueue();
     }
 
     int frames_consumed =
         ComputeConsumedFrames(initial_frames_enqueued, initial_frames_buffered);
 
     // If playing back at normal speed, we should always get back the same
@@ skipping 18 matching lines @@
 
   void WsolaTest(float playback_rate) {
     const int kSampleRateHz = 48000;
     const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
     const int kBytesPerSample = 2;
     const int kNumFrames = kSampleRateHz / 100;  // 10 milliseconds.
 
     channels_ = ChannelLayoutToChannelCount(kChannelLayout);
     AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
                            kSampleRateHz, kBytesPerSample * 8, kNumFrames);
-    algorithm_.Initialize(playback_rate, params);
+    algorithm_.Initialize(params);
 
     // A pulse is 6 milliseconds (even number of samples).
     const int kPulseWidthSamples = 6 * kSampleRateHz / 1000;
     const int kHalfPulseWidthSamples = kPulseWidthSamples / 2;
 
     // For the ease of implementation get 1 frame every call to FillBuffer().
     scoped_ptr<AudioBus> output = AudioBus::Create(channels_, 1);
 
     // Input buffer to inject pulses.
     scoped_refptr<AudioBuffer> input =
@@ skipping 16 matching lines @@
     // reference pulse is compared with this buffer.
     scoped_ptr<AudioBus> pulse_buffer = AudioBus::Create(
         channels_, kPulseWidthSamples);
 
     const float kTolerance = 0.000001f;
     // Equivalent of 4 seconds.
     const int kNumRequestedPulses = kSampleRateHz * 4 / kPulseWidthSamples;
     for (int n = 0; n < kNumRequestedPulses; ++n) {
       int num_buffered_frames = 0;
       while (num_buffered_frames < kPulseWidthSamples) {
-        int num_samples = algorithm_.FillBuffer(output.get(), 1);
+        int num_samples = algorithm_.FillBuffer(output.get(), 1, playback_rate);
         ASSERT_LE(num_samples, 1);
         if (num_samples > 0) {
           output->CopyPartialFramesTo(0, num_samples, num_buffered_frames,
                                       pulse_buffer.get());
           num_buffered_frames++;
         } else {
           algorithm_.EnqueueBuffer(input);
         }
       }
 
@@ skipping 341 matching lines @@
 
 TEST_F(AudioRendererAlgorithmTest, WsolaSlowdown) {
   WsolaTest(0.6f);
 }
 
 TEST_F(AudioRendererAlgorithmTest, WsolaSpeedup) {
   WsolaTest(1.6f);
 }
 
 }  // namespace media