Configure MediaCodec with CDM in ADVA

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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 "content/common/gpu/media/android_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
@@ skipping 54 matching lines @@
     const base::Callback<bool(void)>& make_context_current,
     scoped_ptr<BackingStrategy> strategy)
     : client_(NULL),
       make_context_current_(make_context_current),
       codec_(media::kCodecH264),
       is_encrypted_(false),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       gl_decoder_(decoder),
       strategy_(strategy.Pass()),
+      cdm_registration_id_(0),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+#if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
+  if (cdm_) {
+    DCHECK(cdm_registration_id_);
+    static_cast<media::MediaDrmBridge*>(cdm_.get())
+        ->UnregisterPlayer(cdm_registration_id_);
+  }
+#endif  // defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 bool AndroidVideoDecodeAccelerator::Initialize(const Config& config,
                                                Client* client) {
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Initialize");
 
   DVLOG(1) << __FUNCTION__ << ": profile:" << config.profile
            << " is_encrypted:" << config.is_encrypted;
 
+  DCHECK(client);
   client_ = client;
   codec_ = VideoCodecProfileToVideoCodec(config.profile);
   is_encrypted_ = config.is_encrypted;
 
   bool profile_supported = codec_ == media::kCodecVP8;
 #if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
   profile_supported |=
       (codec_ == media::kCodecVP9 || codec_ == media::kCodecH264);
 #endif
 
@@ skipping 19 matching lines @@
 
   if (!gl_decoder_) {
     LOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
   strategy_->Initialize(this);
 
   surface_texture_ = strategy_->CreateSurfaceTexture();
 
-  if (!ConfigureMediaCodec()) {
-    LOG(ERROR) << "Failed to create MediaCodec instance.";
-    return false;
-  }
+  // For encrypted streams we postpone configuration until MediaCrypto is
+  // available.
+  if (is_encrypted_)
+    return true;
 
-  return true;
+  return ConfigureMediaCodec();
 }
 
 void AndroidVideoDecodeAccelerator::SetCdm(int cdm_id) {
   DVLOG(2) << __FUNCTION__ << ": " << cdm_id;
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
-  // TODO(timav): Implement CDM setting here. See http://crbug.com/542417
-  scoped_refptr<media::MediaKeys> cdm = media::MojoCdmService::GetCdm(cdm_id);
-  DCHECK(cdm);
-#endif
+  using media::MediaDrmBridge;
+
+  // This medhod must be called after Initialize().
+  DCHECK(client_);

[xhwang, 2015/12/04 23:24:09]

Put the comment in the DCHECK statement:

DCHECK(client_) << "SetCdm() must be called after Initialize().";

[Tima Vaisburd, 2015/12/05 01:35:25]

Done.

+
+  if (cdm_) {
+    NOTREACHED() << "We do not support resetting CDM.";
+    NotifyCdmAttached(false);
+    return;
+  }
+
+  cdm_ = media::MojoCdmService::GetCdm(cdm_id);
+  DCHECK(cdm_);
+
+  // On Android platform the MediaKeys will be its subclass MediaDrmBridge.
+  MediaDrmBridge* drm_bridge = static_cast<MediaDrmBridge*>(cdm_.get());
+
+  // Register CDM callbacks. The callbacks registered will be posted back to
+  // this thread via BindToCurrentLoop.
+
+  // Since |this| holds a reference to the |cdm_|, by the time the CDM is
+  // destructed, UnregisterPlayer() must have been called and |this| has been
+  // destructed as well. So the |cdm_unset_cb| will never have a chance to be
+  // called.
+  // TODO(xhwang): Remove |cdm_unset_cb| after it's not used on all platforms.
+  cdm_registration_id_ =
+      drm_bridge->RegisterPlayer(media::BindToCurrentLoop(base::Bind(
+                                     &AndroidVideoDecodeAccelerator::OnKeyAdded,
+                                     weak_this_factory_.GetWeakPtr())),
+                                 base::Bind(&base::DoNothing));

[xhwang, 2015/12/04 23:24:09]

add include for DoNothing()?

[Tima Vaisburd, 2015/12/05 01:35:25]

Done.

+
+  drm_bridge->SetMediaCryptoReadyCB(media::BindToCurrentLoop(
+      base::Bind(&AndroidVideoDecodeAccelerator::OnMediaCryptoReady,
+                 weak_this_factory_.GetWeakPtr())));
+
+  // Postpone NotifyCdmAttached() call till we create the MediaCodec after
+  // OnMediaCryptoReady().
+
+#else
 
   NOTIMPLEMENTED();
   NotifyCdmAttached(false);
+
+#endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 void AndroidVideoDecodeAccelerator::DoIOTask() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DoIOTask");
   if (state_ == ERROR) {
     return;
   }
 
   QueueInput();
@@ skipping 16 matching lines @@
     DCHECK(status == media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER ||
            status == media::MEDIA_CODEC_ERROR);
     return;
   }
 
   base::Time queued_time = pending_bitstream_buffers_.front().second;
   UMA_HISTOGRAM_TIMES("Media.AVDA.InputQueueTime",
                       base::Time::Now() - queued_time);
   media::BitstreamBuffer bitstream_buffer =
       pending_bitstream_buffers_.front().first;
-  pending_bitstream_buffers_.pop();
-  TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
-                 pending_bitstream_buffers_.size());
 
   if (bitstream_buffer.id() == -1) {
+    pending_bitstream_buffers_.pop();
+    TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
+                   pending_bitstream_buffers_.size());
+
     media_codec_->QueueEOS(input_buf_index);
     return;
   }
 
   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(bitstream_buffer.handle(), true));
   RETURN_ON_FAILURE(this, shm->Map(bitstream_buffer.size()),
                     "Failed to SharedMemory::Map()", UNREADABLE_INPUT);
 
   const base::TimeDelta presentation_timestamp =
