[WIP] Call generateRequest BEFORE pushing any segment with PlayReady

src/compat/should_call_generate_request_before_buffering_media.ts

@@ -0,0 +1,23 @@
+/**
+ * (2024-07-23) We noticed issues with most devices relying on PlayReady when
+ * playing some contents with a mix of encrypted and clear segments (not with
+ * Canal+ own contents weirdly enough, yet with multiple others both encoded
+ * and packaged differently).
+ * The issue fixed itself when we called the
+ * `MediaKeySession.prototype.generateRequest` EME API **BEFORE** any segment
+ * was buffered.
+ *
+ * So this function returns `true` when calling `generateRequest` should
+ * probably be performed before buffering any segment.
+ *
+ * @param {string} keySystem - The key system in use.
+ * @returns {boolean}
+ */
+export default function shouldCallGenerateRequestBeforeBufferingMedia(
+  keySystem: string,
+): boolean {
+  if (keySystem.indexOf("playready") !== -1) {
+    return true;
+  }
+  return false;
+}

src/main_thread/decrypt/content_decryptor.ts

@@ -16,6 +16,7 @@
 
 import type { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat/eme";
 import eme, { getInitData } from "../../compat/eme";
+import shouldCallGenerateRequestBeforeBufferingMedia from "../../compat/should_call_generate_request_before_buffering_media";
 import config from "../../config";
 import { EncryptedMediaError, OtherError } from "../../errors";
 import log from "../../log";
@@ -54,6 +55,7 @@ import {
   areSomeKeyIdsContainedIn,
 } from "./utils/key_id_comparison";
 import type KeySessionRecord from "./utils/key_session_record";
+import performFakeGenerateRequest from "./utils/perform_fake_generate_request";
 
 /**
  * Module communicating with the Content Decryption Module (or CDM) to be able
@@ -291,6 +293,22 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
           return;
         }
 
+        if (
+          shouldCallGenerateRequestBeforeBufferingMedia(mediaKeySystemAccess.keySystem)
+        ) {
+          try {
+            await performFakeGenerateRequest(mediaKeys);
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error("Unknown Error");
+            log.warn("DRM: unable to fully perform fake generateRequest call", error);
+          }
+        }
+
+        if (this._isStopped()) {
+          // We might be stopped since then
+          return;
+        }
+
         const prevState = this._stateData.state;
         this._stateData = {
           state: ContentDecryptorState.ReadyForContent,

src/main_thread/decrypt/find_key_system.ts

@@ -17,10 +17,6 @@
 import { canRelyOnRequestMediaKeySystemAccess } from "../../compat/can_rely_on_request_media_key_system_access";
 import type { ICustomMediaKeySystemAccess } from "../../compat/eme";
 import eme from "../../compat/eme";
-import {
-  generatePlayReadyInitData,
-  DUMMY_PLAY_READY_HEADER,
-} from "../../compat/generate_init_data";
 import shouldRenewMediaKeySystemAccess from "../../compat/should_renew_media_key_system_access";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
@@ -31,6 +27,7 @@ import flatMap from "../../utils/flat_map";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+import performFakeGenerateRequest from "./utils/perform_fake_generate_request";
 
 type MediaKeysRequirement = "optional" | "required" | "not-allowed";
 
@@ -418,9 +415,7 @@ export async function testKeySystem(
   if (!canRelyOnRequestMediaKeySystemAccess(keyType)) {
     try {
       const mediaKeys = await keySystemAccess.createMediaKeys();
-      const session = mediaKeys.createSession();
-      const initData = generatePlayReadyInitData(DUMMY_PLAY_READY_HEADER);
-      await session.generateRequest("cenc", initData);
+      await performFakeGenerateRequest(mediaKeys);
     } catch (err) {
       log.debug("DRM: KeySystemAccess was granted but it is not usable");
       throw err;

src/main_thread/decrypt/utils/perform_fake_generate_request.ts

@@ -0,0 +1,33 @@
+import { closeSession } from "../../../compat/eme";
+import type { ICustomMediaKeys } from "../../../compat/eme";
+import {
+  DUMMY_PLAY_READY_HEADER,
+  generatePlayReadyInitData,
+} from "../../../compat/generate_init_data";
+import log from "../../../log";
+
+/**
+ * The EME API is badly implemented on many devices, leading us toward the need
+ * to perform some heavy work-arounds.
+ *
+ * A frequent one is to call the `MediaKeySession.prototype.generateRequest` API
+ * at some point for dummy data an see if it fails (or not, sometimes just
+ * calling it is important).
+ *
+ * This method does just that, resolving the returned Promise if the
+ * `generateRequest` call could be performed and succeeded or rejecting in other
+ * cases.
+ * @param {MediaKeys} mediaKeys
+ * @returns {Promise}
+ */
+export default async function performFakeGenerateRequest(
+  mediaKeys: MediaKeys | ICustomMediaKeys,
+): Promise<void> {
+  const session = mediaKeys.createSession();
+  const initData = generatePlayReadyInitData(DUMMY_PLAY_READY_HEADER);
+  await session.generateRequest("cenc", initData);
+  closeSession(session).catch((err) => {
+    const error = err instanceof Error ? err : new Error("Unknown Error");
+    log.warn("DRM: unable to close fake MediaKeySession", error);
+  });
+}