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

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 73 matching lines @@
 
   void Initialize() {
     Initialize(CHANNEL_LAYOUT_STEREO, kSampleFormatS16, kSamplesPerSecond,
                kSamplesPerSecond / 10);
   }
 
   void Initialize(ChannelLayout channel_layout,
                   SampleFormat sample_format,
                   int samples_per_second,
                   int frames_per_buffer) {
-    Initialize(channel_layout, sample_format, samples_per_second,
-               frames_per_buffer, std::vector<bool>());
+    Initialize(
+        channel_layout, sample_format, samples_per_second, frames_per_buffer,
+        std::vector<bool>(ChannelLayoutToChannelCount(channel_layout), true));
   }
 
   void Initialize(ChannelLayout channel_layout,
                   SampleFormat sample_format,
                   int samples_per_second,
                   int frames_per_buffer,
                   std::vector<bool> channel_mask) {
     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, frames_per_buffer);
-    algorithm_.Initialize(params, channel_mask);
+    algorithm_.Initialize(params);
+    algorithm_.SetChannelMask(std::move(channel_mask));
     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 121 matching lines @@
 
   void WsolaTest(double 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(params, std::vector<bool>());
+    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().
     std::unique_ptr<AudioBus> output = AudioBus::Create(channels_, 1);
 
     // Input buffer to inject pulses.
     scoped_refptr<AudioBuffer> input =
@@ skipping 432 matching lines @@
     FillAlgorithmQueue();
   }
 }
 
 TEST_F(AudioRendererAlgorithmTest, FillBuffer_ChannelMask) {
   // Setup a quad channel layout where even channels are always muted.
   Initialize(CHANNEL_LAYOUT_QUAD, kSampleFormatS16, 44100, 441,
              {true, false, true, false});
 
   std::unique_ptr<AudioBus> bus = AudioBus::Create(channels_, kFrameSize);
-  const int frames_filled =
-      algorithm_.FillBuffer(bus.get(), 0, kFrameSize, 2.0);
+  int frames_filled = algorithm_.FillBuffer(bus.get(), 0, kFrameSize, 2.0);
   ASSERT_GT(frames_filled, 0);
 
   // Verify the channels are muted appropriately; even though the created buffer
   // actually has audio data in it.
   for (int ch = 0; ch < bus->channels(); ++ch) {
     double sum = 0;
     for (int i = 0; i < bus->frames(); ++i)
       sum += bus->channel(ch)[i];
     if (ch % 2 == 1)
       ASSERT_EQ(sum, 0);
     else
       ASSERT_NE(sum, 0);
   }
+
+  // Update the channel mask and verify it's reflected correctly.
+  algorithm_.SetChannelMask({true, true, true, true});
+  frames_filled = algorithm_.FillBuffer(bus.get(), 0, kFrameSize, 2.0);
+  ASSERT_GT(frames_filled, 0);
+
+  // Verify no channels are muted now.
+  for (int ch = 0; ch < bus->channels(); ++ch) {
+    double sum = 0;
+    for (int i = 0; i < bus->frames(); ++i)
+      sum += bus->channel(ch)[i];
+    ASSERT_NE(sum, 0);
+  }
 }
 
 }  // namespace media