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() ==

[DaleCurtis, 2017/05/25 00:29:16]

Why do we need this? I think what you had before is correct. I.e. never do
conversion if WebAudio is attached?

[flim-chromium, 2017/05/25 00:46:06]

Yep, that's still there in line 376. But if webaudio isn't attached, then using
the stream params will lead to an error at audio_converter.cc(35) (has DISCRETE
layout but 0 channels)

[DaleCurtis, 2017/05/25 00:53:38]

Seems like you could just drop this and always call set_channels_for_discrete()
on parameters then? The channels() value should be mapped to the layout already
if not discrete?

[flim-chromium, 2017/05/25 02:16:41]

We'd have to set the channels in AudioRendererMixerManager, AudioManagerPulse
and PulseAudioOutputStream (and maybe ALSA too). The html audio control would
then play but there is no sound. Not sure if this would be preferable?
Sorry, I didn't follow - this is for the discrete layout case only?

[DaleCurtis, 2017/05/25 18:51:01]

Hmm, I was proposing a simplified logic, but after looking again I don't think a
simpler form exists. (!a || !b || c || !d) && !(e && d) is the minimal form. So
this is okay, just add a {} around the conditional here.

[flim-chromium, 2017/05/25 22:00:40]

Done.

+          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