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),
       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_selector_(
+          new DecoderSelector<StreamType>(task_runner,
+                                          std::move(create_decoders_cb),
+                                          media_log)),
       decoder_produced_a_frame_(false),
+      is_on_fallback_decoder_(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_->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,
@@ skipping 152 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 we have not falled back before.
+      if (!decoder_produced_a_frame_ && !is_on_fallback_decoder_) {
+        is_on_fallback_decoder_ = true;
         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();
@@ skipping 49 matching lines @@
     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;
+  is_on_fallback_decoder_ = false;

[DaleCurtis, 2017/05/04 02:37:24]

Name is a bit off since we clear it here. Not sure of a better one though,

   traits_.OnDecodeDone(output);
 
   // |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 257 matching lines @@
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media