media/base/android/media_drm_bridge.cc

   1 // Copyright (c) 2013 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 "media/base/android/media_drm_bridge.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/android/build_info.h"
  10 #include "base/android/jni_array.h"
  11 #include "base/android/jni_string.h"
  12 #include "base/callback_helpers.h"
  13 #include "base/containers/hash_tables.h"
  14 #include "base/lazy_instance.h"
  15 #include "base/location.h"
  16 #include "base/logging.h"
  17 #include "base/message_loop/message_loop_proxy.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/sys_byteorder.h"
  20 #include "jni/MediaDrmBridge_jni.h"
  21
  22 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
  23
  24 using base::android::AttachCurrentThread;
  25 using base::android::ConvertUTF8ToJavaString;
  26 using base::android::ConvertJavaStringToUTF8;
  27 using base::android::JavaByteArrayToByteVector;
  28 using base::android::ScopedJavaLocalRef;
  29
  30 namespace media {
  31
  32 static uint32 ReadUint32(const uint8_t* data) {
  33   uint32 value = 0;
  34   for (int i = 0; i < 4; ++i)
  35     value = (value << 8) | data[i];
  36   return value;
  37 }
  38
  39 static uint64 ReadUint64(const uint8_t* data) {
  40   uint64 value = 0;
  41   for (int i = 0; i < 8; ++i)
  42     value = (value << 8) | data[i];
  43   return value;
  44 }
  45
  46 // The structure of an ISO CENC Protection System Specific Header (PSSH) box is
  47 // as follows. (See ISO/IEC FDIS 23001-7:2011(E).)
  48 // Note: ISO boxes use big-endian values.
  49 //
  50 // PSSH {
  51 //   uint32 Size
  52 //   uint32 Type
  53 //   uint64 LargeSize  # Field is only present if value(Size) == 1.
  54 //   uint32 VersionAndFlags
  55 //   uint8[16] SystemId
  56 //   uint32 DataSize
  57 //   uint8[DataSize] Data
  58 // }
  59 const int kBoxHeaderSize = 8;  // Box's header contains Size and Type.
  60 const int kBoxLargeSizeSize = 8;
  61 const int kPsshVersionFlagSize = 4;
  62 const int kPsshSystemIdSize = 16;
  63 const int kPsshDataSizeSize = 4;
  64 const uint32 kTencType = 0x74656e63;
  65 const uint32 kPsshType = 0x70737368;
  66 const uint8 kWidevineUuid[16] = {
  67     0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
  68     0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
  69
  70 typedef std::vector<uint8> UUID;
  71
  72 class KeySystemUuidManager {
  73  public:
  74   KeySystemUuidManager();
  75   UUID GetUUID(const std::string& key_system);
  76   void AddMapping(const std::string& key_system, const UUID& uuid);
  77   std::vector<std::string> GetPlatformKeySystemNames();
  78
  79  private:
  80   typedef base::hash_map<std::string, UUID> KeySystemUuidMap;
  81
  82   KeySystemUuidMap key_system_uuid_map_;
  83
  84   DISALLOW_COPY_AND_ASSIGN(KeySystemUuidManager);
  85 };
  86
  87 KeySystemUuidManager::KeySystemUuidManager() {
  88   // Widevine is always supported in Android.
  89   key_system_uuid_map_[kWidevineKeySystem] =
  90       UUID(kWidevineUuid, kWidevineUuid + arraysize(kWidevineUuid));
  91 }
  92
  93 UUID KeySystemUuidManager::GetUUID(const std::string& key_system) {
  94   KeySystemUuidMap::iterator it = key_system_uuid_map_.find(key_system);
  95   if (it == key_system_uuid_map_.end())
  96     return UUID();
  97   return it->second;
  98 }
  99
 100 void KeySystemUuidManager::AddMapping(const std::string& key_system,
 101                                       const UUID& uuid) {
 102   KeySystemUuidMap::iterator it = key_system_uuid_map_.find(key_system);
 103   DCHECK(it == key_system_uuid_map_.end())
 104       << "Shouldn't overwrite an existing key system.";
 105   if (it != key_system_uuid_map_.end())
 106     return;
 107   key_system_uuid_map_[key_system] = uuid;
 108 }
 109
 110 std::vector<std::string> KeySystemUuidManager::GetPlatformKeySystemNames() {
 111   std::vector<std::string> key_systems;
 112   for (KeySystemUuidMap::iterator it = key_system_uuid_map_.begin();
 113        it != key_system_uuid_map_.end(); ++it) {
 114     // Rule out the key system handled by Chrome explicitly.
 115     if (it->first != kWidevineKeySystem)
 116       key_systems.push_back(it->first);
 117   }
 118   return key_systems;
 119 }
 120
 121 base::LazyInstance<KeySystemUuidManager>::Leaky g_key_system_uuid_manager =
 122     LAZY_INSTANCE_INITIALIZER;
 123
 124 // Tries to find a PSSH box whose "SystemId" is |uuid| in |data|, parses the
 125 // "Data" of the box and put it in |pssh_data|. Returns true if such a box is
 126 // found and successfully parsed. Returns false otherwise.
 127 // Notes:
 128 // 1, If multiple PSSH boxes are found,the "Data" of the first matching PSSH box
 129 // will be set in |pssh_data|.
 130 // 2, Only PSSH and TENC boxes are allowed in |data|. TENC boxes are skipped.
 131 static bool GetPsshData(const uint8* data, int data_size,
 132                         const UUID& uuid,
 133                         std::vector<uint8>* pssh_data) {
 134   const uint8* cur = data;
 135   const uint8* data_end = data + data_size;
 136   int bytes_left = data_size;
 137
 138   while (bytes_left > 0) {
 139     const uint8* box_head = cur;
 140
 141     if (bytes_left < kBoxHeaderSize)
 142       return false;
 143
 144     uint64_t box_size = ReadUint32(cur);
 145     uint32 type = ReadUint32(cur + 4);
 146     cur += kBoxHeaderSize;
 147     bytes_left -= kBoxHeaderSize;
 148
 149     if (box_size == 1) {  // LargeSize is present.
 150       if (bytes_left < kBoxLargeSizeSize)
 151         return false;
 152
 153       box_size = ReadUint64(cur);
 154       cur += kBoxLargeSizeSize;
 155       bytes_left -= kBoxLargeSizeSize;
 156     } else if (box_size == 0) {
 157       box_size = bytes_left + kBoxHeaderSize;
 158     }
 159
 160     const uint8* box_end = box_head + box_size;
 161     if (data_end < box_end)
 162       return false;
 163
 164     if (type == kTencType) {
 165       // Skip 'tenc' box.
 166       cur = box_end;
 167       bytes_left = data_end - cur;
 168       continue;
 169     } else if (type != kPsshType) {
 170       return false;
 171     }
 172
 173     const int kPsshBoxMinimumSize =
 174         kPsshVersionFlagSize + kPsshSystemIdSize + kPsshDataSizeSize;
 175     if (box_end < cur + kPsshBoxMinimumSize)
 176       return false;
 177
 178     uint32 version_and_flags = ReadUint32(cur);
 179     cur += kPsshVersionFlagSize;
 180     bytes_left -= kPsshVersionFlagSize;
 181     if (version_and_flags != 0)
 182       return false;
 183
 184     DCHECK_GE(bytes_left, kPsshSystemIdSize);
 185     if (!std::equal(uuid.begin(), uuid.end(), cur)) {
 186       cur = box_end;
 187       bytes_left = data_end - cur;
 188       continue;
 189     }
 190
 191     cur += kPsshSystemIdSize;
 192     bytes_left -= kPsshSystemIdSize;
 193
 194     uint32 data_size = ReadUint32(cur);
 195     cur += kPsshDataSizeSize;
 196     bytes_left -= kPsshDataSizeSize;
 197
 198     if (box_end < cur + data_size)
 199       return false;
 200
 201     pssh_data->assign(cur, cur + data_size);
 202     return true;
 203   }
 204
 205   return false;
 206 }
 207
 208 static MediaDrmBridge::SecurityLevel GetSecurityLevelFromString(
 209     const std::string& security_level_str) {
 210   if (0 == security_level_str.compare("L1"))
 211     return MediaDrmBridge::SECURITY_LEVEL_1;
 212   if (0 == security_level_str.compare("L3"))
 213     return MediaDrmBridge::SECURITY_LEVEL_3;
 214   DCHECK(security_level_str.empty());
 215   return MediaDrmBridge::SECURITY_LEVEL_NONE;
 216 }
 217
 218 static std::string GetSecurityLevelString(
 219     MediaDrmBridge::SecurityLevel security_level) {
 220   switch (security_level) {
 221     case MediaDrmBridge::SECURITY_LEVEL_NONE:
 222       return "";
 223     case MediaDrmBridge::SECURITY_LEVEL_1:
 224       return "L1";
 225     case MediaDrmBridge::SECURITY_LEVEL_3:
 226       return "L3";
 227   }
 228   return "";
 229 }
 230
 231 // Checks whether |key_system| is supported with |container_mime_type|. Only
 232 // checks |key_system| support if |container_mime_type| is empty.
 233 // TODO(xhwang): The |container_mime_type| is not the same as contentType in
 234 // the EME spec. Revisit this once the spec issue with initData type is
 235 // resolved.
 236 static bool IsKeySystemSupportedWithTypeImpl(
 237     const std::string& key_system,
 238     const std::string& container_mime_type) {
 239   if (!MediaDrmBridge::IsAvailable())
 240     return false;
 241
 242   UUID scheme_uuid = g_key_system_uuid_manager.Get().GetUUID(key_system);
 243   if (scheme_uuid.empty())
 244     return false;
 245
 246   JNIEnv* env = AttachCurrentThread();
 247   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
 248       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
 249   ScopedJavaLocalRef<jstring> j_container_mime_type =
 250       ConvertUTF8ToJavaString(env, container_mime_type);
 251   return Java_MediaDrmBridge_isCryptoSchemeSupported(
 252       env, j_scheme_uuid.obj(), j_container_mime_type.obj());
 253 }
 254
 255 // static
 256 bool MediaDrmBridge::IsAvailable() {
 257   return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
 258 }
 259
 260 // static
 261 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
 262   DCHECK(IsAvailable());
 263   return SECURITY_LEVEL_1 == security_level;
 264 }
 265
 266 // static
 267 bool MediaDrmBridge::IsSecurityLevelSupported(const std::string& key_system,
 268                                               SecurityLevel security_level) {
 269   if (!IsAvailable())
 270     return false;
 271
 272   scoped_ptr<MediaDrmBridge> media_drm_bridge =
 273       MediaDrmBridge::CreateSessionless(key_system);
 274   if (!media_drm_bridge)
 275     return false;
 276
 277   return media_drm_bridge->SetSecurityLevel(security_level);
 278 }
 279
 280 static void AddKeySystemUuidMapping(JNIEnv* env, jclass clazz,
 281                                     jstring j_key_system,
 282                                     jobject j_buffer) {
 283   std::string key_system = ConvertJavaStringToUTF8(env, j_key_system);
 284   uint8* buffer = static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer));
 285   UUID uuid(buffer, buffer + 16);
 286   g_key_system_uuid_manager.Get().AddMapping(key_system, uuid);
 287 }
 288
 289 // static
 290 std::vector<std::string> MediaDrmBridge::GetPlatformKeySystemNames() {
 291   return g_key_system_uuid_manager.Get().GetPlatformKeySystemNames();
 292 }
 293
 294 // static
 295 bool MediaDrmBridge::IsKeySystemSupported(const std::string& key_system) {
 296   DCHECK(!key_system.empty());
 297   return IsKeySystemSupportedWithTypeImpl(key_system, "");
 298 }
 299
 300 // static
 301 bool MediaDrmBridge::IsKeySystemSupportedWithType(
 302     const std::string& key_system,
 303     const std::string& container_mime_type) {
 304   DCHECK(!key_system.empty() && !container_mime_type.empty());
 305   return IsKeySystemSupportedWithTypeImpl(key_system, container_mime_type);
 306 }
 307
 308 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
 309   return RegisterNativesImpl(env);
 310 }
 311
 312 MediaDrmBridge::MediaDrmBridge(const std::vector<uint8>& scheme_uuid,
 313                                const SessionCreatedCB& session_created_cb,
 314                                const SessionMessageCB& session_message_cb,
 315                                const SessionReadyCB& session_ready_cb,
 316                                const SessionClosedCB& session_closed_cb,
 317                                const SessionErrorCB& session_error_cb)
 318     : scheme_uuid_(scheme_uuid),
 319       session_created_cb_(session_created_cb),
 320       session_message_cb_(session_message_cb),
 321       session_ready_cb_(session_ready_cb),
 322       session_closed_cb_(session_closed_cb),
 323       session_error_cb_(session_error_cb) {
 324   JNIEnv* env = AttachCurrentThread();
 325   CHECK(env);
 326
 327   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
 328       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
 329   j_media_drm_.Reset(Java_MediaDrmBridge_create(
 330       env, j_scheme_uuid.obj(), reinterpret_cast<intptr_t>(this)));
 331 }
 332
 333 MediaDrmBridge::~MediaDrmBridge() {
 334   JNIEnv* env = AttachCurrentThread();
 335   player_tracker_.NotifyCdmUnset();
 336   if (!j_media_drm_.is_null())
 337     Java_MediaDrmBridge_release(env, j_media_drm_.obj());
 338 }
 339
 340 // static
 341 scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(
 342     const std::string& key_system,
 343     const SessionCreatedCB& session_created_cb,
 344     const SessionMessageCB& session_message_cb,
 345     const SessionReadyCB& session_ready_cb,
 346     const SessionClosedCB& session_closed_cb,
 347     const SessionErrorCB& session_error_cb) {
 348   scoped_ptr<MediaDrmBridge> media_drm_bridge;
 349   if (!IsAvailable())
 350     return media_drm_bridge.Pass();
 351
 352   UUID scheme_uuid = g_key_system_uuid_manager.Get().GetUUID(key_system);
 353   if (scheme_uuid.empty())
 354     return media_drm_bridge.Pass();
 355
 356   media_drm_bridge.reset(new MediaDrmBridge(scheme_uuid,
 357                                             session_created_cb,
 358                                             session_message_cb,
 359                                             session_ready_cb,
 360                                             session_closed_cb,
 361                                             session_error_cb));
 362
 363   if (media_drm_bridge->j_media_drm_.is_null())
 364     media_drm_bridge.reset();
 365
 366   return media_drm_bridge.Pass();
 367 }
 368
 369 // static
 370 scoped_ptr<MediaDrmBridge> MediaDrmBridge::CreateSessionless(
 371     const std::string& key_system) {
 372   return MediaDrmBridge::Create(key_system,
 373                                 SessionCreatedCB(),
 374                                 SessionMessageCB(),
 375                                 SessionReadyCB(),
 376                                 SessionClosedCB(),
 377                                 SessionErrorCB());
 378 }
 379
 380 bool MediaDrmBridge::SetSecurityLevel(SecurityLevel security_level) {
 381   JNIEnv* env = AttachCurrentThread();
 382
 383   std::string security_level_str = GetSecurityLevelString(security_level);
 384   if (security_level_str.empty())
 385     return false;
 386
 387   ScopedJavaLocalRef<jstring> j_security_level =
 388       ConvertUTF8ToJavaString(env, security_level_str);
 389   return Java_MediaDrmBridge_setSecurityLevel(
 390       env, j_media_drm_.obj(), j_security_level.obj());
 391 }
 392
 393 bool MediaDrmBridge::CreateSession(uint32 session_id,
 394                                    const std::string& content_type,
 395                                    const uint8* init_data,
 396                                    int init_data_length) {
 397   DVLOG(1) << __FUNCTION__;
 398
 399   DCHECK(!session_created_cb_.is_null())
 400       << "CreateSession called on a sessionless MediaDrmBridge object.";
 401
 402   JNIEnv* env = AttachCurrentThread();
 403   ScopedJavaLocalRef<jbyteArray> j_init_data;
 404   // Caller should always use "video/*" content types.
 405   DCHECK_EQ(0u, content_type.find("video/"));
 406
 407   // Widevine MediaDrm plugin only accepts the "data" part of the PSSH box as
 408   // the init data when using MP4 container.
 409   if (std::equal(scheme_uuid_.begin(), scheme_uuid_.end(), kWidevineUuid) &&
 410       content_type == "video/mp4") {
 411     std::vector<uint8> pssh_data;
 412     if (!GetPsshData(init_data, init_data_length, scheme_uuid_, &pssh_data))
 413       return false;
 414     j_init_data =
 415         base::android::ToJavaByteArray(env, &pssh_data[0], pssh_data.size());
 416   } else {
 417     j_init_data =
 418         base::android::ToJavaByteArray(env, init_data, init_data_length);
 419   }
 420
 421   ScopedJavaLocalRef<jstring> j_mime =
 422       ConvertUTF8ToJavaString(env, content_type);
 423   Java_MediaDrmBridge_createSession(
 424       env, j_media_drm_.obj(), session_id, j_init_data.obj(), j_mime.obj());
 425   return true;
 426 }
 427
 428 void MediaDrmBridge::LoadSession(uint32 session_id,
 429                                  const std::string& web_session_id) {
 430   // MediaDrmBridge doesn't support loading sessions.
 431   NOTREACHED();
 432 }
 433
 434 void MediaDrmBridge::UpdateSession(uint32 session_id,
 435                                    const uint8* response,
 436                                    int response_length) {
 437   DVLOG(1) << __FUNCTION__;
 438
 439   DCHECK(!session_ready_cb_.is_null())
 440       << __FUNCTION__ << " called on a sessionless MediaDrmBridge object.";
 441
 442   JNIEnv* env = AttachCurrentThread();
 443   ScopedJavaLocalRef<jbyteArray> j_response =
 444       base::android::ToJavaByteArray(env, response, response_length);
 445   Java_MediaDrmBridge_updateSession(
 446       env, j_media_drm_.obj(), session_id, j_response.obj());
 447 }
 448
 449 void MediaDrmBridge::ReleaseSession(uint32 session_id) {
 450   DVLOG(1) << __FUNCTION__;
 451
 452   DCHECK(!session_closed_cb_.is_null())
 453       << __FUNCTION__ << " called on a sessionless MediaDrmBridge object.";
 454
 455   JNIEnv* env = AttachCurrentThread();
 456   Java_MediaDrmBridge_releaseSession(env, j_media_drm_.obj(), session_id);
 457 }
 458
 459 int MediaDrmBridge::RegisterPlayer(const base::Closure& new_key_cb,
 460                                    const base::Closure& cdm_unset_cb) {
 461   return player_tracker_.RegisterPlayer(new_key_cb, cdm_unset_cb);
 462 }
 463
 464 void MediaDrmBridge::UnregisterPlayer(int registration_id) {
 465   player_tracker_.UnregisterPlayer(registration_id);
 466 }
 467
 468 void MediaDrmBridge::SetMediaCryptoReadyCB(const base::Closure& closure) {
 469   if (closure.is_null()) {
 470     media_crypto_ready_cb_.Reset();
 471     return;
 472   }
 473
 474   DCHECK(media_crypto_ready_cb_.is_null());
 475
 476   if (!GetMediaCrypto().is_null()) {
 477     base::MessageLoopProxy::current()->PostTask(FROM_HERE, closure);
 478     return;
 479   }
 480
 481   media_crypto_ready_cb_ = closure;
 482 }
 483
 484 void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject) {
 485   DCHECK(!GetMediaCrypto().is_null());
 486   if (!media_crypto_ready_cb_.is_null())
 487     base::ResetAndReturn(&media_crypto_ready_cb_).Run();
 488 }
 489
 490 void MediaDrmBridge::OnSessionCreated(JNIEnv* env,
 491                                       jobject j_media_drm,
 492                                       jint j_session_id,
 493                                       jstring j_web_session_id) {
 494   uint32 session_id = j_session_id;
 495   std::string web_session_id = ConvertJavaStringToUTF8(env, j_web_session_id);
 496   session_created_cb_.Run(session_id, web_session_id);
 497 }
 498
 499 void MediaDrmBridge::OnSessionMessage(JNIEnv* env,
 500                                       jobject j_media_drm,
 501                                       jint j_session_id,
 502                                       jbyteArray j_message,
 503                                       jstring j_destination_url) {
 504   uint32 session_id = j_session_id;
 505   std::vector<uint8> message;
 506   JavaByteArrayToByteVector(env, j_message, &message);
 507   GURL destination_gurl = GURL(ConvertJavaStringToUTF8(env, j_destination_url));
 508   if (!destination_gurl.is_valid() && !destination_gurl.is_empty()) {
 509     DLOG(WARNING) << "SessionMessage destination_url is invalid : "
 510                   << destination_gurl.possibly_invalid_spec();
 511     destination_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
 512   }
 513   session_message_cb_.Run(session_id, message, destination_gurl);
 514 }
 515
 516 void MediaDrmBridge::OnSessionReady(JNIEnv* env,
 517                                     jobject j_media_drm,
 518                                     jint j_session_id) {
 519   uint32 session_id = j_session_id;
 520   session_ready_cb_.Run(session_id);
 521   // TODO(xhwang/jrummell): Move this when usableKeyIds/keyschange are
 522   // implemented.
 523   player_tracker_.NotifyNewKey();
 524 }
 525
 526 void MediaDrmBridge::OnSessionClosed(JNIEnv* env,
 527                                      jobject j_media_drm,
 528                                      jint j_session_id) {
 529   uint32 session_id = j_session_id;
 530   session_closed_cb_.Run(session_id);
 531 }
 532
 533 void MediaDrmBridge::OnSessionError(JNIEnv* env,
 534                                     jobject j_media_drm,
 535                                     jint j_session_id) {
 536   uint32 session_id = j_session_id;
 537   session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
 538 }
 539
 540 ScopedJavaLocalRef<jobject> MediaDrmBridge::GetMediaCrypto() {
 541   JNIEnv* env = AttachCurrentThread();
 542   return Java_MediaDrmBridge_getMediaCrypto(env, j_media_drm_.obj());
 543 }
 544
 545 MediaDrmBridge::SecurityLevel MediaDrmBridge::GetSecurityLevel() {
 546   JNIEnv* env = AttachCurrentThread();
 547   ScopedJavaLocalRef<jstring> j_security_level =
 548       Java_MediaDrmBridge_getSecurityLevel(env, j_media_drm_.obj());
 549   std::string security_level_str =
 550       ConvertJavaStringToUTF8(env, j_security_level.obj());
 551   return GetSecurityLevelFromString(security_level_str);
 552 }
 553
 554 bool MediaDrmBridge::IsProtectedSurfaceRequired() {
 555   return IsSecureDecoderRequired(GetSecurityLevel());
 556 }
 557
 558 void MediaDrmBridge::ResetDeviceCredentials(
 559     const ResetCredentialsCB& callback) {
 560   DCHECK(reset_credentials_cb_.is_null());
 561   reset_credentials_cb_ = callback;
 562   JNIEnv* env = AttachCurrentThread();
 563   Java_MediaDrmBridge_resetDeviceCredentials(env, j_media_drm_.obj());
 564 }
 565
 566 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(
 567     JNIEnv* env, jobject, bool success) {
 568   base::ResetAndReturn(&reset_credentials_cb_).Run(success);
 569 }
 570
 571 }  // namespace media