Support (E)AC3 passthrough

media/base/audio_renderer_mixer.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/base/audio_renderer_mixer.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 36 matching lines @@
   int count_;
   int max_count_;
   DISALLOW_COPY_AND_ASSIGN(UMAMaxValueTracker);
 };
 
 AudioRendererMixer::AudioRendererMixer(const AudioParameters& output_params,
                                        scoped_refptr<AudioRendererSink> sink,
                                        const UmaLogCallback& log_callback)
     : output_params_(output_params),
       audio_sink_(std::move(sink)),
+      raw_input_(nullptr),

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

Why is this necessary? Instead the AudioConverter should be taught about raw
streams and it will do the right thing without modification to this code.

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

Just took a shortcut, since none of these functions are applicable to raw
stream.
I will look into AudioConverter.

[AndyWu, 2016/11/04 19:43:48]

You are right, the change is not necessary.

       master_converter_(output_params, output_params, true),
       pause_delay_(base::TimeDelta::FromSeconds(kPauseDelaySeconds)),
       last_play_time_(base::TimeTicks::Now()),
       // Initialize |playing_| to true since Start() results in an auto-play.
       playing_(true),
       input_count_tracker_(new UMAMaxValueTracker(log_callback)) {
   DCHECK(audio_sink_);
   audio_sink_->Initialize(output_params, this);
   audio_sink_->Start();
 }
@@ skipping 10 matching lines @@
 
 void AudioRendererMixer::AddMixerInput(const AudioParameters& input_params,
                                        AudioConverter::InputCallback* input) {
   base::AutoLock auto_lock(lock_);
   if (!playing_) {
     playing_ = true;
     last_play_time_ = base::TimeTicks::Now();
     audio_sink_->Play();
   }
 
+  if (input_params.IsRawFormat()) {
+    DCHECK(input);
+    DCHECK(!raw_input_);
+
+    raw_input_ = input;
+    return;
+  }
+
   int input_sample_rate = input_params.sample_rate();
   if (is_master_sample_rate(input_sample_rate)) {
     master_converter_.AddInput(input);
   } else {
     AudioConvertersMap::iterator converter =
         converters_.find(input_sample_rate);
     if (converter == converters_.end()) {
       std::pair<AudioConvertersMap::iterator, bool> result =
           converters_.insert(std::make_pair(
               input_sample_rate, base::WrapUnique(
@@ skipping 11 matching lines @@
   }
 
   input_count_tracker_->Increment();
 }
 
 void AudioRendererMixer::RemoveMixerInput(
     const AudioParameters& input_params,
     AudioConverter::InputCallback* input) {
   base::AutoLock auto_lock(lock_);
 
+  if (raw_input_ == input) {
+    raw_input_ = nullptr;
+    return;
+  }
+
   int input_sample_rate = input_params.sample_rate();
   if (is_master_sample_rate(input_sample_rate)) {
     master_converter_.RemoveInput(input);
   } else {
     AudioConvertersMap::iterator converter =
         converters_.find(input_sample_rate);
     DCHECK(converter != converters_.end());
     converter->second->RemoveInput(input);
     if (converter->second->empty()) {
       // Remove converter when it's empty.
@@ skipping 33 matching lines @@
 bool AudioRendererMixer::CurrentThreadIsRenderingThread() {
   return audio_sink_->CurrentThreadIsRenderingThread();
 }
 
 int AudioRendererMixer::Render(AudioBus* audio_bus,
                                uint32_t frames_delayed,
                                uint32_t frames_skipped) {
   TRACE_EVENT0("audio", "AudioRendererMixer::Render");
   base::AutoLock auto_lock(lock_);
 
+  if (raw_input_) {
+    return raw_input_->ProvideInput(audio_bus, frames_delayed);
+  }
+
   // If there are no mixer inputs and we haven't seen one for a while, pause the
   // sink to avoid wasting resources when media elements are present but remain
   // in the pause state.
   const base::TimeTicks now = base::TimeTicks::Now();
   if (!master_converter_.empty()) {
     last_play_time_ = now;
   } else if (now - last_play_time_ >= pause_delay_ && playing_) {
     audio_sink_->Pause();
     playing_ = false;
   }
 
   master_converter_.ConvertWithDelay(frames_delayed, audio_bus);
   return audio_bus->frames();
 }
 
 void AudioRendererMixer::OnRenderError() {
   // Call each mixer input and signal an error.
   base::AutoLock auto_lock(lock_);
   for (const auto& cb : error_callbacks_)
     cb.Run();
 }
 
 }  // namespace media