Prepare MediaDrmBridge to work with MediaCodecPlayer

media/base/android/media_codec_decoder.cc

 // Copyright 2015 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/base/android/media_codec_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "media/base/android/media_codec_bridge.h"
+#include "media/base/android/media_drm_bridge.h"
 
 namespace media {
 
 namespace {
 
 // Stop requesting new data in the kPrefetching state when the queue size
 // reaches this limit.
 const int kPrefetchLimit = 8;
 
 // Request new data in the kRunning state if the queue size is less than this.
 const int kPlaybackLowLimit = 4;
 
 // Posting delay of the next frame processing, in milliseconds
 const int kNextFrameDelay = 1;
 
 // Timeout for dequeuing an input buffer from MediaCodec in milliseconds.
 const int kInputBufferTimeout = 20;
 
 // Timeout for dequeuing an output buffer from MediaCodec in milliseconds.
 const int kOutputBufferTimeout = 20;
 }
 
 MediaCodecDecoder::MediaCodecDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const base::Closure& external_request_data_cb,
     const base::Closure& starvation_cb,
     const base::Closure& decoder_drained_cb,
     const base::Closure& stop_done_cb,
+    const base::Closure& key_required_cb,
     const base::Closure& error_cb,
     const char* decoder_thread_name)
     : media_task_runner_(media_task_runner),
       decoder_thread_(decoder_thread_name),
+      drm_bridge_(nullptr),
       needs_reconfigure_(false),
       drain_decoder_(false),
       always_reconfigure_for_tests_(false),
       external_request_data_cb_(external_request_data_cb),
       starvation_cb_(starvation_cb),
       decoder_drained_cb_(decoder_drained_cb),
       stop_done_cb_(stop_done_cb),
+      key_required_cb_(key_required_cb),
       error_cb_(error_cb),
       state_(kStopped),
       is_prepared_(false),
       eos_enqueued_(false),
+      key_request_posted_(false),
       completed_(false),
       last_frame_posted_(false),
       is_data_request_in_progress_(false),
       is_incoming_data_invalid_(false),
 #ifndef NDEBUG
       verify_next_frame_is_key_(false),
 #endif
       weak_factory_(this) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
@@ skipping 107 matching lines @@
          (!is_prepared_ || preroll_timestamp_ != base::TimeDelta());
 }
 
 void MediaCodecDecoder::SetPrerollTimestamp(base::TimeDelta preroll_timestamp) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << ": " << preroll_timestamp;
 
   preroll_timestamp_ = preroll_timestamp;
 }
 
+void MediaCodecDecoder::SetDrmBridge(MediaDrmBridge* drm_bridge) {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  DVLOG(1) << class_name() << "::" << __FUNCTION__;
+
+  drm_bridge_ = drm_bridge;
+
+  needs_reconfigure_ = true;
+}
+
 base::android::ScopedJavaLocalRef<jobject> MediaCodecDecoder::GetMediaCrypto() {
   base::android::ScopedJavaLocalRef<jobject> media_crypto;
-
-  // TODO(timav): implement DRM.
-  // drm_bridge_ is not implemented
-  // if (drm_bridge_)
-  //   media_crypto = drm_bridge_->GetMediaCrypto();
+  if (drm_bridge_)
+    media_crypto = drm_bridge_->GetMediaCrypto();
   return media_crypto;
 }
 
 void MediaCodecDecoder::Prefetch(const base::Closure& prefetch_done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DCHECK(GetState() == kStopped);
 
@@ skipping 19 matching lines @@
     needs_reconfigure_ = false;
     ReleaseMediaCodec();
   }
 
   if (media_codec_bridge_) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__
              << ": reconfiguration is not required, ignoring";
     return kConfigOk;
   }
 
+  if (IsContentEncrypted() && GetMediaCrypto().is_null()) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__
+             << ": MediaCrypto is missing";
+    return kConfigNoCrypto;
+  }
+
   // Read all |kConfigChanged| units preceding the data one.
   AccessUnitQueue::Info au_info = au_queue_.GetInfo();
   while (au_info.configs) {
     SetDemuxerConfigs(*au_info.configs);
     au_queue_.Advance();
     au_info = au_queue_.GetInfo();
   }
 
   MediaCodecDecoder::ConfigStatus result = ConfigureInternal();
 
@@ skipping 156 matching lines @@
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__
            << " eos_encountered:" << eos_encountered;
 
   decoder_thread_.Stop();  // synchronous
 
   SetState(kStopped);
   completed_ = (eos_encountered && !drain_decoder_);
 
