MEDIA_LOG for large encoded timestamp gaps in decoder stream.

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 24 matching lines @@
 template <>
 const char* GetTraceString<DemuxerStream::VIDEO>() {
   return "DecoderStream<VIDEO>::Decode";
 }
 
 template <>
 const char* GetTraceString<DemuxerStream::AUDIO>() {
   return "DecoderStream<AUDIO>::Decode";
 }
 
+template <typename ConfigType>
+ConfigType GetConfig(DemuxerStream* stream) {
+  return nullptr;
+}
+
+template <>
+AudioDecoderConfig GetConfig(DemuxerStream* stream) {
+  return stream->audio_decoder_config();
+}
+
+template <>
+VideoDecoderConfig GetConfig(DemuxerStream* stream) {
+  return stream->video_decoder_config();
+}
+
 template <DemuxerStream::Type StreamType>
 DecoderStream<StreamType>::DecoderStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<Decoder> decoders,
     const scoped_refptr<MediaLog>& media_log)
-    : task_runner_(task_runner),
+    : traits_(media_log),
+      task_runner_(task_runner),
       media_log_(media_log),
       state_(STATE_UNINITIALIZED),
       stream_(NULL),
       decoder_selector_(new DecoderSelector<StreamType>(task_runner,
                                                         std::move(decoders),
                                                         media_log)),
       decoded_frames_since_fallback_(0),
       active_splice_(false),
       decoding_eos_(false),
       pending_decode_requests_(0),
@@ skipping 42 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
 
   statistics_cb_ = statistics_cb;
   init_cb_ = init_cb;
   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
   stream_ = stream;
 
+  traits_.OnStreamReset(GetConfig<Config>(stream_));

[DaleCurtis, 2016/06/24 00:11:29]

Why was GetConfig() necessary again? Seems like you could just pass
DemuxerStream* and the traits methods would know how to handle it appropriately.

[chcunningham, 2016/06/24 01:56:34]

We chatted. Documenting for posterity:

I disliked passing the DemuxerStream* to the traits_ because I felt it suggested
that traits_ would store the pointer, which raises questions about why we need
it again in traits_.InitializeDecoder and whether we should update it if
DecryptingDemuxerStream comes to later override the pointer in DecoderStream.
This is probably overthinking things though.

We tried passing in a const DemuxerStream&, but this doesn't go well when we try
to grab the audio_decoder_config() out because that method is not const (and
isn't easily const'ed due to ChunkDemuxer -> SourceBufferStream path. 

In the end, I've gone with the pointer. Its simpler. 

+
   state_ = STATE_INITIALIZING;
   SelectDecoder(cdm_context);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Read(const ReadCB& read_cb) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_INITIALIZING)
       << state_;
@@ skipping 35 matching lines @@
 
   reset_cb_ = closure;
 
   if (!read_cb_.is_null()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(base::ResetAndReturn(&read_cb_), ABORTED,
                                       scoped_refptr<Output>()));
   }
 
   ready_outputs_.clear();
+  traits_.OnStreamReset(GetConfig<Config>(stream_));
 
   // It's possible to have received a DECODE_ERROR and entered STATE_ERROR right
   // before a Reset() is executed. If we are still waiting for a demuxer read,
   // OnBufferReady() will handle the reset callback.
   // See crbug.com/597605 and crbug.com/607454.
   if (state_ == STATE_ERROR && !pending_demuxer_read_) {
     task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&reset_cb_));
     return;
   }
 
@@ skipping 60 matching lines @@
 template <DemuxerStream::Type StreamType>
 base::TimeDelta DecoderStream<StreamType>::AverageDuration() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return duration_tracker_.count() ? duration_tracker_.Average()
                                    : base::TimeDelta();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::SelectDecoder(CdmContext* cdm_context) {
   decoder_selector_->SelectDecoder(
-      stream_, cdm_context,
+      &traits_, stream_, cdm_context,
       base::Bind(&DecoderStream<StreamType>::OnDecoderSelected,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                  fallback_weak_factory_.GetWeakPtr()),
       waiting_for_decryption_key_cb_);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderSelected(
     std::unique_ptr<Decoder> selected_decoder,
@@ skipping 94 matching lines @@
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::DecodeInternal(
     const scoped_refptr<DecoderBuffer>& buffer) {
   FUNCTION_DVLOG(2);
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER) << state_;
   DCHECK_LT(pending_decode_requests_, GetMaxDecodeRequests());
   DCHECK(reset_cb_.is_null());
   DCHECK(buffer.get());
 
+  traits_.OnDecode(buffer);
+
   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
 
   TRACE_EVENT_ASYNC_BEGIN2(
       "media", GetTraceString<StreamType>(), this, "key frame",
       !buffer->end_of_stream() && buffer->is_key_frame(), "timestamp (ms)",
       !buffer->end_of_stream() ? buffer->timestamp().InMilliseconds() : 0);
 
   if (buffer->end_of_stream())
     decoding_eos_ = true;
   else if (buffer->duration() != kNoTimestamp())
@@ skipping 45 matching lines @@
     case DecodeStatus::DECODE_ERROR:
       if (!decoded_frames_since_fallback_) {
         pending_decode_requests_ = 0;
 
         // Prevent all pending decode requests and outputs form those requests
         // from being called back.
         fallback_weak_factory_.InvalidateWeakPtrs();
 
         state_ = STATE_REINITIALIZING_DECODER;
         decoder_selector_->SelectDecoder(
-            stream_, nullptr,
+            &traits_, stream_, nullptr,
             base::Bind(&DecoderStream<StreamType>::OnDecoderSelected,
                        weak_factory_.GetWeakPtr()),
             base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                        fallback_weak_factory_.GetWeakPtr()),
             waiting_for_decryption_key_cb_);
         return;
       }
       state_ = STATE_ERROR;
       MEDIA_LOG(ERROR, media_log_) << GetStreamTypeString() << " decode error";
       ready_outputs_.clear();
@@ skipping 42 matching lines @@
   if (state_ == STATE_ERROR) {
     DCHECK(read_cb_.is_null());
     return;
   }
 
   // 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;
 
+  traits_.OnDecodeDone(output);
+
   ++decoded_frames_since_fallback_;
 
   // |decoder_| sucessfully decoded a frame. No need to keep buffers for a
   // fallback decoder.
   // Note: |fallback_buffers_| might still have buffers, and we will keep
   // reading from there before requesting new buffers from |stream_|.
   pending_buffers_.clear();
 
   if (!read_cb_.is_null()) {
     // If |ready_outputs_| was non-empty, the read would have already been
@@ skipping 180 matching lines @@
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::ReinitializeDecoder() {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING_DECODER);
   DCHECK_EQ(pending_decode_requests_, 0);
 
   state_ = STATE_REINITIALIZING_DECODER;
   // Decoders should not need a new CDM during reinitialization.
-  DecoderStreamTraits<StreamType>::InitializeDecoder(
+  traits_.InitializeDecoder(
       decoder_.get(), stream_, nullptr,
       base::Bind(&DecoderStream<StreamType>::OnDecoderReinitialized,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                  fallback_weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderReinitialized(bool success) {
   FUNCTION_DVLOG(2);
@@ skipping 79 matching lines @@
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media