Don't run WSOLA over always muted channels.

media/renderers/audio_renderer_impl_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 "media/renderers/audio_renderer_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 110 matching lines @@
     ScopedVector<AudioDecoder> decoders;
     decoders.push_back(decoder_);
     renderer_.reset(new AudioRendererImpl(message_loop_.task_runner(),
                                           sink_.get(), std::move(decoders),
                                           new MediaLog()));
     testing::Mock::VerifyAndClearExpectations(&demuxer_stream_);
     EXPECT_CALL(demuxer_stream_, SupportsConfigChanges())
         .WillRepeatedly(Return(false));
   }
 
+  // Reconfigures a renderer with config change support using given params.
+  void ConfigureConfigChangeRenderer(const AudioParameters& params,
+                                     const AudioParameters& hardware_params) {
+    hardware_params_ = hardware_params;
+    sink_ = new FakeAudioRendererSink(hardware_params_);
+    decoder_ = new MockAudioDecoder();
+    ScopedVector<AudioDecoder> decoders;
+    decoders.push_back(decoder_);
+    renderer_.reset(new AudioRendererImpl(message_loop_.task_runner(),
+                                          sink_.get(), std::move(decoders),
+                                          new MediaLog()));
+    testing::Mock::VerifyAndClearExpectations(&demuxer_stream_);
+    EXPECT_CALL(demuxer_stream_, SupportsConfigChanges())
+        .WillRepeatedly(Return(true));
+  }
+
   void ExpectUnsupportedAudioDecoder() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
         .WillOnce(DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(false)));
   }
 
   // RendererClient implementation.
   MOCK_METHOD1(OnError, void(PipelineStatus));
   void OnEnded() override {
     CHECK(!ended_);
     ended_ = true;
@@ skipping 225 matching lines @@
 
   InputFrames converter_input_frames_left() const {
     return InputFrames(
         renderer_->buffer_converter_->input_frames_left_for_testing());
   }
 
   base::TimeDelta CurrentMediaTime() {
     return renderer_->CurrentMediaTime();
   }
 
+  std::vector<bool> channel_mask() const { return renderer_->channel_mask_; }
+
   bool ended() const { return ended_; }
 
   // Fixture members.
   AudioParameters hardware_params_;
   base::MessageLoop message_loop_;
   std::unique_ptr<AudioRendererImpl> renderer_;
   scoped_refptr<FakeAudioRendererSink> sink_;
   base::SimpleTestTickClock* tick_clock_;
   PipelineStatistics last_statistics_;
 
@@ skipping 185 matching lines @@
   // Verify in the no-config-changes-expected case.
   ConfigureBasicRenderer(AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, kChannelLayout,
       kOutputSamplesPerSecond, SampleFormatToBytesPerChannel(kSampleFormat) * 8,
       1024 * 15));
 
   Initialize();
   EXPECT_GT(buffer_capacity().value, hardware_params_.frames_per_buffer());
 }
 
+// Verify that the proper reduced search space is configured for playback rate
+// changes when upmixing is applied to the input.
+TEST_F(AudioRendererImplTest, ChannelMask) {
+  Initialize();
+  AudioParameters hw_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                            CHANNEL_LAYOUT_7_1, kOutputSamplesPerSecond,
+                            SampleFormatToBytesPerChannel(kSampleFormat) * 8,
+                            1024);
+  ConfigureConfigChangeRenderer(
+      AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                      CHANNEL_LAYOUT_STEREO, kOutputSamplesPerSecond,
+                      SampleFormatToBytesPerChannel(kSampleFormat) * 8, 1024),
+      hw_params);
+  std::vector<bool> mask = channel_mask();
+  EXPECT_TRUE(mask.empty());
+  Initialize();
+  mask = channel_mask();
+  EXPECT_FALSE(mask.empty());
+  for (int ch = 0; ch < hw_params.channels(); ++ch) {
+    if (ch > 1)
+      ASSERT_FALSE(mask[ch]);
+    else
+      ASSERT_TRUE(mask[ch]);
+  }
+}
+
 TEST_F(AudioRendererImplTest, Underflow_Flush) {
   Initialize();
   Preroll();
   StartTicking();
 
   // Force underflow.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered()));
   WaitForPendingRead();
   EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
   EXPECT_FALSE(ConsumeBufferedData(OutputFrames(1)));
@@ skipping 402 matching lines @@
   // Advance far enough that we shouldn't be clamped to current time (tested
   // already above).
   tick_clock_->Advance(kOneSecond);
   EXPECT_EQ(
       current_time + timestamp_helper.GetFrameDuration(frames_to_consume.value),
       CurrentMediaWallClockTime(&is_time_moving));
   EXPECT_TRUE(is_time_moving);
 }
 
 }  // namespace media