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) {
+  if (codec == media::kCodecVP8)
+    return PP_VIDEOCODEC_VP8;
+
+  return PP_VIDEOCODEC_UNKNOWN;
+}
+
+PP_VideoCodecProfile MediaVideoCodecProfileToPpVideoCodecProfile(
+    media::VideoCodecProfile profile) {
+  if (profile == media::VP8PROFILE_MAIN)
+    return PP_VIDEOCODECPROFILE_VP8_MAIN;
+
+  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:
+    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());
+  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_++;
+
+  // TODO(xhwang): Use individual variables for decoder init request tracking.
+  DCHECK(!ContainsKey(pending_decryption_cbs_, pp_decoder_config.request_id));
+  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 true;
+}
+
 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::DecoderInitialized(PP_Instance instance,
+                                        PP_Bool success,
+                                        uint32_t request_id) {
+  // TODO(xhwang): Use individual variables for decoder init request tracking.
+  DecryptionCBMap::iterator found = pending_decryption_cbs_.find(request_id);
+  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