Fix implicit channel layout configurations at non-1.0 playback rates.

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 64 matching lines @@
       num_candidate_blocks_(0),
       target_block_index_(0),
       ola_window_size_(0),
       ola_hop_size_(0),
       num_complete_frames_(0),
       initial_capacity_(0),
       max_capacity_(0) {}
 
 AudioRendererAlgorithm::~AudioRendererAlgorithm() {}
 
-void AudioRendererAlgorithm::Initialize(const AudioParameters& params,
-                                        std::vector<bool> channel_mask) {
+void AudioRendererAlgorithm::Initialize(const AudioParameters& params) {
   CHECK(params.IsValid());
 
-  channel_mask_ = std::move(channel_mask);
   channels_ = params.channels();
   samples_per_second_ = params.sample_rate();
   initial_capacity_ = capacity_ =
       std::max(params.frames_per_buffer() * 2,
                ConvertMillisecondsToFrames(kStartingCapacityInMs));
   max_capacity_ =
       std::max(initial_capacity_, kMaxCapacityInSeconds * samples_per_second_);
   num_candidate_blocks_ = ConvertMillisecondsToFrames(kWsolaSearchIntervalMs);
   ola_window_size_ = ConvertMillisecondsToFrames(kOlaWindowSizeMs);
 
@@ skipping 19 matching lines @@
   //                                 center
   //              X----X----------------X---------------X-----X
   //              <---------->                     <---------->
   //                Candidate      ...               Candidate
   //                   1,          ...         |num_candidate_blocks_|
   search_block_center_offset_ =
       num_candidate_blocks_ / 2 + (ola_window_size_ / 2 - 1);
 
   // If no mask is provided, assume all channels are valid.
   if (channel_mask_.empty())
-    channel_mask_ = std::vector<bool>(channels_, true);
-  DCHECK_EQ(channel_mask_.size(), static_cast<size_t>(channels_));
+    SetChannelMask(std::vector<bool>(channels_, true));
+}
+
+void AudioRendererAlgorithm::SetChannelMask(std::vector<bool> channel_mask) {
+  DCHECK_EQ(channel_mask.size(), static_cast<size_t>(channels_));
+  channel_mask_ = std::move(channel_mask);
+  if (ola_window_)
+    CreateSearchWrappers();
 }
 
 int AudioRendererAlgorithm::FillBuffer(AudioBus* dest,
                                        int dest_offset,
                                        int requested_frames,
                                        double playback_rate) {
   if (playback_rate == 0)
     return 0;
 
   DCHECK_GT(playback_rate, 0);
@@ skipping 55 matching lines @@
     wsola_output_ =
         AudioBus::Create(channels_, ola_window_size_ + ola_hop_size_);
     wsola_output_->Zero();
 
     // Auxiliary containers.
     optimal_block_ = AudioBus::Create(channels_, ola_window_size_);
     search_block_ = AudioBus::Create(
         channels_, num_candidate_blocks_ + (ola_window_size_ - 1));
     target_block_ = AudioBus::Create(channels_, ola_window_size_);
 
-    // WSOLA is quite expensive to run, so if a channel mask exists, use it to
-    // reduce the size of our search space.
-    std::vector<float*> active_target_channels;
-    std::vector<float*> active_search_channels;
-    for (int ch = 0; ch < channels_; ++ch) {
-      if (channel_mask_[ch]) {
-        active_target_channels.push_back(target_block_->channel(ch));
-        active_search_channels.push_back(search_block_->channel(ch));
-      }
-    }
-
-    target_block_wrapper_ =
-        AudioBus::WrapVector(target_block_->frames(), active_target_channels);
-    search_block_wrapper_ =
-        AudioBus::WrapVector(search_block_->frames(), active_search_channels);
+    // Create potentially smaller wrappers for playback rate adaptation.
+    CreateSearchWrappers();
   }
 
   int rendered_frames = 0;
   do {
     rendered_frames +=
         WriteCompletedFramesTo(requested_frames - rendered_frames,
                                dest_offset + rendered_frames, dest);
   } while (rendered_frames < requested_frames &&
            RunOneWsolaIteration(playback_rate));
   return rendered_frames;
@@ skipping 194 matching lines @@
                                             num_frames_to_read);
     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);
 }
 
+void AudioRendererAlgorithm::CreateSearchWrappers() {
+  // WSOLA is quite expensive to run, so if a channel mask exists, use it to
+  // reduce the size of our search space.
+  std::vector<float*> active_target_channels;
+  std::vector<float*> active_search_channels;
+  for (int ch = 0; ch < channels_; ++ch) {
+    if (channel_mask_[ch]) {
+      active_target_channels.push_back(target_block_->channel(ch));
+      active_search_channels.push_back(search_block_->channel(ch));
+    }
+  }
+
+  target_block_wrapper_ =
+      AudioBus::WrapVector(target_block_->frames(), active_target_channels);
+  search_block_wrapper_ =
+      AudioBus::WrapVector(search_block_->frames(), active_search_channels);
+}
+
 }  // namespace media