Support Opus Ambisonics playback

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),
       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),
       is_encrypted_(false),
+      last_decoded_channels_(0),
       playback_rate_(0.0),
       state_(kUninitialized),
       create_audio_decoders_cb_(create_audio_decoders_cb),
       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),
@@ skipping 301 matching lines @@
   audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
   auto output_device_info = sink_->GetOutputDeviceInfo();
   const AudioParameters& hw_params = output_device_info.output_params();
   expecting_config_changes_ = stream->SupportsConfigChanges();
-  if (!expecting_config_changes_ || !hw_params.IsValid() ||
-      hw_params.format() == AudioParameters::AUDIO_FAKE ||
-      !sink_->IsOptimizedForHardwareParameters()) {
+
+  bool use_stream_params = !expecting_config_changes_ || !hw_params.IsValid() ||
+                           hw_params.format() == AudioParameters::AUDIO_FAKE ||
+                           !sink_->IsOptimizedForHardwareParameters();
+
+  if (stream->audio_decoder_config().channel_layout() ==
+          CHANNEL_LAYOUT_DISCRETE &&
+      sink_->IsOptimizedForHardwareParameters()) {
+    use_stream_params = false;
+  }
+
+  if (use_stream_params) {
     // The actual buffer size is controlled via the size of the AudioBus
     // provided to Render(), but we should choose a value here based on hardware
     // parameters if possible since it affects the initial buffer size used by
     // the algorithm. Too little will cause underflow on Bluetooth devices.
     int buffer_size =
         std::max(stream->audio_decoder_config().samples_per_second() / 100,
                  hw_params.IsValid() ? hw_params.frames_per_buffer() : 0);
     audio_parameters_.Reset(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                             stream->audio_decoder_config().channel_layout(),
                             stream->audio_decoder_config().samples_per_second(),
                             stream->audio_decoder_config().bits_per_channel(),
                             buffer_size);
+    audio_parameters_.set_channels_for_discrete(
+        stream->audio_decoder_config().channels());
     buffer_converter_.reset();
   } else {
     // To allow for seamless sample rate adaptations (i.e. changes from say
     // 16kHz to 48kHz), always resample to the hardware rate.
     int sample_rate = hw_params.sample_rate();
     int preferred_buffer_size = hw_params.frames_per_buffer();
 
 #if defined(OS_CHROMEOS)
     // On ChromeOS let the OS level resampler handle resampling unless the
     // initial sample rate is too low; this allows support for sample rate
     // adaptations where necessary.
     if (stream->audio_decoder_config().samples_per_second() >= 44100) {
       sample_rate = stream->audio_decoder_config().samples_per_second();
       preferred_buffer_size = 0;  // No preference.
     }
 #endif
 
-    int stream_channel_count = ChannelLayoutToChannelCount(
-        stream->audio_decoder_config().channel_layout());
+    int stream_channel_count = stream->audio_decoder_config().channels();
 
     bool try_supported_channel_layouts = false;
 #if defined(OS_WIN)
     try_supported_channel_layouts =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kTrySupportedChannelLayouts);
 #endif
 
     // We don't know how to up-mix for DISCRETE layouts (fancy multichannel
     // hardware with non-standard speaker arrangement). Instead, pretend the
@@ skipping 35 matching lines @@
                             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();
 
   is_encrypted_ = stream->audio_decoder_config().is_encrypted();
 
+  last_decoded_channels_ = stream->audio_decoder_config().channels();
+
   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 127 matching lines @@
         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();
+        last_decoded_channels_ = buffer->channel_count();
 
         // Input layouts should never be discrete.
         DCHECK_NE(last_decoded_channel_layout_, CHANNEL_LAYOUT_DISCRETE);
         ConfigureChannelMask();
       }
     }
 
     DCHECK(buffer_converter_);
     buffer_converter_->AddInput(buffer);
 
@@ skipping 365 matching lines @@
   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()) {
+  if (last_decoded_channels_ >= 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,
+  ChannelMixingMatrix(last_decoded_channel_layout_, last_decoded_channels_,
                       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