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

package/dist/es2017/core/init/utils/content_time_boundaries_observer.d.ts

@@ -22,8 +22,8 @@ import { IStreamOrchestratorPlaybackObservation } from "../../stream";
 /**
  * Observes what's being played and take care of media events relating to time
  * boundaries:
- *   - Emits a `durationUpdate` when the duration of the current content is
- *     known and every time it changes.
+ *   - Emits a `endingPositionChange` when the known maximum playable position
+ *     of the current content is known and every time it changes.
  *   - Emits `endOfStream` API once segments have been pushed until the end and
  *     `resumeStream` if downloads starts back.
  *   - Emits a `periodChange` event when the currently-playing Period seemed to
@@ -56,10 +56,11 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
      */
     constructor(manifest: Manifest, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, bufferTypes: IBufferType[]);
     /**
-     * Returns an estimate of the current duration of the content.
+     * Returns an estimate of the current last position which may be played in
+     * the content at the moment.
      * @returns {Object}
      */
-    getCurrentDuration(): IDurationItem;
+    getCurrentEndingTime(): IEndingPositionInformation;
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -126,20 +127,20 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
     private _addActivelyLoadedPeriod;
     private _removeActivelyLoadedPeriod;
     private _checkCurrentPeriod;
-    private _getManifestDuration;
+    private _getManifestEndTime;
     private _lazilyCreateActiveStreamInfo;
     private _checkEndOfStream;
 }