+  key_request_posted_ = false;
+
   // If the stream is completed during preroll we need to report it since
   // another stream might be running and the player waits for two callbacks.
   if (completed_ && !preroll_done_cb_.is_null()) {
     preroll_timestamp_ = base::TimeDelta();
     media_task_runner_->PostTask(FROM_HERE,
                                  base::ResetAndReturn(&preroll_done_cb_));
   }
 
   if (eos_encountered && drain_decoder_) {
     drain_decoder_ = false;
@@ skipping 77 matching lines @@
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   // After this method returns, decoder thread will not be running.
 
   // Set [kInEmergencyStop| state to block already posted ProcessNextFrame().
   SetState(kInEmergencyStop);
 
   decoder_thread_.Stop();  // synchronous
 
   SetState(kStopped);
+
+  key_request_posted_ = false;
 }
 
 void MediaCodecDecoder::CheckLastFrame(bool eos_encountered,
                                        bool has_delayed_tasks) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   bool last_frame_when_stopping = GetState() == kStopping && !has_delayed_tasks;
 
   if (last_frame_when_stopping || eos_encountered) {
     media_task_runner_->PostTask(
@@ skipping 100 matching lines @@
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   DVLOG(2) << class_name() << "::" << __FUNCTION__;
 
   if (eos_enqueued_) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__
              << ": eos_enqueued, returning";
     return true;  // Nothing to do
   }
 
+  if (key_request_posted_) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__
+             << ": key_request_posted, returning";
+    return true;  // Nothing to do
+  }
+
   // Keep the number pending video frames low, ideally maintaining
   // the same audio and video duration after stop request
   if (NumDelayedRenderTasks() > 1) {
     DVLOG(2) << class_name() << "::" << __FUNCTION__ << ": # delayed buffers ("
              << NumDelayedRenderTasks() << ") exceeds 1, returning";
     return true;  // Nothing to do
   }
 
   // Get the next frame from the queue. As we go, request more data and
   // consume |kConfigChanged| units.
@@ skipping 57 matching lines @@
 
   if (drain_decoder_ || unit->is_end_of_stream) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__ << ": QueueEOS";
     media_codec_bridge_->QueueEOS(index);
     eos_enqueued_ = true;
     return true;
   }
 
   DCHECK(unit);
 
-  DVLOG(2) << class_name() << "::" << __FUNCTION__
-           << ": QueueInputBuffer pts:" << unit->timestamp;
+  if (unit->key_id.empty() || unit->iv.empty()) {
+    DVLOG(2) << class_name() << "::" << __FUNCTION__
+             << ": QueueInputBuffer pts:" << unit->timestamp;
 
-  status = media_codec_bridge_->QueueInputBuffer(
-      index, &unit->data[0], unit->data.size(), unit->timestamp);
+    status = media_codec_bridge_->QueueInputBuffer(
+        index, &unit->data[0], unit->data.size(), unit->timestamp);
+  } else {
+    DVLOG(2) << class_name() << "::" << __FUNCTION__
+             << ": QueueSecureInputBuffer pts:" << unit->timestamp
+             << " key_id size:" << unit->key_id.size()
+             << " iv size:" << unit->iv.size()
+             << " subsamples size:" << unit->subsamples.size();
 
-  if (status == MEDIA_CODEC_ERROR) {
-    DVLOG(0) << class_name() << "::" << __FUNCTION__
-             << ": MEDIA_CODEC_ERROR: QueueInputBuffer failed";
-    media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
-    return false;
+    status = media_codec_bridge_->QueueSecureInputBuffer(
+        index, &unit->data[0], unit->data.size(),
+        reinterpret_cast<const uint8_t*>(&unit->key_id[0]), unit->key_id.size(),
+        reinterpret_cast<const uint8_t*>(&unit->iv[0]), unit->iv.size(),
+        unit->subsamples.empty() ? nullptr : &unit->subsamples[0],
+        unit->subsamples.size(), unit->timestamp);
+  }
+
+  switch (status) {
+    case MEDIA_CODEC_OK:
+      break;
+
+    case MEDIA_CODEC_ERROR:
+      DVLOG(0) << class_name() << "::" << __FUNCTION__
+               << ": MEDIA_CODEC_ERROR: QueueInputBuffer failed";
+      media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
+      return false;
+
+    case MEDIA_CODEC_NO_KEY:
+      DVLOG(1) << class_name() << "::" << __FUNCTION__
+               << ": MEDIA_CODEC_NO_KEY";
+      media_task_runner_->PostTask(FROM_HERE, key_required_cb_);
+
+      // In response to the |key_required_cb_| the player will request to stop
+      // decoder. We need to keep running to properly perform the stop, but
+      // prevent enqueuing the same frame over and over again so we won't
+      // generate more |key_required_cb_|.
+      key_request_posted_ = true;
+      return true;
+
+    default:
+      NOTREACHED() << class_name() << "::" << __FUNCTION__
+                   << ": unexpected error code " << status;
+      media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
+      return false;
   }
 
   // Have successfully queued input buffer, go to next access unit.
   au_queue_.Advance();
   return true;
 }
 
 AccessUnitQueue::Info MediaCodecDecoder::AdvanceAccessUnitQueue(
     bool* drain_decoder) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
@@ skipping 177 matching lines @@
     RETURN_STRING(kStopping);
     RETURN_STRING(kInEmergencyStop);
     RETURN_STRING(kError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media