MediaCodecPlayer implementation - stage 7 (DRM)

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"
@@ skipping 19 matching lines @@
 // 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,

[xhwang, 2015/09/30 18:07:53]

It seems waiting_for_decryption_key_cb is a more common name we use in the code
base for this callback:

https://code.google.com/p/chromium/codesearch#search/&q=waiting_for_decryptio...

[Tima Vaisburd, 2015/09/30 21:24:51]

I prefer to have "waiting..." for states and this callback is rather an event,
as in something happened one time: the absence of key discovered. But I can
change the name, of course, for consistency with other code.

[Tima Vaisburd, 2015/09/30 23:00:50]

Done.

     const base::Closure& error_cb,
     const char* decoder_thread_name)
     : media_task_runner_(media_task_runner),
       decoder_thread_(decoder_thread_name),
       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 19 matching lines @@
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DCHECK_EQ(GetState(), kStopped);
 
   // Flush() is a part of the Seek request. Whenever we request a seek we need
   // to invalidate the current data request.
   if (is_data_request_in_progress_)
     is_incoming_data_invalid_ = true;
 
   eos_enqueued_ = false;
+  key_request_posted_ = false;
   completed_ = false;
   drain_decoder_ = false;
   au_queue_.Flush();
 
   // |is_prepared_| is set on the decoder thread, it shouldn't be running now.
   DCHECK(!decoder_thread_.IsRunning());
   is_prepared_ = false;
 
 #ifndef NDEBUG
   // We check and reset |verify_next_frame_is_key_| on Decoder thread.
@@ skipping 68 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;
 }
 
-base::android::ScopedJavaLocalRef<jobject> MediaCodecDecoder::GetMediaCrypto() {
-  base::android::ScopedJavaLocalRef<jobject> media_crypto;
+void MediaCodecDecoder::SetNeedsReconfigure() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
 
-  // TODO(timav): implement DRM.
-  // drm_bridge_ is not implemented
-  // if (drm_bridge_)
-  //   media_crypto = drm_bridge_->GetMediaCrypto();
-  return media_crypto;
+  DVLOG(1) << class_name() << "::" << __FUNCTION__;
+
+  needs_reconfigure_ = true;
 }
 
 void MediaCodecDecoder::Prefetch(const base::Closure& prefetch_done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DCHECK(GetState() == kStopped);
 
   prefetch_done_cb_ = prefetch_done_cb;
 
   SetState(kPrefetching);
   PrefetchNextChunk();
 }
 
-MediaCodecDecoder::ConfigStatus MediaCodecDecoder::Configure() {
+MediaCodecDecoder::ConfigStatus MediaCodecDecoder::Configure(
+    jobject media_crypto) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   if (GetState() == kError) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state kError";
     return kConfigFailure;
   }
 
   if (needs_reconfigure_) {
@@ skipping 10 matching lines @@
   }
 
   // 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();
+  MediaCodecDecoder::ConfigStatus result = ConfigureInternal(media_crypto);
 
 #ifndef NDEBUG
   // We check and reset |verify_next_frame_is_key_| on Decoder thread.
   // This DCHECK ensures we won't need to lock this variable.
   DCHECK(!decoder_thread_.IsRunning());
 
   // For video the first frame after reconfiguration must be key frame.
   if (result == kConfigOk)
     verify_next_frame_is_key_ = true;
 #endif
@@ skipping 147 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;

[xhwang, 2015/09/30 18:07:53]

Q: In what situation would |key_request_posted_| be true when
OnLastFrameRendered() is called? I thought when |key_request_posted_| is true,
the playback would stall?

[Tima Vaisburd, 2015/09/30 21:24:51]

I'd say the playback would stall but the whole decoder will keep working for
some time. After |key_request_posted_| is set to true we will stop enqueueing
new buffers, but the following DepleteOutputBufferQueue() will be called and
should return true, and we post ProcessNextFrame() over again.

Because of that we would be able to properly process the upcoming stop request:
the ProcessNextFrame() or CheckLastFrame() will eventually see the kStopping
state and will post OnLastFrameRendered(). At least this is what I had in mind.

This OnLastFrameRendered() should see |key_request_posted_| == true.

As I wrote it I realized that we could have made decoder to stop itself, but it
would be the third path: first is by stop request, and second is when the eos
went through decoder.

[xhwang, 2015/10/01 00:04:39]

Acknowledged.

+
   // 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);

[xhwang, 2015/09/30 18:07:53]

Should we check unit.data.empty() somewhere? Otherwise &unit->data[0] could be
invalid...

[Tima Vaisburd, 2015/09/30 23:00:50]

Done.

+  } 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_);

[xhwang, 2015/09/30 18:07:53]

Usually we prefer to letting the callee (the provider of the |key_required_cb|)
make sure the callback is fired on the correct thread. But since we already use
media_task_runner_->PostTask() in various places in this CL this is okay. Just
for future consideration.

[Tima Vaisburd, 2015/09/30 23:00:50]

Acknowledged.

+
+      // 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