Add support for midstream audio configuration changes.

media/filters/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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.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/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
 namespace {
 
 enum AudioRendererEvent {
   INITIALIZED,
   RENDER_ERROR,
   RENDER_EVENT_MAX = RENDER_ERROR,
 };
 
 void HistogramRendererEvent(AudioRendererEvent event) {
   UMA_HISTOGRAM_ENUMERATION(
       "Media.AudioRendererEvents", event, RENDER_EVENT_MAX + 1);
 }
 
 }  // namespace
 
 AudioRendererImpl::AudioRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     media::AudioRendererSink* sink,
     ScopedVector<AudioDecoder> decoders,
-    const SetDecryptorReadyCB& set_decryptor_ready_cb)
+    const SetDecryptorReadyCB& set_decryptor_ready_cb,
+    const AudioHardwareConfig& hardware_config)
     : task_runner_(task_runner),
       sink_(sink),
       audio_buffer_stream_(task_runner,
                            decoders.Pass(),
                            set_decryptor_ready_cb),
+      hardware_config_(hardware_config),
       now_cb_(base::Bind(&base::TimeTicks::Now)),
       state_(kUninitialized),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
       underflow_disabled_(false),
       preroll_aborted_(false),
@@ skipping 101 matching lines @@
     DCHECK(!flush_cb_.is_null());
 
     audio_time_buffered_ = kNoTimestamp();
     current_time_ = kNoTimestamp();
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
     preroll_aborted_ = false;
 
     earliest_end_time_ = now_cb_.Run();
     splicer_->Reset();
+    buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void AudioRendererImpl::Stop(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!callback.is_null());
 
   // TODO(scherkus): Consider invalidating |weak_factory_| and replacing
@@ skipping 85 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
     return;
   }
 
   if (!success) {
     state_ = kUninitialized;
     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  int sample_rate = audio_buffer_stream_.decoder()->samples_per_second();
+  // TODO(rileya): Support hardware config changes
+  audio_parameters_ = hardware_config_.GetOutputConfig();
 
-  // The actual buffer size is controlled via the size of the AudioBus
-  // provided to Render(), so just choose something reasonable here for looks.
-  int buffer_size = audio_buffer_stream_.decoder()->samples_per_second() / 100;
-
-  // TODO(rileya): Remove the channel_layout/bits_per_channel/samples_per_second
-  // getters from AudioDecoder, and adjust this accordingly.
-  audio_parameters_ =
-      AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
-                      audio_buffer_stream_.decoder()->channel_layout(),
-                      sample_rate,
-                      audio_buffer_stream_.decoder()->bits_per_channel(),
-                      buffer_size);
   if (!audio_parameters_.IsValid()) {
     ChangeState_Locked(kUninitialized);
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
-  splicer_.reset(new AudioSplicer(sample_rate));
+  buffer_converter_.reset(new AudioBufferConverter(audio_parameters_));
+  splicer_.reset(new AudioSplicer(audio_parameters_.sample_rate()));
 
   // We're all good! Continue initializing the rest of the audio renderer
   // based on the decoder format.
   algorithm_.reset(new AudioRendererAlgorithm());
   algorithm_->Initialize(0, audio_parameters_);
 
   ChangeState_Locked(kPaused);
 
   HistogramRendererEvent(INITIALIZED);
 
@@ skipping 59 matching lines @@
 
   DCHECK_EQ(status, AudioBufferStream::OK);
   DCHECK(buffer.get());
 
   if (state_ == kFlushing) {
     ChangeState_Locked(kPaused);
     DoFlush_Locked();
     return;
   }
 
-  if (!splicer_->AddInput(buffer)) {
-    HandleAbortedReadOrDecodeError(true);
-    return;
-  }
+  buffer_converter_->AddInput(buffer);
 
-  if (!splicer_->HasNextBuffer()) {
+  if (!buffer_converter_->HasNextBuffer()) {
     AttemptRead_Locked();
     return;
   }
 
   bool need_another_buffer = false;
-  while (splicer_->HasNextBuffer())
-    need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer());
+
+  while (buffer_converter_->HasNextBuffer()) {
+    scoped_refptr<AudioBuffer> converted_buffer =
+        buffer_converter_->GetNextBuffer();
+
+    if (!splicer_->AddInput(converted_buffer)) {
+      HandleAbortedReadOrDecodeError(true);
+      return;
+    }
+
+    while (splicer_->HasNextBuffer())
+      need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer());
+  }
 
   if (!need_another_buffer && !CanRead_Locked())
     return;
 
   AttemptRead_Locked();
 }
 
 bool AudioRendererImpl::HandleSplicerBuffer(
     const scoped_refptr<AudioBuffer>& buffer) {
   if (buffer->end_of_stream()) {
@@ skipping 306 matching lines @@
   }
 }
 
 void AudioRendererImpl::ChangeState_Locked(State new_state) {
   DVLOG(1) << __FUNCTION__ << " : " << state_ << " -> " << new_state;
   lock_.AssertAcquired();
   state_ = new_state;
 }
 
 }  // namespace media