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

package/src/core/init/utils/content_time_boundaries_observer.ts

@@ -32,8 +32,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
@@ -111,7 +111,7 @@ export default class ContentTimeBoundariesObserver
     }, { includeLastObservation: true, clearSignal: cancelSignal });
 
     manifest.addEventListener("manifestUpdate", () => {
-      this.trigger("durationUpdate", this._getManifestDuration());
+      this.trigger("endingPositionChange", this._getManifestEndTime());
       if (cancelSignal.isCancelled()) {
         return;
       }
@@ -120,11 +120,12 @@ export default class ContentTimeBoundariesObserver
   }
 
   /**
-   * 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}
    */
-  public getCurrentDuration() : IDurationItem  {
-    return this._getManifestDuration();
+  public getCurrentEndingTime() : IEndingPositionInformation  {
+    return this._getManifestEndTime();
   }
 
   /**
@@ -157,12 +158,13 @@ export default class ContentTimeBoundariesObserver
               .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);
         }
       }
     }
@@ -311,13 +313,13 @@ export default class ContentTimeBoundariesObserver
     }
   }
 
-  private _getManifestDuration() : IDurationItem {
+  private _getManifestEndTime() : IEndingPositionInformation {
     const endingPosition = this._maximumPositionCalculator.getEndingPosition();
     return endingPosition !== undefined ?
       { isEnd: true,
-        duration: endingPosition } :
+        endingPosition } :
       { isEnd: false,
-        duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+        endingPosition: this._maximumPositionCalculator.getMaximumAvailablePosition() };
   }
 
   private _lazilyCreateActiveStreamInfo(bufferType : IBufferType) : IActiveStreamsInfo {
@@ -348,16 +350,16 @@ export default class ContentTimeBoundariesObserver
   }
 }
 
-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.
@@ -365,7 +367,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;
 }
@@ -380,10 +382,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
@@ -460,8 +462,7 @@ class MaximumPositionCalculator {
  */
   public getMaximumAvailablePosition() : number {
     if (this._manifest.isDynamic) {
-      return this._manifest.getLivePosition() ??
-             this._manifest.getMaximumSafePosition();
+      return this._manifest.getMaximumSafePosition();
     }
     if (this._lastVideoAdaptation === undefined ||
         this._lastAudioAdaptation === undefined)

package/src/core/init/utils/get_initial_time.ts

@@ -43,11 +43,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;
@@ -73,13 +87,7 @@ export default function getInitialTime(
 ) : number {
   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);
@@ -97,12 +105,17 @@ export default function getInitialTime(
       const { fromFirstPosition } = startAt;
       return fromFirstPosition <= 0 ? min :
                                       Math.min(max, min + fromFirstPosition);
-    }
-    else if (!isNullOrUndefined(startAt.fromLastPosition)) {
+    } else if (!isNullOrUndefined(startAt.fromLastPosition)) {
       log.debug("Init: using startAt.fromLastPosition");
       const { fromLastPosition } = startAt;
       return fromLastPosition >= 0 ? max :
                                      Math.max(min, max + fromLastPosition);
+    } else if (!isNullOrUndefined(startAt.fromLivePosition)) {
+      log.debug("Init: using startAt.fromLivePosition");
+      const livePosition = manifest.getLivePosition() ?? 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/src/core/segment_buffers/implementations/text/html/__tests__/utils.test.ts

@@ -261,6 +261,21 @@ describe("HTML Text buffer utils - areNearlyEqual", () => {
   it("should return true if input number are equals", () => {
     expect(areNearlyEqual(5, 5)).toBe(true);
   });
+  it(
+    "should return false if input number are not nearly equals with delta parameter",
+    () => {
+      expect(areNearlyEqual(5, 5.1, 0.02)).toBe(false);
+    });
+  it(
+    "should return true if input number are nearly equals with delta parameter",
+    () => {
+      expect(areNearlyEqual(5, 5.01, 0.02)).toBe(true);
+    });
+  it(
+    "should return true if input number are equals with delta parameter",
+    () => {
+      expect(areNearlyEqual(5, 5, 0.02)).toBe(true);
+    });
 });
 
 describe("HTML Text buffer utils - removeCuesInfosBetween", () => {

package/src/core/segment_buffers/implementations/text/html/text_track_cues_store.ts

@@ -26,6 +26,23 @@ import {
   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.
@@ -72,6 +89,19 @@ 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;
       }
     }
@@ -163,6 +193,11 @@ export default class TextTrackCuesStore {
   insert(cues : IHTMLCue[], start : number, end : number) : void {
     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
@@ -175,7 +210,7 @@ export default class TextTrackCuesStore {
     function onIndexOfNextCueFound(indexOfNextCue : number) : void {
       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|
@@ -210,8 +245,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|
@@ -257,7 +292,7 @@ export default class TextTrackCuesStore {
             //   - add ours before the current one
             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|
@@ -268,7 +303,7 @@ export default class TextTrackCuesStore {
             cuesInfos.start = end;
             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|
@@ -297,7 +332,7 @@ export default class TextTrackCuesStore {
         }
         // else -> start > cuesInfos.start
 
-        if (areNearlyEqual(cuesInfos.end, end)) {
+        if (areNearlyEqual(cuesInfos.end, end, relativeDelta)) {
           //   ours:              |AAAAAA|
           //   the current one: |BBBBBBBB|
           //   Result:          |BBAAAAAA|
@@ -333,6 +368,22 @@ 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/src/core/segment_buffers/implementations/text/html/utils.ts

@@ -50,6 +50,21 @@ import {
  * 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;
@@ -58,10 +73,12 @@ 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 : number, b : number) : boolean {
-  return Math.abs(a - b) <= MAX_DELTA_BUFFER_TIME;
+export function areNearlyEqual(
+  a : number, b : number, delta: number = MAX_DELTA_BUFFER_TIME) : boolean {
+  return Math.abs(a - b) <= Math.min(delta, MAX_DELTA_BUFFER_TIME);
 }
 
 /**

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -1,4 +1,3 @@
-import nextTick from "next-tick";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -7,6 +6,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,
   IReadOnlySharedReference,
@@ -192,7 +192,7 @@ export default function AdaptationStream(
         // 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/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import nextTick from "next-tick";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
@@ -22,6 +21,7 @@ import Manifest, {
   IDecipherabilityUpdateElement,
   Period,
 } from "../../../manifest";
+import queueMicrotask from "../../../utils/queue_microtask";
 import {
   createMappedReference,
   IReadOnlySharedReference,
@@ -351,7 +351,7 @@ export default function StreamOrchestrator(
       // 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(() => {
         if (orchestratorCancelSignal.isCancelled()) {
           return ;
         }
@@ -554,7 +554,7 @@ export default function StreamOrchestrator(
               // 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/src/core/stream/period/period_stream.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import nextTick from "next-tick";
 import config from "../../../config";
 import {
   formatError,
@@ -26,6 +25,7 @@ import {
   Period,
 } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
+import queueMicrotask from "../../../utils/queue_microtask";
 import { getLeftSizeOfBufferedTimeRange } from "../../../utils/ranges";
 import SharedReference, {
   IReadOnlySharedReference,
@@ -362,7 +362,7 @@ export default function PeriodStream(
     // 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/src/core/stream/representation/utils/get_buffer_status.ts

@@ -153,7 +153,7 @@ export default function getBufferStatus(
    * 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;
@@ -221,7 +221,7 @@ function getRangeOfNeededSegments(
       SegmentBuffersStore.isNative(content.adaptation.type) &&
       initialWantedTime >= lastIndexPosition &&
       representationIndex.isInitialized() &&
-      representationIndex.isFinished() &&
+      !representationIndex.isStillAwaitingFutureSegments() &&
       isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime))
   {
     wantedStartPosition = lastIndexPosition - 1;
@@ -233,7 +233,7 @@ function getRangeOfNeededSegments(
 
   let hasReachedPeriodEnd;
   if (!representation.index.isInitialized() ||
-      !representation.index.isFinished() ||
+      representation.index.isStillAwaitingFutureSegments() ||
       period.end === undefined)
   {
     hasReachedPeriodEnd = false;

package/src/core/stream/representation/utils/get_needed_segments.ts

@@ -493,8 +493,8 @@ function doesEndSeemGarbageCollected(
       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);
+             currentSeg.end,
+             currentSeg.bufferedEnd);
     return true;
   }
 

package/src/default_config.ts

@@ -23,6 +23,11 @@ const DEFAULT_CONFIG = {
      */
   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/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -177,7 +177,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,
+        }
       ) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
       const initSegment = content.representation.index.getInitSegment();
       const initSegmentUniqueId = initSegment !== null ?

package/src/experimental/tools/createMetaplaylist/get_duration_from_manifest.ts

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

package/src/manifest/representation.ts

@@ -188,15 +188,28 @@ 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 =
+            `${this.mimeType ?? ""};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/src/manifest/representation_index/static.ts

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

package/src/manifest/representation_index/types.ts

@@ -329,7 +329,7 @@ export interface IRepresentationIndex {
 
   /**
    * 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
@@ -381,13 +381,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

package/src/parsers/manifest/dash/common/__tests__/convert_supplemental_codecs.test.ts

@@ -0,0 +1,37 @@
+import { convertSupplementalCodecsToRFC6381 } from "../convert_supplemental_codecs";
+
+describe("parseSupplementalCodec", () => {
+  it("should return the codec unchanged if there is only one codec", () => {
+    expect(convertSupplementalCodecsToRFC6381("avc1.4d400d"))
+      .toEqual("avc1.4d400d");
+  });
+  it("should trim starting and ending whitespace", () => {
+    expect(
+      convertSupplementalCodecsToRFC6381("  avc1.4d400d  "))
+      .toEqual("avc1.4d400d");
+  });
+  it("should return comma-separated list if input is whitespace-separated", () => {
+    expect(
+      convertSupplementalCodecsToRFC6381("avc1.4d400d avc1.4d4015"))
+      .toEqual("avc1.4d400d, avc1.4d4015");
+  });
+  it("should return comma-separated value if input is already comma-separated", () => {
+    expect(
+      convertSupplementalCodecsToRFC6381("avc1.4d400d, avc1.4d4015"))
+      .toEqual("avc1.4d400d, avc1.4d4015");
+  });
+
+  it("should return comma-separated value if input as missplaced whitespace", () => {
+    expect(
+      convertSupplementalCodecsToRFC6381("avc1.4d400d  ,  avc1.4d4015 "))
+      .toEqual("avc1.4d400d, avc1.4d4015");
+  });
+
+  it(`should return comma-separated value if input is mix of comma and 
+    whitespace separated list`
+  , () => {
+    expect(
+      convertSupplementalCodecsToRFC6381("avc1.4d400d avc1.4d4015, avc1.4d401f"))
+      .toEqual("avc1.4d400d, avc1.4d4015, avc1.4d401f");
+  });
+});