@@ skipping 19 matching lines @@
     status = media_codec_->QueueInputBuffer(input_buf_index, memory,
                                             bitstream_buffer.size(),
                                             presentation_timestamp);
   } else {
     status = media_codec_->QueueSecureInputBuffer(
         input_buf_index, memory, bitstream_buffer.size(), key_id, iv,
         subsamples, presentation_timestamp);
   }
 
   DVLOG(2) << __FUNCTION__
-           << ": QueueInputBuffer: pts:" << presentation_timestamp
+           << ": Queue(Secure)InputBuffer: pts:" << presentation_timestamp
            << " status:" << status;
 
+  if (status == media::MEDIA_CODEC_NO_KEY)
+    return;  // keep trying to enqueue the front pending buffer
+
+  pending_bitstream_buffers_.pop();
+  TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
+                 pending_bitstream_buffers_.size());
+
   RETURN_ON_FAILURE(this, status == media::MEDIA_CODEC_OK,
                     "Failed to QueueInputBuffer: " << status, PLATFORM_FAILURE);
 
   // We should call NotifyEndOfBitstreamBuffer(), when no more decoded output
   // will be returned from the bitstream buffer. However, MediaCodec API is
   // not enough to guarantee it.
   // So, here, we calls NotifyEndOfBitstreamBuffer() in advance in order to
   // keep getting more bitstreams from the client, and throttle them by using
   // |bitstreams_notified_in_advance_|.
   // TODO(dwkang): check if there is a way to remove this workaround.
@@ skipping 243 matching lines @@
   Decode(media::BitstreamBuffer(-1, base::SharedMemoryHandle(), 0));
 }
 
 bool AndroidVideoDecodeAccelerator::ConfigureMediaCodec() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_texture_.get());
   TRACE_EVENT0("media", "AVDA::ConfigureMediaCodec");
 
   gfx::ScopedJavaSurface surface(surface_texture_.get());
 
+  jobject media_crypto = media_crypto_ ? media_crypto_->obj() : nullptr;
+
   // Pass a dummy 320x240 canvas size and let the codec signal the real size
   // when it's known from the bitstream.
   media_codec_.reset(media::VideoCodecBridge::CreateDecoder(
-      codec_, false, gfx::Size(320, 240), surface.j_surface().obj(), NULL));
+      codec_, false, gfx::Size(320, 240), surface.j_surface().obj(),
+      media_crypto));
   strategy_->CodecChanged(media_codec_.get(), output_picture_buffers_);
-  if (!media_codec_)
+  if (!media_codec_) {
+    LOG(ERROR) << "Failed to create MediaCodec instance.";
     return false;
+  }
 
   io_timer_.Start(FROM_HERE,
                   DecodePollDelay(),
                   this,
                   &AndroidVideoDecodeAccelerator::DoIOTask);
   return true;
 }
 
 void AndroidVideoDecodeAccelerator::Reset() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 74 matching lines @@
 
 void AndroidVideoDecodeAccelerator::PostError(
     const ::tracked_objects::Location& from_here,
     media::VideoDecodeAccelerator::Error error) {
   base::MessageLoop::current()->PostTask(
       from_here, base::Bind(&AndroidVideoDecodeAccelerator::NotifyError,
                             weak_this_factory_.GetWeakPtr(), error));
   state_ = ERROR;
 }
 
+void AndroidVideoDecodeAccelerator::OnMediaCryptoReady(
+    media::MediaDrmBridge::JavaObjectPtr media_crypto,
+    bool needs_protected_surface) {
+  DVLOG(1) << __FUNCTION__;
+
+  if (!media_crypto) {
+    LOG(ERROR) << "MediaCrypto is not available, can't play encrypted stream.";
+    NotifyCdmAttached(false);
+    return;
+  }
+
+  DCHECK(!media_crypto->is_null());
+
+  // We assume this is a part of the initialization process, thus MediaCodec
+  // is not created yet.
+  DCHECK(!media_codec_);
+
+  if (needs_protected_surface) {
+    LOG(ERROR) << "Protected surface is not supported.";

[xhwang, 2015/12/04 23:24:09]

Is this NOTIMPLEMENTED() as well?

[Tima Vaisburd, 2015/12/05 01:35:25]

Yes, and actually, the codec part is easy to implement (just pass the flag),
which I did. If the surface does not satisfy the security requirements,
VideoCodecBridge::CreateDecoder() just fails.

+    NotifyCdmAttached(false);
+    return;
+  }
+
+  media_crypto_ = media_crypto.Pass();
+
+  // After receiving |media_crypto_| we can configure MediaCodec.
+  const bool success = ConfigureMediaCodec();
+  NotifyCdmAttached(success);
+}
+
+void AndroidVideoDecodeAccelerator::OnKeyAdded() {
+  DVLOG(1) << __FUNCTION__;
+}
+
 void AndroidVideoDecodeAccelerator::NotifyCdmAttached(bool success) {
   client_->NotifyCdmAttached(success);
 }
 
 void AndroidVideoDecodeAccelerator::NotifyPictureReady(
     const media::Picture& picture) {
   client_->PictureReady(picture);
 }
 
 void AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
@@ skipping 47 matching lines @@
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
 #endif
 
   return profiles;
 }
 
 }  // namespace content