Move audio decoder initialization to AudioRendererImpl.

media/base/pipeline.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/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/clock.h"
+#include "media/base/demuxer_stream.h"

[acolwell GONE FROM CHROMIUM, 2012/10/15 21:00:07]

nit: why is this needed now?

[xhwang, 2012/10/15 22:52:23]

Removed.

 #include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_renderer.h"
 
 using base::TimeDelta;
 
 namespace media {
 
@@ skipping 225 matching lines @@
   state_ = next_state;
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
 }
 
 #define RETURN_STRING(state) case state: return #state;
 
 const char* Pipeline::GetStateString(State state) {
   switch (state) {
     RETURN_STRING(kCreated);
     RETURN_STRING(kInitDemuxer);
-    RETURN_STRING(kInitAudioDecoder);
     RETURN_STRING(kInitAudioRenderer);
     RETURN_STRING(kInitVideoRenderer);
     RETURN_STRING(kInitPrerolling);
     RETURN_STRING(kSeeking);
     RETURN_STRING(kStarting);
     RETURN_STRING(kStarted);
     RETURN_STRING(kStopping);
     RETURN_STRING(kStopped);
   }
   NOTREACHED();
   return "INVALID";
 }
 
 #undef RETURN_STRING
 
 Pipeline::State Pipeline::GetNextState() const {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(stop_cb_.is_null())
       << "State transitions don't happen when stopping";
   DCHECK_EQ(status_, PIPELINE_OK)
       << "State transitions don't happen when there's an error: " << status_;
 
   switch (state_) {
     case kCreated:
       return kInitDemuxer;
 
     case kInitDemuxer:
       if (demuxer_->GetStream(DemuxerStream::AUDIO))
-        return kInitAudioDecoder;
+        return kInitAudioRenderer;
       if (demuxer_->GetStream(DemuxerStream::VIDEO))
         return kInitVideoRenderer;
       return kInitPrerolling;
 
-    case kInitAudioDecoder:
-      return kInitAudioRenderer;
-
     case kInitAudioRenderer:
       if (demuxer_->GetStream(DemuxerStream::VIDEO))
         return kInitVideoRenderer;
       return kInitPrerolling;
 
     case kInitVideoRenderer:
       return kInitPrerolling;
 
     case kInitPrerolling:
       return kStarting;
@@ skipping 143 matching lines @@
   pending_callbacks_.reset();
 
   PipelineStatusCB done_cb = base::Bind(&Pipeline::OnStateTransition, this);
 
   // Switch states, performing any entrance actions for the new state as well.
   SetState(GetNextState());
   switch (state_) {
     case kInitDemuxer:
       return InitializeDemuxer(done_cb);
 
-    case kInitAudioDecoder:
-      return InitializeAudioDecoder(done_cb);
-
     case kInitAudioRenderer:
       return InitializeAudioRenderer(done_cb);
 
     case kInitVideoRenderer:
       return InitializeVideoRenderer(done_cb);
 
     case kInitPrerolling:
       filter_collection_.reset();
       {
         base::AutoLock l(lock_);
@@ skipping 146 matching lines @@
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopping);
   {
     base::AutoLock l(lock_);
     running_ = false;
   }
 
   SetState(kStopped);
   pending_callbacks_.reset();
   filter_collection_.reset();
-  audio_decoder_ = NULL;
   audio_renderer_ = NULL;
   video_renderer_ = NULL;
   demuxer_ = NULL;
 
   // If we stop during initialization/seeking we want to run |seek_cb_|
   // followed by |stop_cb_| so we don't leave outstanding callbacks around.
   if (!seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(status_);
     error_cb_.Reset();
   }
@@ skipping 232 matching lines @@
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
 void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   demuxer_ = filter_collection_->GetDemuxer();
   demuxer_->Initialize(this, done_cb);
 }
 
-void Pipeline::InitializeAudioDecoder(const PipelineStatusCB& done_cb) {
+void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   scoped_refptr<DemuxerStream> stream =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   DCHECK(stream);
 
-  filter_collection_->SelectAudioDecoder(&audio_decoder_);
-  audio_decoder_->Initialize(
-      stream, done_cb, base::Bind(&Pipeline::OnUpdateStatistics, this));
-}
-
-void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(audio_decoder_);
-
   filter_collection_->SelectAudioRenderer(&audio_renderer_);
   audio_renderer_->Initialize(
-      audio_decoder_,
+      stream,
+      *filter_collection_->GetAudioDecoders(),
       done_cb,
+      base::Bind(&Pipeline::OnUpdateStatistics, this),
       base::Bind(&Pipeline::OnAudioUnderflow, this),
       base::Bind(&Pipeline::OnAudioTimeUpdate, this),
       base::Bind(&Pipeline::OnAudioRendererEnded, this),
       base::Bind(&Pipeline::OnAudioDisabled, this),
       base::Bind(&Pipeline::SetError, this));
+  filter_collection_->GetAudioDecoders()->clear();
 }
 
 void Pipeline::InitializeVideoRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   scoped_refptr<DemuxerStream> stream =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   DCHECK(stream);
 
   {
@@ skipping 35 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media