Add callback in VideoDecoder and AudioDecoder to return decoded frames.

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"
@@ skipping 62 matching lines @@
   statistics_cb_ = statistics_cb;
   init_cb_ = init_cb;
   stream_ = stream;
   low_delay_ = low_delay;
 
   state_ = STATE_INITIALIZING;
   // TODO(xhwang): DecoderSelector only needs a config to select a decoder.
   decoder_selector_->SelectDecoder(
       stream, low_delay,
       base::Bind(&DecoderStream<StreamType>::OnDecoderSelected,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                  weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Read(const ReadCB& read_cb) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_ERROR || state_ == STATE_REINITIALIZING_DECODER ||
          state_ == STATE_PENDING_DEMUXER_READ)
@@ skipping 13 matching lines @@
                                       scoped_refptr<Output>()));
     return;
   }
 
   if (!ready_outputs_.empty()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(
         base::ResetAndReturn(&read_cb_), OK, ready_outputs_.front()));
     ready_outputs_.pop_front();
   }
 
-  // Decoder may be in reinitializing state as result of the previous Read().
-  if (state_ == STATE_REINITIALIZING_DECODER)
-    return;
-
-  if (!CanDecodeMore())
-    return;
-
-  if (state_ == STATE_FLUSHING_DECODER) {
-    FlushDecoder();
-    return;
-  }
-
-  if (state_ != STATE_PENDING_DEMUXER_READ)
+  if (state_ == STATE_NORMAL && CanDecodeMore())
     ReadFromDemuxerStream();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Reset(const base::Closure& closure) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_STOPPED) << state_;
   DCHECK(reset_cb_.is_null());
   DCHECK(stop_cb_.is_null());
@@ skipping 70 matching lines @@
   state_ = STATE_STOPPED;
   stream_ = NULL;
   decoder_.reset();
   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();
+  return !ready_outputs_.empty() || decoder_->CanReadWithoutStalling();
 }
 
 template <>
 bool DecoderStream<DemuxerStream::AUDIO>::CanReadWithoutStalling() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return true;
 }
 
 template <DemuxerStream::Type StreamType>
+int DecoderStream<StreamType>::GetMaxDecodeRequests() const {
+  return decoder_->GetMaxDecodeRequests();
+}
+
+template <>
+int DecoderStream<DemuxerStream::AUDIO>::GetMaxDecodeRequests() const {
+  return 1;
+}
+
+template <DemuxerStream::Type StreamType>
 bool DecoderStream<StreamType>::CanDecodeMore() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Limit total number of outputs stored in |ready_outputs_| and being decoded.
   // It only makes sense to saturate decoder completely when output queue is
   // empty.
   int num_decodes =
       static_cast<int>(ready_outputs_.size()) + pending_decode_requests_;
