media: Discard the previous decoder immediately on fallback

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 38 matching lines @@
     MediaLog* media_log)
     : traits_(media_log),
       task_runner_(task_runner),
       media_log_(media_log),
       state_(STATE_UNINITIALIZED),
       stream_(NULL),
       cdm_context_(nullptr),
       decoder_selector_(new DecoderSelector<StreamType>(task_runner,
                                                         std::move(decoders),
                                                         media_log)),
-      decoded_frames_since_fallback_(0),
+      decoder_produced_a_frame_(false),
       decoding_eos_(false),
       pending_decode_requests_(0),
       duration_tracker_(8),
       received_config_change_during_reinit_(false),
       pending_demuxer_read_(false),
       weak_factory_(this),
       fallback_weak_factory_(this) {
   FUNCTION_DVLOG(1);
 }
 
@@ skipping 207 matching lines @@
   DCHECK(state_ == STATE_INITIALIZING || state_ == STATE_REINITIALIZING_DECODER)
       << state_;
   if (state_ == STATE_INITIALIZING) {
     DCHECK(!init_cb_.is_null());
     DCHECK(read_cb_.is_null());
     DCHECK(reset_cb_.is_null());
   } else if (state_ == STATE_REINITIALIZING_DECODER) {
     DCHECK(decoder_);
   }
 
-  previous_decoder_ = std::move(decoder_);
-  decoded_frames_since_fallback_ = 0;
   decoder_ = std::move(selected_decoder);
   if (decrypting_demuxer_stream) {
     decrypting_demuxer_stream_ = std::move(decrypting_demuxer_stream);
     stream_ = decrypting_demuxer_stream_.get();
   }
 
   // TODO(tguilbert): crbug.com/603713 support config changes on decoder reinit.
   if (received_config_change_during_reinit_) {
     CompleteDecoderReinitialization(false);
     return;
@@ skipping 40 matching lines @@
   base::ResetAndReturn(&read_cb_).Run(status, output);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Decode(
     const scoped_refptr<DecoderBuffer>& buffer) {
   FUNCTION_DVLOG(3);
 
   // We don't know if the decoder will error out on first decode yet. Save the
   // buffer to feed it to the fallback decoder later if needed.
-  if (!decoded_frames_since_fallback_)
+  if (!decoder_produced_a_frame_)
     pending_buffers_.push_back(buffer);
 
   // It's possible for a buffer to arrive from the demuxer right after the
   // fallback decoder successfully completed its initialization. At this point
   // |pending_buffers_| has already been copied to |fallback_buffers_| and we
   // need to append it ourselves.
   if (!fallback_buffers_.empty()) {
     fallback_buffers_.push_back(buffer);
 
     scoped_refptr<DecoderBuffer> temp = fallback_buffers_.front();
@@ skipping 64 matching lines @@
     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;
 
   switch (status) {
     case DecodeStatus::DECODE_ERROR:
-      if (!decoded_frames_since_fallback_) {
+      if (!decoder_produced_a_frame_) {
         pending_decode_requests_ = 0;
 
-        // Prevent all pending decode requests and outputs form those requests
+        // Prevent all pending decode requests and outputs from those requests
         // from being called back.
         fallback_weak_factory_.InvalidateWeakPtrs();
 
         FUNCTION_DVLOG(1)
             << ": Falling back to new decoder after initial decode error.";
         state_ = STATE_REINITIALIZING_DECODER;
         SelectDecoder();
         return;
       }
       FUNCTION_DVLOG(1) << ": Decode error!";
@@ skipping 45 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;
 
+  decoder_produced_a_frame_ = true;
   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
     // satisifed by Read().
     DCHECK(ready_outputs_.empty());
     SatisfyRead(OK, output);
     return;
   }
 
   // Store decoded output.
   ready_outputs_.push_back(output);
-
-  // Destruct any previous decoder once we've decoded enough frames to ensure
-  // that it's no longer in use.
-  if (previous_decoder_ &&
-      decoded_frames_since_fallback_ > limits::kMaxVideoFrames) {
-    previous_decoder_.reset();
-  }
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::ReadFromDemuxerStream() {
   FUNCTION_DVLOG(3);
   DCHECK_EQ(state_, STATE_NORMAL);
   DCHECK(CanDecodeMore());
   DCHECK(reset_cb_.is_null());
 
   if (!fallback_buffers_.empty()) {
@@ skipping 17 matching lines @@
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnBufferReady(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
   FUNCTION_DVLOG(3) << ": " << status << ", "
                     << (buffer.get() ? buffer->AsHumanReadableString()
                                      : "NULL");
 
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(pending_demuxer_read_);
-  if (decoded_frames_since_fallback_) {
-    DCHECK(pending_demuxer_read_ || state_ == STATE_ERROR) << state_;

[watk, 2017/04/24 23:13:02]

Two lines above we DCHECK(pending_demuxer_read_) so this branch is useless. I
deleted it. We end up with a pretty weird looking DCHECK but it should be
equivalent to what we had..

-  } else {
+  if (!decoder_produced_a_frame_) {
     DCHECK(state_ == STATE_ERROR || state_ == STATE_REINITIALIZING_DECODER ||
            state_ == STATE_NORMAL)
         << state_;
   }
   DCHECK_EQ(buffer.get() != NULL, status == DemuxerStream::kOk) << status;
   pending_demuxer_read_ = false;
 
   // If parallel decode requests are supported, multiple read requests might
   // have been sent to the demuxer. The buffers might arrive while the decoder
   // is reinitializing after falling back on first decode error.
-  if (state_ == STATE_REINITIALIZING_DECODER &&
-      !decoded_frames_since_fallback_) {
+  if (state_ == STATE_REINITIALIZING_DECODER && !decoder_produced_a_frame_) {
     switch (status) {
       case DemuxerStream::kOk:
         // Save valid buffers to be consumed by the new decoder.
         // |pending_buffers_| is copied to |fallback_buffers| in
         // OnDecoderSelected().
         pending_buffers_.push_back(buffer);
         break;
       case DemuxerStream::kConfigChanged:
         // TODO(tguilbert): crbug.com/603713
         // |decoder_| might have a stale config by the time it is reinitialized.
@@ skipping 190 matching lines @@
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media