Enable implicit signalling for HE AAC v1 & v2 in ADTS.

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 26 matching lines @@
     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)),
       hardware_config_(hardware_config),
       media_log_(media_log),
       tick_clock_(new base::DefaultTickClock()),
       last_audio_memory_usage_(0),
+      last_decoded_sample_rate_(0),
       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),
       weak_factory_(this) {
   audio_buffer_stream_->set_splice_observer(base::Bind(
@@ skipping 305 matching lines @@
 #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
 
-    audio_parameters_.Reset(
-        hw_params.format(),
-        // Always use the source's channel layout to avoid premature downmixing
-        // (http://crbug.com/379288), platform specific issues around channel
-        // layouts (http://crbug.com/266674), and unnecessary upmixing overhead.
-        stream->audio_decoder_config().channel_layout(), sample_rate,
-        hw_params.bits_per_sample(),
-        AudioHardwareConfig::GetHighLatencyBufferSize(sample_rate,
-                                                      preferred_buffer_size));
+    int stream_channel_count = ChannelLayoutToChannelCount(
+        stream->audio_decoder_config().channel_layout());
+
+    // We don't know how to up-mix for DISCRETE layouts (fancy multichannel
+    // hardware with non-standard speaker arrangement). Instead, pretend the
+    // hardware layout is 5.1 and let the OS take care of further up-mixing to
+    // the discrete layout. (http://crbug.com/266674)
+    ChannelLayout hw_channel_layout =
+        (hw_params.channel_layout() == CHANNEL_LAYOUT_DISCRETE)

[DaleCurtis, 2016/03/25 21:57:00]

Remove unnecessary parens. Upon further consideration I think we want to choose
STEREO here since it's the most common format by a huge margin:

https://uma.googleplex.com/histograms/?histograms=Media.AudioChannelLayout

I also think this check should include
CommandLine::HasSwitch(kTrySupportedChannelLayouts) and use STEREO in this case
as well since these are folk that want stereo expansion to all channels on
Windows. You'll need to add that flag to the RendererProcessHostImpl list to use
it here.

[chcunningham, 2016/03/25 23:52:17]

Done.

+            ? CHANNEL_LAYOUT_5_1
+            : hw_params.channel_layout();
+    int hw_channel_count = ChannelLayoutToChannelCount(hw_channel_layout);
+
+    // The layout we pass to |audio_parameters_| will be used for the lifetime
+    // of this audio renderer, regardless of changes to hardware and/or stream
+    // properties. Below we choose the max of stream layout vs. hardware layout
+    // to leave room for changes to the hardware and/or stream (i.e. avoid
+    // premature down-mixing - http://crbug.com/379288).
+    // If stream_channels < hw_channels:
+    //   Taking max means we up-mix to hardware layout. If stream later changes
+    //   to have more channels, we aren't locked into down-mixing to the
+    //   initial stream layout.
+    // If stream_channels > hw_channels:
+    //   We choose to output stream's layout, meaning mixing is a no-op for the
+    //   renderer. Browser-side will down-mix to the hardware config. If the
+    //   hardware later changes to equal stream channels, browser-side will stop
+    //   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(),
+                            AudioHardwareConfig::GetHighLatencyBufferSize(
+                                sample_rate, preferred_buffer_size));
   }
 
   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, statistics_cb, waiting_for_decryption_key_cb);
 }
@@ skipping 74 matching lines @@
   DCHECK_EQ(status, AudioBufferStream::OK);
   DCHECK(buffer.get());
 
   if (state_ == kFlushing) {
     ChangeState_Locked(kFlushed);
     DoFlush_Locked();
     return;
   }
 
   if (expecting_config_changes_) {
+    if (buffer->sample_rate() != last_decoded_sample_rate_) {
+      DVLOG(1) << __FUNCTION__ << " 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();
+
     DCHECK(buffer_converter_);
     buffer_converter_->AddInput(buffer);
     while (buffer_converter_->HasNextBuffer()) {
       if (!splicer_->AddInput(buffer_converter_->GetNextBuffer())) {
         HandleAbortedReadOrDecodeError(AUDIO_RENDERER_ERROR_SPLICE_FAILED);
         return;
       }
     }
   } else {
     if (!splicer_->AddInput(buffer)) {
@@ skipping 342 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media