Roll up of playback rate efficiency improvements for M56.

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>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/default_tick_clock.h"
 #include "build/build_config.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_buffer_converter.h"
 #include "media/base/audio_latency.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/channel_mixing_matrix.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer_client.h"
 #include "media/base/timestamp_constants.h"
 #include "media/filters/audio_clock.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
 AudioRendererImpl::AudioRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     media::AudioRendererSink* sink,
     ScopedVector<AudioDecoder> decoders,
     const scoped_refptr<MediaLog>& media_log)
     : 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 361 matching lines @@
         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));
   }
 
+  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,
                  weak_factory_.GetWeakPtr()));
@@ skipping 19 matching lines @@
     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_);
+  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