Add AudioBufferStream.

media/filters/decoder_stream.cc

 // Copyright 2014 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/decoder_stream.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
+#include "media/base/audio_decoder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/video_decoder.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
 // TODO(rileya) Devise a better way of specifying trace/UMA/etc strings for
 // templated classes such as this.
 template <DemuxerStream::Type StreamType>
 static const char* GetTraceString();
 
 template <>
 const char* GetTraceString<DemuxerStream::VIDEO>() {
   return "DecoderStream<VIDEO>::Decode";
 }
 
+template <>
+const char* GetTraceString<DemuxerStream::AUDIO>() {
+  return "DecoderStream<AUDIO>::Decode";
+}
+
 template <DemuxerStream::Type StreamType>
 DecoderStream<StreamType>::DecoderStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<Decoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb)
     : task_runner_(task_runner),
       weak_factory_(this),
       state_(STATE_UNINITIALIZED),
       stream_(NULL),
       decoder_selector_(
@@ skipping 17 matching lines @@
   DCHECK(!init_cb.is_null());
 
   statistics_cb_ = statistics_cb;
   init_cb_ = init_cb;
   stream_ = stream;
 
   state_ = STATE_INITIALIZING;
   // TODO(xhwang): DecoderSelector only needs a config to select a decoder.
   decoder_selector_->SelectDecoder(
       stream,
-      StatisticsCB(),
       base::Bind(&DecoderStream<StreamType>::OnDecoderSelected,
                  weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Read(const ReadCB& read_cb) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_ERROR) << state_;
   // No two reads in the flight at any time.
   DCHECK(read_cb_.is_null());
   // No read during resetting or stopping process.
   DCHECK(reset_cb_.is_null());
   DCHECK(stop_cb_.is_null());
 
   if (state_ == STATE_ERROR) {
     task_runner_->PostTask(FROM_HERE, base::Bind(
         read_cb, DECODE_ERROR, scoped_refptr<Output>()));
     return;
   }
 
   read_cb_ = read_cb;
 
   if (state_ == STATE_FLUSHING_DECODER) {
     FlushDecoder();
     return;
   }
 
-  ReadFromDemuxerStream();
+  if (!SendQueuedOutput())
+    ReadFromDemuxerStream();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Reset(const base::Closure& closure) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_STOPPED) << state_;
   DCHECK(reset_cb_.is_null());
   DCHECK(stop_cb_.is_null());
 
@@ skipping 69 matching lines @@
   decrypting_demuxer_stream_.reset();
   task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&stop_cb_));
 }
 
 template <DemuxerStream::Type StreamType>
 bool DecoderStream<StreamType>::CanReadWithoutStalling() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return decoder_->CanReadWithoutStalling();
 }
 
+template <>
+bool DecoderStream<DemuxerStream::AUDIO>::CanReadWithoutStalling() const {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  return true;
+}
+
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderSelected(
     scoped_ptr<Decoder> selected_decoder,
     scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING) << state_;
   DCHECK(!init_cb_.is_null());
   DCHECK(read_cb_.is_null());
   DCHECK(reset_cb_.is_null());
@@ skipping 114 matching lines @@
   }
 
   if (status == Decoder::kNotEnoughData) {
     if (state_ == STATE_NORMAL)
       ReadFromDemuxerStream();
     else if (state_ == STATE_FLUSHING_DECODER)
       FlushDecoder();
     return;
   }
 
+  DCHECK(output);
   SatisfyRead(OK, output);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::ReadFromDemuxerStream() {
   DVLOG(2) << __FUNCTION__;
   DCHECK_EQ(state_, STATE_NORMAL) << state_;
   DCHECK(!read_cb_.is_null());
   DCHECK(reset_cb_.is_null());
   DCHECK(stop_cb_.is_null());
 
   state_ = STATE_PENDING_DEMUXER_READ;
   stream_->Read(base::Bind(&DecoderStream<StreamType>::OnBufferReady,
                            weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
+bool DecoderStream<StreamType>::SendQueuedOutput() {
+  return false;
+}
+
+template <>
+bool DecoderStream<DemuxerStream::AUDIO>::SendQueuedOutput() {

[xhwang, 2014/02/27 19:52:28]

The name "SendQueuedOutput" is a bit odd. How about adding GetDecodeOutput() to
both AudioDecoder and VideoDecoder, and having VideoDecoder::GetDecodeOutput()
always return NULL, then we don't need this specialization here.

+  AudioDecoder::Status status;
+  if (scoped_refptr<AudioBuffer> buffer = decoder_->GetAudioBuffer(&status)) {
+    OnDecodeOutputReady(0, status, buffer);

[xhwang, 2014/02/27 19:52:28]

since the first parameter is always 0, how about calling SatisfyRead() directly?

+    return true;
+  }
+  return false;
+}
+
+template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnBufferReady(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_PENDING_DEMUXER_READ) << state_;
   DCHECK_EQ(buffer.get() != NULL, status == DemuxerStream::kOk) << status;
   DCHECK(!read_cb_.is_null());
   DCHECK(stop_cb_.is_null());
 
@@ skipping 31 matching lines @@
   DCHECK(status == DemuxerStream::kOk) << status;
   Decode(buffer);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::ReinitializeDecoder() {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING_DECODER) << state_;
 
-  // TODO(rileya): Specialize this for audio, or, better yet, change
-  // DemuxerStream config getters to be templated.
-  DCHECK(stream_->video_decoder_config().IsValidConfig());
+  DCHECK(StreamTraits::GetDecoderConfig(*stream_).IsValidConfig());
   state_ = STATE_REINITIALIZING_DECODER;
   decoder_->Initialize(
-      stream_->video_decoder_config(),
+      StreamTraits::GetDecoderConfig(*stream_),
       base::Bind(&DecoderStream<StreamType>::OnDecoderReinitialized,
                  weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderReinitialized(PipelineStatus status) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_REINITIALIZING_DECODER) << state_;
   DCHECK(stop_cb_.is_null());
@@ skipping 79 matching lines @@
   DCHECK(!stop_cb_.is_null());
 
   state_ = STATE_STOPPED;
   stream_ = NULL;
   decoder_.reset();
   decrypting_demuxer_stream_.reset();
   base::ResetAndReturn(&stop_cb_).Run();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
+template class DecoderStream<DemuxerStream::AUDIO>;
 }  // namespace media