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

media/renderers/audio_renderer_impl.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 <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
@@ skipping 30 matching lines @@
     : task_runner_(task_runner),
       expecting_config_changes_(false),
       sink_(sink),
       audio_buffer_stream_(
           new AudioBufferStream(task_runner, std::move(decoders), media_log)),
       media_log_(media_log),
       client_(nullptr),
       tick_clock_(new base::DefaultTickClock()),
       last_audio_memory_usage_(0),
       last_decoded_sample_rate_(0),
+      last_decoded_channel_layout_(CHANNEL_LAYOUT_NONE),
       playback_rate_(0.0),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       is_suspending_(false),
       weak_factory_(this) {
@@ skipping 359 matching lines @@
     //   down-mixing and use the data from all stream channels.
     ChannelLayout renderer_channel_layout =
         hw_channel_count > stream_channel_count
             ? hw_channel_layout
             : stream->audio_decoder_config().channel_layout();
 
     audio_parameters_.Reset(hw_params.format(), renderer_channel_layout,
                             sample_rate, hw_params.bits_per_sample(),
                             media::AudioLatency::GetHighLatencyBufferSize(
                                 sample_rate, preferred_buffer_size));
+  }
 
-    // Figure out if there are muted channels that we should ignore when
-    // playback rate adapatation is requested (it's expensive).
-    if (stream_channel_count < audio_parameters_.channels()) {
-      std::vector<std::vector<float>> matrix;
-      ChannelMixingMatrix(
-          stream->audio_decoder_config().channel_layout(), stream_channel_count,
-          audio_parameters_.channel_layout(), audio_parameters_.channels())
-          .CreateTransformationMatrix(&matrix);
-
-      // All channels with a zero mix are muted and can be ignored.
-      channel_mask_ = std::vector<bool>(audio_parameters_.channels(), false);
-      for (size_t ch = 0; ch < matrix.size(); ++ch) {
-        channel_mask_[ch] = std::any_of(matrix[ch].begin(), matrix[ch].end(),
-                                        [](float mix) { return !!mix; });
-      }
-    }
-  }
+  last_decoded_channel_layout_ =
+      stream->audio_decoder_config().channel_layout();
 
   audio_clock_.reset(
       new AudioClock(base::TimeDelta(), audio_parameters_.sample_rate()));
 
   audio_buffer_stream_->Initialize(
       stream, base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                          weak_factory_.GetWeakPtr()),
       cdm_context, base::Bind(&AudioRendererImpl::OnStatisticsUpdate,
                               weak_factory_.GetWeakPtr()),
       base::Bind(&AudioRendererImpl::OnWaitingForDecryptionKey,
@@ skipping 19 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
   if (expecting_config_changes_)
     buffer_converter_.reset(new AudioBufferConverter(audio_parameters_));
 
   // We're all good! Continue initializing the rest of the audio renderer
   // based on the decoder format.
   algorithm_.reset(new AudioRendererAlgorithm());
-  algorithm_->Initialize(audio_parameters_, channel_mask_);
+  algorithm_->Initialize(audio_parameters_);
+  ConfigureChannelMask();
 
   ChangeState_Locked(kFlushed);
 
   {
     base::AutoUnlock auto_unlock(lock_);
     sink_->Initialize(audio_parameters_, this);
     sink_->Start();
 
     // Some sinks play on start...
     sink_->Pause();
@@ skipping 72 matching lines @@
 
   if (state_ == kFlushing) {
     ChangeState_Locked(kFlushed);
     DoFlush_Locked();
     return;
   }
 
   bool need_another_buffer = true;
 
   if (expecting_config_changes_) {
-    if (last_decoded_sample_rate_ &&
-        buffer->sample_rate() != last_decoded_sample_rate_) {
-      DVLOG(1) << __func__ << " Updating audio sample_rate."
-               << " ts:" << buffer->timestamp().InMicroseconds()
-               << " old:" << last_decoded_sample_rate_
-               << " new:" << buffer->sample_rate();
-      OnConfigChange();
+    if (!buffer->end_of_stream()) {
+      if (last_decoded_sample_rate_ &&
+          buffer->sample_rate() != last_decoded_sample_rate_) {
+        DVLOG(1) << __func__ << " Updating audio sample_rate."
+                 << " ts:" << buffer->timestamp().InMicroseconds()
+                 << " old:" << last_decoded_sample_rate_
+                 << " new:" << buffer->sample_rate();
+        OnConfigChange();
+      }
+      last_decoded_sample_rate_ = buffer->sample_rate();
+
+      if (last_decoded_channel_layout_ != buffer->channel_layout()) {
+        last_decoded_channel_layout_ = buffer->channel_layout();
+
+        // Input layouts should never be discrete.
+        DCHECK_NE(last_decoded_channel_layout_, CHANNEL_LAYOUT_DISCRETE);
+        ConfigureChannelMask();
+      }
     }
-    last_decoded_sample_rate_ = buffer->sample_rate();
 
     DCHECK(buffer_converter_);
     buffer_converter_->AddInput(buffer);
 
     while (buffer_converter_->HasNextBuffer()) {
       need_another_buffer =
           HandleDecodedBuffer_Locked(buffer_converter_->GetNextBuffer());
     }
   } else {
     // TODO(chcunningham, tguilbert): Figure out if we want to support implicit
@@ skipping 350 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
+void AudioRendererImpl::ConfigureChannelMask() {
+  DCHECK(algorithm_);
+  DCHECK(audio_parameters_.IsValid());
+  DCHECK_NE(last_decoded_channel_layout_, CHANNEL_LAYOUT_NONE);
+  DCHECK_NE(last_decoded_channel_layout_, CHANNEL_LAYOUT_UNSUPPORTED);
+  DCHECK_NE(last_decoded_channel_layout_, CHANNEL_LAYOUT_DISCRETE);
+
+  const int input_channel_count =
+      ChannelLayoutToChannelCount(last_decoded_channel_layout_);
+
+  // If we're actually downmixing the signal, no mask is necessary, but ensure
+  // we clear any existing mask if present.
+  if (input_channel_count >= audio_parameters_.channels()) {
+    algorithm_->SetChannelMask(
+        std::vector<bool>(audio_parameters_.channels(), true));
+    return;
+  }
+
+  // Determine the matrix used to upmix the channels.
+  std::vector<std::vector<float>> matrix;
+  ChannelMixingMatrix(last_decoded_channel_layout_, input_channel_count,
+                      audio_parameters_.channel_layout(),
+                      audio_parameters_.channels())
+      .CreateTransformationMatrix(&matrix);
+
+  // All channels with a zero mix are muted and can be ignored.
+  std::vector<bool> channel_mask(audio_parameters_.channels(), false);
+  for (size_t ch = 0; ch < matrix.size(); ++ch) {
+    channel_mask[ch] = std::any_of(matrix[ch].begin(), matrix[ch].end(),
+                                   [](float mix) { return !!mix; });
+  }
+  algorithm_->SetChannelMask(std::move(channel_mask));
+}
+
 }  // namespace media