-  return num_decodes < decoder_->GetMaxDecodeRequests();
-}
-
-template <>
-bool DecoderStream<DemuxerStream::AUDIO>::CanDecodeMore() const {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  return !pending_decode_requests_ && ready_outputs_.empty();
+  return num_decodes < GetMaxDecodeRequests();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderSelected(
     scoped_ptr<Decoder> selected_decoder,
     scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING) << state_;
   DCHECK(!init_cb_.is_null());
@@ skipping 29 matching lines @@
     const scoped_refptr<Output>& output) {
   DCHECK(!read_cb_.is_null());
   base::ResetAndReturn(&read_cb_).Run(status, output);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Decode(
     const scoped_refptr<DecoderBuffer>& buffer) {
   FUNCTION_DVLOG(2);
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER) << state_;
-  DCHECK(CanDecodeMore());
+  DCHECK_LT(pending_decode_requests_, GetMaxDecodeRequests());
   DCHECK(reset_cb_.is_null());
   DCHECK(stop_cb_.is_null());
   DCHECK(buffer);
 
   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
 
   TRACE_EVENT_ASYNC_BEGIN0("media", GetTraceString<StreamType>(), this);
   ++pending_decode_requests_;
   decoder_->Decode(buffer,
-                   base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
+                   base::Bind(&DecoderStream<StreamType>::OnDecodeDone,
                               weak_factory_.GetWeakPtr(),
-                              buffer_size));
+                              buffer_size,
+                              buffer->end_of_stream()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::FlushDecoder() {
-  if (pending_decode_requests_ == 0)
-    Decode(DecoderBuffer::CreateEOSBuffer());
+  Decode(DecoderBuffer::CreateEOSBuffer());
 }
 
 template <DemuxerStream::Type StreamType>
-void DecoderStream<StreamType>::OnDecodeOutputReady(
-    int buffer_size,
-    typename Decoder::Status status,
-    const scoped_refptr<Output>& output) {
-  FUNCTION_DVLOG(2) << status << " " << output;
+void DecoderStream<StreamType>::OnDecodeDone(int buffer_size,
+                                             bool end_of_stream,
+                                             typename Decoder::Status status) {
+  FUNCTION_DVLOG(2) << status;
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR)
       << state_;
   DCHECK(stop_cb_.is_null());
-  DCHECK_EQ(status == Decoder::kOk, output != NULL);
   DCHECK_GT(pending_decode_requests_, 0);
 
   --pending_decode_requests_;
 
   TRACE_EVENT_ASYNC_END0("media", GetTraceString<StreamType>(), this);
 
   if (state_ == STATE_ERROR) {
     DCHECK(read_cb_.is_null());
     return;
   }
 
-  if (status == Decoder::kDecodeError) {
-    state_ = STATE_ERROR;
-    ready_outputs_.clear();
-    if (!read_cb_.is_null())
-      SatisfyRead(DECODE_ERROR, NULL);
+  // Drop decoding result if Reset() was called during decoding.
+  // The resetting process will be handled when the decoder is reset.
+  if (!reset_cb_.is_null())
+    return;
+
+  switch (status) {
+    case Decoder::kDecodeError:
+    case Decoder::kDecryptError:
+      state_ = STATE_ERROR;
+      ready_outputs_.clear();
+      if (!read_cb_.is_null())
+        SatisfyRead(DECODE_ERROR, NULL);
+      break;
+
+    case Decoder::kAborted:
+      // Decoder can return kAborted only when Reset is pending.
+      NOTREACHED();
+      break;
+
+    case Decoder::kOk:
+      // Any successful decode counts!
+      if (buffer_size > 0) {
+        StreamTraits::ReportStatistics(statistics_cb_, buffer_size);
+      }
+
+      if (state_ == STATE_NORMAL) {
+        if (CanDecodeMore() && !end_of_stream)
+          ReadFromDemuxerStream();
+      } else if (state_ == STATE_FLUSHING_DECODER) {
+        if (!pending_decode_requests_)
+          ReinitializeDecoder();
+      }
+      break;
+  }
+}
+
+template <DemuxerStream::Type StreamType>
+void DecoderStream<StreamType>::OnDecodeOutputReady(
+    const scoped_refptr<Output>& output) {
+  FUNCTION_DVLOG(2) << output;
+  DCHECK(output);
+  DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
+         state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR)
+      << state_;
+
+  if (state_ == STATE_ERROR) {
+    DCHECK(read_cb_.is_null());
     return;
   }
 
-  if (status == Decoder::kDecryptError) {
-    state_ = STATE_ERROR;
-    ready_outputs_.clear();
-    if (!read_cb_.is_null())
-      SatisfyRead(DECRYPT_ERROR, NULL);
-    return;
-  }
-
-  if (status == Decoder::kAborted) {
-    if (!read_cb_.is_null())
-      SatisfyRead(ABORTED, NULL);
-    return;
-  }
-
-  // Any successful decode counts!
-  if (buffer_size > 0) {
-    StreamTraits::ReportStatistics(statistics_cb_, buffer_size);
-  }
-
   // Drop decoding result if Reset() was called during decoding.
   // The resetting process will be handled when the decoder is reset.
   if (!reset_cb_.is_null())
     return;
 
-  // Decoder flushed. Reinitialize the decoder.
-  if (state_ == STATE_FLUSHING_DECODER &&
-      status == Decoder::kOk && output->end_of_stream()) {
-    ReinitializeDecoder();
+  if (state_ == STATE_FLUSHING_DECODER && output->end_of_stream()) {
+    // ReinitializeDecoder() will be called from OnDecodeDone().
     return;
   }
 
-  if (status == Decoder::kNotEnoughData) {
-    if (state_ == STATE_NORMAL)
-      ReadFromDemuxerStream();
-    else if (state_ == STATE_FLUSHING_DECODER)
-      FlushDecoder();
-    return;
-  }
-
-  DCHECK(output);
-
   // Store decoded output.
   ready_outputs_.push_back(output);
-  scoped_refptr<Output> extra_output;
-  while ((extra_output = decoder_->GetDecodeOutput()) != NULL) {
-    ready_outputs_.push_back(extra_output);
-  }
 
   // Satisfy outstanding read request, if any.
   if (!read_cb_.is_null()) {
     scoped_refptr<Output> read_result = ready_outputs_.front();
     ready_outputs_.pop_front();
     SatisfyRead(OK, output);
   }
 }
 
 template <DemuxerStream::Type StreamType>
@@ skipping 52 matching lines @@
 
   if (!reset_cb_.is_null()) {
     // If we are using DecryptingDemuxerStream, we already called DDS::Reset()
     // which will continue the resetting process in it's callback.
     if (!decrypting_demuxer_stream_)
       Reset(base::ResetAndReturn(&reset_cb_));
     return;
   }
 
   if (status == DemuxerStream::kAborted) {
-    SatisfyRead(DEMUXER_READ_ABORTED, NULL);
+    if (!read_cb_.is_null())
+      SatisfyRead(DEMUXER_READ_ABORTED, NULL);
     return;
   }
 
   if (!splice_observer_cb_.is_null() && !buffer->end_of_stream()) {
     const bool has_splice_ts = buffer->splice_timestamp() != kNoTimestamp();
     if (active_splice_ || has_splice_ts) {
       splice_observer_cb_.Run(buffer->splice_timestamp());
       active_splice_ = has_splice_ts;
     }
   }
@@ skipping 13 matching lines @@
   DCHECK_EQ(state_, STATE_FLUSHING_DECODER) << state_;
   DCHECK_EQ(pending_decode_requests_, 0);
 
   DCHECK(StreamTraits::GetDecoderConfig(*stream_).IsValidConfig());
   state_ = STATE_REINITIALIZING_DECODER;
   DecoderStreamTraits<StreamType>::Initialize(
       decoder_.get(),
       StreamTraits::GetDecoderConfig(*stream_),
       low_delay_,
       base::Bind(&DecoderStream<StreamType>::OnDecoderReinitialized,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                  weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderReinitialized(PipelineStatus status) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_REINITIALIZING_DECODER) << state_;
   DCHECK(stop_cb_.is_null());
 
@@ skipping 68 matching lines @@
   decrypting_demuxer_stream_.reset();
   // Post |stop_cb_| because pending |read_cb_| and/or |reset_cb_| are also
   // posted in Stop().
   task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&stop_cb_));
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media