rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/manifest/classes/representation.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import features from "../../features";
 import log from "../../log";
 import type { IRepresentationMetadata } from "../../manifest";
 import type {
@@ -25,6 +24,7 @@ import type {
 import type { ITrackType, IHDRInformation } from "../../public_types";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import idGenerator from "../../utils/id_generator";
+import type codecSupportCache from "./codec_support_cache";
 import type { IRepresentationIndex } from "./representation_index";
 
 const generateRepresentationUniqueId = idGenerator();
@@ -100,16 +100,25 @@ class Representation implements IRepresentationMetadata {
    * @see IRepresentationMetadata
    */
   public isSupported: boolean | undefined;
+  /**
+   * @see ITrackType
+   */
+  public trackType: ITrackType;
 
   /**
    * @param {Object} args
    * @param {string} trackType
    */
-  constructor(args: IParsedRepresentation, trackType: ITrackType) {
+  constructor(
+    args: IParsedRepresentation,
+    trackType: ITrackType,
+    cachedCodecSupport: codecSupportCache,
+  ) {
     this.id = args.id;
     this.uniqueId = generateRepresentationUniqueId();
     this.bitrate = args.bitrate;
     this.codecs = [];
+    this.trackType = trackType;
 
     if (args.isSpatialAudio !== undefined) {
       this.isSpatialAudio = args.isSpatialAudio;
@@ -142,42 +151,36 @@ class Representation implements IRepresentationMetadata {
     this.cdnMetadata = args.cdnMetadata;
     this.index = args.index;
 
+    const isEncrypted = this.contentProtections !== undefined;
+
     if (trackType === "audio" || trackType === "video") {
-      if (features.codecSupportProber !== null) {
-        // Supplemental codecs are defined as backwards-compatible codecs enhancing
-        // the experience of a base layer codec
-        if (args.supplementalCodecs !== undefined) {
-          const isSupplementaryCodecSupported = features.codecSupportProber.isSupported(
+      // Supplemental codecs are defined as backwards-compatible codecs enhancing
+      // the experience of a base layer codec
+      if (args.supplementalCodecs !== undefined) {
+        const isSupplementaryCodecSupported = cachedCodecSupport.isSupported(
+          this.mimeType ?? "",
+          args.supplementalCodecs ?? "",
+          isEncrypted,
+        );
+
+        if (isSupplementaryCodecSupported !== false) {
+          this.codecs = [args.supplementalCodecs];
+          this.isSupported = isSupplementaryCodecSupported;
+        }
+      }
+      if (this.isSupported !== true) {
+        if (this.codecs.length > 0) {
+          // We couldn't check for support of another supplemental codec.
+          // Just push that codec without testing support yet, we'll check
+          // support later.
+          this.codecs.push(args.codecs ?? "");
+        } else {
+          this.codecs = args.codecs === undefined ? [] : [args.codecs];
+          this.isSupported = cachedCodecSupport.isSupported(
             this.mimeType ?? "",
-            args.supplementalCodecs ?? "",
+            args.codecs ?? "",
+            isEncrypted,
           );
-          if (isSupplementaryCodecSupported !== false) {
-            this.codecs = [args.supplementalCodecs];
-            if (isSupplementaryCodecSupported === true) {
-              this.isSupported = true;
-            }
-          }
-        }
-        if (this.isSupported !== true) {
-          if (this.codecs.length > 0) {
-            // We couldn't check for support of another supplemental codec.
-            // Just push that codec without testing support yet, we'll check
-            // support later.
-            this.codecs.push(args.codecs ?? "");
-          } else {
-            this.codecs = args.codecs === undefined ? [] : [args.codecs];
-            this.isSupported = features.codecSupportProber.isSupported(
-              this.mimeType ?? "",
-              args.codecs ?? "",
-            );
-          }
-        }
-      } else {
-        if (args.supplementalCodecs !== undefined) {
-          this.codecs.push(args.supplementalCodecs);
-        }
-        if (args.codecs !== undefined) {
-          this.codecs.push(args.codecs);
         }
       }
     } else {
@@ -192,44 +195,50 @@ class Representation implements IRepresentationMetadata {
    * 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 `Representation`'s `isSupported` property will be updated accordingly.
    *
-   * @param {Array.<Object>} supportList
+   * @param {Array.<Object>} cachedCodecSupport;
    */
-  public refreshCodecSupport(supportList: ICodecSupportList): void {
+  public refreshCodecSupport(cachedCodecSupport: codecSupportCache) {
+    if (this.isSupported !== undefined) {
+      return;
+    }
+
+    const isEncrypted = this.contentProtections !== undefined;
+    let isSupported: boolean | undefined = false;
     const mimeType = this.mimeType ?? "";
-    let codecs = this.codecs;
+    let codecs = this.codecs ?? [];
     if (codecs.length === 0) {
       codecs = [""];
     }
-
-    // Go through each codec, from the most detailed to the most compatible one
-    for (let codecIdx = 0; codecIdx < codecs.length; codecIdx++) {
-      // Find out if an entry is present for it in the support list
-      for (const obj of supportList) {
-        const codec = codecs[codecIdx];
-        if (obj.codec === codec && obj.mimeType === mimeType) {
-          if (obj.result) {
-            // We found that this codec was supported. Remove all reference to
-            // other codecs which are either unsupported, less detailed, or
-            // both and anounce support.
-            this.isSupported = true;
-            this.codecs = [codec];
-            return;
-          } else if (codecIdx === codecs.length) {
-            // The last more compatible codec, was still found unsupported,
-            // this Representation is not decodable.
-            // Put the more compatible codec only for the API.
-            this.isSupported = false;
-            this.codecs = [codec];
-            return;
-          }
-        }
+    let representationHasUnknownCodecs = false;
+    for (const codec of codecs) {
+      isSupported = cachedCodecSupport.isSupported(mimeType, codec, isEncrypted);
+      if (isSupported === true) {
+        this.codecs = [codec];
+        break;
+      }
+      if (isSupported === undefined) {
+        representationHasUnknownCodecs = true;
+      }
+    }
+    /** If any codec is supported, the representation is supported */
+    if (isSupported === true) {
+      this.isSupported = true;
+    } else {
+      /** If some codecs support are not known it's too early to assume
+       *  representation is unsupported */
+      if (representationHasUnknownCodecs) {
+        this.isSupported = undefined;
+      } else {
+        /** If all codecs support are known and none are supported,
+         * the representation is not supported.
+         */
+        this.isSupported = false;
       }
     }
   }
@@ -478,10 +487,4 @@ export interface IRepresentationProtectionData {
   }>;
 }
 
-export type ICodecSupportList = Array<{
-  codec: string;
-  mimeType: string;
-  result: boolean;
-}>;
-
 export default Representation;

package/src/manifest/index.ts

@@ -1,6 +1,6 @@
 import type {
   IDecipherabilityUpdateElement,
-  ICodecSupportList,
+  ICodecSupportInfo,
   Period,
   Adaptation,
   Representation,
@@ -27,7 +27,7 @@ export type IRepresentation = Representation;
 
 export type {
   IDecipherabilityUpdateElement,
-  ICodecSupportList,
+  ICodecSupportInfo,
   IPeriodsUpdateResult,
   IRepresentationIndex,
   ISegment,

package/src/manifest/types.ts

@@ -256,6 +256,36 @@ export interface IPeriodMetadata {
   streamEvents: IManifestStreamEvent[];
 }
 
+/**
+ * Object describing the global support state for an Adaptation's
+ * Representations.
+ */
+export interface IAdaptationSupportStatus {
+  /**
+   * `true` if at least one of its Representation has a codecs currently
+   * supported.
+   * `false` if this is not the case.
+   * `undefined` if this is not known yet.
+   */
+  hasSupportedCodec: boolean | undefined;
+  /**
+   * `true` if some of its Representation's codec support is `undefined` - and
+   * thus needs to be checked.
+   *
+   * `false` if support is known for all codecs associated to this Adaptation's
+   * Representations.
+   */
+  hasCodecWithUndefinedSupport: boolean;
+  /**
+   * `true` if at least one of its Representation is known to be decipherable.
+   *
+   * `false` if none of its Representation are decipherable.
+   *
+   * `undefined` if this is unknown.
+   */
+  isDecipherable: boolean | undefined;
+}
+
 export interface IAdaptationMetadata {
   /** ID uniquely identifying the Adaptation in the Period. */
   id: string;
@@ -277,12 +307,10 @@ export interface IAdaptationMetadata {
    */
   isForcedSubtitles?: boolean | undefined;
   /**
-   * `true` if at least one Representation is in a supported codec. `false` otherwise.
-   *
-   * `undefined` for when this is not yet known (we're still in the process of
-   * probing for support).
+   * Object describing the global support state for that Adaptation's
+   * Representations.
    */
-  isSupported?: boolean | undefined;
+  supportStatus: IAdaptationSupportStatus;
   /** Language this Adaptation is in, when translated into an ISO639-3 code. */
   normalizedLanguage?: string | undefined;
   /**

package/src/manifest/utils.ts

@@ -84,7 +84,7 @@ export function getMaximumSafePosition(manifest: IManifestMetadata): number {
 }
 
 /**
- * Returns Adaptations that contain Representations in supported codecs.
+ * Returns Adaptations that contain supported Representation(s).
  * @param {string|undefined} type - If set filter on a specific Adaptation's
  * type. Will return for all types if `undefined`.
  * @returns {Array.<Adaptation>}
@@ -103,7 +103,10 @@ export function getSupportedAdaptations(
 ): IAdaptationMetadata[] | IAdaptation[] {
   if (type === undefined) {
     return getAdaptations(period).filter((ada) => {
-      return ada.isSupported === true;
+      return (
+        ada.supportStatus.hasSupportedCodec !== false &&
+        ada.supportStatus.isDecipherable !== false
+      );
     });
   }
   const adaptationsForType = period.adaptations[type];
@@ -111,7 +114,10 @@ export function getSupportedAdaptations(
     return [];
   }
   return adaptationsForType.filter((ada) => {
-    return ada.isSupported === true;
+    return (
+      ada.supportStatus.hasSupportedCodec !== false &&
+      ada.supportStatus.isDecipherable !== false
+    );
   });
 }
 
@@ -503,13 +509,28 @@ function updateRepresentationsDeciperability(
       [],
     );
     for (const adaptation of adaptations) {
+      let hasOnlyUndecipherableRepresentations = true;
       for (const representation of adaptation.representations) {
         const result = isDecipherable(representation);
+        if (result !== false) {
+          hasOnlyUndecipherableRepresentations = false;
+        }
         if (result !== representation.decipherable) {
+          if (result === true) {
+            adaptation.supportStatus.isDecipherable = true;
+          } else if (
+            result === undefined &&
+            adaptation.supportStatus.isDecipherable === false
+          ) {
+            adaptation.supportStatus.isDecipherable = undefined;
+          }
           updates.push({ manifest, period, adaptation, representation });
           representation.decipherable = result;
         }
       }
+      if (hasOnlyUndecipherableRepresentations) {
+        adaptation.supportStatus.isDecipherable = false;
+      }
     }
   }
   return updates;
@@ -602,7 +623,7 @@ export function replicateUpdatesOnManifestMetadata(
                     for (const prop of Object.keys(newRepresentation) as Array<
                       keyof IRepresentationMetadata
                     >) {
-                      if (prop !== "decipherable" && prop !== "isSupported") {
+                      if (prop !== "decipherable") {
                         // eslint-disable-next-line
                         (baseRepresentation as any)[prop] = newRepresentation[prop];
                       }

package/src/minimal.ts

@@ -23,22 +23,15 @@
 
 import isDebugModeEnabled from "./compat/is_debug_mode_enabled";
 import patchWebkitSourceBuffer from "./compat/patch_webkit_source_buffer";
-import features from "./features";
 import logger from "./log";
 import Player from "./main_thread/api";
-import MainCodecSupportProber from "./mse/main_codec_support_prober";
 
 patchWebkitSourceBuffer();
 
-// TODO this should be auto-imported when the various features that needs it
-// are added.
-// For now, I'm scare of breaking things so I'm not removing it yet.
-features.codecSupportProber = MainCodecSupportProber;
-
 if (isDebugModeEnabled()) {
-  logger.setLevel("DEBUG");
+  logger.setLevel("DEBUG", "standard");
 } else if ((__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.DEV as number)) {
-  logger.setLevel(__LOGGER_LEVEL__.CURRENT_LEVEL);
+  logger.setLevel(__LOGGER_LEVEL__.CURRENT_LEVEL, "standard");
 }
 
 /**

package/src/mse/index.ts

@@ -2,6 +2,5 @@ export type {
   IMediaSourceInterface,
   ISourceBufferInterface,
   ISourceBufferInterfaceAppendBufferParameters,
-  ICodecSupportProber,
 } from "./types";
 export { SourceBufferType } from "./types";

package/src/mse/main_media_source_interface.ts

@@ -1,3 +1,4 @@
+import type { IMediaSource, ISourceBuffer } from "../compat/browser_compatibility_types";
 import { MediaSource_ } from "../compat/browser_compatibility_types";
 import tryToChangeSourceBufferType from "../compat/change_source_buffer_type";
 import { onSourceClose, onSourceEnded, onSourceOpen } from "../compat/event_listeners";
@@ -44,7 +45,7 @@ export default class MainMediaSourceInterface
   /** @see IMediaSourceInterface */
   public readyState: ReadyState;
   /** The MSE `MediaSource` instance linked to that `IMediaSourceInterface`. */
-  private _mediaSource: MediaSource;
+  private _mediaSource: IMediaSource;
   /**
    * Abstraction allowing to set and update the MediaSource's duration.
    */
@@ -83,12 +84,13 @@ export default class MainMediaSourceInterface
 
     log.info("Init: Creating MediaSource");
     const mediaSource = new MediaSource_();
-    this.readyState = mediaSource.readyState;
     const handle = (mediaSource as unknown as { handle: MediaProvider }).handle;
     this.handle = isNullOrUndefined(handle)
-      ? { type: "media-source", value: mediaSource }
+      ? /* eslint-disable-next-line @typescript-eslint/no-restricted-types */
+        { type: "media-source", value: mediaSource as unknown as MediaSource }
       : { type: "handle", value: handle };
     this._mediaSource = mediaSource;
+    this.readyState = mediaSource.readyState;
     this._durationUpdater = new MediaSourceDurationUpdater(mediaSource);
     this._endOfStreamCanceller = null;
     onSourceOpen(
@@ -181,7 +183,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
    */
   private _canceller: TaskCanceller;
   /** The MSE `SourceBuffer` instance linked to that `ISourceBufferInterface`. */
-  private _sourceBuffer: SourceBuffer;
+  private _sourceBuffer: ISourceBuffer;
   /**
    * Queue of operations, from the most to the least urgent, currently waiting
    * their turn to be performed on the `SourceBuffer`.
@@ -202,7 +204,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
    * @param {string} codec
    * @param {SourceBuffer} sourceBuffer
    */
-  constructor(sbType: SourceBufferType, codec: string, sourceBuffer: SourceBuffer) {
+  constructor(sbType: SourceBufferType, codec: string, sourceBuffer: ISourceBuffer) {
     this.type = sbType;
     this.codec = codec;
     this._canceller = new TaskCanceller();
@@ -255,11 +257,12 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
       }
       this._performNextOperation();
     };
-    sourceBuffer.addEventListener("error", onError);
+
     sourceBuffer.addEventListener("updateend", onUpdateEnd);
+    sourceBuffer.addEventListener("error", onError);
     this._canceller.signal.register(() => {
-      sourceBuffer.removeEventListener("error", onError);
       sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+      sourceBuffer.removeEventListener("error", onError);
     });
   }
 
@@ -543,7 +546,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
   }
 }
 
-function resetMediaSource(mediaSource: MediaSource): void {
+function resetMediaSource(mediaSource: IMediaSource): void {
   if (mediaSource.readyState !== "closed") {
     const { readyState, sourceBuffers } = mediaSource;
     for (let i = sourceBuffers.length - 1; i >= 0; i--) {

package/src/mse/types.ts

@@ -163,6 +163,7 @@ export type IMediaSourceHandle =
        * Do not forget to revoke such URL (e.g. through `URL.revokeObjectURL`) when
        * you're done.
        */
+      /* eslint-disable-next-line @typescript-eslint/no-restricted-types */
       value: MediaSource;
     };
 
@@ -282,33 +283,3 @@ export interface IMediaSourceInterfaceEvents {
    */
   mediaSourceClose: null;
 }
-
-/**
- * Object allowing to probe for codec support, regarless of the environment
- * (e.g. in a WebWorker or in the main thread - which may have different API).
- */
-export interface ICodecSupportProber {
-  /**
-   * Probe for codec support of the given mime-type + codec combination,
-   * returning a boolean which is `true` when that combination is supported on
-   * the current browser, `false` when it is not or `undefined` if it cannot
-   * be known currently.
-   *
-   * @param {string} mimeType
-   * @param {string} codec
-   * @returns {boolean|undefined}
-   */
-  isSupported(mimeType: string, codec: string): boolean | undefined;
-  /**
-   * Some implementations may rely on a caching mechanism to improve the
-   * pertinence / speed of `isSupported`.
-   *
-   * Calling this method allows to add the entry refered by these arguments to
-   * the cache.
-   *
-   * @param {string} mimeType
-   * @param {string} codec
-   * @param {boolean} isSupported
-   */
-  updateCache?: (mimeType: string, codec: string, isSupported: boolean) => void;
-}

package/src/mse/utils/end_of_stream.ts

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+import type {
+  IMediaSource,
+  ISourceBuffer,
+  ISourceBufferList,
+} from "../../compat/browser_compatibility_types";
 import {
   onRemoveSourceBuffers,
   onSourceOpen,
@@ -28,8 +33,8 @@ import TaskCanceller from "../../utils/task_canceller";
  * @param {SourceBufferList} sourceBuffers
  * @returns {Array.<SourceBuffer>}
  */
-function getUpdatingSourceBuffers(sourceBuffers: SourceBufferList): SourceBuffer[] {
-  const updatingSourceBuffers: SourceBuffer[] = [];
+function getUpdatingSourceBuffers(sourceBuffers: ISourceBufferList): ISourceBuffer[] {
+  const updatingSourceBuffers: ISourceBuffer[] = [];
   for (let i = 0; i < sourceBuffers.length; i++) {
     const SourceBuffer = sourceBuffers[i];
     if (SourceBuffer.updating) {
@@ -49,7 +54,7 @@ function getUpdatingSourceBuffers(sourceBuffers: SourceBufferList): SourceBuffer
  * @param {Object} cancelSignal
  */
 export default function triggerEndOfStream(
-  mediaSource: MediaSource,
+  mediaSource: IMediaSource,
   cancelSignal: CancellationSignal,
 ): void {
   log.debug("Init: Trying to call endOfStream");
@@ -106,7 +111,7 @@ export default function triggerEndOfStream(
  * @param {Object} cancelSignal
  */
 export function maintainEndOfStream(
-  mediaSource: MediaSource,
+  mediaSource: IMediaSource,
   cancelSignal: CancellationSignal,
 ): void {
   let endOfStreamCanceller = new TaskCanceller();

package/src/mse/utils/media_source_duration_updater.ts

@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 
+import type {
+  IMediaSource,
+  ISourceBufferList,
+} from "../../compat/browser_compatibility_types";
 import { onSourceOpen, onSourceEnded, onSourceClose } from "../../compat/event_listeners";
 import hasIssuesWithHighMediaSourceDuration from "../../compat/has_issues_with_high_media_source_duration";
 import log from "../../log";
@@ -34,7 +38,7 @@ export default class MediaSourceDurationUpdater {
   /**
    * `MediaSource` on which we're going to update the `duration` attribute.
    */
-  private _mediaSource: MediaSource;
+  private _mediaSource: IMediaSource;
 
   /**
    * Abort the current duration-setting logic.
@@ -47,7 +51,7 @@ export default class MediaSourceDurationUpdater {
    * @param {MediaSource} mediaSource - The MediaSource on which the content is
    * played.
    */
-  constructor(mediaSource: MediaSource) {
+  constructor(mediaSource: IMediaSource) {
     this._mediaSource = mediaSource;
     this._currentMediaSourceDurationUpdateCanceller = null;
   }
@@ -150,7 +154,7 @@ export default class MediaSourceDurationUpdater {
  * @returns {string}
  */
 function setMediaSourceDuration(
-  mediaSource: MediaSource,
+  mediaSource: IMediaSource,
   duration: number,
   isRealEndKnown: boolean,
 ): MediaSourceDurationUpdateStatus {
@@ -245,7 +249,7 @@ const enum MediaSourceDurationUpdateStatus {
  * @returns {Object}
  */
 function createSourceBuffersUpdatingReference(
-  sourceBuffers: SourceBufferList,
+  sourceBuffers: ISourceBufferList,
   cancelSignal: CancellationSignal,
 ): IReadOnlySharedReference<boolean> {
   if (sourceBuffers.length === 0) {
@@ -289,7 +293,7 @@ function createSourceBuffersUpdatingReference(
  * @returns {Object}
  */
 function createMediaSourceOpenReference(
-  mediaSource: MediaSource,
+  mediaSource: IMediaSource,
   cancelSignal: CancellationSignal,
 ): IReadOnlySharedReference<boolean> {
   const isMediaSourceOpen = new SharedReference(
@@ -335,7 +339,7 @@ function createMediaSourceOpenReference(
  * @param {Object} cancelSignal
  */
 function recursivelyForceDurationUpdate(
-  mediaSource: MediaSource,
+  mediaSource: IMediaSource,
   duration: number,
   isRealEndKnown: boolean,
   cancelSignal: CancellationSignal,

package/src/multithread_types.ts

@@ -28,9 +28,9 @@ import type {
   SourceBufferType,
 } from "./mse";
 import type { IFreezingStatus, IRebufferingStatus } from "./playback_observer";
-import type { ITrackType } from "./public_types";
+import type { ICmcdOptions, ITrackType } from "./public_types";
 import type { ITransportOptions } from "./transports";
-import type { ILoggerLevel } from "./utils/logger";
+import type { ILogFormat, ILoggerLevel } from "./utils/logger";
 import type { IRange } from "./utils/ranges";
 
 /**
@@ -65,6 +65,12 @@ export interface IInitMessage {
     hasMseInWorker: boolean;
     /** Initial logging level that should be set. */
     logLevel: ILoggerLevel;
+    /** Intitial logger's log format that should be set. */
+    logFormat: ILogFormat;
+    /**
+     * If `true`, logs should be sent back to the main thread, through a
+     * `ILogMessageWorkerMessage` message.
+     */
     sendBackLogs: boolean;
     /**
      * Value of `Date.now()` at the time the `timestamp` property was generated.
@@ -97,6 +103,10 @@ export interface IContentInitializationData {
    * Protects against all kind of race conditions or asynchronous issues.
    */
   contentId: string;
+  /**
+   * When set to an object, enable "Common Media Client Data", or "CMCD".
+   */
+  cmcd?: ICmcdOptions | undefined;
   /**
    * URL at which the content's Manifest is accessible.
    * `undefined` if unknown.
@@ -128,7 +138,7 @@ export interface IContentInitializationData {
   /**
    * Options relative to the fetching and refreshing of the Manifest.
    */
-  manifestRetryOptions: IManifestFetcherSettings;
+  manifestRetryOptions: Omit<IManifestFetcherSettings, "cmcdDataBuilder">;
   /** Options relative to the fetching of media segments. */
   segmentRetryOptions: ISegmentFetcherCreatorBackoffOptions;
 }
@@ -138,6 +148,12 @@ export interface ILogLevelUpdateMessage {
   value: {
     /** The new logger level that should be set. */
     logLevel: ILoggerLevel;
+    /** Intitial logger's log format that should be set. */
+    logFormat: ILogFormat;
+    /**
+     * If `true`, logs should be sent back to the main thread, through a
+     * `ILogMessageWorkerMessage` message.
+     */
     sendBackLogs: boolean;
   };
 }
@@ -222,17 +238,14 @@ export interface IStartPreparedContentMessageValue {
  */
 export interface ICodecSupportUpdateMessage {
   type: MainThreadMessageType.CodecSupportUpdate;
-  value: Array<{
-    /** The corresponding codec (e.g. "ec-3"). */
-    codec: string;
-    /** The mime-type associated (e.g. "audio/mp4"). */
-    mimeType: string;
-    /**
-     * If `true`, this `mimeType` and `codec` combination is supported.
-     * If `false`, it is not supported.
-     */
-    result: boolean;
-  }>;
+  value: ICodecSupportInfo[];
+}
+
+export interface ICodecSupportInfo {
+  mimeType: string;
+  codec: string;
+  supported?: boolean | undefined;
+  supportedIfEncrypted?: boolean | undefined;
 }
 
 /**