-export interface IDurationItem {
+export interface IEndingPositionInformation {
     /**
      * The new maximum known position (note that this is the ending position
      * currently known of the current content, it might be superior to the last
      * position at which segments are available and it might also evolve over
      * time), in seconds.
      */
-    duration: number;
+    endingPosition: number;
     /**
-     * If `true`, the communicated `duration` is the actual end of the content.
+     * If `true`, the communicated `endingPosition` is the actual end of the content.
      * It may still be updated due to a track change or to add precision, but it
      * is still a (rough) estimate of the maximum position that content should
      * have.
@@ -147,7 +148,7 @@ export interface IDurationItem {
      * If `false`, this is the currently known maximum position associated to
      * the content, but the content is still evolving (typically, new media
      * segments are still being generated) and as such it can still have a
-     * longer duration in the future.
+     * longer `endingPosition` in the future.
      */
     isEnd: boolean;
 }
@@ -161,10 +162,10 @@ export interface IContentTimeBoundariesObserverEvent {
     /** Triggered when a new `Period` is currently playing. */
     periodChange: Period;
     /**
-     * Triggered when the duration of the currently-playing content became known
-     * or changed.
+     * Triggered when the ending position of the currently-playing content became
+     * known or changed.
      */
-    durationUpdate: IDurationItem;
+    endingPositionChange: IEndingPositionInformation;
     /**
      * Triggered when the last possible chronological segment for all types of
      * buffers has either been pushed or is being pushed to the corresponding

package/dist/es2017/core/init/utils/content_time_boundaries_observer.js

@@ -21,8 +21,8 @@ import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Observes what's being played and take care of media events relating to time
  * boundaries:
- *   - Emits a `durationUpdate` when the duration of the current content is
- *     known and every time it changes.
+ *   - Emits a `endingPositionChange` when the known maximum playable position
+ *     of the current content is known and every time it changes.
  *   - Emits `endOfStream` API once segments have been pushed until the end and
  *     `resumeStream` if downloads starts back.
  *   - Emits a `periodChange` event when the currently-playing Period seemed to
@@ -65,7 +65,7 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
             }
         }, { includeLastObservation: true, clearSignal: cancelSignal });
         manifest.addEventListener("manifestUpdate", () => {
-            this.trigger("durationUpdate", this._getManifestDuration());
+            this.trigger("endingPositionChange", this._getManifestEndTime());
             if (cancelSignal.isCancelled()) {
                 return;
             }
@@ -73,11 +73,12 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
         }, cancelSignal);
     }
     /**
-     * Returns an estimate of the current duration of the content.
+     * Returns an estimate of the current last position which may be played in
+     * the content at the moment.
      * @returns {Object}
      */
-    getCurrentDuration() {
-        return this._getManifestDuration();
+    getCurrentEndingTime() {
+        return this._getManifestEndTime();
     }
     /**
      * Method to call any time an Adaptation has been selected.
@@ -106,12 +107,13 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
                             .updateLastVideoAdaptation(adaptation);
                     }
                     const endingPosition = this._maximumPositionCalculator.getEndingPosition();
-                    const newDuration = endingPosition !== undefined ?
+                    const newEndingPosition = endingPosition !== undefined ?
                         { isEnd: true,
-                            duration: endingPosition } :
+                            endingPosition } :
                         { isEnd: false,
-                            duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
-                    this.trigger("durationUpdate", newDuration);
+                            endingPosition: this._maximumPositionCalculator
+                                .getMaximumAvailablePosition() };
+                    this.trigger("endingPositionChange", newEndingPosition);
                 }
             }
         }
@@ -238,13 +240,13 @@ export default class ContentTimeBoundariesObserver extends EventEmitter {
             }
         }
     }
-    _getManifestDuration() {
+    _getManifestEndTime() {
         const endingPosition = this._maximumPositionCalculator.getEndingPosition();
         return endingPosition !== undefined ?
             { isEnd: true,
-                duration: endingPosition } :
+                endingPosition } :
             { isEnd: false,
-                duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+                endingPosition: this._maximumPositionCalculator.getMaximumAvailablePosition() };
     }
     _lazilyCreateActiveStreamInfo(bufferType) {
         let streamInfo = this._activeStreams.get(bufferType);
@@ -315,9 +317,8 @@ class MaximumPositionCalculator {
      * @returns {number}
      */
     getMaximumAvailablePosition() {
-        var _a;
         if (this._manifest.isDynamic) {
-            return (_a = this._manifest.getLivePosition()) !== null && _a !== void 0 ? _a : this._manifest.getMaximumSafePosition();
+            return this._manifest.getMaximumSafePosition();
         }
         if (this._lastVideoAdaptation === undefined ||
             this._lastAudioAdaptation === undefined) {

package/dist/es2017/core/init/utils/get_initial_time.d.ts

@@ -37,11 +37,25 @@ export interface IInitialTimeOptions {
      */
     fromFirstPosition?: number | null | undefined;
     /**
-     * If set, we should begin at this position relative to the content's end,
-     * in seconds.
+     * If set, we should begin at this position relative to the content's maximum
+     * seekable position, in seconds.
+     *
+     * It should consequently in most cases be a negative value.
      */
     fromLastPosition?: number | null | undefined;
-    /** If set, we should begin at this position relative to the whole duration of
+    /**
+     * If set, we should begin at this position relative to the content's live
+     * edge if it makes sense, in seconds.
+     *
+     * It should consequently in most cases be a negative value.
+     *
+     * If the live edge is unknown or if it does not make sense for the current
+     * content, that position is relative to the content's maximum position
+     * instead.
+     */
+    fromLivePosition?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the whole duration of
      * the content, in percentage.
      */
     percentage?: number | null | undefined;

package/dist/es2017/core/init/utils/get_initial_time.js

@@ -31,15 +31,10 @@ import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
  * @returns {Number}
  */
 export default function getInitialTime(manifest, lowLatencyMode, startAt) {
+    var _a;
     if (!isNullOrUndefined(startAt)) {
         const min = manifest.getMinimumSafePosition();
-        let max;
-        if (manifest.isLive) {
-            max = manifest.getLivePosition();
-        }
-        if (max === undefined) {
-            max = manifest.getMaximumSafePosition();
-        }
+        const max = manifest.getMaximumSafePosition();
         if (!isNullOrUndefined(startAt.position)) {
             log.debug("Init: using startAt.minimumPosition");
             return Math.max(Math.min(startAt.position, max), min);
@@ -64,6 +59,13 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
             return fromLastPosition >= 0 ? max :
                 Math.max(min, max + fromLastPosition);
         }
+        else if (!isNullOrUndefined(startAt.fromLivePosition)) {
+            log.debug("Init: using startAt.fromLivePosition");
+            const livePosition = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : max;
+            const { fromLivePosition } = startAt;
+            return fromLivePosition >= 0 ? livePosition :
+                Math.max(min, livePosition + fromLivePosition);
+        }
         else if (!isNullOrUndefined(startAt.percentage)) {
             log.debug("Init: using startAt.percentage");
             const { percentage } = startAt;

package/dist/es2017/core/segment_buffers/implementations/text/html/text_track_cues_store.js

@@ -15,6 +15,22 @@
  */
 import assert from "../../../../../utils/assert";
 import { areNearlyEqual, getCuesAfter, getCuesBefore, removeCuesInfosBetween, } from "./utils";
+/**
+ * first or last IHTMLCue in a group can have a slighlty different start
+ * or end time than the start or end time of the ICuesGroup due to parsing
+ * approximation.
+ * DELTA_CUES_GROUP defines the tolerance level when comparing the start/end
+ * of a IHTMLCue to the start/end of a ICuesGroup.
+ * Having this value too high may lead to have unwanted subtitle displayed
+ * Having this value too low may lead to have subtitles not displayed
+ */
+const DELTA_CUES_GROUP = 1e-3;
+/**
+ * segment_duration / RELATIVE_DELTA_RATIO = relative_delta
+ *
+ * relative_delta is the tolerance to determine if two segements are the same
+ */
+const RELATIVE_DELTA_RATIO = 5;
 /**
  * Manage the buffer of the HTMLTextSegmentBuffer.
  * Allows to add, remove and recuperate cues at given times.
@@ -57,6 +73,18 @@ export default class TextTrackCuesStore {
                         ret.push(cues[j].element);
                     }
                 }
+                // first or last IHTMLCue in a group can have a slighlty different start
+                // or end time than the start or end time of the ICuesGroup due to parsing
+                // approximation.
+                // Add a tolerance of 1ms to fix this issue
+                if (ret.length === 0 && cues.length > 0) {
+                    for (let j = 0; j < cues.length; j++) {
+                        if (areNearlyEqual(time, cues[j].start, DELTA_CUES_GROUP)
+                            || areNearlyEqual(time, cues[j].end, DELTA_CUES_GROUP)) {
+                            ret.push(cues[j].element);
+                        }
+                    }
+                }
                 return ret;
             }
         }
@@ -143,6 +171,11 @@ export default class TextTrackCuesStore {
     insert(cues, start, end) {
         const cuesBuffer = this._cuesBuffer;
         const cuesInfosToInsert = { start, end, cues };
+        // it's preferable to have a delta depending on the duration of the segment
+        // if the delta is one fifth of the length of the segment:
+        // a segment of [0, 2] is the "same" segment as [0, 2.1]
+        // but [0, 0.04] is not the "same" segement as [0,04, 0.08]
+        const relativeDelta = Math.abs(start - end) / RELATIVE_DELTA_RATIO;
         /**
          * Called when we found the index of the next cue relative to the cue we
          * want to insert (that is a cue starting after its start or at the same
@@ -154,7 +187,7 @@ export default class TextTrackCuesStore {
         function onIndexOfNextCueFound(indexOfNextCue) {
             const nextCue = cuesBuffer[indexOfNextCue];
             if (nextCue === undefined || // no cue
-                areNearlyEqual(cuesInfosToInsert.end, nextCue.end)) // samey end
+                areNearlyEqual(cuesInfosToInsert.end, nextCue.end, relativeDelta)) // samey end
              {
                 //   ours:            |AAAAA|
                 //   the current one: |BBBBB|
@@ -190,8 +223,8 @@ export default class TextTrackCuesStore {
         for (let cueIdx = 0; cueIdx < cuesBuffer.length; cueIdx++) {
             let cuesInfos = cuesBuffer[cueIdx];
             if (start < cuesInfos.end) {
-                if (areNearlyEqual(start, cuesInfos.start)) {
-                    if (areNearlyEqual(end, cuesInfos.end)) {
+                if (areNearlyEqual(start, cuesInfos.start, relativeDelta)) {
+                    if (areNearlyEqual(end, cuesInfos.end, relativeDelta)) {
                         // exact same segment
                         //   ours:            |AAAAA|
                         //   the current one: |BBBBB|
@@ -239,7 +272,7 @@ export default class TextTrackCuesStore {
                         cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
                         return;
                     }
-                    else if (areNearlyEqual(end, cuesInfos.start)) {
+                    else if (areNearlyEqual(end, cuesInfos.start, relativeDelta)) {
                         // our cue goes just before the current one:
                         //   ours:            |AAAAAAA|
                         //   the current one:         |BBBB|
@@ -251,7 +284,7 @@ export default class TextTrackCuesStore {
                         cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
                         return;
                     }
-                    else if (areNearlyEqual(end, cuesInfos.end)) {
+                    else if (areNearlyEqual(end, cuesInfos.end, relativeDelta)) {
                         //   ours:            |AAAAAAA|
                         //   the current one:    |BBBB|
                         //   Result:          |AAAAAAA|
@@ -279,7 +312,7 @@ export default class TextTrackCuesStore {
                     return;
                 }
                 // else -> start > cuesInfos.start
-                if (areNearlyEqual(cuesInfos.end, end)) {
+                if (areNearlyEqual(cuesInfos.end, end, relativeDelta)) {
                     //   ours:              |AAAAAA|
                     //   the current one: |BBBBBBBB|
                     //   Result:          |BBAAAAAA|
@@ -315,6 +348,21 @@ export default class TextTrackCuesStore {
                 }
             }
         }
+        if (cuesBuffer.length) {
+            const lastCue = cuesBuffer[cuesBuffer.length - 1];
+            if (areNearlyEqual(lastCue.end, start, relativeDelta)) {
+                // Match the end of the previous cue to the start of the following one
+                // if they are close enough. If there is a small gap between two segments
+                // it can lead to having no subtitles for a short time, this is noticeable when
+                // two successive segments displays the same text, making it diseappear
+                // and reappear quickly, which gives the impression of blinking
+                //
+                //   ours:                   |AAAAA|
+                //   the current one: |BBBBB|...
+                //   Result:          |BBBBBBBAAAAA|
+                lastCue.end = start;
+            }
+        }
         // no cues group has the end after our current start.
         // These cues should be the last one
         cuesBuffer.push(cuesInfosToInsert);

package/dist/es2017/core/segment_buffers/implementations/text/html/utils.d.ts

@@ -18,9 +18,10 @@ import { ICuesGroup, IHTMLCue } from "./types";
  * @see MAX_DELTA_BUFFER_TIME
  * @param {Number} a
  * @param {Number} b
+ * @param {Number} delta
  * @returns {Boolean}
  */
-export declare function areNearlyEqual(a: number, b: number): boolean;
+export declare function areNearlyEqual(a: number, b: number, delta?: number): boolean;
 /**
  * Get all cues which have data before the given time.
  * @param {Object} cues

package/dist/es2017/core/segment_buffers/implementations/text/html/utils.js

@@ -44,6 +44,21 @@
  * Setting a value too high might lead to two segments targeting different times
  * to be wrongly believed to target the same time. In worst case scenarios, this
  * could lead to wanted text tracks being removed.
+ *
+ * When comparing 2 segments s1 and s2, you may want to take into account the duration
+ * of the segments:
+ *   - if s1 is [0, 2] and s2 is [0, 2.1] s1 and s2 can be considered as nearly equal as
+ *     there is a relative difference of: (2.1-2) / 2 = 5%;
+ *     Formula: (end_s1 - end_s2) / duration_s2 = relative_difference
+ *   - if s1 is [0, 0.04] and s2 is [0.04, 0.08] s1 and s2 may not considered as nearly
+ *     equal as there is a relative difference of: (0.04-0.08) / 0.04 = 100%
+ *
+ * To compare relatively to the duration of a segment you can provide and additional
+ * parameter "delta" that remplace MAX_DELTA_BUFFER_TIME.
+ * If parameter "delta" is higher than MAX_DELTA_BUFFER_TIME, MAX_DELTA_BUFFER_TIME
+ * is used instead of delta. This ensure that segments are nearly equal when comparing
+ * relatively AND absolutely.
+ *
  * @type Number
  */
 const MAX_DELTA_BUFFER_TIME = 0.2;
@@ -51,10 +66,11 @@ const MAX_DELTA_BUFFER_TIME = 0.2;
  * @see MAX_DELTA_BUFFER_TIME
  * @param {Number} a
  * @param {Number} b
+ * @param {Number} delta
  * @returns {Boolean}
  */
-export function areNearlyEqual(a, b) {
-    return Math.abs(a - b) <= MAX_DELTA_BUFFER_TIME;
+export function areNearlyEqual(a, b, delta = MAX_DELTA_BUFFER_TIME) {
+    return Math.abs(a - b) <= Math.min(delta, MAX_DELTA_BUFFER_TIME);
 }
 /**
  * Get all cues which have data before the given time.

package/dist/es2017/core/stream/adaptation/adaptation_stream.js

@@ -1,4 +1,3 @@
-import nextTick from "next-tick";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -6,6 +5,7 @@ import assertUnreachable from "../../../utils/assert_unreachable";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
+import queueMicrotask from "../../../utils/queue_microtask";
 import SharedReference, { createMappedReference, } from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
 import RepresentationStream from "../representation";
@@ -133,7 +133,7 @@ export default function AdaptationStream({ playbackObserver, content, options, r
                 // conditions where the inner logic would be called synchronously before
                 // the next observation (which may reflect very different playback conditions)
                 // is actually received.
-                return nextTick(() => {
+                return queueMicrotask(() => {
                     playbackObserver.listen(() => {
                         if (fnCancelSignal.isCancelled()) {
                             return;

package/dist/es2017/core/stream/orchestrator/stream_orchestrator.js

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import nextTick from "next-tick";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
+import queueMicrotask from "../../../utils/queue_microtask";
 import { createMappedReference, } from "../../../utils/reference";
 import SortedList from "../../../utils/sorted_list";
 import TaskCanceller from "../../../utils/task_canceller";
@@ -265,7 +265,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             // Schedule micro task before checking the last playback observation
             // to reduce the risk of race conditions where the next observation
             // was going to be emitted synchronously.
-            nextTick(() => {
+            queueMicrotask(() => {
                 var _a;
                 if (orchestratorCancelSignal.isCancelled()) {
                     return;
@@ -430,7 +430,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                             // conditions where the inner logic would be called synchronously before
                             // the next observation (which may reflect very different playback
                             // conditions) is actually received.
-                            return nextTick(() => {
+                            return queueMicrotask(() => {
                                 if (innerCancelSignal.isCancelled()) {
                                     return;
                                 }

package/dist/es2017/core/stream/period/period_stream.js

@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import nextTick from "next-tick";
 import config from "../../../config";
 import { formatError, MediaError, } from "../../../errors";
 import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
+import queueMicrotask from "../../../utils/queue_microtask";
 import { getLeftSizeOfBufferedTimeRange } from "../../../utils/ranges";
 import SharedReference from "../../../utils/reference";
 import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
@@ -253,7 +253,7 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
         // is actually received.
         // It can happen when `askForMediaSourceReload` is called as a side-effect of
         // the same event that triggers the playback observation to be emitted.
-        nextTick(() => {
+        queueMicrotask(() => {
             playbackObserver.listen(() => {
                 if (cancelSignal.isCancelled()) {
                     return;

package/dist/es2017/core/stream/representation/utils/get_buffer_status.js

@@ -74,7 +74,7 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
      * needed segments for this Representation until the end of the Period.
      */
     const hasFinishedLoading = representation.index.isInitialized() &&
-        representation.index.isFinished() &&
+        !representation.index.isStillAwaitingFutureSegments() &&
         neededRange.hasReachedPeriodEnd &&
         prioritizedNeededSegments.length === 0 &&
         segmentsOnHold.length === 0;
@@ -128,7 +128,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
         SegmentBuffersStore.isNative(content.adaptation.type) &&
         initialWantedTime >= lastIndexPosition &&
         representationIndex.isInitialized() &&
-        representationIndex.isFinished() &&
+        !representationIndex.isStillAwaitingFutureSegments() &&
         isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime)) {
         wantedStartPosition = lastIndexPosition - 1;
     }
@@ -138,7 +138,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     const wantedEndPosition = wantedStartPosition + bufferGoal;
     let hasReachedPeriodEnd;
     if (!representation.index.isInitialized() ||
-        !representation.index.isFinished() ||
+        representation.index.isStillAwaitingFutureSegments() ||
         period.end === undefined) {
         hasReachedPeriodEnd = false;
     }

package/dist/es2017/core/stream/representation/utils/get_needed_segments.js

@@ -320,7 +320,7 @@ function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     }
     if (minimumEndTime > currentSeg.bufferedEnd &&
         currentSeg.end - currentSeg.bufferedEnd > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-        log.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
+        log.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.end, currentSeg.bufferedEnd);
         return true;
     }
     return false;

package/dist/es2017/default_config.d.ts

@@ -21,6 +21,11 @@ declare const DEFAULT_CONFIG: {
      * @type {Number}
      */
     DEFAULT_REQUEST_TIMEOUT: number;
+    /**
+     * Default connection time after which a request will timeout, in ms.
+     * @type {Number}
+     */
+    DEFAULT_CONNECTION_TIMEOUT: number;
     /**
      * Can be either:
      *   - "native": Subtitles are all displayed in a <track> element

package/dist/es2017/default_config.js

@@ -21,6 +21,11 @@ const DEFAULT_CONFIG = {
      * @type {Number}
      */
     DEFAULT_REQUEST_TIMEOUT: 30 * 1000,
+    /**
+     * Default connection time after which a request will timeout, in ms.
+     * @type {Number}
+     */
+    DEFAULT_CONNECTION_TIMEOUT: 15 * 1000,
     /**
      * Can be either:
      *   - "native": Subtitles are all displayed in a <track> element

package/dist/es2017/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.js

@@ -128,7 +128,9 @@ export default class VideoThumbnailLoader {
             {}, { baseDelay: 0,
                 maxDelay: 0,
                 maxRetry: 0,
-                requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT });
+                requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+                connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+            });
             const initSegment = content.representation.index.getInitSegment();
             const initSegmentUniqueId = initSegment !== null ?
                 content.representation.uniqueId :

package/dist/es2017/experimental/tools/createMetaplaylist/get_duration_from_manifest.js

@@ -69,6 +69,7 @@ async function getDurationFromManifest(url, transport) {
             url,
             responseType: "document",
             timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+            connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
             // We won't cancel
             cancelSignal: new TaskCanceller().signal,
         });
@@ -106,6 +107,7 @@ async function getDurationFromManifest(url, transport) {
         url,
         responseType: "text",
         timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+        connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
         // We won't cancel
         cancelSignal: new TaskCanceller().signal,
     });

package/dist/es2017/manifest/representation.js

@@ -27,6 +27,7 @@ class Representation {
      * @param {Object} args
      */
     constructor(args, opts) {
+        var _a;
         this.id = args.id;
         this.uniqueId = generateRepresentationUniqueId();
         this.bitrate = args.bitrate;
@@ -55,12 +56,24 @@ class Representation {
         this.cdnMetadata = args.cdnMetadata;
         this.index = args.index;
         if (opts.type === "audio" || opts.type === "video") {
-            const mimeTypeStr = this.getMimeTypeString();
-            const isSupported = isCodecSupported(mimeTypeStr);
-            if (!isSupported) {
-                log.info("Unsupported Representation", mimeTypeStr, this.id, this.bitrate);
+            this.isSupported = false;
+            // Supplemental codecs are defined as backwards-compatible codecs enhancing
+            // the experience of a base layer codec
+            if (args.supplementalCodecs !== undefined) {
+                const supplementalCodecMimeTypeStr = `${(_a = this.mimeType) !== null && _a !== void 0 ? _a : ""};codecs="${args.supplementalCodecs}"`;
+                if (isCodecSupported(supplementalCodecMimeTypeStr)) {
+                    this.codec = args.supplementalCodecs;
+                    this.isSupported = true;
+                }
+            }
+            if (!this.isSupported) {
+                const mimeTypeStr = this.getMimeTypeString();
+                const isSupported = isCodecSupported(mimeTypeStr);
+                if (!isSupported) {
+                    log.info("Unsupported Representation", mimeTypeStr, this.id, this.bitrate);
+                }
+                this.isSupported = isSupported;
             }
-            this.isSupported = isSupported;
         }
         else {
             this.isSupported = true; // TODO for other types

package/dist/es2017/manifest/representation_index/static.d.ts

@@ -89,7 +89,7 @@ export default class StaticRepresentationIndex implements IRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished(): true;
+    isStillAwaitingFutureSegments(): false;
     /**
      * @returns {Boolean}
      */

package/dist/es2017/manifest/representation_index/static.js

@@ -115,8 +115,8 @@ export default class StaticRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished() {
-        return true;
+    isStillAwaitingFutureSegments() {
+        return false;
     }
     /**
      * @returns {Boolean}

package/dist/es2017/manifest/representation_index/types.d.ts

@@ -304,7 +304,7 @@ export interface IRepresentationIndex {
     getLastAvailablePosition(): number | null | undefined;
     /**
      * Returns the ending time, in seconds, of the Representation once it is
-     * "finished" (@see isFinished).
+     * "finished" (@see isStillAwaitingFutureSegments).
      * Should thus be equivalent to `getLastAvailablePosition` once finished.
      *
      * Returns `null` if nothing is in the index
@@ -352,13 +352,13 @@ export interface IRepresentationIndex {
      */
     checkDiscontinuity(time: number): number | null;
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated so that we can freely go to the next period.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      * @returns {boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * Returns `true` if this index has all the data it needs to give the list
      * of available segments.