Improve EME Controller: Add PlayReady support

docs/API.md

@@ -74,6 +74,11 @@
   - [`abrBandWidthUpFactor`](#abrbandwidthupfactor)
   - [`abrMaxWithRealBitrate`](#abrmaxwithrealbitrate)
   - [`minAutoBitrate`](#minautobitrate)
+  - [`emeEnabled`](#emeenabled)
+  - [`licenseXhrSetup`](#licensexhrsetup)
+  - [`drmSystem`](#drmsystem)
+  - [`widevineLicenseUrl`](#widevinelicenseurl)
+  - [`playreadyLicenseUrl`](#playreadylicenseurl)
 - [Video Binding/Unbinding API](#video-bindingunbinding-api)
   - [`hls.attachMedia(videoElement)`](#hlsattachmediavideoelement)
   - [`hls.detachMedia()`](#hlsdetachmedia)
@@ -964,6 +969,47 @@ then if config value is set to `true`, ABR will use 2.5 Mb/s for this quality le
 Return the capping/min bandwidth value that could be used by automatic level selection algorithm.
 Useful when browser or tab of the browser is not in the focus and bandwidth drops
 
+### `emeEnabled`
+
+(default: `false`)
+
+Whether or not to enable eme.
+
+### `licenseXhrSetup`
+
+(default: `undefined`)
+
+`XMLHttpRequest` customization callback for default XHR based loader.
+
+Parameter should be a function with two arguments `(xhr: XMLHttpRequest, url: string)`.
+If `licenseXhrSetup` is specified, default loader will invoke it before calling `xhr.send()`.
+This allows user to easily modify/setup XHR. See example below.
+
+```js
+  var config = {
+    licenseXhrSetup: function(xhr, url) {
+      xhr.setRequestHeader('Content-Type', 'text/xml; charset=utf-8'); //indicate resource is xml
+    }
+  }
+```
+
+### `drmSystem`
+
+(default: `undefined`)
+
+Which DRM system use. (`WIDEVINE` or `PLAYREADY`)
+
+### `widevineLicenseUrl`
+
+(default: `undefined`)
+
+Specify widevine license url.
+
+### `playreadyLicenseUrl`
+
+(default: `undefined`)
+
+Specify playready license url.
 
 ## Video Binding/Unbinding API
 

src/config.js

@@ -89,6 +89,8 @@ export var hlsDefaultConfig = {
   minAutoBitrate: 0, // used by hls
   emeEnabled: false, // used by eme-controller
   widevineLicenseUrl: undefined, // used by eme-controller
+  drmSystem: undefined, // used by eme-controller
+  playreadyLicenseUrl: undefined, // used by eme-controller
   requestMediaKeySystemAccessFunc:
             requestMediaKeySystemAccess // used by eme-controller
 };

src/controller/eme-controller.js

@@ -7,10 +7,10 @@
 import EventHandler from '../event-handler';
 import Event from '../events';
 import { ErrorTypes, ErrorDetails } from '../errors';
-
+import { base64ToArrayBuffer, buildPlayReadyPSSHBox, makePlayreadyHeaders } from '../utils/eme-helper';
 import { logger } from '../utils/logger';
 
-const { XMLHttpRequest } = window;
+const { XMLHttpRequest, atob, DOMParser } = window;
 
 const MAX_LICENSE_REQUEST_FAILURES = 3;
 
@@ -22,6 +22,11 @@ const KeySystems = {
   PLAYREADY: 'com.microsoft.playready'
 };
 
+const DRMIdentifiers = {
+  WIDEVINE: 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
+  PLAYREADY: 'com.microsoft.playready'
+};
+
 /**
  * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaKeySystemConfiguration
  * @param {Array<string>} audioCodecs List of required audio codecs to support
@@ -67,6 +72,7 @@ const createWidevineMediaKeySystemConfigurations = function (audioCodecs, videoC
 const getSupportedMediaKeySystemConfigurations = function (keySystem, audioCodecs, videoCodecs) {
   switch (keySystem) {
   case KeySystems.WIDEVINE:
+  case KeySystems.PLAYREADY:
     return createWidevineMediaKeySystemConfigurations(audioCodecs, videoCodecs);
   default:
     throw Error('Unknown key-system: ' + keySystem);
@@ -88,12 +94,16 @@ class EMEController extends EventHandler {
   constructor (hls) {
     super(hls,
       Event.MEDIA_ATTACHED,
-      Event.MANIFEST_PARSED
+      Event.MANIFEST_PARSED,
+      Event.LEVEL_LOADED,
+      Event.FRAG_LOADED
     );
 
     this._widevineLicenseUrl = hls.config.widevineLicenseUrl;
+    this._playreadyLicenseUrl = hls.config.playreadyLicenseUrl;
     this._licenseXhrSetup = hls.config.licenseXhrSetup;
     this._emeEnabled = hls.config.emeEnabled;
+    this._selectedDrm = hls.config.drmSystem;
 
     this._requestMediaKeySystemAccess = hls.config.requestMediaKeySystemAccessFunc;
 
@@ -104,6 +114,9 @@ class EMEController extends EventHandler {
     this._isMediaEncrypted = false;
 
     this._requestLicenseFailureCount = 0;
+
+    this._initData = null;
+    this._initDataType = '';
   }
 
   /**
@@ -117,6 +130,9 @@ class EMEController extends EventHandler {
     case KeySystems.WIDEVINE:
       url = this._widevineLicenseUrl;
       break;
+    case KeySystems.PLAYREADY:
+      url = this._playreadyLicenseUrl;
+      break;
     default:
       url = null;
       break;
@@ -195,7 +211,6 @@ class EMEController extends EventHandler {
         mediaKeysListItem.mediaKeys = mediaKeys;
 
         logger.log(`Media-keys created for key-system "${keySystem}"`);
-
         this._onMediaKeysCreated();
       })
       .catch((err) => {
@@ -212,6 +227,7 @@ class EMEController extends EventHandler {
     this._mediaKeysList.forEach((mediaKeysListItem) => {
       if (!mediaKeysListItem.mediaKeysSession) {
         mediaKeysListItem.mediaKeysSession = mediaKeysListItem.mediaKeys.createSession();
+        this._haveKeySession = true;
         this._onNewMediaKeySession(mediaKeysListItem.mediaKeysSession);
       }
     });
@@ -240,7 +256,6 @@ class EMEController extends EventHandler {
 
   _onMediaEncrypted (initDataType, initData) {
     logger.log(`Media is encrypted using "${initDataType}" init data type`);
-
     this._isMediaEncrypted = true;
     this._mediaEncryptionInitDataType = initDataType;
     this._mediaEncryptionInitData = initData;
@@ -356,7 +371,7 @@ class EMEController extends EventHandler {
 
     xhr.responseType = 'arraybuffer';
     xhr.onreadystatechange =
-        this._onLicenseRequestReadyStageChange.bind(this, xhr, url, keyMessage, callback);
+      this._onLicenseRequestReadyStageChange.bind(this, xhr, url, keyMessage, callback);
     return xhr;
   }
 
@@ -404,28 +419,16 @@ class EMEController extends EventHandler {
     let challenge;
 
     if (keysListItem.mediaKeySystemDomain === KeySystems.PLAYREADY) {
-      logger.error('PlayReady is not supported (yet)');
-
       // from https://github.com/MicrosoftEdge/Demos/blob/master/eme/scripts/demo.js
-      /*
-        if (this.licenseType !== this.LICENSE_TYPE_WIDEVINE) {
-            // For PlayReady CDMs, we need to dig the Challenge out of the XML.
-            var keyMessageXml = new DOMParser().parseFromString(String.fromCharCode.apply(null, new Uint16Array(keyMessage)), 'application/xml');
-            if (keyMessageXml.getElementsByTagName('Challenge')[0]) {
-                challenge = atob(keyMessageXml.getElementsByTagName('Challenge')[0].childNodes[0].nodeValue);
-            } else {
-                throw 'Cannot find <Challenge> in key message';
-            }
-            var headerNames = keyMessageXml.getElementsByTagName('name');
-            var headerValues = keyMessageXml.getElementsByTagName('value');
-            if (headerNames.length !== headerValues.length) {
-                throw 'Mismatched header <name>/<value> pair in key message';
-            }
-            for (var i = 0; i < headerNames.length; i++) {
-                xhr.setRequestHeader(headerNames[i].childNodes[0].nodeValue, headerValues[i].childNodes[0].nodeValue);
-            }
-        }
-        */
+      // For PlayReady CDMs, we need to dig the Challenge out of the XML.
+      const keyMessageXml = new DOMParser().parseFromString(String.fromCharCode.apply(null, new Uint16Array(keyMessage)), 'application/xml');
+      const challengeElement = keyMessageXml.querySelector('Challenge');
+
+      if (challengeElement) {
+        challenge = atob(challengeElement.textContent);
+      } else {
+        throw Error('Cannot find <Challenge> in key message');
+      }
     } else if (keysListItem.mediaKeySystemDomain === KeySystems.WIDEVINE) {
       // For Widevine CDMs, the challenge is the keyMessage.
       challenge = keyMessage;
@@ -452,38 +455,78 @@ class EMEController extends EventHandler {
 
     const url = this.getLicenseServerUrl(keysListItem.mediaKeySystemDomain);
     const xhr = this._createLicenseXhr(url, keyMessage, callback);
+    const challenge = this._generateLicenseRequestChallenge(keysListItem, keyMessage);
+
+    if (keysListItem.mediaKeySystemDomain === KeySystems.PLAYREADY) {
+      const playReadyHeaders = makePlayreadyHeaders(keyMessage);
+
+      if (playReadyHeaders.length > 0) {
+        playReadyHeaders.forEach((header) => {
+          xhr.setRequestHeader(header.name, header.value);
+        });
+      }
+    }
 
     logger.log(`Sending license request to URL: ${url}`);
 
-    xhr.send(this._generateLicenseRequestChallenge(keysListItem, keyMessage));
+    xhr.send(challenge);
   }
 
   onMediaAttached (data) {
-    if (!this._emeEnabled) {
-      return;
-    }
-
     const media = data.media;
 
     // keep reference of media
     this._media = media;
 
     // FIXME: also handle detaching media !
-
-    media.addEventListener('encrypted', (e) => {
-      this._onMediaEncrypted(e.initDataType, e.initData);
-    });
+    if (!this._hasSetMediaKeys) {
+      media.addEventListener('encrypted', (e) => {
+        this._onMediaEncrypted(e.initDataType, e.initData);
+      });
+    }
   }
 
   onManifestParsed (data) {
-    if (!this._emeEnabled) {
-      return;
-    }
-
     const audioCodecs = data.levels.map((level) => level.audioCodec);
     const videoCodecs = data.levels.map((level) => level.videoCodec);
 
-    this._attemptKeySystemAccess(KeySystems.WIDEVINE, audioCodecs, videoCodecs);
+    this._attemptKeySystemAccess(KeySystems[this._selectedDrm], audioCodecs, videoCodecs);
+  }
+
+  onFragLoaded () {
+    // add initData and type if they are included in playlist
+    if (this._initData && !this._hasSetMediaKeys && this._haveKeySession) {
+      this._onMediaEncrypted(this._initDataType, this._initData);
+    }
+  }
+
+  /**
+   * @param {object} data
+   */
+  onLevelLoaded (data) {
+    if (data.details && data.details.drmInfo && data.details.drmInfo.length > 0) {
+      const drmInfo = data.details.drmInfo;
+
+      drmInfo.forEach((levelkey) => {
+        const details = levelkey.reluri.split(',');
+        const encoding = details[0];
+        const pssh = details[1];
+
+        if (levelkey.format === DRMIdentifiers[this._selectedDrm]) {
+          if (encoding.includes('base64')) {
+            if (DRMIdentifiers[this._selectedDrm] === 'com.microsoft.playready') {
+              this._initData = buildPlayReadyPSSHBox(base64ToArrayBuffer(pssh)); // Playready is particular about the pssh box, so it needs to be handcrafted.
+            } else if (DRMIdentifiers[this._selectedDrm] === 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed') {
+              this._initData = base64ToArrayBuffer(pssh); // Widevine pssh box
+            } else {
+              logger.log('not supported');
+            }
+          }
+
+          this._initDataType = 'cenc';
+        }
+      });
+    }
   }
 }
 

src/hls.js

@@ -198,7 +198,7 @@ export default class Hls extends Observer {
     }
 
     Controller = config.emeController;
-    if (Controller) {
+    if (Controller && config.emeEnabled) {
       const emeController = new Controller(this);
 
       /**

src/loader/m3u8-parser.js

@@ -154,6 +154,7 @@ export default class M3U8Parser {
     let frag = new Fragment();
     let result;
     let i;
+    let drmInfo = [];
 
     let firstPdtIndex = null;
 
@@ -166,7 +167,7 @@ export default class M3U8Parser {
         // avoid sliced strings    https://github.com/video-dev/hls.js/issues/939
         const title = (' ' + result[2]).slice(1);
         frag.title = title || null;
-        frag.tagList.push(title ? [ 'INF', duration, title ] : [ 'INF', duration ]);
+        frag.tagList.push(title ? ['INF', duration, title] : ['INF', duration]);
       } else if (result[3]) { // url
         if (Number.isFinite(frag.duration)) {
           const sn = currentSN++;
@@ -217,7 +218,7 @@ export default class M3U8Parser {
 
         switch (result[i]) {
         case '#':
-          frag.tagList.push(value2 ? [ value1, value2 ] : [ value1 ]);
+          frag.tagList.push(value2 ? [value1, value2] : [value1]);
           break;
         case 'PLAYLIST-TYPE':
           level.type = value1.toUpperCase();
@@ -252,15 +253,18 @@ export default class M3U8Parser {
             decryptiv = keyAttrs.hexadecimalInteger('IV');
           if (decryptmethod) {
             levelkey = new LevelKey();
-            if ((decrypturi) && (['AES-128', 'SAMPLE-AES', 'SAMPLE-AES-CENC'].indexOf(decryptmethod) >= 0)) {
+            if ((decrypturi) && (['AES-128', 'SAMPLE-AES', 'SAMPLE-AES-CENC', 'SAMPLE-AES-CTR'].indexOf(decryptmethod) >= 0)) {
               levelkey.method = decryptmethod;
               // URI to get the key
               levelkey.baseuri = baseurl;
               levelkey.reluri = decrypturi;
               levelkey.key = null;
+              levelkey.format = keyAttrs.KEYFORMAT;
               // Initialization Vector (IV)
               levelkey.iv = decryptiv;
             }
+
+            drmInfo.push(levelkey);
           }
           break;
         case 'START':
@@ -302,6 +306,7 @@ export default class M3U8Parser {
     level.endSN = currentSN - 1;
     level.startCC = level.fragments[0] ? level.fragments[0].cc : 0;
     level.endCC = cc;
+    level.drmInfo = drmInfo;
 
     if (!level.initSegment && level.fragments.length) {
       // this is a bit lurky but HLS really has no other way to tell us