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>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
+#include "base/command_line.h"
 #include "base/logging.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_hardware_config.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
+#include "media/base/media_switches.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 AudioHardwareConfig& hardware_config,
     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());
+
+    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
+    // hardware layout is stereo and let the OS take care of further up-mixing
+    // to the discrete layout (http://crbug.com/266674). Additionally, pretend
+    // hardware is stereo whenever kTrySupportedChannelLayouts is set. This flag
+    // is for savvy users who want stereo content to output in all surround
+    // speakers. Using the actual layout (likely 5.1 or higher) will mean our
+    // mixer will attempt to up-mix stereo source streams to just the left/right
+    // speaker of the 5.1 setup, nulling out the other channels
+    // (http://crbug.com/177872).
+    ChannelLayout hw_channel_layout =
+        hw_params.channel_layout() == CHANNEL_LAYOUT_DISCRETE ||
+                try_supported_channel_layouts
+            ? CHANNEL_LAYOUT_STEREO
+            : 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 (last_decoded_sample_rate_ &&
+        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