Add PPAPI CDM video decoder initialization.

webkit/plugins/ppapi/ppapi_plugin_instance.cc

 // Copyright (c) 2012 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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor_client.h"
+#include "media/base/video_decoder_config.h"
+#include "media/base/video_frame.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_text_input_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_gamepad.h"
@@ skipping 345 matching lines @@
   for (uint32_t i = 0; i < block_info->num_subsamples; ++i) {
     block_info->subsamples[i].clear_bytes =
         decrypt_config.subsamples()[i].clear_bytes;
     block_info->subsamples[i].cipher_bytes =
         decrypt_config.subsamples()[i].cypher_bytes;
   }
 
   return true;
 }
 
+PP_VideoCodec MediaVideoCodecToPpVideoCodec(media::VideoCodec codec) {
+  switch (codec) {
+    case media::kCodecVP8:
+      return PP_VIDEOCODEC_VP8;
+
+    case media::kCodecH264:
+    case media::kCodecVC1:
+    case media::kCodecMPEG2:
+    case media::kCodecMPEG4:
+    case media::kCodecTheora:

[xhwang, 2012/10/08 17:16:13]

Why do we need to list them all? Is it because if we don't we'll get a compiler
warning? Can we just do:

if (codec == media::kCodecVP8)
  return PP_VIDEOCODEC_VP8;

return PP_VIDEOCODEC_UNKNOWN;

[Tom Finegan, 2012/10/08 23:23:27]

Done.

+    default:
+      NOTREACHED();

[xhwang, 2012/10/08 17:16:13]

By having NOTREACHED() here, we are assuming that the media pipeline never
passes in unsupported codec for initialization. But how can the media pipeline
know which codec is supported? It seems to me that's the responsibility of the
PluginInstance or the CDM. So here, can we just return PP_VIDEOCODEC_UNKNOWN and
remove the NOTREACHED()?

[Tom Finegan, 2012/10/08 23:23:27]

Removed the NOTREACHED (here and in other conversion functions), and removed the
PP_DCHECKs from conversion functions in the wrapper.

+  }
+  return PP_VIDEOCODEC_UNKNOWN;
+}
+
+PP_VideoCodecProfile MediaVideoCodecProfileToPpVideoCodecProfile(
+    media::VideoCodecProfile profile) {
+  switch (profile) {
+    case media::VP8PROFILE_MAIN:
+      return PP_VIDEOCODECPROFILE_VP8_MAIN;
+
+    case media::VIDEO_CODEC_PROFILE_UNKNOWN:
+    case media::H264PROFILE_BASELINE:
+    case media::H264PROFILE_MAIN:
+    case media::H264PROFILE_EXTENDED:
+    case media::H264PROFILE_HIGH:
+    case media::H264PROFILE_HIGH10PROFILE:
+    case media::H264PROFILE_HIGH422PROFILE:
+    case media::H264PROFILE_HIGH444PREDICTIVEPROFILE:
+    case media::H264PROFILE_SCALABLEBASELINE:
+    case media::H264PROFILE_SCALABLEHIGH:
+    case media::H264PROFILE_STEREOHIGH:
+    case media::H264PROFILE_MULTIVIEWHIGH:

[xhwang, 2012/10/08 17:16:13]

ditto

[Tom Finegan, 2012/10/08 23:23:27]

Done.

+    default:
+      NOTREACHED();
+  }
+  return PP_VIDEOCODECPROFILE_UNKNOWN;
+}
+
+PP_DecryptedFrameFormat MediaVideoFormatToPpDecryptedFrameFormat(
+    media::VideoFrame::Format format) {
+  switch (format) {
+    case media::VideoFrame::YV12:
+      return PP_DECRYPTEDFRAMEFORMAT_YV12;
+
+    case media::VideoFrame::I420:
+      return PP_DECRYPTEDFRAMEFORMAT_I420;
+
+    case media::VideoFrame::INVALID:
+    case media::VideoFrame::RGB32:
+    case media::VideoFrame::YV16:
+    case media::VideoFrame::EMPTY:
+    case media::VideoFrame::NATIVE_TEXTURE:

[xhwang, 2012/10/08 17:16:13]

ditto

[Tom Finegan, 2012/10/08 23:23:27]

Done.

[xhwang, 2012/10/09 00:49:08]

This is not done?

[Tom Finegan, 2012/10/09 01:12:42]

Sorry. Missed it, done now.

+    default:
+      NOTREACHED();
+  }
+  return PP_DECRYPTEDFRAMEFORMAT_UNKNOWN;
+}
+
+
 }  // namespace
 
 // static
 PluginInstance* PluginInstance::Create(PluginDelegate* delegate,
                                        PluginModule* module) {
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module);
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined)
@@ skipping 1145 matching lines @@
 
   DCHECK(!ContainsKey(pending_decryption_cbs_, request_id));
   pending_decryption_cbs_.insert(std::make_pair(request_id, decrypt_cb));
 
   plugin_decryption_interface_->Decrypt(pp_instance(),
                                         encrypted_resource,
                                         &block_info);
   return true;
 }
 
