src/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 "base/android/build_info.h"
   8 #include "base/android/jni_array.h"
   9 #include "base/android/jni_string.h"
  10 #include "base/callback_helpers.h"
  11 #include "base/location.h"
  12 #include "base/logging.h"
  13 #include "base/message_loop/message_loop_proxy.h"
  14 #include "base/strings/string_util.h"
  15 #include "jni/MediaDrmBridge_jni.h"
  16 #include "media/base/android/media_player_manager.h"
  17
  18 using base::android::AttachCurrentThread;
  19 using base::android::ConvertUTF8ToJavaString;
  20 using base::android::ConvertJavaStringToUTF8;
  21 using base::android::JavaByteArrayToByteVector;
  22 using base::android::ScopedJavaLocalRef;
  23
  24 namespace media {
  25
  26 static uint32 ReadUint32(const uint8_t* data) {
  27   uint32 value = 0;
  28   for (int i = 0; i < 4; ++i)
  29     value = (value << 8) | data[i];
  30   return value;
  31 }
  32
  33 static uint64 ReadUint64(const uint8_t* data) {
  34   uint64 value = 0;
  35   for (int i = 0; i < 8; ++i)
  36     value = (value << 8) | data[i];
  37   return value;
  38 }
  39
  40 // The structure of an ISO CENC Protection System Specific Header (PSSH) box is
  41 // as follows. (See ISO/IEC FDIS 23001-7:2011(E).)
  42 // Note: ISO boxes use big-endian values.
  43 //
  44 // PSSH {
  45 //   uint32 Size
  46 //   uint32 Type
  47 //   uint64 LargeSize  # Field is only present if value(Size) == 1.
  48 //   uint32 VersionAndFlags
  49 //   uint8[16] SystemId
  50 //   uint32 DataSize
  51 //   uint8[DataSize] Data
  52 // }
  53 static const int kBoxHeaderSize = 8;  // Box's header contains Size and Type.
  54 static const int kBoxLargeSizeSize = 8;
  55 static const int kPsshVersionFlagSize = 4;
  56 static const int kPsshSystemIdSize = 16;
  57 static const int kPsshDataSizeSize = 4;
  58 static const uint32 kTencType = 0x74656e63;
  59 static const uint32 kPsshType = 0x70737368;
  60
  61 // Tries to find a PSSH box whose "SystemId" is |uuid| in |data|, parses the
  62 // "Data" of the box and put it in |pssh_data|. Returns true if such a box is
  63 // found and successfully parsed. Returns false otherwise.
  64 // Notes:
  65 // 1, If multiple PSSH boxes are found,the "Data" of the first matching PSSH box
  66 // will be set in |pssh_data|.
  67 // 2, Only PSSH and TENC boxes are allowed in |data|. TENC boxes are skipped.
  68 static bool GetPsshData(const uint8* data, int data_size,
  69                         const std::vector<uint8>& uuid,
  70                         std::vector<uint8>* pssh_data) {
  71   const uint8* cur = data;
  72   const uint8* data_end = data + data_size;
  73   int bytes_left = data_size;
  74
  75   while (bytes_left > 0) {
  76     const uint8* box_head = cur;
  77
  78     if (bytes_left < kBoxHeaderSize)
  79       return false;
  80
  81     uint64_t box_size = ReadUint32(cur);
  82     uint32 type = ReadUint32(cur + 4);
  83     cur += kBoxHeaderSize;
  84     bytes_left -= kBoxHeaderSize;
  85
  86     if (box_size == 1) {  // LargeSize is present.
  87       if (bytes_left < kBoxLargeSizeSize)
  88         return false;
  89
  90       box_size = ReadUint64(cur);
  91       cur += kBoxLargeSizeSize;
  92       bytes_left -= kBoxLargeSizeSize;
  93     } else if (box_size == 0) {
  94       box_size = bytes_left + kBoxHeaderSize;
  95     }
  96
  97     const uint8* box_end = box_head + box_size;
  98     if (data_end < box_end)
  99       return false;
 100
 101     if (type == kTencType) {
 102       // Skip 'tenc' box.
 103       cur = box_end;
 104       bytes_left = data_end - cur;
 105       continue;
 106     } else if (type != kPsshType) {
 107       return false;
 108     }
 109
 110     const int kPsshBoxMinimumSize =
 111         kPsshVersionFlagSize + kPsshSystemIdSize + kPsshDataSizeSize;
 112     if (box_end < cur + kPsshBoxMinimumSize)
 113       return false;
 114
 115     uint32 version_and_flags = ReadUint32(cur);
 116     cur += kPsshVersionFlagSize;
 117     bytes_left -= kPsshVersionFlagSize;
 118     if (version_and_flags != 0)
 119       return false;
 120
 121     DCHECK_GE(bytes_left, kPsshSystemIdSize);
 122     if (!std::equal(uuid.begin(), uuid.end(), cur)) {
 123       cur = box_end;
 124       bytes_left = data_end - cur;
 125       continue;
 126     }
 127
 128     cur += kPsshSystemIdSize;
 129     bytes_left -= kPsshSystemIdSize;
 130
 131     uint32 data_size = ReadUint32(cur);
 132     cur += kPsshDataSizeSize;
 133     bytes_left -= kPsshDataSizeSize;
 134
 135     if (box_end < cur + data_size)
 136       return false;
 137
 138     pssh_data->assign(cur, cur + data_size);
 139     return true;
 140   }
 141
 142   return false;
 143 }
 144
 145 static MediaDrmBridge::SecurityLevel GetSecurityLevelFromString(
 146     const std::string& security_level_str) {
 147   if (0 == security_level_str.compare("L1"))
 148     return MediaDrmBridge::SECURITY_LEVEL_1;
 149   if (0 == security_level_str.compare("L3"))
 150     return MediaDrmBridge::SECURITY_LEVEL_3;
 151   DCHECK(security_level_str.empty());
 152   return MediaDrmBridge::SECURITY_LEVEL_NONE;
 153 }
 154
 155 static std::string GetSecurityLevelString(
 156     MediaDrmBridge::SecurityLevel security_level) {
 157   switch (security_level) {
 158     case MediaDrmBridge::SECURITY_LEVEL_NONE:
 159       return "";
 160     case MediaDrmBridge::SECURITY_LEVEL_1:
 161       return "L1";
 162     case MediaDrmBridge::SECURITY_LEVEL_3:
 163       return "L3";
 164   }
 165   return "";
 166 }
 167
 168 // static
 169 bool MediaDrmBridge::IsAvailable() {
 170   return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
 171 }
 172
 173 // static
 174 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
 175   return SECURITY_LEVEL_1 == security_level;
 176 }
 177
 178 bool MediaDrmBridge::IsSecurityLevelSupported(
 179     const std::vector<uint8>& scheme_uuid,
 180     SecurityLevel security_level) {
 181   // Pass 0 as |media_keys_id| and NULL as |manager| as they are not used in
 182   // creation time of MediaDrmBridge.
 183   scoped_ptr<MediaDrmBridge> media_drm_bridge =
 184       MediaDrmBridge::Create(0, scheme_uuid, GURL(), NULL);
 185   if (!media_drm_bridge)
 186     return false;
 187
 188   return media_drm_bridge->SetSecurityLevel(security_level);
 189 }
 190
 191 bool MediaDrmBridge::IsCryptoSchemeSupported(
 192     const std::vector<uint8>& scheme_uuid,
 193     const std::string& container_mime_type) {
 194   JNIEnv* env = AttachCurrentThread();
 195   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
 196       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
 197   ScopedJavaLocalRef<jstring> j_container_mime_type =
 198       ConvertUTF8ToJavaString(env, container_mime_type);
 199   return Java_MediaDrmBridge_isCryptoSchemeSupported(
 200       env, j_scheme_uuid.obj(), j_container_mime_type.obj());
 201 }
 202
 203 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
 204   return RegisterNativesImpl(env);
 205 }
 206
 207 MediaDrmBridge::MediaDrmBridge(int media_keys_id,
 208                                const std::vector<uint8>& scheme_uuid,
 209                                const GURL& frame_url,
 210                                MediaPlayerManager* manager)
 211     : media_keys_id_(media_keys_id),
 212       scheme_uuid_(scheme_uuid),
 213       frame_url_(frame_url),
 214       manager_(manager) {
 215   JNIEnv* env = AttachCurrentThread();
 216   CHECK(env);
 217
 218   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
 219       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
 220   j_media_drm_.Reset(Java_MediaDrmBridge_create(
 221       env, j_scheme_uuid.obj(), reinterpret_cast<intptr_t>(this)));
 222 }
 223
 224 MediaDrmBridge::~MediaDrmBridge() {
 225   JNIEnv* env = AttachCurrentThread();
 226   if (!j_media_drm_.is_null())
 227     Java_MediaDrmBridge_release(env, j_media_drm_.obj());
 228 }
 229
 230 // static
 231 scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(
 232     int media_keys_id,
 233     const std::vector<uint8>& scheme_uuid,
 234     const GURL& frame_url,
 235     MediaPlayerManager* manager) {
 236   scoped_ptr<MediaDrmBridge> media_drm_bridge;
 237
 238   if (IsAvailable() && !scheme_uuid.empty()) {
 239     // TODO(qinmin): check whether the uuid is valid.
 240     media_drm_bridge.reset(new MediaDrmBridge(
 241         media_keys_id, scheme_uuid, frame_url, manager));
 242     if (media_drm_bridge->j_media_drm_.is_null())
 243       media_drm_bridge.reset();
 244   }
 245
 246   return media_drm_bridge.Pass();
 247 }
 248
 249 bool MediaDrmBridge::SetSecurityLevel(SecurityLevel security_level) {
 250   JNIEnv* env = AttachCurrentThread();
 251
 252   std::string security_level_str = GetSecurityLevelString(security_level);
 253   if (security_level_str.empty())
 254     return false;
 255
 256   ScopedJavaLocalRef<jstring> j_security_level =
 257       ConvertUTF8ToJavaString(env, security_level_str);
 258   return Java_MediaDrmBridge_setSecurityLevel(
 259       env, j_media_drm_.obj(), j_security_level.obj());
 260 }
 261
 262 bool MediaDrmBridge::CreateSession(uint32 session_id,
 263                                    const std::string& content_type,
 264                                    const uint8* init_data,
 265                                    int init_data_length) {
 266   std::vector<uint8> pssh_data;
 267   if (!GetPsshData(init_data, init_data_length, scheme_uuid_, &pssh_data))
 268     return false;
 269
 270   JNIEnv* env = AttachCurrentThread();
 271   ScopedJavaLocalRef<jbyteArray> j_pssh_data =
 272       base::android::ToJavaByteArray(env, &pssh_data[0], pssh_data.size());
 273   ScopedJavaLocalRef<jstring> j_mime =
 274       ConvertUTF8ToJavaString(env, content_type);
 275   Java_MediaDrmBridge_createSession(
 276       env, j_media_drm_.obj(), session_id, j_pssh_data.obj(), j_mime.obj());
 277   return true;
 278 }
 279
 280 void MediaDrmBridge::LoadSession(uint32 session_id,
 281                                  const std::string& web_session_id) {
 282   // MediaDrmBridge doesn't support loading sessions.
 283   NOTREACHED();
 284 }
 285
 286 void MediaDrmBridge::UpdateSession(uint32 session_id,
 287                                    const uint8* response,
 288                                    int response_length) {
 289   DVLOG(1) << __FUNCTION__;
 290   JNIEnv* env = AttachCurrentThread();
 291   ScopedJavaLocalRef<jbyteArray> j_response =
 292       base::android::ToJavaByteArray(env, response, response_length);
 293   Java_MediaDrmBridge_updateSession(
 294       env, j_media_drm_.obj(), session_id, j_response.obj());
 295 }
 296
 297 void MediaDrmBridge::ReleaseSession(uint32 session_id) {
 298   DVLOG(1) << __FUNCTION__;
 299   JNIEnv* env = AttachCurrentThread();
 300   Java_MediaDrmBridge_releaseSession(env, j_media_drm_.obj(), session_id);
 301 }
 302
 303 void MediaDrmBridge::SetMediaCryptoReadyCB(const base::Closure& closure) {
 304   if (closure.is_null()) {
 305     media_crypto_ready_cb_.Reset();
 306     return;
 307   }
 308
 309   DCHECK(media_crypto_ready_cb_.is_null());
 310
 311   if (!GetMediaCrypto().is_null()) {
 312     base::MessageLoopProxy::current()->PostTask(FROM_HERE, closure);
 313     return;
 314   }
 315
 316   media_crypto_ready_cb_ = closure;
 317 }
 318
 319 void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject) {
 320   DCHECK(!GetMediaCrypto().is_null());
 321   if (!media_crypto_ready_cb_.is_null())
 322     base::ResetAndReturn(&media_crypto_ready_cb_).Run();
 323 }
 324
 325 void MediaDrmBridge::OnSessionCreated(JNIEnv* env,
 326                                       jobject j_media_drm,
 327                                       jint j_session_id,
 328                                       jstring j_web_session_id) {
 329   uint32 session_id = j_session_id;
 330   std::string web_session_id = ConvertJavaStringToUTF8(env, j_web_session_id);
 331   manager_->OnSessionCreated(media_keys_id_, session_id, web_session_id);
 332 }
 333
 334 void MediaDrmBridge::OnSessionMessage(JNIEnv* env,
 335                                       jobject j_media_drm,
 336                                       jint j_session_id,
 337                                       jbyteArray j_message,
 338                                       jstring j_destination_url) {
 339   uint32 session_id = j_session_id;
 340   std::vector<uint8> message;
 341   JavaByteArrayToByteVector(env, j_message, &message);
 342   std::string destination_url = ConvertJavaStringToUTF8(env, j_destination_url);
 343   GURL destination_gurl(destination_url);
 344   if (!destination_gurl.is_valid() && !destination_gurl.is_empty()) {
 345     DLOG(WARNING) << "SessionMessage destination_url is invalid : "
 346                   << destination_gurl.possibly_invalid_spec();
 347     destination_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
 348   }
 349
 350   manager_->OnSessionMessage(
 351       media_keys_id_, session_id, message, destination_gurl);
 352 }
 353
 354 void MediaDrmBridge::OnSessionReady(JNIEnv* env,
 355                                     jobject j_media_drm,
 356                                     jint j_session_id) {
 357   uint32 session_id = j_session_id;
 358   manager_->OnSessionReady(media_keys_id_, session_id);
 359 }
 360
 361 void MediaDrmBridge::OnSessionClosed(JNIEnv* env,
 362                                      jobject j_media_drm,
 363                                      jint j_session_id) {
 364   uint32 session_id = j_session_id;
 365   manager_->OnSessionClosed(media_keys_id_, session_id);
 366 }
 367
 368 void MediaDrmBridge::OnSessionError(JNIEnv* env,
 369                                     jobject j_media_drm,
 370                                     jint j_session_id) {
 371   uint32 session_id = j_session_id;
 372   manager_->OnSessionError(
 373       media_keys_id_, session_id, MediaKeys::kUnknownError, 0);
 374 }
 375
 376 ScopedJavaLocalRef<jobject> MediaDrmBridge::GetMediaCrypto() {
 377   JNIEnv* env = AttachCurrentThread();
 378   return Java_MediaDrmBridge_getMediaCrypto(env, j_media_drm_.obj());
 379 }
 380
 381 MediaDrmBridge::SecurityLevel MediaDrmBridge::GetSecurityLevel() {
 382   JNIEnv* env = AttachCurrentThread();
 383   ScopedJavaLocalRef<jstring> j_security_level =
 384       Java_MediaDrmBridge_getSecurityLevel(env, j_media_drm_.obj());
 385   std::string security_level_str =
 386       ConvertJavaStringToUTF8(env, j_security_level.obj());
 387   return GetSecurityLevelFromString(security_level_str);
 388 }
 389
 390 bool MediaDrmBridge::IsProtectedSurfaceRequired() {
 391   return IsSecureDecoderRequired(GetSecurityLevel());
 392 }
 393
 394 void MediaDrmBridge::ResetDeviceCredentials(
 395     const ResetCredentialsCB& callback) {
 396   DCHECK(reset_credentials_cb_.is_null());
 397   reset_credentials_cb_ = callback;
 398   JNIEnv* env = AttachCurrentThread();
 399   Java_MediaDrmBridge_resetDeviceCredentials(env, j_media_drm_.obj());
 400 }
 401
 402 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(
 403     JNIEnv* env, jobject, bool success) {
 404   base::ResetAndReturn(&reset_credentials_cb_).Run(success);
 405 }
 406
 407 }  // namespace media