Support (E)AC3 passthrough

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/power_monitor/power_monitor.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_latency.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_client.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer_client.h"
 #include "media/base/timestamp_constants.h"
 #include "media/filters/audio_clock.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
+static const int kMaxFramesPerCompressedAudioBuffer = 4096;
+
 AudioRendererImpl::AudioRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     media::AudioRendererSink* sink,
     ScopedVector<AudioDecoder> decoders,
     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)),
       media_log_(media_log),
       client_(nullptr),
       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),
       is_suspending_(false),
+      is_passthrough_(false),
       last_reported_media_time_(kNoTimestamp),
       weak_factory_(this) {
   audio_buffer_stream_->set_splice_observer(base::Bind(
       &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
   audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
 
   // Tests may not have a power monitor.
   base::PowerMonitor* monitor = base::PowerMonitor::Get();
   if (!monitor)
@@ skipping 287 matching lines @@
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(sink_.get());
 
   state_ = kInitializing;
   client_ = client;
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
+  AudioCodec codec = stream->audio_decoder_config().codec();
+  MediaClient* media_client = GetMediaClient();
+  is_passthrough_ =
+      media_client && media_client->IsSupportedPassthroughAudio(codec);
+
   const AudioParameters& hw_params =
       sink_->GetOutputDeviceInfo().output_params();
   expecting_config_changes_ = stream->SupportsConfigChanges();
-  if (!expecting_config_changes_ || !hw_params.IsValid() ||
-      hw_params.format() == AudioParameters::AUDIO_FAKE) {
+
+  if (is_passthrough_) {
+    AudioParameters::Format format = AudioParameters::AUDIO_FAKE;
+    if (codec == kCodecAC3) {
+      format = AudioParameters::AUDIO_RAW_AC3;
+    } else if (codec == kCodecEAC3) {
+      format = AudioParameters::AUDIO_RAW_EAC3;
+    } else {
+      NOTREACHED();
+    }
+
+    const int buffer_size = kMaxFramesPerCompressedAudioBuffer *
+                            stream->audio_decoder_config().bytes_per_frame();
+
+    audio_parameters_.Reset(
+        format, stream->audio_decoder_config().channel_layout(),
+        stream->audio_decoder_config().samples_per_second(),
+        stream->audio_decoder_config().bits_per_channel(), buffer_size);
+    buffer_converter_.reset();
+  } else if (!expecting_config_changes_ || !hw_params.IsValid() ||
+             hw_params.format() == AudioParameters::AUDIO_FAKE) {
     // 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(),
@@ skipping 191 matching lines @@
 
   DCHECK_EQ(status, AudioBufferStream::OK);
   DCHECK(buffer.get());
 
   if (state_ == kFlushing) {
     ChangeState_Locked(kFlushed);
     DoFlush_Locked();
     return;
   }
 
+  if (buffer->sample_format() == kSampleFormatRaw) {
+    if (last_decoded_sample_rate_ &&
+        buffer->sample_rate() != last_decoded_sample_rate_) {
+      OnConfigChange();
+    }
+    last_decoded_sample_rate_ = buffer->sample_rate();
+
+    if (!HandleSplicerBuffer_Locked(buffer) && !CanRead_Locked())
+      return;
+
+    AttemptRead_Locked();
+    return;
+  }
+
   if (expecting_config_changes_) {
     if (last_decoded_sample_rate_ &&
         buffer->sample_rate() != last_decoded_sample_rate_) {
       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();
@@ skipping 47 matching lines @@
 
   AttemptRead_Locked();
 }
 
 bool AudioRendererImpl::HandleSplicerBuffer_Locked(
     const scoped_refptr<AudioBuffer>& buffer) {
   lock_.AssertAcquired();
   if (buffer->end_of_stream()) {
     received_end_of_stream_ = true;
   } else {
-    if (state_ == kPlaying) {
+    if (state_ == kPlaying && buffer->sample_format() != kSampleFormatRaw) {

[DaleCurtis, 2016/11/01 23:05:13]

This is incorrect, seeking is going to return the wrong data. You need at least
IsBeforeStartTime() and further you'll need some mechanism for reporting the
actual start time in cases where you're unable to trim the audio buffer to the
correct start time.

[AndyWu, 2016/11/04 18:04:24]

Thanks for pointing it out.
Mark reporting time as a to-do item. What's the defect we have now? AV is
slightly out of sync in the beginning, and AV sync will be recovered after a
short period of time, right?

[DaleCurtis, 2016/11/04 19:48:29]

No, AV sync will never recover for this case since audio renderer will think
time T-x is actually time T -- so a todo is insufficient here.

[AndyWu, 2016/11/08 00:04:21]

I see. I reset start_timestamp_and audio_clock_in PS#5. Thanks a lot.

[DaleCurtis, 2016/11/08 00:11:47]

I don't think this will work. There is code in other layers to prevent the time
from going backwards. +watk who is familiar with this.

[watk, 2016/11/08 19:59:30]

PipelineImpl::GetMediaTime() tracks the last reported current time to make sure
its callers don't see time go backwards. I can't tell you whether it's necessary
though. I never got around to investigating what the implications of removing it
are.

[AndyWu, 2016/11/11 17:52:48]

Thanks a lot for your information. I guess I can do the same thing in
AudioRendererImpl.

       if (IsBeforeStartTime(buffer))
         return true;
 
       // Trim off any additional time before the start timestamp.
       const base::TimeDelta trim_time = start_timestamp_ - buffer->timestamp();
       if (trim_time > base::TimeDelta()) {
         buffer->TrimStart(buffer->frame_count() *
                           (static_cast<double>(trim_time.InMicroseconds()) /
                            buffer->duration().InMicroseconds()));
         buffer->set_timestamp(start_timestamp_);
@@ skipping 70 matching lines @@
       return false;
 
     case kPlaying:
       break;
   }
 
   return !pending_read_ && !received_end_of_stream_ &&
       !algorithm_->IsQueueFull();
 }
 
 void AudioRendererImpl::SetPlaybackRate(double playback_rate) {

[DaleCurtis, 2016/11/01 23:05:13]

Values other than 0 or 1 need to be ignored when outputing in raw.

[AndyWu, 2016/11/04 18:04:24]

Done.

   DVLOG(1) << __func__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GE(playback_rate, 0);
   DCHECK(sink_.get());
 
   base::AutoLock auto_lock(lock_);
 
   // We have two cases here:
   // Play: current_playback_rate == 0 && playback_rate != 0
   // Pause: current_playback_rate != 0 && playback_rate == 0
@@ skipping 17 matching lines @@
 bool AudioRendererImpl::IsBeforeStartTime(
     const scoped_refptr<AudioBuffer>& buffer) {
   DCHECK_EQ(state_, kPlaying);
   return buffer.get() && !buffer->end_of_stream() &&
          (buffer->timestamp() + buffer->duration()) < start_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               uint32_t frames_delayed,
                               uint32_t frames_skipped) {
-  const int frames_requested = audio_bus->frames();
+  int frames_requested = audio_bus->frames();
   DVLOG(4) << __func__ << " frames_delayed:" << frames_delayed
            << " frames_skipped:" << frames_skipped
            << " frames_requested:" << frames_requested;
 
   int frames_written = 0;
   {
     base::AutoLock auto_lock(lock_);
     last_render_time_ = tick_clock_->NowTicks();
 
     if (!stop_rendering_time_.is_null()) {
@@ skipping 15 matching lines @@
       return 0;
     }
 
     // Mute audio by returning 0 when not playing.
     if (state_ != kPlaying) {
       audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
                                playback_rate_);
       return 0;
     }
 
-    // Delay playback by writing silence if we haven't reached the first
-    // timestamp yet; this can occur if the video starts before the audio.
-    if (algorithm_->frames_buffered() > 0) {
+    if (is_passthrough_ && algorithm_->frames_buffered() > 0) {
+      frames_written += algorithm_->FillBuffer(audio_bus, 0, frames_requested,
+                                               playback_rate_);
+      frames_requested = frames_written;
+    } else if (algorithm_->frames_buffered() > 0) {
+      // Delay playback by writing silence if we haven't reached the first
+      // timestamp yet; this can occur if the video starts before the audio.
       CHECK_NE(first_packet_timestamp_, kNoTimestamp);
       CHECK_GE(first_packet_timestamp_, base::TimeDelta());
       const base::TimeDelta play_delay =
           first_packet_timestamp_ - audio_clock_->back_timestamp();
       if (play_delay > base::TimeDelta()) {
         DCHECK_EQ(frames_written, 0);
 
         // Don't multiply |play_delay| out since it can be a huge value on
         // poorly encoded media and multiplying by the sample rate could cause
         // the value to overflow.
@@ skipping 149 matching lines @@
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 }  // namespace media