src/ppapi/cpp/private/content_decryptor_private.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/cpp/private/content_decryptor_private.h"
   6
   7 #include <cstring>  // memcpy
   8
   9 #include "ppapi/c/ppb_var.h"
  10 #include "ppapi/c/private/ppb_content_decryptor_private.h"
  11 #include "ppapi/c/private/ppp_content_decryptor_private.h"
  12 #include "ppapi/cpp/instance.h"
  13 #include "ppapi/cpp/instance_handle.h"
  14 #include "ppapi/cpp/logging.h"
  15 #include "ppapi/cpp/module.h"
  16 #include "ppapi/cpp/module_impl.h"
  17 #include "ppapi/cpp/var.h"
  18
  19 namespace pp {
  20
  21 namespace {
  22
  23 static const char kPPPContentDecryptorInterface[] =
  24     PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
  25
  26 void Initialize(PP_Instance instance,
  27                 PP_Var key_system_arg) {
  28   void* object =
  29       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  30   if (!object)
  31     return;
  32
  33   pp::Var key_system_var(pp::PASS_REF, key_system_arg);
  34   if (!key_system_var.is_string())
  35     return;
  36
  37   static_cast<ContentDecryptor_Private*>(object)->Initialize(
  38       key_system_var.AsString());
  39 }
  40
  41 void CreateSession(PP_Instance instance,
  42                    uint32_t session_id,
  43                    PP_Var type_arg,
  44                    PP_Var init_data_arg) {
  45   void* object =
  46       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  47   if (!object)
  48     return;
  49
  50   pp::Var type_var(pp::PASS_REF, type_arg);
  51   if (!type_var.is_string())
  52     return;
  53
  54   pp::Var init_data_var(pp::PASS_REF, init_data_arg);
  55   if (!init_data_var.is_array_buffer())
  56     return;
  57   pp::VarArrayBuffer init_data_array_buffer(init_data_var);
  58
  59   static_cast<ContentDecryptor_Private*>(object)
  60       ->CreateSession(session_id, type_var.AsString(), init_data_array_buffer);
  61 }
  62
  63 void UpdateSession(PP_Instance instance,
  64                    uint32_t session_id,
  65                    PP_Var response_arg) {
  66   void* object =
  67       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  68   if (!object)
  69     return;
  70
  71   pp::Var response_var(pp::PASS_REF, response_arg);
  72   if (!response_var.is_array_buffer())
  73     return;
  74   pp::VarArrayBuffer response(response_var);
  75
  76   static_cast<ContentDecryptor_Private*>(object)
  77       ->UpdateSession(session_id, response);
  78 }
  79
  80 void ReleaseSession(PP_Instance instance, uint32_t session_id) {
  81   void* object =
  82       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  83   if (!object)
  84     return;
  85
  86   static_cast<ContentDecryptor_Private*>(object)->ReleaseSession(session_id);
  87 }
  88
  89
  90 void Decrypt(PP_Instance instance,
  91              PP_Resource encrypted_resource,
  92              const PP_EncryptedBlockInfo* encrypted_block_info) {
  93   pp::Buffer_Dev encrypted_block(encrypted_resource);
  94
  95   void* object =
  96       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
  97   if (!object)
  98     return;
  99
 100   static_cast<ContentDecryptor_Private*>(object)->Decrypt(
 101       encrypted_block,
 102       *encrypted_block_info);
 103 }
 104
 105 void InitializeAudioDecoder(
 106     PP_Instance instance,
 107     const PP_AudioDecoderConfig* decoder_config,
 108     PP_Resource extra_data_resource) {
 109   pp::Buffer_Dev extra_data_buffer(extra_data_resource);
 110
 111   void* object =
 112       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 113   if (!object)
 114     return;
 115
 116   static_cast<ContentDecryptor_Private*>(object)->InitializeAudioDecoder(
 117       *decoder_config,
 118       extra_data_buffer);
 119 }
 120
 121 void InitializeVideoDecoder(
 122     PP_Instance instance,
 123     const PP_VideoDecoderConfig* decoder_config,
 124     PP_Resource extra_data_resource) {
 125   pp::Buffer_Dev extra_data_buffer(extra_data_resource);
 126
 127   void* object =
 128       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 129   if (!object)
 130     return;
 131
 132   static_cast<ContentDecryptor_Private*>(object)->InitializeVideoDecoder(
 133       *decoder_config,
 134       extra_data_buffer);
 135 }
 136
 137 void DeinitializeDecoder(PP_Instance instance,
 138                          PP_DecryptorStreamType decoder_type,
 139                          uint32_t request_id) {
 140   void* object =
 141       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 142   if (!object)
 143     return;
 144   static_cast<ContentDecryptor_Private*>(object)->DeinitializeDecoder(
 145       decoder_type,
 146       request_id);
 147 }
 148
 149 void ResetDecoder(PP_Instance instance,
 150                   PP_DecryptorStreamType decoder_type,
 151                   uint32_t request_id) {
 152   void* object =
 153       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 154   if (!object)
 155     return;
 156   static_cast<ContentDecryptor_Private*>(object)->ResetDecoder(decoder_type,
 157                                                                request_id);
 158 }
 159
 160 void DecryptAndDecode(PP_Instance instance,
 161                       PP_DecryptorStreamType decoder_type,
 162                       PP_Resource encrypted_resource,
 163                       const PP_EncryptedBlockInfo* encrypted_block_info) {
 164   pp::Buffer_Dev encrypted_buffer(encrypted_resource);
 165
 166   void* object =
 167       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
 168   if (!object)
 169     return;
 170
 171   static_cast<ContentDecryptor_Private*>(object)->DecryptAndDecode(
 172       decoder_type,
 173       encrypted_buffer,
 174       *encrypted_block_info);
 175 }
 176
 177 const PPP_ContentDecryptor_Private ppp_content_decryptor = {
 178   &Initialize,
 179   &CreateSession,
 180   &UpdateSession,
 181   &ReleaseSession,
 182   &Decrypt,
 183   &InitializeAudioDecoder,
 184   &InitializeVideoDecoder,
 185   &DeinitializeDecoder,
 186   &ResetDecoder,
 187   &DecryptAndDecode
 188 };
 189
 190 template <> const char* interface_name<PPB_ContentDecryptor_Private>() {
 191   return PPB_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
 192 }
 193
 194 }  // namespace
 195
 196 ContentDecryptor_Private::ContentDecryptor_Private(Instance* instance)
 197     : associated_instance_(instance) {
 198   Module::Get()->AddPluginInterface(kPPPContentDecryptorInterface,
 199                                     &ppp_content_decryptor);
 200   instance->AddPerInstanceObject(kPPPContentDecryptorInterface, this);
 201 }
 202
 203 ContentDecryptor_Private::~ContentDecryptor_Private() {
 204   Instance::RemovePerInstanceObject(associated_instance_,
 205                                     kPPPContentDecryptorInterface,
 206                                     this);
 207 }
 208
 209 void ContentDecryptor_Private::SessionCreated(
 210     uint32_t session_id,
 211     const std::string& web_session_id) {
 212   if (has_interface<PPB_ContentDecryptor_Private>()) {
 213     pp::Var web_session_id_var(web_session_id);
 214     get_interface<PPB_ContentDecryptor_Private>()->SessionCreated(
 215         associated_instance_.pp_instance(),
 216         session_id,
 217         web_session_id_var.pp_var());
 218   }
 219 }
 220
 221 void ContentDecryptor_Private::SessionMessage(uint32_t session_id,
 222                                               pp::VarArrayBuffer message,
 223                                               const std::string& default_url) {
 224   if (has_interface<PPB_ContentDecryptor_Private>()) {
 225     pp::Var default_url_var(default_url);
 226     get_interface<PPB_ContentDecryptor_Private>()->SessionMessage(
 227         associated_instance_.pp_instance(),
 228         session_id,
 229         message.pp_var(),
 230         default_url_var.pp_var());
 231   }
 232 }
 233
 234 void ContentDecryptor_Private::SessionReady(uint32_t session_id) {
 235   if (has_interface<PPB_ContentDecryptor_Private>()) {
 236     get_interface<PPB_ContentDecryptor_Private>()->SessionReady(
 237         associated_instance_.pp_instance(), session_id);
 238   }
 239 }
 240
 241 void ContentDecryptor_Private::SessionClosed(uint32_t session_id) {
 242   if (has_interface<PPB_ContentDecryptor_Private>()) {
 243     get_interface<PPB_ContentDecryptor_Private>()->SessionClosed(
 244         associated_instance_.pp_instance(), session_id);
 245   }
 246 }
 247
 248 void ContentDecryptor_Private::SessionError(uint32_t session_id,
 249                                             int32_t media_error,
 250                                             int32_t system_code) {
 251   if (has_interface<PPB_ContentDecryptor_Private>()) {
 252     get_interface<PPB_ContentDecryptor_Private>()->SessionError(
 253         associated_instance_.pp_instance(),
 254         session_id,
 255         media_error,
 256         system_code);
 257   }
 258 }
 259
 260 void ContentDecryptor_Private::DeliverBlock(
 261     pp::Buffer_Dev decrypted_block,
 262     const PP_DecryptedBlockInfo& decrypted_block_info) {
 263   if (has_interface<PPB_ContentDecryptor_Private>()) {
 264     get_interface<PPB_ContentDecryptor_Private>()->DeliverBlock(
 265         associated_instance_.pp_instance(),
 266         decrypted_block.pp_resource(),
 267         &decrypted_block_info);
 268   }
 269 }
 270
 271 void ContentDecryptor_Private::DecoderInitializeDone(
 272     PP_DecryptorStreamType decoder_type,
 273     uint32_t request_id,
 274     bool success) {
 275   if (has_interface<PPB_ContentDecryptor_Private>()) {
 276     get_interface<PPB_ContentDecryptor_Private>()->DecoderInitializeDone(
 277         associated_instance_.pp_instance(),
 278         decoder_type,
 279         request_id,
 280         PP_FromBool(success));
 281   }
 282 }
 283
 284 void ContentDecryptor_Private::DecoderDeinitializeDone(
 285     PP_DecryptorStreamType decoder_type,
 286     uint32_t request_id) {
 287   if (has_interface<PPB_ContentDecryptor_Private>()) {
 288     get_interface<PPB_ContentDecryptor_Private>()->DecoderDeinitializeDone(
 289         associated_instance_.pp_instance(),
 290         decoder_type,
 291         request_id);
 292   }
 293 }
 294
 295 void ContentDecryptor_Private::DecoderResetDone(
 296     PP_DecryptorStreamType decoder_type,
 297     uint32_t request_id) {
 298   if (has_interface<PPB_ContentDecryptor_Private>()) {
 299     get_interface<PPB_ContentDecryptor_Private>()->DecoderResetDone(
 300         associated_instance_.pp_instance(),
 301         decoder_type,
 302         request_id);
 303   }
 304 }
 305
 306 void ContentDecryptor_Private::DeliverFrame(
 307     pp::Buffer_Dev decrypted_frame,
 308     const PP_DecryptedFrameInfo& decrypted_frame_info) {
 309   if (has_interface<PPB_ContentDecryptor_Private>()) {
 310     get_interface<PPB_ContentDecryptor_Private>()->DeliverFrame(
 311         associated_instance_.pp_instance(),
 312         decrypted_frame.pp_resource(),
 313         &decrypted_frame_info);
 314   }
 315 }
 316
 317 void ContentDecryptor_Private::DeliverSamples(
 318     pp::Buffer_Dev audio_frames,
 319     const PP_DecryptedSampleInfo& decrypted_sample_info) {
 320   if (has_interface<PPB_ContentDecryptor_Private>()) {
 321     get_interface<PPB_ContentDecryptor_Private>()->DeliverSamples(
 322         associated_instance_.pp_instance(),
 323         audio_frames.pp_resource(),
 324         &decrypted_sample_info);
 325   }
 326 }
 327
 328 }  // namespace pp