media: Prefer decrypting pipeline when CDM is attached

media/filters/decoder_selector.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_selector.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 22 matching lines @@
       return stream->audio_decoder_config().IsValidConfig();
     case DemuxerStream::VIDEO:
       return stream->video_decoder_config().IsValidConfig();
     case DemuxerStream::TEXT:
     case DemuxerStream::UNKNOWN:
       NOTREACHED();
   }
   return false;
 }
 
-static bool IsStreamEncrypted(DemuxerStream* stream) {
-  switch (stream->type()) {
-    case DemuxerStream::AUDIO:
-      return stream->audio_decoder_config().is_encrypted();
-    case DemuxerStream::VIDEO:
-      return stream->video_decoder_config().is_encrypted();
-    case DemuxerStream::TEXT:
-    case DemuxerStream::UNKNOWN:
-      NOTREACHED();
-  }
-  return false;
-}
-
 template <DemuxerStream::Type StreamType>
 DecoderSelector<StreamType>::DecoderSelector(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<Decoder> decoders,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
       decoders_(std::move(decoders)),
       media_log_(media_log),
       input_stream_(nullptr),
       weak_ptr_factory_(this) {}
@@ skipping 33 matching lines @@
   if (!HasValidStreamConfig(stream)) {
     DLOG(ERROR) << "Invalid stream config.";
     ReturnNullDecoder();
     return;
   }
 
   traits_ = traits;
   input_stream_ = stream;
   output_cb_ = output_cb;
 
-  if (!IsStreamEncrypted(input_stream_)) {
-    InitializeDecoder();
+  // When there is a CDM attached, always try the decrypting decoder or
+  // demuxer-stream first.
+  if (cdm_context_) {
+#if !defined(OS_ANDROID)
+    InitializeDecryptingDecoder();
+#else
+    InitializeDecryptingDemuxerStream();
+#endif
     return;
   }
 
-  // This could be null during fallback after decoder reinitialization failure.
-  // See DecoderStream<StreamType>::OnDecoderReinitialized().
-  if (!cdm_context_) {
-    ReturnNullDecoder();
-    return;
-  }
+  config_ = StreamTraits::GetDecoderConfig(input_stream_);
 
-#if !defined(OS_ANDROID)
-  InitializeDecryptingDecoder();
-#else
-  InitializeDecryptingDemuxerStream();
-#endif
+  // If the input stream is encrypted, CdmContext must be non-null.
+  DCHECK(!config_.is_encrypted());
+
+  InitializeDecoder();
 }
 
 #if !defined(OS_ANDROID)
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::InitializeDecryptingDecoder() {
   DVLOG(2) << __func__;
   decoder_.reset(new typename StreamTraits::DecryptingDecoderType(
       task_runner_, media_log_, waiting_for_decryption_key_cb_));
 
   traits_->InitializeDecoder(
@@ skipping 34 matching lines @@
       base::Bind(&DecoderSelector<StreamType>::DecryptingDemuxerStreamInitDone,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::DecryptingDemuxerStreamInitDone(
     PipelineStatus status) {
   DVLOG(2) << __func__
            << ": status=" << MediaLog::PipelineStatusToString(status);
   DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(cdm_context_);
 
   // If DecryptingDemuxerStream initialization succeeded, we'll use it to do
   // decryption and use a decoder to decode the clear stream. Otherwise, we'll
   // try to see whether any decoder can decrypt-and-decode the encrypted stream
   // directly. So in both cases, we'll initialize the decoders.
 
   if (status == PIPELINE_OK) {
     input_stream_ = decrypted_stream_.get();
-    DCHECK(!IsStreamEncrypted(input_stream_));
+    config_ = StreamTraits::GetDecoderConfig(input_stream_);
+    DCHECK(!config_.is_encrypted());
   } else {
     decrypted_stream_.reset();
-    DCHECK(IsStreamEncrypted(input_stream_));
+    config_ = StreamTraits::GetDecoderConfig(input_stream_);
+
+    // Prefer decrypting decoder by using an encrypted config.
+    if (!config_.is_encrypted())
+      config_.SetIsEncrypted(true);
   }
 
   InitializeDecoder();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::InitializeDecoder() {
   DVLOG(2) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!decoder_);
 
   if (decoders_.empty()) {
     ReturnNullDecoder();
     return;
   }
 
   decoder_.reset(decoders_.front());
   decoders_.weak_erase(decoders_.begin());
 
   traits_->InitializeDecoder(
-      decoder_.get(), StreamTraits::GetDecoderConfig(input_stream_),
+      decoder_.get(), config_,
       input_stream_->liveness() == DemuxerStream::LIVENESS_LIVE, cdm_context_,
       base::Bind(&DecoderSelector<StreamType>::DecoderInitDone,
                  weak_ptr_factory_.GetWeakPtr()),
       output_cb_);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::DecoderInitDone(bool success) {
   DVLOG(2) << __func__ << ": success=" << success;
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 23 matching lines @@
 
 // These forward declarations tell the compiler that we will use
 // DecoderSelector with these arguments, allowing us to keep these definitions
 // in our .cc without causing linker errors. This also means if anyone tries to
 // instantiate a DecoderSelector with anything but these two specializations
 // they'll most likely get linker errors.
 template class DecoderSelector<DemuxerStream::AUDIO>;
 template class DecoderSelector<DemuxerStream::VIDEO>;
 
 }  // namespace media