-// Note: this method can be used with an unencrypted frame.
+bool PluginInstance::InitializeVideoDecoder(
+    const media::VideoDecoderConfig& decoder_config,
+    const media::Decryptor::DecryptCB& decrypt_cb) {
+  PP_VideoDecoderConfig pp_decoder_config;
+  pp_decoder_config.codec =
+      MediaVideoCodecToPpVideoCodec(decoder_config.codec());

[xhwang, 2012/10/08 17:16:13]

So here if the codec is invalid (unknown), we are still passing them down to the
plugin? But in cdm wrapper, we have a PP_CHECK that the code cannot be unknown.

[Tom Finegan, 2012/10/08 23:23:27]

Done.

+  pp_decoder_config.profile =
+      MediaVideoCodecProfileToPpVideoCodecProfile(decoder_config.profile());
+  pp_decoder_config.format =
+      MediaVideoFormatToPpDecryptedFrameFormat(decoder_config.format());
+  pp_decoder_config.width = decoder_config.coded_size().width();
+  pp_decoder_config.height = decoder_config.coded_size().height();
+  pp_decoder_config.request_id = next_decryption_request_id_++;
+
+  DCHECK(!ContainsKey(pending_decryption_cbs_, pp_decoder_config.request_id));

[xhwang, 2012/10/08 17:16:13]

We'll have at most two pending decoder initialization here, video/audio. Instead
of using a map, how about just use two pending cbs and request id:
pending_video_decoder_init_cb, pending_video_decoder_init_request_id? Later on,
I need to add canceling logic in PluginInstance, so we need to be able to
differentiate video/audio callbacks.

You can also leave this part to me if you want as I am updating
DecryptAndDecodeFrame() in this file.

[Tom Finegan, 2012/10/08 23:23:27]

Added TODO(xhwang).

[xhwang, 2012/10/09 00:49:08]

Thanks!

+  pending_decryption_cbs_.insert(std::make_pair(pp_decoder_config.request_id,
+                                                decrypt_cb));
+
+  ScopedPPResource extra_data_resource(
+      ScopedPPResource::PassRef(),
+      MakeBufferResource(pp_instance(),
+                         decoder_config.extra_data(),
+                         decoder_config.extra_data_size()));
+
+  plugin_decryption_interface_->InitializeVideoDecoder(pp_instance(),
+                                                       &pp_decoder_config,
+                                                       extra_data_resource);
+  return false;

[xhwang, 2012/10/08 17:16:13]

always return false?

[Tom Finegan, 2012/10/08 23:23:27]

Oops! Done.

+}
+
 bool PluginInstance::DecryptAndDecodeFrame(
     const scoped_refptr<media::DecoderBuffer>& encrypted_frame,
     const media::Decryptor::DecryptCB& decrypt_cb) {
   if (!LoadContentDecryptorInterface())
     return false;
 
   ScopedPPResource encrypted_resource(MakeBufferResource(
       pp_instance(),
       encrypted_frame->GetData(),
       encrypted_frame->GetDataSize()));
@@ skipping 712 matching lines @@
   }
 
   DCHECK(decryptor_client_);
   decryptor_client_->KeyError(
       key_system_string->value(),
       session_id_string->value(),
       static_cast<media::Decryptor::KeyError>(media_error),
       system_code);
 }
 
+void PluginInstance::DecoderInitializeStatus(PP_Instance instance,
+                                             PP_Bool success,
+                                             uint32_t request_id) {
+  DecryptionCBMap::iterator found = pending_decryption_cbs_.find(request_id);

[xhwang, 2012/10/08 17:16:13]

ditto, we'll not use map here and use individual variables for pending callback
and request id. Also, use DecoderInitCB instead of DecryptCB.

[Tom Finegan, 2012/10/08 23:23:27]

Added TODO(xhwang).

+  if (found == pending_decryption_cbs_.end())
+    return;
+  media::Decryptor::DecryptCB decrypt_cb = found->second;
+  pending_decryption_cbs_.erase(found);
+
+  media::Decryptor::Status status =
+      success == PP_TRUE ? media::Decryptor::kSuccess :
+                           media::Decryptor::kError;
+  decrypt_cb.Run(status, NULL);
+}
+
 void PluginInstance::DeliverBlock(PP_Instance instance,
                                   PP_Resource decrypted_block,
                                   const PP_DecryptedBlockInfo* block_info) {
   DCHECK(block_info);
   DecryptionCBMap::iterator found = pending_decryption_cbs_.find(
       block_info->tracking_info.request_id);
   if (found == pending_decryption_cbs_.end())
     return;
   media::Decryptor::DecryptCB decrypt_cb = found->second;
   pending_decryption_cbs_.erase(found);
@@ skipping 416 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit