rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/dist/es2017/manifest/manifest.js

@@ -18,11 +18,11 @@ import log from "../log";
 import arrayFind from "../utils/array_find";
 import EventEmitter from "../utils/event_emitter";
 import idGenerator from "../utils/id_generator";
-import getMonotonicTimeStamp from "../utils/monotonic_timestamp";
 import warnOnce from "../utils/warn_once";
 import Period from "./period";
-import { MANIFEST_UPDATE_TYPE } from "./types";
+import { MANIFEST_UPDATE_TYPE, } from "./types";
 import { replacePeriods, updatePeriods, } from "./update_periods";
+import { getLivePosition, getMaximumSafePosition, getMinimumSafePosition, getPeriodForTime, getPeriodAfter, toTaggedTrack, } from "./utils";
 const generateNewManifestId = idGenerator();
 /**
  * Normalized Manifest structure.
@@ -48,7 +48,7 @@ export default class Manifest extends EventEmitter {
      * Construct a Manifest instance from a parsed Manifest object (as returned by
      * Manifest parsers) and options.
      *
-     * Some minor errors can arise during that construction. `this.contentWarnings`
+     * Some minor errors can arise during that construction. `warnings`
      * will contain all such errors, in the order they have been encountered.
      * @param {Object} parsedManifest
      * @param {Object} options
@@ -59,6 +59,7 @@ export default class Manifest extends EventEmitter {
         var _a;
         super();
         const { representationFilter, manifestUpdateUrl } = options;
+        this.manifestFormat = 0 /* ManifestMetadataFormat.Class */;
         this.id = generateNewManifestId();
         this.expired = (_a = parsedManifest.expired) !== null && _a !== void 0 ? _a : null;
         this.transport = parsedManifest.transportType;
@@ -69,7 +70,7 @@ export default class Manifest extends EventEmitter {
             return period;
         }).sort((a, b) => a.start - b.start);
         if (unsupportedAdaptations.length > 0) {
-            const error = new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { adaptations: unsupportedAdaptations });
+            const error = new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { tracks: unsupportedAdaptations.map(toTaggedTrack) });
             warnings.push(error);
         }
         /**
@@ -80,7 +81,7 @@ export default class Manifest extends EventEmitter {
         this.adaptations = this.periods[0] === undefined ? {} :
             this.periods[0].adaptations;
         /* eslint-enable import/no-deprecated */
-        this._timeBounds = parsedManifest.timeBounds;
+        this.timeBounds = parsedManifest.timeBounds;
         this.isDynamic = parsedManifest.isDynamic;
         this.isLive = parsedManifest.isLive;
         this.isLastPeriodKnown = parsedManifest.isLastPeriodKnown;
@@ -88,10 +89,35 @@ export default class Manifest extends EventEmitter {
             parsedManifest.uris;
         this.updateUrl = manifestUpdateUrl;
         this.lifetime = parsedManifest.lifetime;
+        this.clockOffset = parsedManifest.clockOffset;
         this.suggestedPresentationDelay = parsedManifest.suggestedPresentationDelay;
         this.availabilityStartTime = parsedManifest.availabilityStartTime;
         this.publishTime = parsedManifest.publishTime;
     }
+    /**
+     * 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.
+     *
+     * @param {Array.<Object>} supportList
+     * @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.
+     */
+    refreshCodecSupport(supportList) {
+        const unsupportedAdaptations = [];
+        for (const period of this.periods) {
+            period.refreshCodecSupport(supportList, unsupportedAdaptations);
+        }
+        if (unsupportedAdaptations.length > 0) {
+            return new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { tracks: unsupportedAdaptations.map(toTaggedTrack) });
+        }
+        return null;
+    }
     /**
      * Returns the Period corresponding to the given `id`.
      * Returns `undefined` if there is none.
@@ -110,10 +136,7 @@ export default class Manifest extends EventEmitter {
      * @returns {Object|undefined}
      */
     getPeriodForTime(time) {
-        return arrayFind(this.periods, (period) => {
-            return time >= period.start &&
-                (period.end === undefined || period.end > time);
-        });
+        return getPeriodForTime(this, time);
     }
     /**
      * Returns the first Period starting strictly after the given time.
@@ -133,15 +156,7 @@ export default class Manifest extends EventEmitter {
      * @returns {Object|null}
      */
     getPeriodAfter(period) {
-        const endOfPeriod = period.end;
-        if (endOfPeriod === undefined) {
-            return null;
-        }
-        const nextPeriod = arrayFind(this.periods, (_period) => {
-            return _period.end === undefined || endOfPeriod < _period.end;
-        });
-        return nextPeriod === undefined ? null :
-            nextPeriod;
+        return getPeriodAfter(this, period);
     }
     /**
      * Returns the most important URL from which the Manifest can be refreshed.
@@ -179,22 +194,7 @@ export default class Manifest extends EventEmitter {
      * @returns {number}
      */
     getMinimumSafePosition() {
-        var _a, _b;
-        const windowData = this._timeBounds;
-        if (windowData.timeshiftDepth === null) {
-            return (_a = windowData.minimumSafePosition) !== null && _a !== void 0 ? _a : 0;
-        }
-        const { maximumTimeData } = windowData;
-        let maximumTime;
-        if (!windowData.maximumTimeData.isLinear) {
-            maximumTime = maximumTimeData.maximumSafePosition;
-        }
-        else {
-            const timeDiff = getMonotonicTimeStamp() - maximumTimeData.time;
-            maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1000;
-        }
-        const theoricalMinimum = maximumTime - windowData.timeshiftDepth;
-        return Math.max((_b = windowData.minimumSafePosition) !== null && _b !== void 0 ? _b : 0, theoricalMinimum);
+        return getMinimumSafePosition(this);
     }
     /**
      * Get the position of the live edge - that is, the position of what is
@@ -202,15 +202,7 @@ export default class Manifest extends EventEmitter {
      * @returns {number|undefined}
      */
     getLivePosition() {
-        const { maximumTimeData } = this._timeBounds;
-        if (!this.isLive || maximumTimeData.livePosition === undefined) {
-            return undefined;
-        }
-        if (!maximumTimeData.isLinear) {
-            return maximumTimeData.livePosition;
-        }
-        const timeDiff = getMonotonicTimeStamp() - maximumTimeData.time;
-        return maximumTimeData.livePosition + timeDiff / 1000;
+        return getLivePosition(this);
     }
     /**
      * Returns the theoretical maximum playable position on the content
@@ -218,12 +210,7 @@ export default class Manifest extends EventEmitter {
      * time.
      */
     getMaximumSafePosition() {
-        const { maximumTimeData } = this._timeBounds;
-        if (!maximumTimeData.isLinear) {
-            return maximumTimeData.maximumSafePosition;
-        }
-        const timeDiff = getMonotonicTimeStamp() - maximumTimeData.time;
-        return maximumTimeData.maximumSafePosition + timeDiff / 1000;
+        return getMaximumSafePosition(this);
     }
     /**
      * Look in the Manifest for Representations linked to the given key ID,
@@ -285,6 +272,39 @@ export default class Manifest extends EventEmitter {
         return arrayFind(this.getAdaptations(), ({ id }) => wantedId === id);
         /* eslint-enable import/no-deprecated */
     }
