rx-player 4.0.0-dev.2023110700 → 4.0.0-dev.2023120600

package/dist/_esm5.processed/core/api/track_management/tracks_store.js

@@ -0,0 +1,932 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/**
+ * This file is used to abstract the notion of text, audio and video tracks
+ * switching for an easier API management.
+ */
+import config from "../../../config";
+import log from "../../../log";
+import arrayFind from "../../../utils/array_find";
+import assert from "../../../utils/assert";
+import EventEmitter from "../../../utils/event_emitter";
+import objectAssign from "../../../utils/object_assign";
+import SharedReference from "../../../utils/reference";
+import TrackDispatcher from "./track_dispatcher";
+/**
+ * Class helping with the management of the audio, video and text tracks and
+ * qualities.
+ *
+ * The `TracksStore` allows to choose a track and qualities for different types
+ * of media through a simpler API.
+ *
+ * @class TracksStore
+ */
+var TracksStore = /** @class */ (function (_super) {
+    __extends(TracksStore, _super);
+    function TracksStore(args) {
+        var _a;
+        var _this = _super.call(this) || this;
+        _this._storedPeriodInfo = [];
+        _this._isDisposed = false;
+        _this._cachedPeriodInfo = new WeakMap();
+        _this._isTrickModeTrackEnabled = args.preferTrickModeTracks;
+        _this._defaultAudioTrackSwitchingMode =
+            (_a = args.defaultAudioTrackSwitchingMode) !== null && _a !== void 0 ? _a : config.getCurrent().DEFAULT_AUDIO_TRACK_SWITCHING_MODE;
+        return _this;
+    }
+    /**
+     * Return Array of Period information, to allow an outside application to
+     * modify the track of any Period.
+     * @returns {Array.<Object>}
+     */
+    TracksStore.prototype.getAvailablePeriods = function () {
+        // Note: We voluntarly do not include any Period from `_cachedPeriodInfo` here;
+        // because we do not want to allow the user switching tracks for older
+        // Periods.
+        return this._storedPeriodInfo.map(function (p) { return toExposedPeriod(p.period); });
+    };
+    /**
+     * Update the list of Periods handled by the TracksStore and make a
+     * track choice decision for each of them.
+     * @param {Object} manifest - The new Manifest object
+     */
+    TracksStore.prototype.updatePeriodList = function (manifest) {
+        var _a;
+        var _this = this;
+        var _b, _c, _d;
+        var DEFAULT_VIDEO_TRACK_SWITCHING_MODE = config.getCurrent().DEFAULT_VIDEO_TRACK_SWITCHING_MODE;
+        var periods = manifest.periods;
+        // We assume that they are always sorted chronologically
+        // In dev mode, perform a runtime check that this is the case
+        if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+            for (var i = 1; i < periods.length; i++) {
+                assert(periods[i - 1].start <= periods[i].start);
+            }
+        }
+        /** Periods which have just been added. */
+        var addedPeriods = [];
+        var newPListIdx = 0;
+        var _loop_1 = function (i) {
+            var oldPeriod = this_1._storedPeriodInfo[i].period;
+            var newPeriod = periods[newPListIdx];
+            if (newPeriod === undefined) {
+                // We reached the end of the new Periods, remove remaining old Periods
+                for (var j = this_1._storedPeriodInfo.length - 1; j >= i; j--) {
+                    this_1._storedPeriodInfo[j].inManifest = false;
+                    if (isPeriodItemRemovable(this_1._storedPeriodInfo[j])) {
+                        this_1._removePeriodObject(j);
+                    }
+                }
+            }
+            else if (oldPeriod === newPeriod) {
+                newPListIdx++;
+                var curWantedTextTrack_1 = this_1._storedPeriodInfo[i].text.storedSettings;
+                if (curWantedTextTrack_1 !== null) {
+                    var textAdaptations = newPeriod.getSupportedAdaptations("text");
+                    var stillHere = textAdaptations
+                        .some(function (a) { return a.id === curWantedTextTrack_1.adaptation.id; });
+                    if (!stillHere) {
+                        log.warn("TracksStore: Chosen text Adaptation not available anymore");
+                        var periodInfo = this_1._storedPeriodInfo[i];
+                        periodInfo.text.storedSettings = null;
+                        this_1.trigger("trackUpdate", { period: toExposedPeriod(newPeriod),
+                            trackType: "text",
+                            reason: "missing" });
+                        // The previous event trigger could have had side-effects, so we
+                        // re-check if we're still mostly in the same state
+                        if (this_1._isDisposed) {
+                            return { value: void 0 };
+                        }
+                        var periodItem = getPeriodItem(this_1._storedPeriodInfo, periodInfo.period.id);
+                        if (periodItem !== undefined && periodItem.text.storedSettings === null) {
+                            (_b = periodItem.text.dispatcher) === null || _b === void 0 ? void 0 : _b.updateTrack(null);
+                        }
+                    }
+                }
+                var curWantedVideoTrack_1 = this_1._storedPeriodInfo[i].video.storedSettings;
+                if (curWantedVideoTrack_1 !== null) {
+                    var videoAdaptations = newPeriod.getSupportedAdaptations("video");
+                    var stillHere = videoAdaptations
+                        .some(function (a) { return a.id === curWantedVideoTrack_1.adaptation.id; });
+                    if (!stillHere) {
+                        log.warn("TracksStore: Chosen video Adaptation not available anymore");
+                        var periodItem = this_1._storedPeriodInfo[i];
+                        var storedSettings = void 0;
+                        if (videoAdaptations.length === 0) {
+                            storedSettings = null;
+                        }
+                        else {
+                            var adaptationBase = videoAdaptations[0];
+                            var adaptation = getRightVideoTrack(adaptationBase, this_1._isTrickModeTrackEnabled);
+                            var lockedRepresentations = new SharedReference(null);
+                            storedSettings = { adaptationBase: adaptationBase, adaptation: adaptation, switchingMode: DEFAULT_VIDEO_TRACK_SWITCHING_MODE, lockedRepresentations: lockedRepresentations };
+                        }
+                        periodItem.video.storedSettings = storedSettings;
+                        this_1.trigger("trackUpdate", { period: toExposedPeriod(newPeriod),
+                            trackType: "video",
+                            reason: "missing" });
+                        // The previous event trigger could have had side-effects, so we
+                        // re-check if we're still mostly in the same state
+                        if (this_1._isDisposed) {
+                            return { value: void 0 };
+                        }
+                        var newPeriodItem = getPeriodItem(this_1._storedPeriodInfo, periodItem.period.id);
+                        if (newPeriodItem !== undefined &&
+                            newPeriodItem.video.storedSettings === storedSettings) {
+                            (_c = newPeriodItem.video.dispatcher) === null || _c === void 0 ? void 0 : _c.updateTrack(storedSettings);
+                        }
+                    }
+                }
+                var curWantedAudioTrack_1 = this_1._storedPeriodInfo[i].audio.storedSettings;
+                if (curWantedAudioTrack_1 !== null) {
+                    var audioAdaptations = newPeriod.getSupportedAdaptations("audio");
+                    var stillHere = audioAdaptations
+                        .some(function (a) { return a.id === curWantedAudioTrack_1.adaptation.id; });
+                    if (!stillHere) {
+                        log.warn("TracksStore: Chosen audio Adaptation not available anymore");
+                        var periodItem = this_1._storedPeriodInfo[i];
+                        var storedSettings = audioAdaptations.length === 0 ?
+                            null :
+                            { adaptation: audioAdaptations[0],
+                                switchingMode: this_1._defaultAudioTrackSwitchingMode,
+                                lockedRepresentations: new SharedReference(null) };
+                        periodItem.audio.storedSettings = storedSettings;
+                        this_1.trigger("trackUpdate", { period: toExposedPeriod(newPeriod),
+                            trackType: "audio",
+                            reason: "missing" });
+                        // The previous event trigger could have had side-effects, so we
+                        // re-check if we're still mostly in the same state
+                        if (this_1._isDisposed) {
+                            return { value: void 0 };
+                        }
+                        var newPeriodItem = getPeriodItem(this_1._storedPeriodInfo, periodItem.period.id);
+                        if (newPeriodItem !== undefined &&
+                            newPeriodItem.audio.storedSettings === storedSettings) {
+                            (_d = newPeriodItem.audio.dispatcher) === null || _d === void 0 ? void 0 : _d.updateTrack(storedSettings);
+                        }
+                    }
+                }
+                // (If not, what do?)
+            }
+            else if (oldPeriod.start <= newPeriod.start) {
+                // This old Period does not exist anymore.
+                this_1._storedPeriodInfo[i].inManifest = false;
+                if (isPeriodItemRemovable(this_1._storedPeriodInfo[i])) {
+                    this_1._removePeriodObject(i);
+                    i--;
+                }
+            }
+            else {
+                var newPeriodInfo = generatePeriodInfo(newPeriod, true, this_1._isTrickModeTrackEnabled, this_1._defaultAudioTrackSwitchingMode);
+                // oldPeriod.start > newPeriod.start: insert newPeriod before
+                this_1._storedPeriodInfo.splice(i, 0, newPeriodInfo);
+                addedPeriods.push(newPeriodInfo);
+                newPListIdx++;
+                // Note: we don't increment `i` on purpose here, as we want to check the
+                // same oldPeriod at the next loop iteration
+            }
+            out_i_1 = i;
+        };
+        var this_1 = this, out_i_1;
+        for (var i = 0; i < this._storedPeriodInfo.length; i++) {
+            var state_1 = _loop_1(i);
+            i = out_i_1;
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+        if (newPListIdx < periods.length) {
+            // Add further new Period
+            var periodsToAdd = periods.slice(newPListIdx)
+                .map(function (p) { return generatePeriodInfo(p, true, _this._isTrickModeTrackEnabled, _this._defaultAudioTrackSwitchingMode); });
+            (_a = this._storedPeriodInfo).push.apply(_a, periodsToAdd);
+            addedPeriods.push.apply(addedPeriods, periodsToAdd);
+        }
+        var periodsAdded = addedPeriods.reduce(function (acc, p) {
+            if (!p.isRemoved) {
+                acc.push({ id: p.period.id, start: p.period.start, end: p.period.end });
+            }
+            return acc;
+        }, []);
+        if (periodsAdded.length > 0) {
+            this.trigger("newAvailablePeriods", periodsAdded);
+        }
+    };
+    /**
+     * Add shared reference to choose Adaptation for new "audio", "video" or
+     * "text" Period.
+     *
+     * Note that such reference has to be removed through `removeTrackReference`
+     * so ressources can be freed.
+     * @param {string} bufferType - The concerned buffer type
+     * @param {Object} manifest
+     * @param {Period} period - The concerned Period.
+     * @param {Object} adaptationRef - A reference through which
+     * the choice will be given.
+     */
+    TracksStore.prototype.addTrackReference = function (bufferType, manifest, period, adaptationRef) {
+        var _this = this;
+        var periodObj = getPeriodItem(this._storedPeriodInfo, period.id);
+        if (periodObj === undefined) { // The Period has not yet been added.
+            periodObj = this._addPeriod(period);
+            this.trigger("newAvailablePeriods", [{ id: period.id,
+                    start: period.start,
+                    end: period.end }]);
+        }
+        if (periodObj[bufferType].dispatcher !== null) {
+            log.error("TracksStore: Subject already added for ".concat(bufferType, " ") +
+                "and Period ".concat(period.start));
+            return;
+        }
+        var trackSetting = periodObj[bufferType].storedSettings;
+        var dispatcher = new TrackDispatcher(manifest, adaptationRef, trackSetting);
+        periodObj[bufferType].dispatcher = dispatcher;
+        dispatcher.addEventListener("noPlayableLockedRepresentation", function () {
+            trackSetting === null || trackSetting === void 0 ? void 0 : trackSetting.lockedRepresentations.setValue(null);
+            _this.trigger("brokenRepresentationsLock", { period: { id: period.id,
+                    start: period.start,
+                    end: period.end },
+                trackType: bufferType });
+        });
+    };
+    /**
+     * Remove shared reference to choose an "audio", "video" or "text" Adaptation
+     * for a Period.
+     * @param {string} bufferType - The concerned buffer type
+     * @param {Period} period - The concerned Period.
+     */
+    TracksStore.prototype.removeTrackReference = function (bufferType, period) {
+        var periodIndex = findPeriodIndex(this._storedPeriodInfo, period);
+        if (periodIndex === undefined) {
+            log.warn("TracksStore: ".concat(bufferType, " not found for period"), period.start);
+            return;
+        }
+        var periodObj = this._storedPeriodInfo[periodIndex];
+        var choiceItem = periodObj[bufferType];
+        if ((choiceItem === null || choiceItem === void 0 ? void 0 : choiceItem.dispatcher) === null) {
+            log.warn("TracksStore: TrackDispatcher already removed for ".concat(bufferType, " ") +
+                "and Period ".concat(period.start));
+            return;
+        }
+        choiceItem.dispatcher.dispose();
+        choiceItem.dispatcher = null;
+        if (isPeriodItemRemovable(periodObj)) {
+            this._removePeriodObject(periodIndex);
+        }
+    };
+    /**
+     * Allows to recuperate a "Period Object" - used in get/set methods of the
+     * `TracksStore` - by giving the Period itself.
+     *
+     * This method should be preferred when possible over `getPeriodObjectFromId`
+     * because it is able to fallback on an internal cache in case the
+     * corresponding Period is not stored anymore.
+     * This for example could happen when a Period has been removed from the
+     * Manifest yet may still be needed (e.g. because its linked segments might
+     * still live in the buffers).
+     *
+     * Note however that this cache-retrieval logic is based on a Map whose key
+     * is the Period's JavaScript reference. As such, the cache won't be used if
+     * `Period` corresponds to a copy of the original `Period` object.
+     *
+     * @param {Object} period
+     * @returns {Object}
+     */
+    TracksStore.prototype.getPeriodObjectFromPeriod = function (period) {
+        var periodObj = getPeriodItem(this._storedPeriodInfo, period.id);
+        if (periodObj === undefined && period !== undefined) {
+            return this._cachedPeriodInfo.get(period);
+        }
+        return periodObj;
+    };
+    /**
+     * Allows to recuperate a "Period Object" - used in get/set methods of the
+     * `TracksStore` - by giving the Period's id.
+     *
+     * Note that unlike `getPeriodObjectFromPeriod` this method is only going to look
+     * into currently stored Period and as such old Periods not in the Manifest
+     * anymore might not be retrievable.
+     * If you want to retrieve Period objects linked to such Period, you might
+     * prefer to use `getPeriodObjectFromPeriod` (which necessitates the original
+     * Period object).
+     *
+     * @param {string} periodId - The concerned Period's id
+     * @returns {Object}
+     */
+    TracksStore.prototype.getPeriodObjectFromId = function (periodId) {
+        return getPeriodItem(this._storedPeriodInfo, periodId);
+    };
+    TracksStore.prototype.disableVideoTrickModeTracks = function () {
+        if (!this._isTrickModeTrackEnabled) {
+            return;
+        }
+        this._isTrickModeTrackEnabled = false;
+        this._resetVideoTrackChoices("trickmode-disabled");
+    };
+    TracksStore.prototype.enableVideoTrickModeTracks = function () {
+        if (this._isTrickModeTrackEnabled) {
+            return;
+        }
+        this._isTrickModeTrackEnabled = true;
+        this._resetVideoTrackChoices("trickmode-enabled");
+    };
+    /**
+     * Reset the TracksStore's Period objects:
+     *   - All Period which are not in the manifest currently will be removed.
+     *   - All References used to communicate the wanted track will be removed.
+     *
+     * You might want to call this API when restarting playback.
+     */
+    TracksStore.prototype.resetPeriodObjects = function () {
+        var _a, _b, _c;
+        for (var i = this._storedPeriodInfo.length - 1; i >= 0; i--) {
+            var storedObj = this._storedPeriodInfo[i];
+            (_a = storedObj.audio.dispatcher) === null || _a === void 0 ? void 0 : _a.dispose();
+            storedObj.audio.dispatcher = null;
+            (_b = storedObj.video.dispatcher) === null || _b === void 0 ? void 0 : _b.dispose();
+            storedObj.video.dispatcher = null;
+            (_c = storedObj.text.dispatcher) === null || _c === void 0 ? void 0 : _c.dispose();
+            storedObj.text.dispatcher = null;
+            if (!storedObj.inManifest) {
+                this._removePeriodObject(i);
+            }
+        }
+    };
+    /**
+     * @returns {boolean}
+     */
+    TracksStore.prototype.isTrickModeEnabled = function () {
+        return this._isTrickModeTrackEnabled;
+    };
+    /**
+     * Set audio track based on the ID of its Adaptation for a given added Period.
+     * @param {Object} periodObj - The concerned Period's object.
+     * @param {string} wantedId - adaptation id of the wanted track.
+     * @param {string} switchingMode - Behavior when replacing the track by
+     * another.
+     * @param {Object|null} reprsToLock - Audio Representations that should be
+     * locked after switchingMode to that track.
+     * `null` if no Audio Representation should be locked.
+     */
+    TracksStore.prototype.setAudioTrack = function (periodObj, wantedId, switchingMode, reprsToLock) {
+        return this._setAudioOrTextTrack("audio", periodObj, wantedId, switchingMode !== null && switchingMode !== void 0 ? switchingMode : this._defaultAudioTrackSwitchingMode, reprsToLock);
+    };
+    /**
+     * Set text track based on the ID of its Adaptation for a given added Period.
+     * @param {Object} periodObj - The concerned Period's object.
+     * @param {string} wantedId - adaptation id of the wanted track.
+     */
+    TracksStore.prototype.setTextTrack = function (periodObj, wantedId) {
+        return this._setAudioOrTextTrack("text", periodObj, wantedId, "direct", null);
+    };
+    /**
+     * Set audio track based on the ID of its Adaptation for a given added Period.
+     * @param {Object} periodObj - The concerned Period's object.
+     * @param {string} wantedId - adaptation id of the wanted track.
+     * @param {string} switchingMode - Behavior when replacing the track by
+     * another.
+     * @param {Array.<string>|null} reprsToLock - Audio Representations that should be
+     * locked after switchingMode to that track.
+     * `null` if no Audio Representation should be locked.
+     */
+    TracksStore.prototype._setAudioOrTextTrack = function (bufferType, periodObj, wantedId, switchingMode, reprsToLock) {
+        var _a;
+        var period = periodObj.period;
+        var wantedAdaptation = arrayFind(period.getSupportedAdaptations(bufferType), function (_a) {
+            var id = _a.id;
+            return id === wantedId;
+        });
+        if (wantedAdaptation === undefined) {
+            throw new Error("Wanted ".concat(bufferType, " track not found."));
+        }
+        var typeInfo = periodObj[bufferType];
+        var lockedRepresentations;
+        if (reprsToLock === null) {
+            lockedRepresentations = new SharedReference(null);
+        }
+        else {
+            var representationsToLock = this._getRepresentationsToLock(wantedAdaptation, reprsToLock);
+            var repSwitchingMode = bufferType === "audio" ?
+                this._defaultAudioTrackSwitchingMode :
+                "direct";
+            lockedRepresentations = new SharedReference({
+                representations: representationsToLock,
+                switchingMode: repSwitchingMode,
+            });
+        }
+        var storedSettings = { adaptation: wantedAdaptation, switchingMode: switchingMode, lockedRepresentations: lockedRepresentations };
+        typeInfo.storedSettings = storedSettings;
+        this.trigger("trackUpdate", { period: toExposedPeriod(period),
+            trackType: bufferType,
+            reason: "manual" });
+        // The previous event trigger could have had side-effects, so we
+        // re-check if we're still mostly in the same state
+        if (this._isDisposed) {
+            return; // Someone disposed the `TracksStore` on the previous side-effect
+        }
+        var newPeriodItem = getPeriodItem(this._storedPeriodInfo, period.id);
+        if (newPeriodItem !== undefined &&
+            newPeriodItem[bufferType].storedSettings === storedSettings) {
+            (_a = newPeriodItem[bufferType].dispatcher) === null || _a === void 0 ? void 0 : _a.updateTrack(storedSettings);
+        }
+    };
+    /**
+     * Set video track based on the ID of its Adaptation for a given added Period.
+     * @param {Object} periodObj - The concerned Period's object.
+     * @param {string} wantedId - adaptation id of the wanted track.
+     * @param {string} switchingMode - Behavior when replacing the track by
+     * another.
+     * @param {Array.<string>|null} reprsToLock - Video Representations that should be
+     * locked after switchingMode to that track.
+     * `null` if no Video Representation should be locked.
+     */
+    TracksStore.prototype.setVideoTrack = function (periodObj, wantedId, switchingMode, reprsToLock) {
+        var _a;
+        var period = periodObj.period;
+        var wantedAdaptation = arrayFind(period.getSupportedAdaptations("video"), function (_a) {
+            var id = _a.id;
+            return id === wantedId;
+        });
+        if (wantedAdaptation === undefined) {
+            throw new Error("Wanted video track not found.");
+        }
+        var DEFAULT_VIDEO_TRACK_SWITCHING_MODE = config.getCurrent().DEFAULT_VIDEO_TRACK_SWITCHING_MODE;
+        var typeInfo = periodObj.video;
+        var newAdaptation = getRightVideoTrack(wantedAdaptation, this._isTrickModeTrackEnabled);
+        var lockedRepresentations;
+        if (reprsToLock === null) {
+            lockedRepresentations = new SharedReference(null);
+        }
+        else {
+            var representationsToLock = this._getRepresentationsToLock(wantedAdaptation, reprsToLock);
+            var repSwitchingMode = DEFAULT_VIDEO_TRACK_SWITCHING_MODE;
+            lockedRepresentations = new SharedReference({
+                representations: representationsToLock,
+                switchingMode: repSwitchingMode,
+            });
+        }
+        var storedSettings = { adaptationBase: wantedAdaptation,
+            switchingMode: switchingMode !== null && switchingMode !== void 0 ? switchingMode : DEFAULT_VIDEO_TRACK_SWITCHING_MODE,
+            adaptation: newAdaptation, lockedRepresentations: lockedRepresentations };
+        typeInfo.storedSettings = storedSettings;
+        this.trigger("trackUpdate", { period: toExposedPeriod(period),
+            trackType: "video",
+            reason: "manual" });
+        // The previous event trigger could have had side-effects, so we
+        // re-check if we're still mostly in the same state
+        if (this._isDisposed) {
+            return; // Someone disposed the `TracksStore` on the previous side-effect
+        }
+        var newPeriodItem = getPeriodItem(this._storedPeriodInfo, period.id);
+        if (newPeriodItem !== undefined &&
+            newPeriodItem.video.storedSettings === storedSettings) {
+            (_a = newPeriodItem.video.dispatcher) === null || _a === void 0 ? void 0 : _a.updateTrack(storedSettings);
+        }
+    };
+    /**
+     * Disable the current text track for a given period.
+     *
+     * @param {Object} periodObj - The concerned Period's object
+     * @param {string} bufferType - The type of track to disable.
+     * @throws Error - Throws if the period given has not been added
+     */
+    TracksStore.prototype.disableTrack = function (periodObj, bufferType) {
+        var _a, _b;
+        var trackInfo = periodObj[bufferType];
+        if (trackInfo.storedSettings === null) {
+            return;
+        }
+        if (bufferType !== "text") {
+            // Potentially unneeded, but let's be clean
+            (_a = periodObj[bufferType].storedSettings) === null || _a === void 0 ? void 0 : _a.lockedRepresentations.finish();
+        }
+        trackInfo.storedSettings = null;
+        this.trigger("trackUpdate", { period: toExposedPeriod(periodObj.period),
+            trackType: bufferType,
+            reason: "manual" });
+        // The previous event trigger could have had side-effects, so we
+        // re-check if we're still mostly in the same state
+        if (this._isDisposed) {
+            return; // Someone disposed the `TracksStore` on the previous side-effect
+        }
+        var newPeriodItem = getPeriodItem(this._storedPeriodInfo, periodObj.period.id);
+        if (newPeriodItem !== undefined &&
+            newPeriodItem[bufferType].storedSettings === null) {
+            (_b = newPeriodItem[bufferType].dispatcher) === null || _b === void 0 ? void 0 : _b.updateTrack(null);
+        }
+    };
+    /**
+     * Returns an object describing the chosen audio track for the given audio
+     * Period.
+     *
+     * Returns `null` is the the current audio track is disabled or not
+     * set yet.a pas bcp de marge de manoeuvre j'ai l'impression
+     *
+     * Returns `undefined` if the given Period's id is not currently found in the
+     * `TracksStore`. The cause being most probably that the corresponding
+     * Period is not available anymore.
+     * If you're in that case and if still have the corresponding JavaScript
+     * reference to the wanted Period, you can call `getOldAudioTrack` with it. It
+     * will try retrieving the choice it made from its cache.
+     * @param {Object} periodObj - The concerned Period's object
+     * @returns {Object|null|undefined} - The audio track chosen for this Period.
+     * `null` if audio tracks were disabled and `undefined` if the Period is not
+     * known.
+     */
+    TracksStore.prototype.getChosenAudioTrack = function (periodObj) {
+        return periodObj.audio.storedSettings === null ?
+            null :
+            periodObj.audio.storedSettings.adaptation.toAudioTrack(true);
+    };
+    /**
+     * Returns an object describing the chosen text track for the given text
+     * Period.
+     *
+     * Returns null is the the current text track is disabled or not
+     * set yet.
+     *
+     * @param {Object} periodObj - The concerned Period's object
+     * @returns {Object|null} - The text track chosen for this Period
+     */
+    TracksStore.prototype.getChosenTextTrack = function (periodObj) {
+        return periodObj.text.storedSettings === null ?
+            null :
+            periodObj.text.storedSettings.adaptation.toTextTrack();
+    };
+    /**
+     * Returns an object describing the chosen video track for the given video
+     * Period.
+     *
+     * Returns null is the the current video track is disabled or not
+     * set yet.
+     *
+     * @param {Object} periodObj - The concerned Period's object
+     * @returns {Object|null} - The video track chosen for this Period
+     */
+    TracksStore.prototype.getChosenVideoTrack = function (periodObj) {
+        if (periodObj.video.storedSettings === null) {
+            return null;
+        }
+        return periodObj.video.storedSettings.adaptation.toVideoTrack(true);
+    };
+    /**
+     * Returns all available audio tracks for a given Period, as an array of
+     * objects.
+     *
+     * Returns `undefined` if the given Period's id is not known.
+     *
+     * @param {Object} periodObj - The concerned Period's object
+     * @returns {Array.<Object>}
+     */
+    TracksStore.prototype.getAvailableAudioTracks = function (periodObj) {
+        var storedSettings = periodObj.audio.storedSettings;
+        var currentId = storedSettings !== null ?
+            storedSettings.adaptation.id :
+            null;
+        return periodObj.period.getSupportedAdaptations("audio")
+            .map(function (adaptation) {
+            var active = currentId === null ? false :
+                currentId === adaptation.id;
+            return objectAssign(adaptation.toAudioTrack(true), { active: active });
+        });
+    };
+    /**
+     * Returns all available text tracks for a given Period, as an array of
+     * objects.
+     *
+     * Returns `undefined` if the given Period's id is not known.
+     *
+     * @param {Object} periodObj - The concerned Period's object
+     * @returns {Array.<Object>}
+     */
+    TracksStore.prototype.getAvailableTextTracks = function (periodObj) {
+        var storedSettings = periodObj.text.storedSettings;
+        var currentId = storedSettings !== null ?
+            storedSettings.adaptation.id :
+            null;
+        return periodObj.period.getSupportedAdaptations("text")
+            .map(function (adaptation) {
+            var active = currentId === null ? false :
+                currentId === adaptation.id;
+            return objectAssign(adaptation.toTextTrack(), { active: active });
+        });
+    };
+    /**
+     * Returns all available video tracks for a given Period, as an array of
+     * objects.
+     *
+     * Returns `undefined` if the given Period's id is not known.
+     *
+     * @param {Object} periodObj - The concerned Period's object
+     * @returns {Array.<Object>}
+     */
+    TracksStore.prototype.getAvailableVideoTracks = function (periodObj) {
+        var storedSettings = periodObj.video.storedSettings;
+        var currentId = storedSettings === null ?
+            undefined :
+            storedSettings.adaptation.id;
+        return periodObj.period.getSupportedAdaptations("video")
+            .map(function (adaptation) {
+            var active = currentId === null ? false :
+                currentId === adaptation.id;
+            var track = adaptation.toVideoTrack(true);
+            var trickModeTracks = track.trickModeTracks !== undefined ?
+                track.trickModeTracks.map(function (trickModeAdaptation) {
+                    var isActive = currentId === null ? false :
+                        currentId === trickModeAdaptation.id;
+                    return objectAssign(trickModeAdaptation, { active: isActive });
+                }) :
+                [];
+            var availableTrack = objectAssign(track, { active: active });
+            if (trickModeTracks !== undefined) {
+                availableTrack.trickModeTracks = trickModeTracks;
+            }
+            return availableTrack;
+        });
+    };
+    TracksStore.prototype.getLockedAudioRepresentations = function (periodObj) {
+        var storedSettings = periodObj.audio.storedSettings;
+        if (storedSettings === null) {
+            return null;
+        }
+        var lastLockedSettings = storedSettings.lockedRepresentations.getValue();
+        return lastLockedSettings === null ?
+            null :
+            lastLockedSettings.representations.map(function (r) { return r.id; });
+    };
+    TracksStore.prototype.getLockedVideoRepresentations = function (periodObj) {
+        var storedSettings = periodObj.video.storedSettings;
+        if (storedSettings === null) {
+            return null;
+        }
+        var lastLockedSettings = storedSettings.lockedRepresentations.getValue();
+        return lastLockedSettings === null ?
+            null :
+            lastLockedSettings.representations.map(function (r) { return r.id; });
+    };
+    TracksStore.prototype.lockAudioRepresentations = function (periodObj, lockSettings) {
+        var _a;
+        var storedSettings = periodObj.audio.storedSettings;
+        if (storedSettings === null) {
+            return;
+        }
+        var DEFAULT_AUDIO_REPRESENTATIONS_SWITCHING_MODE = config.getCurrent().DEFAULT_AUDIO_REPRESENTATIONS_SWITCHING_MODE;
+        var filtered = this._getRepresentationsToLock(storedSettings.adaptation, lockSettings.representations);
+        var switchingMode = (_a = lockSettings.switchingMode) !== null && _a !== void 0 ? _a : DEFAULT_AUDIO_REPRESENTATIONS_SWITCHING_MODE;
+        storedSettings.lockedRepresentations.setValue({ representations: filtered, switchingMode: switchingMode });
+    };
+    TracksStore.prototype.lockVideoRepresentations = function (periodObj, lockSettings) {
+        var _a;
+        var storedSettings = periodObj.video.storedSettings;
+        if (storedSettings === null) {
+            return;
+        }
+        var DEFAULT_VIDEO_REPRESENTATIONS_SWITCHING_MODE = config.getCurrent().DEFAULT_VIDEO_REPRESENTATIONS_SWITCHING_MODE;
+        var filtered = this._getRepresentationsToLock(storedSettings.adaptation, lockSettings.representations);
+        var switchingMode = (_a = lockSettings.switchingMode) !== null && _a !== void 0 ? _a : DEFAULT_VIDEO_REPRESENTATIONS_SWITCHING_MODE;
+        storedSettings.lockedRepresentations.setValue({ representations: filtered, switchingMode: switchingMode });
+    };
+    TracksStore.prototype.unlockAudioRepresentations = function (periodObj) {
+        var storedSettings = periodObj.audio.storedSettings;
+        if (storedSettings === null ||
+            storedSettings.lockedRepresentations.getValue() === null) {
+            return;
+        }
+        storedSettings.lockedRepresentations.setValue(null);
+    };
+    TracksStore.prototype.unlockVideoRepresentations = function (periodObj) {
+        var storedSettings = periodObj.video.storedSettings;
+        if (storedSettings === null ||
+            storedSettings.lockedRepresentations.getValue() === null) {
+            return;
+        }
+        storedSettings.lockedRepresentations.setValue(null);
+    };
+    TracksStore.prototype.dispose = function () {
+        this._isDisposed = true;
+        while (true) {
+            var lastPeriod = this._storedPeriodInfo.pop();
+            if (lastPeriod === undefined) {
+                return;
+            }
+            lastPeriod.isRemoved = true;
+        }
+    };
+    /**
+     * @param {Period} period
+     * @returns {Object}
+     */
+    TracksStore.prototype._addPeriod = function (period) {
+        var periodObj = generatePeriodInfo(period, false, this._isTrickModeTrackEnabled, this._defaultAudioTrackSwitchingMode);
+        for (var i = 0; i < this._storedPeriodInfo.length; i++) {
+            if (this._storedPeriodInfo[i].period.start > period.start) {
+                this._storedPeriodInfo.splice(i, 0, periodObj);
+                return periodObj;
+            }
+        }
+        this._storedPeriodInfo.push(periodObj);
+        return periodObj;
+    };
+    TracksStore.prototype._resetVideoTrackChoices = function (reason) {
+        var _a;
+        for (var i = 0; i < this._storedPeriodInfo.length; i++) {
+            var periodObj = this._storedPeriodInfo[i];
+            if (periodObj.video.storedSettings !== null) {
+                var chosenBaseTrack = periodObj.video.storedSettings.adaptationBase;
+                if (chosenBaseTrack !== null) {
+                    var chosenTrack = getRightVideoTrack(chosenBaseTrack, this._isTrickModeTrackEnabled);
+                    periodObj.video.storedSettings.adaptationBase = chosenBaseTrack;
+                    periodObj.video.storedSettings.adaptation = chosenTrack;
+                }
+            }
+        }
+        // Clone the current Period list to not be influenced if Periods are removed
+        // or added while the loop is running.
+        var sliced = this._storedPeriodInfo.slice();
+        for (var i = 0; i < sliced.length; i++) {
+            var period = sliced[i].period;
+            var videoItem = sliced[i].video;
+            var storedSettings = videoItem.storedSettings;
+            this.trigger("trackUpdate", { period: toExposedPeriod(period),
+                trackType: "video", reason: reason });
+            // The previous event trigger could have had side-effects, so we
+            // re-check if we're still mostly in the same state
+            if (this._isDisposed) {
+                return; // Someone disposed the `TracksStore` on the previous side-effect
+            }
+            var newPeriodItem = getPeriodItem(this._storedPeriodInfo, period.id);
+            if (newPeriodItem !== undefined &&
+                newPeriodItem.video.storedSettings === storedSettings) {
+                (_a = newPeriodItem.video.dispatcher) === null || _a === void 0 ? void 0 : _a.updateTrack(storedSettings);
+            }
+        }
+    };
+    TracksStore.prototype._removePeriodObject = function (index) {
+        if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+            assert(index < this._storedPeriodInfo.length, "Invalid index for Period removal");
+        }
+        var oldPeriodItem = this._storedPeriodInfo[index];
+        this._storedPeriodInfo[index].isRemoved = true;
+        this._storedPeriodInfo.splice(index, 1);
+        this._cachedPeriodInfo.set(oldPeriodItem.period, oldPeriodItem);
+    };
+    TracksStore.prototype._getRepresentationsToLock = function (adaptation, representationIds) {
+        var filtered = representationIds.reduce(function (acc, repId) {
+            var foundRep = arrayFind(adaptation.representations, function (r) {
+                return r.id === repId;
+            });
+            if (foundRep === undefined) {
+                log.warn("API: Wanted locked Representation not found.");
+            }
+            else {
+                acc.push(foundRep);
+            }
+            return acc;
+        }, []);
+        if (filtered.length === 0) {
+            throw new Error("Cannot lock Representations: " +
+                "None of the given Representation id are found");
+        }
+        return filtered;
+    };
+    return TracksStore;
+}(EventEmitter));
+export default TracksStore;
+/**
+ * Returns the index of the given `period` in the given `periods`
+ * Array.
+ * Returns `undefined` if that `period` is not found.
+ * @param {Object} periods
+ * @param {Object} period
+ * @returns {number|undefined}
+ */
+function findPeriodIndex(periods, period) {
+    for (var i = 0; i < periods.length; i++) {
+        var periodI = periods[i];
+        if (periodI.period.id === period.id) {
+            return i;
+        }
+    }
+}
+/**
+ * Returns element in the given `periods` Array that corresponds to the
+ * `period` given.
+ * Returns `undefined` if that `period` is not found.
+ * @param {Object} periods
+ * @param {string} periodId
+ * @returns {Object|undefined}
+ */
+function getPeriodItem(periods, periodId) {
+    for (var i = 0; i < periods.length; i++) {
+        var periodI = periods[i];
+        if (periodI.period.id === periodId) {
+            return periodI;
+        }
+    }
+}
+/**
+ * A `ITMPeriodObject` should only be removed once all References linked to it
+ * do not exist anymore, to keep the possibility of making track choices.
+ * @param {Object} periodObj
+ * @returns {boolean}
+ */
+function isPeriodItemRemovable(periodObj) {
+    var _a, _b, _c;
+    return !periodObj.inManifest &&
+        ((_a = periodObj.text) === null || _a === void 0 ? void 0 : _a.dispatcher) === null &&
+        ((_b = periodObj.audio) === null || _b === void 0 ? void 0 : _b.dispatcher) === null &&
+        ((_c = periodObj.video) === null || _c === void 0 ? void 0 : _c.dispatcher) === null;
+}
+function getRightVideoTrack(adaptation, isTrickModeEnabled) {
+    var _a;
+    if (isTrickModeEnabled &&
+        ((_a = adaptation.trickModeTracks) === null || _a === void 0 ? void 0 : _a[0]) !== undefined) {
+        return adaptation.trickModeTracks[0];
+    }
+    return adaptation;
+}
+/**
+ * Generate an `ITMPeriodObject` object for the given Period, selecting the
+ * default track for each type.
+ * @param {Object} period
+ * @param {boolean} inManifest
+ * @param {boolean} isTrickModeTrackEnabled
+ * @returns {object}
+ */
+function generatePeriodInfo(period, inManifest, isTrickModeTrackEnabled, defaultAudioTrackSwitchingMode) {
+    var _a;
+    var audioAdaptation = period.getSupportedAdaptations("audio")[0];
+    var baseVideoAdaptation = period.getSupportedAdaptations("video")[0];
+    var videoAdaptation = getRightVideoTrack(baseVideoAdaptation, isTrickModeTrackEnabled);
+    var DEFAULT_VIDEO_TRACK_SWITCHING_MODE = config.getCurrent().DEFAULT_VIDEO_TRACK_SWITCHING_MODE;
+    var audioSettings = audioAdaptation !== undefined ?
+        { adaptation: audioAdaptation,
+            switchingMode: defaultAudioTrackSwitchingMode,
+            lockedRepresentations: new SharedReference(null) } :
+        null;
+    var videoSettings = videoAdaptation !== undefined ?
+        { adaptation: videoAdaptation,
+            adaptationBase: baseVideoAdaptation,
+            switchingMode: DEFAULT_VIDEO_TRACK_SWITCHING_MODE,
+            lockedRepresentations: new SharedReference(null) } :
+        null;
+    var textAdaptation = null;
+    var forcedSubtitles = period.getAdaptationsForType("text")
+        .filter(function (ad) { return ad.isForcedSubtitles === true; });
+    if (forcedSubtitles.length > 0) {
+        if (audioAdaptation !== null && audioAdaptation !== undefined) {
+            var sameLanguage = arrayFind(forcedSubtitles, function (f) {
+                return f.normalizedLanguage === audioAdaptation.normalizedLanguage;
+            });
+            if (sameLanguage !== undefined) {
+                textAdaptation = sameLanguage;
+            }
+        }
+        if (textAdaptation === null) {
+            textAdaptation = (_a = arrayFind(forcedSubtitles, function (f) { return f.normalizedLanguage === undefined; })) !== null && _a !== void 0 ? _a : null;
+        }
+    }
+    var textSettings = null;
+    if (textAdaptation !== null) {
+        textSettings = { adaptation: textAdaptation,
+            switchingMode: "direct",
+            lockedRepresentations: new SharedReference(null) };
+    }
+    return { period: period, inManifest: inManifest, isRemoved: false,
+        audio: { storedSettings: audioSettings,
+            dispatcher: null },
+        video: { storedSettings: videoSettings,
+            dispatcher: null },
+        text: { storedSettings: textSettings,
+            dispatcher: null } };
+}
+function toExposedPeriod(p) {
+    return { start: p.start, end: p.end, id: p.id };
+}