Revert 258215 "Remove muting for extreme playbackRates."

media/filters/audio_renderer_algorithm.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 "media/filters/audio_renderer_algorithm.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 //
 // 5) Overlap-and-add |optimal_block_| to the |wsola_output_|.
 //
 // 6) Update:
 //    |target_block_| = |optimal_index| + |ola_window_size_| / 2.
 //    |output_index_| = |output_index_| + |ola_window_size_| / 2,
 //    |search_block_center_offset_| = |output_index_| * |playback_rate_|, and
 //    |search_block_index_| = |search_block_center_offset_| -
 //        |search_block_center_offset_|.
 
+// Max/min supported playback rates for fast/slow audio. Audio outside of these
+// ranges are muted.
+// Audio at these speeds would sound better under a frequency domain algorithm.
+static const float kMinPlaybackRate = 0.5f;
+static const float kMaxPlaybackRate = 4.0f;
+
 // Overlap-and-add window size in milliseconds.
 static const int kOlaWindowSizeMs = 20;
 
 // Size of search interval in milliseconds. The search interval is
 // [-delta delta] around |output_index_| * |playback_rate_|. So the search
 // interval is 2 * delta.
 static const int kWsolaSearchIntervalMs = 30;
 
 // The maximum size in seconds for the |audio_buffer_|. Arbitrarily determined.
 static const int kMaxCapacityInSeconds = 3;
 
 // The starting size in frames for |audio_buffer_|. Previous usage maintained a
 // queue of 16 AudioBuffers, each of 512 frames. This worked well, so we
 // maintain this number of frames.
 static const int kStartingBufferSizeInFrames = 16 * 512;
 
 COMPILE_ASSERT(kStartingBufferSizeInFrames <
                (kMaxCapacityInSeconds * limits::kMinSampleRate),
                max_capacity_smaller_than_starting_buffer_size);
 
 AudioRendererAlgorithm::AudioRendererAlgorithm()
     : channels_(0),
       samples_per_second_(0),
       playback_rate_(0),
+      muted_(false),
+      muted_partial_frame_(0),
       capacity_(kStartingBufferSizeInFrames),
       output_time_(0.0),
       search_block_center_offset_(0),
       search_block_index_(0),
       num_candidate_blocks_(0),
       target_block_index_(0),
       ola_window_size_(0),
       ola_hop_size_(0),
       num_complete_frames_(0) {
 }
@@ skipping 53 matching lines @@
       channels_, num_candidate_blocks_ + (ola_window_size_ - 1));
   target_block_ = AudioBus::Create(channels_, ola_window_size_);
 }
 
 int AudioRendererAlgorithm::FillBuffer(AudioBus* dest, int requested_frames) {
   if (playback_rate_ == 0)
     return 0;
 
   DCHECK_EQ(channels_, dest->channels());
 
+  // Optimize the |muted_| case to issue a single clear instead of performing
+  // the full crossfade and clearing each crossfaded frame.
+  if (muted_) {
+    int frames_to_render =
+        std::min(static_cast<int>(audio_buffer_.frames() / playback_rate_),
+                 requested_frames);
+
+    // Compute accurate number of frames to actually skip in the source data.
+    // Includes the leftover partial frame from last request. However, we can
+    // only skip over complete frames, so a partial frame may remain for next
+    // time.
+    muted_partial_frame_ += frames_to_render * playback_rate_;
+    int seek_frames = static_cast<int>(muted_partial_frame_);
+    dest->ZeroFrames(frames_to_render);
+    audio_buffer_.SeekFrames(seek_frames);
+
+    // Determine the partial frame that remains to be skipped for next call. If
+    // the user switches back to playing, it may be off time by this partial
+    // frame, which would be undetectable. If they subsequently switch to
+    // another playback rate that mutes, the code will attempt to line up the
+    // frames again.
+    muted_partial_frame_ -= seek_frames;
+    return frames_to_render;
+  }
+
   int slower_step = ceil(ola_window_size_ * playback_rate_);
   int faster_step = ceil(ola_window_size_ / playback_rate_);
 
   // Optimize the most common |playback_rate_| ~= 1 case to use a single copy
   // instead of copying frame by frame.
   if (ola_window_size_ <= faster_step && slower_step >= ola_window_size_) {
     const int frames_to_copy =
         std::min(audio_buffer_.frames(), requested_frames);
     const int frames_read = audio_buffer_.ReadFrames(frames_to_copy, 0, dest);
     DCHECK_EQ(frames_read, frames_to_copy);
     return frames_read;
   }
 
   int rendered_frames = 0;
   do {
     rendered_frames += WriteCompletedFramesTo(
         requested_frames - rendered_frames, rendered_frames, dest);
   } while (rendered_frames < requested_frames && RunOneWsolaIteration());
   return rendered_frames;
 }
 
 void AudioRendererAlgorithm::SetPlaybackRate(float new_rate) {
   DCHECK_GE(new_rate, 0);
   playback_rate_ = new_rate;
+  muted_ =
+      playback_rate_ < kMinPlaybackRate || playback_rate_ > kMaxPlaybackRate;
 }
 
 void AudioRendererAlgorithm::FlushBuffers() {
   // Clear the queue of decoded packets (releasing the buffers).
   audio_buffer_.Clear();
   output_time_ = 0.0;
   search_block_index_ = 0;
   target_block_index_ = 0;
   wsola_output_->Zero();
   num_complete_frames_ = 0;
@@ skipping 172 matching lines @@
     read_offset_frames = 0;
     num_frames_to_read -= num_zero_frames_appended;
     write_offset = num_zero_frames_appended;
     dest->ZeroFrames(num_zero_frames_appended);
   }
   audio_buffer_.PeekFrames(num_frames_to_read, read_offset_frames,
                            write_offset, dest);
 }
 
 }  // namespace media