rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/manifest/classes/adaptation.ts

@@ -15,7 +15,6 @@
  */
 
 import log from "../../log";
-import type { IAdaptationMetadata, IRepresentationMetadata } from "../../manifest";
 import type { IParsedAdaptation } from "../../parsers/manifest";
 import type {
   ITrackType,
@@ -25,7 +24,12 @@ import type {
 import arrayFind from "../../utils/array_find";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import normalizeLanguage from "../../utils/languages";
-import type { ICodecSupportList } from "./representation";
+import type {
+  IAdaptationMetadata,
+  IRepresentationMetadata,
+  IAdaptationSupportStatus,
+} from "../types";
+import type CodecSupportCache from "./codec_support_cache";
 import Representation from "./representation";
 
 /**
@@ -83,7 +87,7 @@ export default class Adaptation implements IAdaptationMetadata {
   /**
    * @see IRepresentationMetadata
    */
-  public isSupported: boolean | undefined;
+  public supportStatus: IAdaptationSupportStatus;
   /**
    * @see IRepresentationMetadata
    */
@@ -104,6 +108,7 @@ export default class Adaptation implements IAdaptationMetadata {
    */
   constructor(
     parsedAdaptation: IParsedAdaptation,
+    cachedCodecSupport: CodecSupportCache,
     options: {
       representationFilter?: IRepresentationFilter | undefined;
       isManuallyAdded?: boolean | undefined;
@@ -143,14 +148,24 @@ export default class Adaptation implements IAdaptationMetadata {
     }
 
     if (trickModeTracks !== undefined && trickModeTracks.length > 0) {
-      this.trickModeTracks = trickModeTracks.map((track) => new Adaptation(track));
+      this.trickModeTracks = trickModeTracks.map(
+        (track) => new Adaptation(track, cachedCodecSupport),
+      );
     }
 
     const argsRepresentations = parsedAdaptation.representations;
     const representations: Representation[] = [];
-    let isSupported: boolean | undefined;
+    this.supportStatus = {
+      hasSupportedCodec: false,
+      hasCodecWithUndefinedSupport: false,
+      isDecipherable: false,
+    };
     for (let i = 0; i < argsRepresentations.length; i++) {
-      const representation = new Representation(argsRepresentations[i], this.type);
+      const representation = new Representation(
+        argsRepresentations[i],
+        this.type,
+        cachedCodecSupport,
+      );
       let shouldAdd = true;
       if (!isNullOrUndefined(representationFilter)) {
         const reprObject: IRepresentationFilterRepresentation = {
@@ -183,12 +198,20 @@ export default class Adaptation implements IAdaptationMetadata {
       }
       if (shouldAdd) {
         representations.push(representation);
-        if (isSupported === undefined) {
-          if (representation.isSupported === true) {
-            isSupported = true;
-          } else if (representation.isSupported === false) {
-            isSupported = false;
+        if (representation.isSupported === undefined) {
+          this.supportStatus.hasCodecWithUndefinedSupport = true;
+          if (this.supportStatus.hasSupportedCodec === false) {
+            this.supportStatus.hasSupportedCodec = undefined;
           }
+        } else if (representation.isSupported) {
+          this.supportStatus.hasSupportedCodec = true;
+        }
+        if (representation.decipherable === undefined) {
+          if (this.supportStatus.isDecipherable === false) {
+            this.supportStatus.isDecipherable = undefined;
+          }
+        } else if (representation.decipherable) {
+          this.supportStatus.isDecipherable = true;
         }
       } else {
         log.debug(
@@ -203,8 +226,6 @@ export default class Adaptation implements IAdaptationMetadata {
     representations.sort((a, b) => a.bitrate - b.bitrate);
     this.representations = representations;
 
-    this.isSupported = isSupported;
-
     // for manuallyAdded adaptations (not in the manifest)
     this.manuallyAdded = isManuallyAdded === true;
   }
@@ -213,30 +234,42 @@ export default class Adaptation implements IAdaptationMetadata {
    * Some environments (e.g. in a WebWorker) may not have the capability to know
    * if a mimetype+codec combination is supported on the current platform.
    *
-   * Calling `refreshCodecSupport` manually with a clear list of codecs supported
-   * once it has been requested on a compatible environment (e.g. in the main
-   * thread) allows to work-around this issue.
+   * Calling `refreshCodecSupport` manually once the codecs supported are known
+   * by the current environnement allows to work-around this issue.
+   *
    *
    * If the right mimetype+codec combination is found in the provided object,
    * this `Adaptation`'s `isSupported` property will be updated accordingly as
    * well as all of its inner `Representation`'s `isSupported` attributes.
    *
-   * @param {Array.<Object>} supportList
+   * @param {Array.<Object>} cachedCodecSupport
    */
-  refreshCodecSupport(supportList: ICodecSupportList): void {
+  refreshCodecSupport(cachedCodecSupport: CodecSupportCache): void {
+    let hasCodecWithUndefinedSupport = false;
+    let hasSupportedRepresentation = false;
     for (const representation of this.representations) {
+      representation.refreshCodecSupport(cachedCodecSupport);
       if (representation.isSupported === undefined) {
-        representation.refreshCodecSupport(supportList);
-        if (this.isSupported !== true && representation.isSupported === true) {
-          this.isSupported = true;
-        } else if (
-          this.isSupported === undefined &&
-          representation.isSupported === false
-        ) {
-          this.isSupported = false;
-        }
+        hasCodecWithUndefinedSupport = true;
+      } else if (representation.isSupported) {
+        hasSupportedRepresentation = true;
       }
     }
+
+    if (hasSupportedRepresentation) {
+      /* The adaptation is supported because at least one representation is supported */
+      this.supportStatus.hasSupportedCodec = true;
+    } else if (hasCodecWithUndefinedSupport) {
+      /* The adaptation support is unknown because there is no representation explicitly
+      supported but there is codec with unknown support */
+      this.supportStatus.hasSupportedCodec = undefined;
+    } else {
+      /* All codecs support are known and no codecs are supported, adaptation
+      is not supported */
+      this.supportStatus.hasSupportedCodec = false;
+    }
+
+    this.supportStatus.hasCodecWithUndefinedSupport = hasCodecWithUndefinedSupport;
   }
 
   /**
@@ -271,7 +304,7 @@ export default class Adaptation implements IAdaptationMetadata {
     return {
       id: this.id,
       type: this.type,
-      isSupported: this.isSupported,
+      supportStatus: this.supportStatus,
       language: this.language,
       isForcedSubtitles: this.isForcedSubtitles,
       isClosedCaption: this.isClosedCaption,

package/src/manifest/classes/codec_support_cache.ts

@@ -0,0 +1,82 @@
+/**
+ * Interface representing codec and support information.
+ */
+export interface ICodecSupportInfo extends ICodecSupportMatrix {
+  mimeType: string;
+  codec: string;
+}
+/**
+ * Interface representing support information.
+ */
+interface ICodecSupportMatrix {
+  supported?: boolean | undefined;
+  supportedIfEncrypted?: boolean | undefined;
+}
+/**
+ * Class setting up a cache of which codec is currently known to be supported or
+ * not.
+ *
+ * We keep this only at the Manifest level because external conditions can change
+ * from Manifest to Manifest (e.g. not the same decryption cabalities used etc.).
+ */
+export default class CodecSupportCache {
+  public supportMap: Map<string, Map<string, ICodecSupportMatrix>>;
+
+  /**
+   * Constructs an CodecSupportCache instance.
+   * @param {Array} codecList - List of codec support information.
+   */
+  constructor(codecList: ICodecSupportInfo[]) {
+    this.supportMap = new Map();
+    this.addCodecs(codecList);
+  }
+
+  /**
+   * Adds codec support information to this `CodecSupportCache`.
+   * @param {Array} codecList - List of codec support information.
+   */
+  public addCodecs(codecList: ICodecSupportInfo[]) {
+    for (const codec of codecList) {
+      let mimeTypeMap = this.supportMap.get(codec.mimeType);
+      if (mimeTypeMap === undefined) {
+        mimeTypeMap = new Map();
+        this.supportMap.set(codec.mimeType, mimeTypeMap);
+      }
+
+      mimeTypeMap.set(codec.codec, {
+        supported: codec.supported,
+        supportedIfEncrypted: codec.supportedIfEncrypted,
+      });
+    }
+  }
+
+  /**
+   * Checks if a codec is supported for a given MIME type.
+   * @param {string} mimeType - The MIME type to check.
+   * @param {string} codec - The codec to check.
+   * @param {boolean} isEncrypted - Whether the content is encrypted.
+   * @returns {boolean | undefined} - `true` if the codec is supported, `false`
+   * if not, or `undefined` if no support information is found.
+   */
+  public isSupported(
+    mimeType: string,
+    codec: string,
+    isEncrypted: boolean,
+  ): boolean | undefined {
+    const mimeTypeMap = this.supportMap.get(mimeType);
+    if (mimeTypeMap === undefined) {
+      return undefined;
+    }
+
+    const result = mimeTypeMap.get(codec);
+    if (result === undefined) {
+      return undefined;
+    }
+
+    if (isEncrypted) {
+      return result.supportedIfEncrypted;
+    } else {
+      return result.supported;
+    }
+  }
+}

package/src/manifest/classes/index.ts

@@ -15,10 +15,10 @@
  */
 
 import Adaptation from "./adaptation";
+import type { ICodecSupportInfo } from "./codec_support_cache";
 import type { IDecipherabilityUpdateElement, IManifestParsingOptions } from "./manifest";
 import Manifest from "./manifest";
 import Period from "./period";
-import type { ICodecSupportList } from "./representation";
 import Representation from "./representation";
 import type {
   IMetaPlaylistPrivateInfos,
@@ -35,7 +35,7 @@ export * from "./types";
 export type { IPeriodsUpdateResult } from "./update_periods";
 export type {
   IBufferedChunkInfos,
-  ICodecSupportList,
+  ICodecSupportInfo,
   IDecipherabilityUpdateElement,
   IManifestParsingOptions,
   IMetaPlaylistPrivateInfos,

package/src/manifest/classes/manifest.ts

@@ -16,6 +16,7 @@
 
 import { MediaError } from "../../errors";
 import log from "../../log";
+import { getCodecsWithUnknownSupport } from "../../main_thread/init/utils/update_manifest_codec_support";
 import type { IParsedManifest } from "../../parsers/manifest";
 import type { ITrackType, IRepresentationFilter, IPlayerError } from "../../public_types";
 import arrayFind from "../../utils/array_find";
@@ -38,9 +39,10 @@ import {
   toTaggedTrack,
 } from "../utils";
 import type Adaptation from "./adaptation";
+import CodecSupportCache from "./codec_support_cache";
+import type { ICodecSupportInfo } from "./codec_support_cache";
 import type { IManifestAdaptations } from "./period";
 import Period from "./period";
-import type { ICodecSupportList } from "./representation";
 import type Representation from "./representation";
 import { MANIFEST_UPDATE_TYPE } from "./types";
 import type { IPeriodsUpdateResult } from "./update_periods";
@@ -74,6 +76,8 @@ export interface IManifestEvents {
   manifestUpdate: IPeriodsUpdateResult;
   /** Some Representation's decipherability status has been updated */
   decipherabilityUpdate: IDecipherabilityUpdateElement[];
+  /** Some Representation's support status has been updated */
+  supportUpdate: null;
 }
 
 /**
@@ -299,6 +303,12 @@ export default class Manifest
     };
   };
 
+  /**
+   * Caches the information if a codec is supported or not in the context of the
+   * current content.
+   */
+  private _cachedCodecSupport: CodecSupportCache;
+
   /**
    * Construct a Manifest instance from a parsed Manifest object (as returned by
    * Manifest parsers) and options.
@@ -322,6 +332,7 @@ export default class Manifest
     this.expired = parsedManifest.expired ?? null;
     this.transport = parsedManifest.transportType;
     this.clockOffset = parsedManifest.clockOffset;
+    this._cachedCodecSupport = new CodecSupportCache([]);
 
     const unsupportedAdaptations: Adaptation[] = [];
     this.periods = parsedManifest.periods
@@ -329,6 +340,7 @@ export default class Manifest
         const period = new Period(
           parsedPeriod,
           unsupportedAdaptations,
+          this._cachedCodecSupport,
           representationFilter,
         );
         return period;
@@ -370,21 +382,28 @@ export default class Manifest
    * Some environments (e.g. in a WebWorker) may not have the capability to know
    * if a mimetype+codec combination is supported on the current platform.
    *
-   * Calling `refreshCodecSupport` manually with a clear list of codecs supported
-   * once it has been requested on a compatible environment (e.g. in the main
-   * thread) allows to work-around this issue.
+   * Calling `updateCodecSupport` manually once the codecs supported are known
+   * by the current environnement allows to work-around this issue.
    *
-   * @param {Array.<Object>} supportList
+   * @param {Array<Object>} [updatedCodecSupportInfo]
    * @returns {Error|null} - Refreshing codec support might reveal that some
    * `Adaptation` don't have any of their `Representation`s supported.
    * In that case, an error object will be created and returned, so you can
    * e.g. later emit it as a warning through the RxPlayer API.
    */
-  public refreshCodecSupport(supportList: ICodecSupportList): MediaError | null {
+  public updateCodecSupport(
+    updatedCodecSupportInfo: ICodecSupportInfo[] = [],
+  ): MediaError | null {
+    if (updatedCodecSupportInfo.length === 0) {
+      return null;
+    }
+
+    this._cachedCodecSupport.addCodecs(updatedCodecSupportInfo);
     const unsupportedAdaptations: Adaptation[] = [];
     for (const period of this.periods) {
-      period.refreshCodecSupport(supportList, unsupportedAdaptations);
+      period.refreshCodecSupport(unsupportedAdaptations, this._cachedCodecSupport);
     }
+    this.trigger("supportUpdate", null);
     if (unsupportedAdaptations.length > 0) {
       return new MediaError(
         "MANIFEST_INCOMPATIBLE_CODECS_ERROR",
@@ -499,6 +518,10 @@ export default class Manifest
     return getMaximumSafePosition(this);
   }
 
+  public updateCodecSupportList(cachedCodecSupport: CodecSupportCache) {
+    this._cachedCodecSupport = cachedCodecSupport;
+  }
+
   /**
    * Look in the Manifest for Representations linked to the given key ID,
    * and mark them as being impossible to decrypt.
@@ -612,6 +635,20 @@ export default class Manifest
     };
   }
 
+  /**
+   * Returns a list of all codecs that the support is not known yet.
+   * If a representation with (`isSupported`) is undefined, we consider the
+   * codec support as unknown.
+   *
+   * This function iterates through all periods, adaptations, and representations,
+   * and collects unknown codecs.
+   *
+   * @returns {Array} The list of codecs with unknown support status.
+   */
+  public getCodecsWithUnknownSupport(): Array<{ mimeType: string; codec: string }> {
+    return getCodecsWithUnknownSupport(this);
+  }
+
   /**
    * @param {Object} newManifest
    * @param {number} updateType
@@ -651,6 +688,8 @@ export default class Manifest
       }
     }
 
+    this.updateCodecSupport();
+
     // Re-set this.adaptations for retro-compatibility in v3.x.x
     /* eslint-disable import/no-deprecated */
     this.adaptations = this.periods[0] === undefined ? {} : this.periods[0].adaptations;
@@ -686,12 +725,24 @@ function updateDeciperability(
   const updates: IDecipherabilityUpdateElement[] = [];
   for (const period of manifest.periods) {
     for (const adaptation of period.getAdaptations()) {
+      let hasOnlyUndecipherableRepresentations = true;
       for (const representation of adaptation.representations) {
         const content = { manifest, period, adaptation, representation };
         const result = isDecipherable(content);
+        if (result !== false) {
+          hasOnlyUndecipherableRepresentations = false;
+        }
         if (result !== representation.decipherable) {
           updates.push(content);
           representation.decipherable = result;
+          if (result === true) {
+            adaptation.supportStatus.isDecipherable = true;
+          } else if (
+            result === undefined &&
+            adaptation.supportStatus.isDecipherable === false
+          ) {
+            adaptation.supportStatus.isDecipherable = undefined;
+          }
           log.debug(
             `Decipherability changed for "${representation.id}"`,
             `(${representation.bitrate})`,
@@ -699,6 +750,9 @@ function updateDeciperability(
           );
         }
       }
+      if (hasOnlyUndecipherableRepresentations) {
+        adaptation.supportStatus.isDecipherable = false;
+      }
     }
   }
   return updates;

package/src/manifest/classes/period.ts

@@ -21,7 +21,7 @@ import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import type { IAdaptationMetadata, IPeriodMetadata } from "../types";
 import { getAdaptations, getSupportedAdaptations, periodContainsTime } from "../utils";
 import Adaptation from "./adaptation";
-import type { ICodecSupportList } from "./representation";
+import type CodecSupportCache from "./codec_support_cache";
 
 /** Structure listing every `Adaptation` in a Period. */
 export type IManifestAdaptations = Partial<Record<ITrackType, Adaptation[]>>;
@@ -68,6 +68,8 @@ export default class Period implements IPeriodMetadata {
   constructor(
     args: IParsedPeriod,
     unsupportedAdaptations: Adaptation[],
+    cachedCodecSupport: CodecSupportCache,
+
     representationFilter?: IRepresentationFilter | undefined,
   ) {
     this.id = args.id;
@@ -80,12 +82,12 @@ export default class Period implements IPeriodMetadata {
       }
       const filteredAdaptations = adaptationsForType
         .map((adaptation): Adaptation => {
-          const newAdaptation = new Adaptation(adaptation, {
+          const newAdaptation = new Adaptation(adaptation, cachedCodecSupport, {
             representationFilter,
           });
           if (
             newAdaptation.representations.length > 0 &&
-            newAdaptation.isSupported === false
+            newAdaptation.supportStatus.hasSupportedCodec === false
           ) {
             unsupportedAdaptations.push(newAdaptation);
           }
@@ -95,7 +97,9 @@ export default class Period implements IPeriodMetadata {
           (adaptation): adaptation is Adaptation => adaptation.representations.length > 0,
         );
       if (
-        filteredAdaptations.every((adaptation) => adaptation.isSupported === false) &&
+        filteredAdaptations.every(
+          (adaptation) => adaptation.supportStatus.hasSupportedCodec === false,
+        ) &&
         adaptationsForType.length > 0 &&
         (type === "video" || type === "audio")
       ) {
@@ -135,19 +139,18 @@ export default class Period implements IPeriodMetadata {
    * Some environments (e.g. in a WebWorker) may not have the capability to know
    * if a mimetype+codec combination is supported on the current platform.
    *
-   * Calling `refreshCodecSupport` manually with a clear list of codecs supported
-   * once it has been requested on a compatible environment (e.g. in the main
-   * thread) allows to work-around this issue.
+   * Calling `refreshCodecSupport` manually once the codecs supported are known
+   * by the current environnement allows to work-around this issue.
    *
-   * @param {Array.<Object>} supportList
    * @param {Array.<Object>} unsupportedAdaptations - Array on which
    * `Adaptation`s objects which are now known to have no supported
    * `Representation` will be pushed.
    * This array might be useful for minor error reporting.
+   * @param {Array.<Object>} cachedCodecSupport
    */
   refreshCodecSupport(
-    supportList: ICodecSupportList,
     unsupportedAdaptations: Adaptation[],
+    cachedCodecSupport: CodecSupportCache,
   ) {
     (Object.keys(this.adaptations) as ITrackType[]).forEach((ttype) => {
       const adaptationsForType = this.adaptations[ttype];
@@ -156,17 +159,30 @@ export default class Period implements IPeriodMetadata {
       }
       let hasSupportedAdaptations: boolean | undefined = false;
       for (const adaptation of adaptationsForType) {
-        const wasSupported = adaptation.isSupported;
-        adaptation.refreshCodecSupport(supportList);
-        if (wasSupported !== false && adaptation.isSupported === false) {
+        if (!adaptation.supportStatus.hasCodecWithUndefinedSupport) {
+          // Go to next adaptation as an optimisation measure.
+          // NOTE this only is true if we never change a codec from supported
+          // to unsuported and its opposite.
+
+          if (adaptation.supportStatus.hasSupportedCodec === true) {
+            hasSupportedAdaptations = true;
+          }
+          continue;
+        }
+        const wasSupported = adaptation.supportStatus.hasSupportedCodec;
+        adaptation.refreshCodecSupport(cachedCodecSupport);
+        if (
+          wasSupported !== false &&
+          adaptation.supportStatus.hasSupportedCodec === false
+        ) {
           unsupportedAdaptations.push(adaptation);
         }
 
         if (hasSupportedAdaptations === false) {
-          hasSupportedAdaptations = adaptation.isSupported;
+          hasSupportedAdaptations = adaptation.supportStatus.hasSupportedCodec;
         } else if (
           hasSupportedAdaptations === undefined &&
-          adaptation.isSupported === true
+          adaptation.supportStatus.hasSupportedCodec === true
         ) {
           hasSupportedAdaptations = true;
         }