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 42 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
 
+    int stream_channel_count = ChannelLayoutToChannelCount(stream->audio_decoder_config().channel_layout());
+    int fiveptone_channel_count = ChannelLayoutToChannelCount(CHANNEL_LAYOUT_5_1);
+
+    // 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).
+    // 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 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 = CHANNEL_LAYOUT_NONE;
+
+// WORRY: IF STREAM CHANGES, WHERE DOES MIXER LEARN OF THE NEW INPUT CHANNEL COUNT?

[chcunningham, 2016/03/17 21:48:19]

This happens in AudioBufferConverter::AddBuffer. Each time we add a buffer the
buffer's configuration is evaluated against the existing config. If things
change, it makes a new internal AudioConverter with the new input parameters.

+// WORRY: WHERE IS BROWSER LEARNING OF NEW HW CHANNEL COUNT IF SOMETHING GETS PLUGGED IN? WHERE IS BROWSER-SIDE MIXER?

[chcunningham, 2016/03/17 21:48:19]

The HW channel count is updated via audio_device_listener_{mac|win}.cc. We're
missing this feature on linux, so I filed http://crbug.com/595877

The browser-side mixing is done in the AudioConverter held by
OnMoreDataConverter. When the HW changes are detected,
AudioOutputController::OnDeviceChange() will be called, creating a new stream
with the updated configuration making its way to a new OnMoreDataConverter.

+// TODO ABOVE: ADD CRBUGS TO COMMENT. ADD TODO FOR TO BE ABLE TO CHANGE LAYOUTS ON FLY
+// TODO BELOW: TRY USING INTERMEDIATE hw_layout = discrete ? 5.1 : hw_params TO SIMPLIFY CODE.
+
+
+    // We don't know how to mix for DISCRETE layouts (fancy multichannel
+    // hardware). Instead we choose the max of 5.1 and the stream layout with
+    // the hope that the OS will know best how to up-mix to the DISCRETE layout.
+    // Choosing the max avoids pre-maturely down-mixing.
+    if (hw_params.channel_layout() == CHANNEL_LAYOUT_DISCRETE) {

[DaleCurtis, 2016/03/18 00:16:23]

Why not just always use the discrete layout in this case?

[chcunningham, 2016/03/25 01:41:16]

We chatted - thing is we aren't confident that we can properly do the mixing for
discrete. Hoping the OS can umpix us from 5.1 to whatever the fancy layout
happens to be. 

NOTE TO SELF: ping the old bug and see that folks aren't regressed.

+      renderer_channel_layout = stream_channel_count < fiveptone_channel_count ?
+          CHANNEL_LAYOUT_5_1 : stream->audio_decoder_config().channel_layout();
+    } else {
+      // For all non-discrete layouts we know how to up-mix to the hardware
+      // layout. Using the max of stream and hardware channel counts  avoids
+      // premature down-mixing should either the stream or hardware later change
+      // to have more channels.
+      renderer_channel_layout = stream_channel_count < ChannelLayoutToChannelCount(hw_params.channel_layout()) ?
+          hw_params.channel_layout() : stream->audio_decoder_config().channel_layout();
+    }
+
     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,
+        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,
@@ skipping 79 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(true);
         return;
       }
     }
   } else {
     if (!splicer_->AddInput(buffer)) {
@@ skipping 346 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