+    /**
+     * Format the current `Manifest`'s properties into a
+     * `IManifestMetadata` format which can better be communicated through
+     * another thread.
+     *
+     * Please bear in mind however that the returned object will not be updated
+     * when the current `Manifest` instance is updated, it is only a
+     * snapshot at the current time.
+     *
+     * If you want to keep that data up-to-date with the current `Manifest`
+     * instance, you will have to do it yourself.
+     *
+     * @returns {Object}
+     */
+    getMetadataSnapshot() {
+        const periods = [];
+        for (const period of this.periods) {
+            periods.push(period.getMetadataSnapshot());
+        }
+        return {
+            manifestFormat: 1 /* ManifestMetadataFormat.MetadataObject */,
+            id: this.id,
+            periods,
+            isDynamic: this.isDynamic,
+            isLive: this.isLive,
+            isLastPeriodKnown: this.isLastPeriodKnown,
+            suggestedPresentationDelay: this.suggestedPresentationDelay,
+            clockOffset: this.clockOffset,
+            uris: this.uris,
+            availabilityStartTime: this.availabilityStartTime,
+            timeBounds: this.timeBounds,
+        };
+    }
     /**
      * @param {Object} newManifest
      * @param {number} updateType
@@ -301,12 +321,12 @@ export default class Manifest extends EventEmitter {
         this.publishTime = newManifest.publishTime;
         let updatedPeriodsResult;
         if (updateType === MANIFEST_UPDATE_TYPE.Full) {
-            this._timeBounds = newManifest._timeBounds;
+            this.timeBounds = newManifest.timeBounds;
             this.uris = newManifest.uris;
             updatedPeriodsResult = replacePeriods(this.periods, newManifest.periods);
         }
         else {
-            this._timeBounds.maximumTimeData = newManifest._timeBounds.maximumTimeData;
+            this.timeBounds.maximumTimeData = newManifest.timeBounds.maximumTimeData;
             this.updateUrl = newManifest.uris[0];
             updatedPeriodsResult = updatePeriods(this.periods, newManifest.periods);
             // Partial updates do not remove old Periods.
@@ -349,9 +369,10 @@ function updateDeciperability(manifest, isDecipherable) {
     for (const period of manifest.periods) {
         for (const adaptation of period.getAdaptations()) {
             for (const representation of adaptation.representations) {
-                const result = isDecipherable(representation);
+                const content = { manifest, period, adaptation, representation };
+                const result = isDecipherable(content);
                 if (result !== representation.decipherable) {
-                    updates.push({ manifest, period, adaptation, representation });
+                    updates.push(content);
                     representation.decipherable = result;
                     log.debug(`Decipherability changed for "${representation.id}"`, `(${representation.bitrate})`, String(representation.decipherable));
                 }

package/dist/es2017/manifest/period.d.ts

@@ -1,6 +1,8 @@
 import { IManifestStreamEvent, IParsedPeriod } from "../parsers/manifest";
 import { ITrackType, IRepresentationFilter } from "../public_types";
 import Adaptation from "./adaptation";
+import { ICodecSupportList } from "./representation";
+import { IPeriodMetadata } from "./types";
 /** Structure listing every `Adaptation` in a Period. */
 export type IManifestAdaptations = Partial<Record<ITrackType, Adaptation[]>>;
 /**
@@ -8,7 +10,7 @@ export type IManifestAdaptations = Partial<Record<ITrackType, Adaptation[]>>;
  * period in the the Manifest.
  * @class Period
  */
