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),
       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()));
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
 void AudioRendererImpl::Play(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 91 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();
+    if (buffer_converter_)
+      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 62 matching lines @@
 
   state_ = kInitializing;
 
   init_cb_ = init_cb;
   underflow_cb_ = underflow_cb;
   time_cb_ = time_cb;
   ended_cb_ = ended_cb;
   disabled_cb_ = disabled_cb;
   error_cb_ = error_cb;
 
+  expecting_config_changes_ = stream->SupportsConfigChanges();
+  if (!expecting_config_changes_) {
+    // 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 = stream->audio_decoder_config().samples_per_second() / 100;
+    audio_parameters_.Reset(
+        AudioParameters::AUDIO_PCM_LOW_LATENCY,
+        stream->audio_decoder_config().channel_layout(),
+        ChannelLayoutToChannelCount(
+            stream->audio_decoder_config().channel_layout()),
+        0,
+        stream->audio_decoder_config().samples_per_second(),
+        stream->audio_decoder_config().bits_per_channel(),
+        buffer_size);
+    buffer_converter_.reset();
+  } else {
+    // TODO(rileya): Support hardware config changes
+    audio_parameters_ = hardware_config_.GetOutputConfig();
+  }
+
   audio_buffer_stream_.Initialize(
       stream,
       statistics_cb,
       base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
 
   if (state_ == kStopped) {
     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();
-
-  // 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));
+  if (expecting_config_changes_)
+    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;
+  if (expecting_config_changes_) {
+    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)) {
+      HandleAbortedReadOrDecodeError(true);
+      return;
+    }
   }
 
   if (!splicer_->HasNextBuffer()) {
     AttemptRead_Locked();
     return;
   }
 
   bool need_another_buffer = false;
   while (splicer_->HasNextBuffer())
     need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer());
@@ skipping 320 matching lines @@
   DVLOG(1) << __FUNCTION__ << " : " << state_ << " -> " << new_state;
   lock_.AssertAcquired();
   state_ = new_state;
 }
 
 void AudioRendererImpl::OnNewSpliceBuffer(base::TimeDelta splice_timestamp) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   splicer_->SetSpliceTimestamp(splice_timestamp);
 }
 
+void AudioRendererImpl::OnConfigChange() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  buffer_converter_->ResetTimestampState();
+}
+
 }  // namespace media