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

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 65 matching lines @@
         sink_(new FakeAudioRendererSink(hardware_params_)),
         tick_clock_(new base::SimpleTestTickClock()),
         demuxer_stream_(DemuxerStream::AUDIO),
         decoder_(new MockAudioDecoder()),
         ended_(false) {
     AudioDecoderConfig audio_config(kCodec, kSampleFormat, kChannelLayout,
                                     kInputSamplesPerSecond, EmptyExtraData(),
                                     Unencrypted());
     demuxer_stream_.set_audio_decoder_config(audio_config);
 
-    // Used to save callbacks and run them at a later time.
-    EXPECT_CALL(*decoder_, Decode(_, _))
-        .WillRepeatedly(Invoke(this, &AudioRendererImplTest::DecodeDecoder));
-    EXPECT_CALL(*decoder_, Reset(_))
-        .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ResetDecoder));
+    ConfigureDecoder();
+    ConfigureDemuxerStream(true);
 
-    // Mock out demuxer reads.
-    EXPECT_CALL(demuxer_stream_, Read(_)).WillRepeatedly(
-        RunCallback<0>(DemuxerStream::kOk,
-                       scoped_refptr<DecoderBuffer>(new DecoderBuffer(0))));
-    EXPECT_CALL(demuxer_stream_, SupportsConfigChanges())
-        .WillRepeatedly(Return(true));
     AudioParameters out_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                kChannelLayout,
                                kOutputSamplesPerSecond,
                                SampleFormatToBytesPerChannel(kSampleFormat) * 8,
                                512);
     ScopedVector<AudioDecoder> decoders;
     decoders.push_back(decoder_);
     renderer_.reset(new AudioRendererImpl(message_loop_.task_runner(),
                                           sink_.get(), std::move(decoders),
                                           new MediaLog()));
     renderer_->tick_clock_.reset(tick_clock_);
     tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
   }
 
   virtual ~AudioRendererImplTest() {
     SCOPED_TRACE("~AudioRendererImplTest()");
   }
 
+  // Used to save callbacks and run them at a later time.
+  void ConfigureDecoder() {
+    EXPECT_CALL(*decoder_, Decode(_, _))
+        .WillRepeatedly(Invoke(this, &AudioRendererImplTest::DecodeDecoder));
+    EXPECT_CALL(*decoder_, Reset(_))
+        .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ResetDecoder));
+  }
+
+  // Mock out demuxer reads.
+  void ConfigureDemuxerStream(bool supports_config_changes) {
+    EXPECT_CALL(demuxer_stream_, Read(_))
+        .WillRepeatedly(
+            RunCallback<0>(DemuxerStream::kOk,
+                           scoped_refptr<DecoderBuffer>(new DecoderBuffer(0))));
+    EXPECT_CALL(demuxer_stream_, SupportsConfigChanges())
+        .WillRepeatedly(Return(supports_config_changes));
+  }
+
   // Reconfigures a renderer without config change support using given params.
   void ConfigureBasicRenderer(const AudioParameters& params) {
     hardware_params_ = params;
     sink_ = new FakeAudioRendererSink(hardware_params_);
     decoder_ = new MockAudioDecoder();
+    ConfigureDecoder();
     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));
+    ConfigureDemuxerStream(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();
+    ConfigureDecoder();
     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));
+    ConfigureDemuxerStream(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 {
@@ skipping 227 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_; }
+  std::vector<bool> channel_mask() const {
+    CHECK(renderer_->algorithm_);
+    return renderer_->algorithm_->channel_mask_for_testing();
+  }
 
   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_;
-
- private:
   void DecodeDecoder(const scoped_refptr<DecoderBuffer>& buffer,
                      const AudioDecoder::DecodeCB& decode_cb) {
     // TODO(scherkus): Make this a DCHECK after threading semantics are fixed.
     if (base::MessageLoop::current() != &message_loop_) {
       message_loop_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&AudioRendererImplTest::DecodeDecoder,
                                 base::Unretained(this), buffer, decode_cb));
       return;
     }
 
@@ skipping 23 matching lines @@
     if (buffer.get() && !buffer->end_of_stream())
       output_cb_.Run(buffer);
     base::ResetAndReturn(&decode_cb_).Run(status);
 
     if (!reset_cb_.is_null())
       base::ResetAndReturn(&reset_cb_).Run();
 
     base::RunLoop().RunUntilIdle();
   }
 
+  // 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_;
+
   MockDemuxerStream demuxer_stream_;
   MockAudioDecoder* decoder_;
 
   // Used for satisfying reads.
   AudioDecoder::OutputCB output_cb_;
   AudioDecoder::DecodeCB decode_cb_;
   base::Closure reset_cb_;
   std::unique_ptr<AudioTimestampHelper> next_timestamp_;
 
   // Run during DecodeDecoder() to unblock WaitForPendingRead().
@@ skipping 134 matching lines @@
       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);
+  Initialize();
   std::vector<bool> mask = channel_mask();
-  EXPECT_TRUE(mask.empty());
-  Initialize();
-  mask = channel_mask();
   EXPECT_FALSE(mask.empty());
+  ASSERT_EQ(mask.size(), static_cast<size_t>(hw_params.channels()));
   for (int ch = 0; ch < hw_params.channels(); ++ch) {
     if (ch > 1)
       ASSERT_FALSE(mask[ch]);
     else
       ASSERT_TRUE(mask[ch]);
   }
+
+  renderer_->SetMediaTime(base::TimeDelta());
+  renderer_->StartPlaying();
+  WaitForPendingRead();
+
+  // Force a channel configuration change.
+  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<float>(
+      kSampleFormat, hw_params.channel_layout(), hw_params.channels(),
+      kInputSamplesPerSecond, 1.0f, 0.0f, 256, base::TimeDelta());
+  DeliverBuffer(DecodeStatus::OK, buffer);
+
+  // All channels should now be enabled.
+  mask = channel_mask();
+  EXPECT_FALSE(mask.empty());
+  ASSERT_EQ(mask.size(), static_cast<size_t>(hw_params.channels()));
+  for (int ch = 0; ch < hw_params.channels(); ++ch)
+    ASSERT_TRUE(mask[ch]);
 }
 
 TEST_F(AudioRendererImplTest, Underflow_Flush) {
   Initialize();
   Preroll();
   StartTicking();
 
   // Force underflow.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered()));
   WaitForPendingRead();
@@ skipping 404 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