-export default class Period {
+export default class Period implements IPeriodMetadata {
     /** ID uniquely identifying the Period in the Manifest. */
     readonly id: string;
     /** Every 'Adaptation' in that Period, per type of Adaptation. */
@@ -30,9 +32,28 @@ export default class Period {
     /**
      * @constructor
      * @param {Object} args
+     * @param {Array.<Object>} unsupportedAdaptations - Array on which
+     * `Adaptation`s objects which have no supported `Representation` will be
+     * pushed.
+     * This array might be useful for minor error reporting.
      * @param {function|undefined} [representationFilter]
      */
     constructor(args: IParsedPeriod, unsupportedAdaptations: Adaptation[], representationFilter?: IRepresentationFilter | undefined);
+    /**
+     * 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.
+     *
+     * @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.
+     */
+    refreshCodecSupport(supportList: ICodecSupportList, unsupportedAdaptations: Adaptation[]): void;
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period, in an
      * Array.
@@ -58,11 +79,28 @@ export default class Period {
      * type. Will return for all types if `undefined`.
      * @returns {Array.<Adaptation>}
      */
-    getSupportedAdaptations(type?: ITrackType): Adaptation[];
+    getSupportedAdaptations(type?: ITrackType | undefined): Adaptation[];
     /**
      * Returns true if the give time is in the time boundaries of this `Period`.
      * @param {number} time
+     * @param {object|null} nextPeriod - Period coming chronologically just
+     * after in the same Manifest. `null` if this instance is the last `Period`.
      * @returns {boolean}
      */
-    containsTime(time: number): boolean;
+    containsTime(time: number, nextPeriod: Period | null): boolean;
+    /**
+     * Format the current `Period`'s properties into a
+     * `IPeriodMetadata` format which can better be communicated through
+     * another thread.
+     *
+     * Please bear in mind however that the returned object will not be updated
+     * when the current `Period` instance is updated, it is only a
+     * snapshot at the current time.
+     *
+     * If you want to keep that data up-to-date with the current `Period`
+     * instance, you will have to do it yourself.
+     *
+     * @returns {Object}
+     */
+    getMetadataSnapshot(): IPeriodMetadata;
 }

package/dist/es2017/manifest/period.js

@@ -15,8 +15,8 @@
  */
 import { MediaError } from "../errors";
 import arrayFind from "../utils/array_find";
-import objectValues from "../utils/object_values";
 import Adaptation from "./adaptation";
+import { getAdaptations, getSupportedAdaptations, periodContainsTime, } from "./utils";
 /**
  * Class representing the tracks and qualities available from a given time
  * period in the the Manifest.
@@ -26,6 +26,10 @@ export default class Period {
     /**
      * @constructor
      * @param {Object} args
+     * @param {Array.<Object>} unsupportedAdaptations - Array on which
+     * `Adaptation`s objects which have no supported `Representation` will be
+     * pushed.
+     * This array might be useful for minor error reporting.
      * @param {function|undefined} [representationFilter]
      */
     constructor(args, unsupportedAdaptations, representationFilter) {
@@ -39,16 +43,17 @@ export default class Period {
             const filteredAdaptations = adaptationsForType
                 .map((adaptation) => {
                 const newAdaptation = new Adaptation(adaptation, { representationFilter });
-                if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
+                if (newAdaptation.representations.length > 0
+                    && newAdaptation.isSupported === false) {
                     unsupportedAdaptations.push(newAdaptation);
                 }
                 return newAdaptation;
             })
                 .filter((adaptation) => adaptation.representations.length > 0);
-            if (filteredAdaptations.every(adaptation => !adaptation.isSupported) &&
+            if (filteredAdaptations.every(adaptation => adaptation.isSupported === false) &&
                 adaptationsForType.length > 0 &&
                 (type === "video" || type === "audio")) {
-                throw new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + type + " adaptations", { adaptations: undefined });
+                throw new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + type + " adaptations", { tracks: undefined });
             }
             if (filteredAdaptations.length > 0) {
                 acc[type] = filteredAdaptations;
@@ -68,17 +73,54 @@ export default class Period {
             [] :
             args.streamEvents;
     }
+    /**
+     * 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.
+     *
+     * @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.
+     */
+    refreshCodecSupport(supportList, unsupportedAdaptations) {
+        Object.keys(this.adaptations).forEach((ttype) => {
+            const adaptationsForType = this.adaptations[ttype];
+            if (adaptationsForType === undefined) {
+                return;
+            }
+            let hasSupportedAdaptations = false;
+            for (const adaptation of adaptationsForType) {
+                const wasSupported = adaptation.isSupported;
+                adaptation.refreshCodecSupport(supportList);
+                if (wasSupported !== false && adaptation.isSupported === false) {
+                    unsupportedAdaptations.push(adaptation);
+                }
+                if (hasSupportedAdaptations === false) {
+                    hasSupportedAdaptations = adaptation.isSupported;
+                }
+                else if (hasSupportedAdaptations === undefined &&
+                    adaptation.isSupported === true) {
+                    hasSupportedAdaptations = true;
+                }
+            }
+            if ((ttype === "video" || ttype === "audio") &&
+                hasSupportedAdaptations === false) {
+                throw new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + ttype + " adaptations", { tracks: undefined });
+            }
+        }, {});
+    }
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period, in an
      * Array.
      * @returns {Array.<Object>}
      */
     getAdaptations() {
-        const adaptationsByType = this.adaptations;
-        return objectValues(adaptationsByType).reduce(
-        // Note: the second case cannot happen. TS is just being dumb here
-        (acc, adaptations) => adaptations != null ? acc.concat(adaptations) :
-            acc, []);
+        return getAdaptations(this);
     }
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period for a
@@ -106,26 +148,47 @@ export default class Period {
      * @returns {Array.<Adaptation>}
      */
     getSupportedAdaptations(type) {
-        if (type === undefined) {
-            return this.getAdaptations().filter(ada => {
-                return ada.isSupported;
-            });
-        }
-        const adaptationsForType = this.adaptations[type];
-        if (adaptationsForType === undefined) {
-            return [];
-        }
-        return adaptationsForType.filter(ada => {
-            return ada.isSupported;
-        });
+        return getSupportedAdaptations(this, type);
     }
     /**
      * Returns true if the give time is in the time boundaries of this `Period`.
      * @param {number} time
+     * @param {object|null} nextPeriod - Period coming chronologically just
+     * after in the same Manifest. `null` if this instance is the last `Period`.
      * @returns {boolean}
      */
-    containsTime(time) {
-        return time >= this.start && (this.end === undefined ||
-            time < this.end);
+    containsTime(time, nextPeriod) {
+        return periodContainsTime(this, time, nextPeriod);
+    }
+    /**
+     * Format the current `Period`'s properties into a
+     * `IPeriodMetadata` format which can better be communicated through
+     * another thread.
+     *
+     * Please bear in mind however that the returned object will not be updated
+     * when the current `Period` instance is updated, it is only a
+     * snapshot at the current time.
+     *
+     * If you want to keep that data up-to-date with the current `Period`
+     * instance, you will have to do it yourself.
+     *
+     * @returns {Object}
+     */
+    getMetadataSnapshot() {
+        const adaptations = {};
+        const baseAdaptations = this.getAdaptations();
+        for (const adaptation of baseAdaptations) {
+            let currentAdaps = adaptations[adaptation.type];
+            if (currentAdaps === undefined) {
+                currentAdaps = [];
+                adaptations[adaptation.type] = currentAdaps;
+            }
+            currentAdaps.push(adaptation.getMetadataSnapshot());
+        }
+        return { start: this.start,
+            end: this.end,
+            id: this.id,
+            streamEvents: this.streamEvents,
+            adaptations };
     }
 }

package/dist/es2017/manifest/representation.d.ts

@@ -14,36 +14,28 @@
  * limitations under the License.
  */
 import { ICdnMetadata, IContentProtections, IParsedRepresentation } from "../parsers/manifest";
-import { IAudioRepresentation, ITrackType, IHDRInformation, IVideoRepresentation } from "../public_types";
+import { ITrackType, IHDRInformation } from "../public_types";
 import { IRepresentationIndex } from "./representation_index";
+import { IRepresentationMetadata } from "./types";
 /**
  * Normalized Representation structure.
  * @class Representation
  */
-declare class Representation {
-    /**
-     * ID uniquely identifying the `Representation` in its parent `Adaptation`.
-     *
-     * This identifier might be linked to an identifier present in the original
-     * Manifest file, it is thus the identifier to use to determine if a
-     * `Representation` from a refreshed `Manifest` is actually the same one than
-     * one in the previously loaded Manifest (as long as the `Adaptation` and
-     * `Period` are also the same).
-     *
-     * For a globally unique identifier regardless of the `Adaptation`, `Period`
-     * or even `Manifest`, you can rely on `uniqueId` instead.
-     */
+declare class Representation implements IRepresentationMetadata {
+    /** ID uniquely identifying the Representation in its parent Adaptation. */
     readonly id: string;
     /**
-     * Globally unique identifier for this `Representation` object.
-     *
-     * This identifier is guaranteed to be unique for any `Representation`s of all
-     * `Manifest` objects created in the current JS Realm.
-     * As such, it can be used as an identifier for the JS object itself, whereas
-     * `id` is the identifier for the original Manifest's Representation in the
-     * scope of its parent `Adaptation`.
+     * @see IRepresentationMetadata
      */
     readonly uniqueId: string;
+    /**
+     * @see IRepresentationMetadata
+     */
+    bitrate: number;
+    /**
+     * @see IRepresentationMetadata
+     */
+    frameRate?: number;
     /**
      * Interface allowing to get information about segments available for this
      * Representation.
@@ -60,70 +52,61 @@ declare class Representation {
      * no resource can be loaded in that situation.
      */
     cdnMetadata: ICdnMetadata[] | null;
-    /** Bitrate this Representation is in, in bits per seconds. */
-    bitrate: number;
-    /**
-     * Frame-rate, when it can be applied, of this Representation, in any textual
-     * indication possible (often under a ratio form).
-     */
-    frameRate?: number;
     /**
-     * `true` if this `Representation` is linked to a spatial audio technology.
-     * For example, it may be set to `true` if the Representation relies on the
-     * "Dolby Atmos". technology.
-     *
-     * `false` if it is known that this `Representation` does not contain any
-     * spatial audio.
-     *
-     * `undefined` if we do not know whether this `Representation` contains
-     * spatial audio or not.
+     * @see IRepresentationMetadata
      */
     isSpatialAudio?: boolean | undefined;
     /**
-     * A string describing the codec used for this Representation.
-     * undefined if we do not know.
+     * @see IRepresentationMetadata
      */
-    codec: string | undefined;
+    codecs: string[];
     /**
-     * A string describing the mime-type for this Representation.
-     * Examples: audio/mp4, video/webm, application/mp4, text/plain
-     * undefined if we do not know.
+     * @see IRepresentationMetadata
      */
     mimeType?: string;
     /**
-     * If this Representation is linked to video content, this value is the width
-     * in pixel of the corresponding video data.
+     * @see IRepresentationMetadata
      */
     width?: number;
     /**
-     * If this Representation is linked to video content, this value is the height
-     * in pixel of the corresponding video data.
+     * @see IRepresentationMetadata
      */
     height?: number;
-    /** Encryption information for this Representation. */
+    /**
+     * @see IRepresentationMetadata
+     */
     contentProtections?: IContentProtections;
     /**
-     * If the track is HDR, give the characteristics of the content
+     * @see IRepresentationMetadata
      */
     hdrInfo?: IHDRInformation;
     /**
-     * Whether we are able to decrypt this Representation / unable to decrypt it or
-     * if we don't know yet:
-     *   - if `true`, it means that we know we were able to decrypt this
-     *     Representation in the current content.
-     *   - if `false`, it means that we know we were unable to decrypt this
-     *     Representation
-     *   - if `undefined` there is no certainty on this matter
+     * @see IRepresentationMetadata
      */
     decipherable?: boolean | undefined;
-    /** `true` if the Representation is in a supported codec, false otherwise. */
-    isSupported: boolean;
+    /**
+     * @see IRepresentationMetadata
+     */
+    isSupported: boolean | undefined;
     /**
      * @param {Object} args
+     * @param {string} trackType
+     */
+    constructor(args: IParsedRepresentation, trackType: ITrackType);
+    /**
+     * 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.
+     *
+     * 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
      */
-    constructor(args: IParsedRepresentation, opts: {
-        type: ITrackType;
-    });
+    refreshCodecSupport(supportList: ICodecSupportList): void;
     /**
      * Returns "mime-type string" which includes both the mime-type and the codec,
      * which is often needed when interacting with the browser's APIs.
@@ -199,21 +182,20 @@ declare class Representation {
         data: Uint8Array;
     }>): boolean;
     /**
-     * Format Representation as an `IAudioRepresentation`.
-     * @returns {Object}
-     */
-    toAudioRepresentation(): IAudioRepresentation;
-    /**
-     * Format Representation as an `IVideoRepresentation`.
+     * Format the current `Representation`'s properties into a
+     * `IRepresentationMetadata` format which can better be communicated through
+     * another thread.
+     *
+     * Please bear in mind however that the returned object will not be updated
+     * when the current `Representation` instance is updated, it is only a
+     * snapshot at the current time.
+     *
+     * If you want to keep that data up-to-date with the current `Representation`
+     * instance, you will have to do it yourself.
+     *
      * @returns {Object}
      */
-    toVideoRepresentation(): IVideoRepresentation;
-    /**
-     * Returns `true` if this Representation can be played (that is: not
-     * undecipherable and with a supported codec).
-     * @returns {Array.<Representation>}
-     */
-    isPlayable(): boolean;
+    getMetadataSnapshot(): IRepresentationMetadata;
 }
 /** Protection data as returned by a Representation. */
 export interface IRepresentationProtectionData {
@@ -248,4 +230,9 @@ export interface IRepresentationProtectionData {
         data: Uint8Array;
     }>;
 }
+export type ICodecSupportList = Array<{
+    codec: string;
+    mimeType: string;
+    result: boolean;
+}>;
 export default Representation;