media: Support better decoder switching

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 27 matching lines @@
 }
 
 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,
+    CreateDecodersCB create_decoders_cb,
     MediaLog* media_log)
     : traits_(media_log),
       task_runner_(task_runner),
+      create_decoders_cb_(std::move(create_decoders_cb)),
       media_log_(media_log),
       state_(STATE_UNINITIALIZED),
       stream_(NULL),
       cdm_context_(nullptr),
-      decoder_selector_(new DecoderSelector<StreamType>(task_runner,
-                                                        std::move(decoders),
-                                                        media_log)),
       decoder_produced_a_frame_(false),
+      has_fallen_back_once_on_decode_error_(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 179 matching lines @@
                                    : base::TimeDelta();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::SelectDecoder() {
   // If we are already using DecryptingDemuxerStream (DDS), e.g. during
   // fallback, the |stream_| will always be clear. In this case, no need pass in
   // the |cdm_context_|. This will also help prevent creating a new DDS on top
   // of the current DDS.
   CdmContext* cdm_context = decrypting_demuxer_stream_ ? nullptr : cdm_context_;
+  std::string blacklisted_decoder = decoder_ ? decoder_->GetDisplayName() : "";
+
+  decoder_selector_.reset(new DecoderSelector<StreamType>(
+      task_runner_, create_decoders_cb_, media_log_));
 
   decoder_selector_->SelectDecoder(
-      &traits_, stream_, cdm_context,
+      &traits_, stream_, cdm_context, blacklisted_decoder,
       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,
     std::unique_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream) {
   FUNCTION_DVLOG(1) << ": "
                     << (selected_decoder ? selected_decoder->GetDisplayName()
                                          : "No decoder selected.");
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == STATE_INITIALIZING || state_ == STATE_REINITIALIZING_DECODER)
       << state_;
+
+  decoder_selector_.reset();
+
   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_);
   }
 
   decoder_ = std::move(selected_decoder);
   if (decrypting_demuxer_stream) {
@@ skipping 135 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 (!decoder_produced_a_frame_) {
+      // Only fall back to a new decoder after failing to decode the first
+      // buffer, and if we have not fallen back before.
+      if (!decoder_produced_a_frame_ &&
+          !has_fallen_back_once_on_decode_error_) {
+        has_fallen_back_once_on_decode_error_ = true;

[sandersd (OOO until July 31), 2017/05/05 00:36:46]

It seems this should be reset after a successful decode?

[xhwang, 2017/05/05 02:42:59]

We could do that, but then this name is not accurate, as pointed out by Dale and
Chris.

Also it will not help anything for now, since we never fallback again after
decoder_produced_a_frame_ is true, even after reinitialization. In the next CL,
I'll try to remove this restriction. Basically after reinitialization, we should
be able to fallback again on decode error on the first buffer.

         pending_decode_requests_ = 0;
 
         // 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!";
       state_ = STATE_ERROR;
       MEDIA_LOG(ERROR, media_log_) << GetStreamTypeString() << " decode error";
       ready_outputs_.clear();
       if (!read_cb_.is_null())
         SatisfyRead(DECODE_ERROR, NULL);
       return;
 
     case DecodeStatus::ABORTED:
       // Decoder can return DecodeStatus::ABORTED during Reset() or during
@@ skipping 39 matching lines @@
   }
 
   // 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);
 
-  // |decoder_| sucessfully decoded a frame. No need to keep buffers for a
+  // |decoder_| successfully 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);
@@ skipping 254 matching lines @@
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media