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 GenerateKeyRequest(PP_Instance instance, 27 PP_Var key_system_arg, 28 PP_Var type_arg, 29 PP_Var init_data_arg) { 30 void* object = 31 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 32 if (!object) 33 return; 34 35 pp::Var key_system_var(pp::PASS_REF, key_system_arg); 36 if (!key_system_var.is_string()) 37 return; 38 39 pp::Var type_var(pp::PASS_REF, type_arg); 40 if (!type_var.is_string()) 41 return; 42 43 pp::Var init_data_var(pp::PASS_REF, init_data_arg); 44 if (!init_data_var.is_array_buffer()) 45 return; 46 pp::VarArrayBuffer init_data_array_buffer(init_data_var); 47 48 static_cast<ContentDecryptor_Private*>(object)->GenerateKeyRequest( 49 key_system_var.AsString(), 50 type_var.AsString(), 51 init_data_array_buffer); 52 } 53 54 void AddKey(PP_Instance instance, 55 PP_Var session_id_arg, 56 PP_Var key_arg, 57 PP_Var init_data_arg) { 58 void* object = 59 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 60 if (!object) 61 return; 62 63 pp::Var session_id_var(pp::PASS_REF, session_id_arg); 64 if (!session_id_var.is_string()) 65 return; 66 67 pp::Var key_var(pp::PASS_REF, key_arg); 68 if (!key_var.is_array_buffer()) 69 return; 70 pp::VarArrayBuffer key(key_var); 71 72 pp::Var init_data_var(pp::PASS_REF, init_data_arg); 73 if (!init_data_var.is_array_buffer()) 74 return; 75 pp::VarArrayBuffer init_data(init_data_var); 76 77 78 static_cast<ContentDecryptor_Private*>(object)->AddKey( 79 session_id_var.AsString(), 80 key, 81 init_data); 82 } 83 84 void CancelKeyRequest(PP_Instance instance, PP_Var session_id_arg) { 85 void* object = 86 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 87 if (!object) 88 return; 89 90 pp::Var session_id_var(pp::PASS_REF, session_id_arg); 91 if (!session_id_var.is_string()) 92 return; 93 94 static_cast<ContentDecryptor_Private*>(object)->CancelKeyRequest( 95 session_id_var.AsString()); 96 } 97 98 99 void Decrypt(PP_Instance instance, 100 PP_Resource encrypted_resource, 101 const PP_EncryptedBlockInfo* encrypted_block_info) { 102 pp::Buffer_Dev encrypted_block(encrypted_resource); 103 104 void* object = 105 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 106 if (!object) 107 return; 108 109 static_cast<ContentDecryptor_Private*>(object)->Decrypt( 110 encrypted_block, 111 *encrypted_block_info); 112 } 113 114 void InitializeAudioDecoder( 115 PP_Instance instance, 116 const PP_AudioDecoderConfig* decoder_config, 117 PP_Resource extra_data_resource) { 118 pp::Buffer_Dev extra_data_buffer(extra_data_resource); 119 120 void* object = 121 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 122 if (!object) 123 return; 124 125 static_cast<ContentDecryptor_Private*>(object)->InitializeAudioDecoder( 126 *decoder_config, 127 extra_data_buffer); 128 } 129 130 void InitializeVideoDecoder( 131 PP_Instance instance, 132 const PP_VideoDecoderConfig* decoder_config, 133 PP_Resource extra_data_resource) { 134 pp::Buffer_Dev extra_data_buffer(extra_data_resource); 135 136 void* object = 137 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 138 if (!object) 139 return; 140 141 static_cast<ContentDecryptor_Private*>(object)->InitializeVideoDecoder( 142 *decoder_config, 143 extra_data_buffer); 144 } 145 146 void DeinitializeDecoder(PP_Instance instance, 147 PP_DecryptorStreamType decoder_type, 148 uint32_t request_id) { 149 void* object = 150 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 151 if (!object) 152 return; 153 static_cast<ContentDecryptor_Private*>(object)->DeinitializeDecoder( 154 decoder_type, 155 request_id); 156 } 157 158 void ResetDecoder(PP_Instance instance, 159 PP_DecryptorStreamType decoder_type, 160 uint32_t request_id) { 161 void* object = 162 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 163 if (!object) 164 return; 165 static_cast<ContentDecryptor_Private*>(object)->ResetDecoder(decoder_type, 166 request_id); 167 } 168 169 void DecryptAndDecode(PP_Instance instance, 170 PP_DecryptorStreamType decoder_type, 171 PP_Resource encrypted_resource, 172 const PP_EncryptedBlockInfo* encrypted_block_info) { 173 pp::Buffer_Dev encrypted_buffer(encrypted_resource); 174 175 void* object = 176 Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface); 177 if (!object) 178 return; 179 180 static_cast<ContentDecryptor_Private*>(object)->DecryptAndDecode( 181 decoder_type, 182 encrypted_buffer, 183 *encrypted_block_info); 184 } 185 186 const PPP_ContentDecryptor_Private ppp_content_decryptor = { 187 &GenerateKeyRequest, 188 &AddKey, 189 &CancelKeyRequest, 190 &Decrypt, 191 &InitializeAudioDecoder, 192 &InitializeVideoDecoder, 193 &DeinitializeDecoder, 194 &ResetDecoder, 195 &DecryptAndDecode 196 }; 197 198 template <> const char* interface_name<PPB_ContentDecryptor_Private>() { 199 return PPB_CONTENTDECRYPTOR_PRIVATE_INTERFACE; 200 } 201 202 } // namespace 203 204 ContentDecryptor_Private::ContentDecryptor_Private(Instance* instance) 205 : associated_instance_(instance) { 206 Module::Get()->AddPluginInterface(kPPPContentDecryptorInterface, 207 &ppp_content_decryptor); 208 instance->AddPerInstanceObject(kPPPContentDecryptorInterface, this); 209 } 210 211 ContentDecryptor_Private::~ContentDecryptor_Private() { 212 Instance::RemovePerInstanceObject(associated_instance_, 213 kPPPContentDecryptorInterface, 214 this); 215 } 216 217 void ContentDecryptor_Private::NeedKey(const std::string& key_system, 218 const std::string& session_id, 219 pp::VarArrayBuffer init_data) { 220 // session_id can be empty here. 221 if (has_interface<PPB_ContentDecryptor_Private>()) { 222 pp::Var key_system_var(key_system); 223 pp::Var session_id_var(session_id); 224 225 get_interface<PPB_ContentDecryptor_Private>()->NeedKey( 226 associated_instance_.pp_instance(), 227 key_system_var.pp_var(), 228 session_id_var.pp_var(), 229 init_data.pp_var()); 230 } 231 } 232 233 void ContentDecryptor_Private::KeyAdded(const std::string& key_system, 234 const std::string& session_id) { 235 if (has_interface<PPB_ContentDecryptor_Private>()) { 236 pp::Var key_system_var(key_system); 237 pp::Var session_id_var(session_id); 238 get_interface<PPB_ContentDecryptor_Private>()->KeyAdded( 239 associated_instance_.pp_instance(), 240 key_system_var.pp_var(), 241 session_id_var.pp_var()); 242 } 243 } 244 245 void ContentDecryptor_Private::KeyMessage(const std::string& key_system, 246 const std::string& session_id, 247 pp::VarArrayBuffer message, 248 const std::string& default_url) { 249 if (has_interface<PPB_ContentDecryptor_Private>()) { 250 pp::Var key_system_var(key_system); 251 pp::Var session_id_var(session_id); 252 pp::Var default_url_var(default_url); 253 get_interface<PPB_ContentDecryptor_Private>()->KeyMessage( 254 associated_instance_.pp_instance(), 255 key_system_var.pp_var(), 256 session_id_var.pp_var(), 257 message.pp_var(), 258 default_url_var.pp_var()); 259 } 260 } 261 262 void ContentDecryptor_Private::KeyError(const std::string& key_system, 263 const std::string& session_id, 264 int32_t media_error, 265 int32_t system_code) { 266 if (has_interface<PPB_ContentDecryptor_Private>()) { 267 pp::Var key_system_var(key_system); 268 pp::Var session_id_var(session_id); 269 get_interface<PPB_ContentDecryptor_Private>()->KeyError( 270 associated_instance_.pp_instance(), 271 key_system_var.pp_var(), 272 session_id_var.pp_var(), 273 media_error, 274 system_code); 275 } 276 } 277 278 void ContentDecryptor_Private::DeliverBlock( 279 pp::Buffer_Dev decrypted_block, 280 const PP_DecryptedBlockInfo& decrypted_block_info) { 281 if (has_interface<PPB_ContentDecryptor_Private>()) { 282 get_interface<PPB_ContentDecryptor_Private>()->DeliverBlock( 283 associated_instance_.pp_instance(), 284 decrypted_block.pp_resource(), 285 &decrypted_block_info); 286 } 287 } 288 289 void ContentDecryptor_Private::DecoderInitializeDone( 290 PP_DecryptorStreamType decoder_type, 291 uint32_t request_id, 292 bool success) { 293 if (has_interface<PPB_ContentDecryptor_Private>()) { 294 get_interface<PPB_ContentDecryptor_Private>()->DecoderInitializeDone( 295 associated_instance_.pp_instance(), 296 decoder_type, 297 request_id, 298 PP_FromBool(success)); 299 } 300 } 301 302 void ContentDecryptor_Private::DecoderDeinitializeDone( 303 PP_DecryptorStreamType decoder_type, 304 uint32_t request_id) { 305 if (has_interface<PPB_ContentDecryptor_Private>()) { 306 get_interface<PPB_ContentDecryptor_Private>()->DecoderDeinitializeDone( 307 associated_instance_.pp_instance(), 308 decoder_type, 309 request_id); 310 } 311 } 312 313 void ContentDecryptor_Private::DecoderResetDone( 314 PP_DecryptorStreamType decoder_type, 315 uint32_t request_id) { 316 if (has_interface<PPB_ContentDecryptor_Private>()) { 317 get_interface<PPB_ContentDecryptor_Private>()->DecoderResetDone( 318 associated_instance_.pp_instance(), 319 decoder_type, 320 request_id); 321 } 322 } 323 324 void ContentDecryptor_Private::DeliverFrame( 325 pp::Buffer_Dev decrypted_frame, 326 const PP_DecryptedFrameInfo& decrypted_frame_info) { 327 if (has_interface<PPB_ContentDecryptor_Private>()) { 328 get_interface<PPB_ContentDecryptor_Private>()->DeliverFrame( 329 associated_instance_.pp_instance(), 330 decrypted_frame.pp_resource(), 331 &decrypted_frame_info); 332 } 333 } 334 335 void ContentDecryptor_Private::DeliverSamples( 336 pp::Buffer_Dev audio_frames, 337 const PP_DecryptedBlockInfo& decrypted_block_info) { 338 if (has_interface<PPB_ContentDecryptor_Private>()) { 339 get_interface<PPB_ContentDecryptor_Private>()->DeliverSamples( 340 associated_instance_.pp_instance(), 341 audio_frames.pp_resource(), 342 &decrypted_block_info); 343 } 344 } 345 346 } // namespace pp 347
