rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/parsers/containers/isobmff/read.ts

@@ -14,10 +14,14 @@
  * limitations under the License.
  */
 
-import { getBoxContent } from "./get_box";
+import {
+  getBoxContent,
+  getBoxesContent,
+} from "./get_box";
 
 /**
- * Returns TRAF Box from the whole ISOBMFF File.
+ * Returns the content of the first "traf" box encountered in the given ISOBMFF
+ * data.
  * Returns null if not found.
  * @param {Uint8Array} buffer
  * @returns {Uint8Array|null}
@@ -31,7 +35,27 @@ function getTRAF(buffer : Uint8Array) : Uint8Array|null {
 }
 
 /**
- * Returns MDAT Box from the whole ISOBMFF File.
+ * Returns the content of all "traf" boxes encountered in the given ISOBMFF
+ * data.
+ * Might be preferred to just `getTRAF` if you suspect that your ISOBMFF may
+ * have multiple "moof" boxes.
+ * @param {Uint8Array} buffer
+ * @returns {Array.<Uint8Array>}
+ */
+function getTRAFs(buffer : Uint8Array) : Uint8Array[] {
+  const moofs = getBoxesContent(buffer, 0x6D6F6F66 /* moof */);
+  return moofs.reduce((acc : Uint8Array[], moof : Uint8Array) => {
+    const traf = getBoxContent(moof, 0x74726166 /* traf */);
+    if (traf !== null) {
+      acc.push(traf);
+    }
+    return acc;
+  }, []);
+}
+
+/**
+ * Returns the content of the first "moof" box encountered in the given ISOBMFF
+ * data.
  * Returns null if not found.
  * @param {Uint8Array} buffer
  * @returns {Uint8Array|null}
@@ -41,7 +65,8 @@ function getMDAT(buf : Uint8Array) : Uint8Array|null {
 }
 
 /**
- * Returns MDIA Box from the whole ISOBMFF File.
+ * Returns the content of the first "mdia" box encountered in the given ISOBMFF
+ * data.
  * Returns null if not found.
  * @param {Uint8Array} buffer
  * @returns {Uint8Array|null}
@@ -61,7 +86,8 @@ function getMDIA(buf : Uint8Array) : Uint8Array|null {
 }
 
 /**
- * Returns EMSG Box from the while ISOBMFF File.
+ * Returns the content of the first "emsg" box encountered in the given ISOBMFF
+ * data.
  * Returns null if not found.
  * @param {Uint8Array} buffer
  * @returns {Uint8Array|null}
@@ -72,6 +98,7 @@ function getEMSG(buffer: Uint8Array, offset = 0) : Uint8Array|null {
 
 export {
   getTRAF,
+  getTRAFs,
   getMDAT,
   getMDIA,
   getEMSG,

package/src/parsers/containers/isobmff/utils.ts

@@ -40,6 +40,7 @@ import {
   getEMSG,
   getMDIA,
   getTRAF,
+  getTRAFs,
 } from "./read";
 
 /** Information related to a PSSH box. */
@@ -240,68 +241,72 @@ function getDefaultDurationFromTFHDInTRAF(traf : Uint8Array) : number | undefine
  * @returns {number | undefined}
  */
 function getDurationFromTrun(buffer : Uint8Array) : number | undefined {
-  const traf = getTRAF(buffer);
-  if (traf === null) {
+  const trafs = getTRAFs(buffer);
+  if (trafs.length === 0) {
     return undefined;
   }
 
-  const trun = getBoxContent(traf, 0x7472756E /* trun */);
-  if (trun === null) {
-    return undefined;
-  }
-  let cursor = 0;
-  const version = trun[cursor]; cursor += 1;
-  if (version > 1) {
-    return undefined;
-  }
-
-  const flags = be3toi(trun, cursor); cursor += 3;
-  const hasSampleDuration = (flags & 0x000100) > 0;
-
-  let defaultDuration : number | undefined = 0;
-  if (!hasSampleDuration) {
-    defaultDuration = getDefaultDurationFromTFHDInTRAF(traf);
-    if (defaultDuration === undefined) {
+  let completeDuration : number = 0;
+  for (const traf of trafs) {
+    const trun = getBoxContent(traf, 0x7472756E /* trun */);
+    if (trun === null) {
+      return undefined;
+    }
+    let cursor = 0;
+    const version = trun[cursor]; cursor += 1;
+    if (version > 1) {
       return undefined;
     }
-  }
 
-  const hasDataOffset = (flags & 0x000001) > 0;
-  const hasFirstSampleFlags = (flags & 0x000004) > 0;
-  const hasSampleSize = (flags & 0x000200) > 0;
-  const hasSampleFlags = (flags & 0x000400) > 0;
-  const hasSampleCompositionOffset = (flags & 0x000800) > 0;
+    const flags = be3toi(trun, cursor); cursor += 3;
+    const hasSampleDuration = (flags & 0x000100) > 0;
 
-  const sampleCounts = be4toi(trun, cursor); cursor += 4;
+    let defaultDuration : number | undefined = 0;
+    if (!hasSampleDuration) {
+      defaultDuration = getDefaultDurationFromTFHDInTRAF(traf);
+      if (defaultDuration === undefined) {
+        return undefined;
+      }
+    }
 
-  if (hasDataOffset) {
-    cursor += 4;
-  }
-  if (hasFirstSampleFlags) {
-    cursor += 4;
-  }
+    const hasDataOffset = (flags & 0x000001) > 0;
+    const hasFirstSampleFlags = (flags & 0x000004) > 0;
+    const hasSampleSize = (flags & 0x000200) > 0;
+    const hasSampleFlags = (flags & 0x000400) > 0;
+    const hasSampleCompositionOffset = (flags & 0x000800) > 0;
 
-  let i = sampleCounts;
-  let duration = 0;
-  while (i-- > 0) {
-    if (hasSampleDuration) {
-      duration += be4toi(trun, cursor);
-      cursor += 4;
-    } else {
-      duration += defaultDuration;
-    }
-    if (hasSampleSize) {
+    const sampleCounts = be4toi(trun, cursor); cursor += 4;
+
+    if (hasDataOffset) {
       cursor += 4;
     }
-    if (hasSampleFlags) {
+    if (hasFirstSampleFlags) {
       cursor += 4;
     }
-    if (hasSampleCompositionOffset) {
-      cursor += 4;
+
+    let i = sampleCounts;
+    let duration = 0;
+    while (i-- > 0) {
+      if (hasSampleDuration) {
+        duration += be4toi(trun, cursor);
+        cursor += 4;
+      } else {
+        duration += defaultDuration;
+      }
+      if (hasSampleSize) {
+        cursor += 4;
+      }
+      if (hasSampleFlags) {
+        cursor += 4;
+      }
+      if (hasSampleCompositionOffset) {
+        cursor += 4;
+      }
     }
-  }
 
-  return duration;
+    completeDuration += duration;
+  }
+  return completeDuration;
 }
 
 /**

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

@@ -14,15 +14,19 @@
  * limitations under the License.
  */
 
+import type {
+  IParsedAdaptations,
+  IParsedAdaptation,
+} from "../../../types";
 import attachTrickModeTrack from "../attach_trickmode_track";
 
 describe("attachTrickModeTrack", () => {
   it("should correclty attach trickmode tracks", () => {
-    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
     const trickModeTracks = [
       { adaptation: { type: "video" }, trickModeAttachedAdaptationIds: ["1", "3"] },
       { adaptation: { type: "audio" }, trickModeAttachedAdaptationIds: ["1"] },
-    ] as any;
+    ] as Array<{ adaptation : IParsedAdaptation;
+                 trickModeAttachedAdaptationIds : string[]; }>;
 
     const adaptations = {
       video: [
@@ -36,8 +40,7 @@ describe("attachTrickModeTrack", () => {
         { id: "2", trickModeTracks: undefined },
         { id: "3", trickModeTracks: undefined },
       ],
-    } as any;
-    /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+    } as unknown as IParsedAdaptations;
 
     attachTrickModeTrack(adaptations, trickModeTracks);
 

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

@@ -49,7 +49,7 @@ describe("flattenOverlappingPeriods", function() {
 
     expect(logSpy).toHaveBeenCalledTimes(1);
     expect(logSpy).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", periods[1], periods[2]);
+      "DASH: Updating overlapping Periods.", 60, 60);
     logSpy.mockRestore();
   });
 
@@ -78,7 +78,7 @@ describe("flattenOverlappingPeriods", function() {
 
     expect(logSpy).toHaveBeenCalledTimes(1);
     expect(logSpy).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", periods[1], periods[2]);
+      "DASH: Updating overlapping Periods.", 60, 90);
     logSpy.mockRestore();
   });
 
@@ -104,9 +104,9 @@ describe("flattenOverlappingPeriods", function() {
 
     expect(logSpy).toHaveBeenCalledTimes(2);
     expect(logSpy).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", periods[0], periods[2]);
+      "DASH: Updating overlapping Periods.", 60, 50);
     expect(logSpy).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", periods[1], periods[2]);
+      "DASH: Updating overlapping Periods.", 0, 50);
     logSpy.mockRestore();
   });
 

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

@@ -14,7 +14,12 @@
  * limitations under the License.
  */
 
+import type { IPeriodIntermediateRepresentation } from "../../node_parser_types";
+import type { IParsedPeriodsContext } from "../get_periods_time_infos";
+// https://github.com/typescript-eslint/typescript-eslint/issues/2315
+/* eslint-disable no-duplicate-imports */
 import getPeriodsTimeInformation from "../get_periods_time_infos";
+/* eslint-enable no-duplicate-imports */
 
 describe("DASH Parser - getPeriodsTimeInformation", () => {
   it("should guess duration and end from next period.", () => {
@@ -22,7 +27,10 @@ describe("DASH Parser - getPeriodsTimeInformation", () => {
       { attributes: { start: 0 } },
       { attributes: { start: 10 } },
     ];
-    const timeInfos = getPeriodsTimeInformation(periodsInfos as any, {} as any);
+    const timeInfos = getPeriodsTimeInformation(
+      periodsInfos as IPeriodIntermediateRepresentation[],
+      {} as IParsedPeriodsContext
+    );
     expect(timeInfos[0].periodDuration).toBe(10);
     expect(timeInfos[0].periodEnd).toBe(10);
     expect(timeInfos[1].periodDuration).toBe(undefined);
@@ -34,7 +42,10 @@ describe("DASH Parser - getPeriodsTimeInformation", () => {
       { attributes: { start: 0, duration: 10 } },
       { attributes: { duration: 10 } },
     ];
-    const timeInfos = getPeriodsTimeInformation(periodsInfos as any, {} as any);
+    const timeInfos = getPeriodsTimeInformation(
+      periodsInfos as IPeriodIntermediateRepresentation[],
+      {} as IParsedPeriodsContext
+    );
     expect(timeInfos[0].periodEnd).toBe(10);
     expect(timeInfos[1].periodStart).toBe(10);
     expect(timeInfos[1].periodEnd).toBe(20);
@@ -45,7 +56,10 @@ describe("DASH Parser - getPeriodsTimeInformation", () => {
       { attributes: { start: 0, duration: 5 } },
       { attributes: { start: 5, duration: 10 } },
     ];
-    const timeInfos = getPeriodsTimeInformation(periodsInfos as any, {} as any);
+    const timeInfos = getPeriodsTimeInformation(
+      periodsInfos as IPeriodIntermediateRepresentation[],
+      {} as IParsedPeriodsContext
+    );
     expect(timeInfos[0].periodStart).toEqual(periodsInfos[0].attributes.start);
     expect(timeInfos[0].periodDuration).toEqual(periodsInfos[0].attributes.duration);
     expect(timeInfos[1].periodStart).toEqual(periodsInfos[1].attributes.start);
@@ -60,7 +74,10 @@ describe("DASH Parser - getPeriodsTimeInformation", () => {
       duration: 20,
     };
     const timeInfos =
-      getPeriodsTimeInformation(periodsInfos as any, manifestInfos as any);
+      getPeriodsTimeInformation(
+        periodsInfos as IPeriodIntermediateRepresentation[],
+        manifestInfos as IParsedPeriodsContext
+      );
     expect(timeInfos[0].periodDuration).toEqual(manifestInfos.duration);
   });
 
@@ -73,7 +90,10 @@ describe("DASH Parser - getPeriodsTimeInformation", () => {
       availabilityStartTime: 500,
     };
     const timeInfos =
-      getPeriodsTimeInformation(periodsInfos as any, manifestInfos as any);
+      getPeriodsTimeInformation(
+        periodsInfos as IPeriodIntermediateRepresentation[],
+        manifestInfos as IParsedPeriodsContext
+      );
     expect(timeInfos[0].periodStart).toBe(500);
     expect(timeInfos[0].periodDuration).toBe(10);
     expect(timeInfos[0].periodEnd).toBe(510);
@@ -87,7 +107,10 @@ describe("DASH Parser - getPeriodsTimeInformation", () => {
       isDynamic: false,
     };
     const timeInfos =
-      getPeriodsTimeInformation(periodsInfos as any, manifestInfos as any);
+      getPeriodsTimeInformation(
+        periodsInfos as IPeriodIntermediateRepresentation[],
+        manifestInfos as IParsedPeriodsContext
+      );
     expect(timeInfos[0].periodStart).toBe(0);
     expect(timeInfos[0].periodDuration).toBe(10);
     expect(timeInfos[0].periodEnd).toBe(10);

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

@@ -46,6 +46,7 @@ describe("DASH parsers - ManifestBoundsCalculator", () => {
   /* eslint-enable max-len */
     const manifestBoundsCalculator = new ManifestBoundsCalculator({
       isDynamic: false,
+      timeShiftBufferDepth: undefined,
     });
     expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);
     expect(manifestBoundsCalculator.estimateMinimumBound()).toEqual(0);

package/src/parsers/manifest/dash/common/attach_trickmode_track.ts

@@ -32,16 +32,13 @@ function attachTrickModeTrack(
   trickModeTracks: Array<{ adaptation: IParsedAdaptation;
                            trickModeAttachedAdaptationIds: string[]; }>
 ): void {
-  for (let i = 0; i < trickModeTracks.length; i++) {
-    const { adaptation, trickModeAttachedAdaptationIds } = trickModeTracks[i];
-    for (let m = 0; m < trickModeAttachedAdaptationIds.length; m++) {
-      const trickModeAttachedAdaptationId = trickModeAttachedAdaptationIds[m];
-      for (let j = 0; j < SUPPORTED_ADAPTATIONS_TYPE.length; j++) {
-        const adaptationType = SUPPORTED_ADAPTATIONS_TYPE[j];
+  for (const track of trickModeTracks) {
+    const { adaptation, trickModeAttachedAdaptationIds } = track;
+    for (const trickModeAttachedAdaptationId of trickModeAttachedAdaptationIds) {
+      for (const adaptationType of SUPPORTED_ADAPTATIONS_TYPE) {
         const adaptationsByType = adaptations[adaptationType];
         if (adaptationsByType !== undefined) {
-          for (let k = 0; k < adaptationsByType.length; k++) {
-            const adaptationByType = adaptationsByType[k];
+          for (const adaptationByType of adaptationsByType) {
             if (adaptationByType.id === trickModeAttachedAdaptationId) {
               if (adaptationByType.trickModeTracks === undefined) {
                 adaptationByType.trickModeTracks = [];

package/src/parsers/manifest/dash/common/flatten_overlapping_periods.ts

@@ -54,10 +54,12 @@ export default function flattenOverlappingPeriods(
     const parsedPeriod = parsedPeriods[i];
     let lastFlattenedPeriod = flattenedPeriods[flattenedPeriods.length - 1];
     while (
-      lastFlattenedPeriod.duration == null ||
+      lastFlattenedPeriod.duration === undefined ||
       (lastFlattenedPeriod.start + lastFlattenedPeriod.duration) > parsedPeriod.start
     ) {
-      log.warn("DASH: Updating overlapping Periods.", lastFlattenedPeriod, parsedPeriod);
+      log.warn("DASH: Updating overlapping Periods.",
+               lastFlattenedPeriod?.start,
+               parsedPeriod.start);
       lastFlattenedPeriod.duration = parsedPeriod.start - lastFlattenedPeriod.start;
       lastFlattenedPeriod.end = parsedPeriod.start;
       if (lastFlattenedPeriod.duration <= 0) {

package/src/parsers/manifest/dash/common/get_clock_offset.ts

@@ -30,11 +30,11 @@ import log from "../../../../log";
  * @returns {number|undefined}
  */
 export default function getClockOffset(
-  serverClock : string
-) : number|undefined {
+  serverClock: string
+): number | undefined {
   const httpOffset = Date.parse(serverClock) - performance.now();
   if (isNaN(httpOffset)) {
-    log.warn("DASH Parser: Invalid clock received: ",  serverClock);
+    log.warn("DASH Parser: Invalid clock received: ", serverClock);
     return undefined;
   }
   return httpOffset;

package/src/parsers/manifest/dash/common/get_hdr_information.ts

@@ -39,7 +39,7 @@ export interface IParsedWEBMHDRInformation {
    *
    * It may be used to ask about output device color space support.
    */
-  colorSpace?: "rec2020";
+  colorSpace: "rec2020" | undefined;
 }
 
 /**

package/src/parsers/manifest/dash/common/get_http_utc-timing_url.ts

@@ -16,6 +16,16 @@
 
 import { IMPDIntermediateRepresentation } from "../node_parser_types";
 
+type ISupportedHttpUtcTimingScheme =
+  {
+    schemeIdUri : "urn:mpeg:dash:utc:http-iso:2014";
+    value : string;
+  } |
+  {
+    schemeIdUri : "urn:mpeg:dash:utc:http-xsdate:2014";
+    value : string;
+  };
+
 /**
  * @param {Object} mpdIR
  * @returns {string|undefined}
@@ -24,12 +34,11 @@ export default function getHTTPUTCTimingURL(
   mpdIR : IMPDIntermediateRepresentation
 ) : string|undefined {
   const UTCTimingHTTP = mpdIR.children.utcTimings
-    .filter((utcTiming) : utcTiming is {
-      schemeIdUri : "urn:mpeg:dash:utc:http-iso:2014";
-      value : string;
-    } =>
-      utcTiming.schemeIdUri === "urn:mpeg:dash:utc:http-iso:2014" &&
-      utcTiming.value !== undefined
+    .filter((utcTiming) : utcTiming is ISupportedHttpUtcTimingScheme =>
+      (
+        utcTiming.schemeIdUri === "urn:mpeg:dash:utc:http-iso:2014" ||
+        utcTiming.schemeIdUri === "urn:mpeg:dash:utc:http-xsdate:2014"
+      ) && utcTiming.value !== undefined
     );
 
   return UTCTimingHTTP.length > 0 ? UTCTimingHTTP[0].value :

package/src/parsers/manifest/dash/common/get_periods_time_infos.ts

@@ -21,9 +21,9 @@ interface IPeriodTimeInformation {
   /** Time in seconds at which the Period starts. */
   periodStart: number;
   /** Difference in seconds between the Period's end and its start. */
-  periodDuration?: number;
+  periodDuration?: number | undefined;
   /** Time in seconds at which the Period ends. */
-  periodEnd?: number;
+  periodEnd?: number | undefined;
 }
 
 /** Additionnal context needed to retrieve the period time information. */
@@ -31,7 +31,7 @@ export interface IParsedPeriodsContext {
   /** Value of MPD@availabilityStartTime. */
   availabilityStartTime : number;
   /** Value of MPD@mediaPresentationDuration. */
-  duration? : number;
+  duration? : number | undefined;
   /** `true` if MPD@type is equal to "dynamic". */
   isDynamic : boolean;
 }

package/src/parsers/manifest/dash/common/indexes/base.ts

@@ -26,6 +26,7 @@ import {
   IIndexSegment,
   toIndexTime,
 } from "../../../utils/index_helpers";
+import { IResolvedBaseUrl } from "../resolve_base_urls";
 import getInitSegment from "./get_init_segment";
 import getSegmentsFromTimeline from "./get_segments_from_timeline";
 import { createIndexURLs } from "./tokens";
@@ -37,7 +38,7 @@ import { createIndexURLs } from "./tokens";
  */
 export interface IBaseIndex {
   /** Byte range for a possible index of segments in the server. */
-  indexRange?: [number, number];
+  indexRange?: [number, number] | undefined;
   /**
    * Temporal offset, in the current timescale (see timescale), to add to the
    * presentation time (time a segment has at decoding time) to obtain the
@@ -56,15 +57,15 @@ export interface IBaseIndex {
     /** URLs to access the initialization segment. */
     mediaURLs: string[] | null;
     /** possible byte range to request it. */
-    range?: [number, number];
-  };
+    range?: [number, number] | undefined;
+  } | undefined;
   /**
    * Base URL(s) to access any segment. Can contain tokens to replace to convert
    * it to real URLs.
    */
   mediaURLs : string[] | null;
   /** Number from which the first segments in this index starts with. */
-  startNumber? : number;
+  startNumber? : number | undefined;
   /** Every segments defined in this index. */
   timeline : IIndexSegment[];
   /**
@@ -110,11 +111,11 @@ export interface IBaseIndexContextArgument {
   /** End of the period concerned by this RepresentationIndex, in seconds. */
   periodEnd : number|undefined;
   /** Base URL for the Representation concerned. */
-  representationBaseURLs : string[];
+  representationBaseURLs : IResolvedBaseUrl[];
   /** ID of the Representation concerned. */
-  representationId? : string;
+  representationId? : string | undefined;
   /** Bitrate of the Representation concerned. */
-  representationBitrate? : number;
+  representationBitrate? : number | undefined;
   /* Function that tells if an EMSG is whitelisted by the manifest */
   isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
 }
@@ -192,7 +193,8 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
 
     const indexTimeOffset = presentationTimeOffset - periodStart * timescale;
 
-    const mediaURLs = createIndexURLs(representationBaseURLs,
+    const urlSources : string[] = representationBaseURLs.map(b => b.url);
+    const mediaURLs = createIndexURLs(urlSources,
                                      index.initialization !== undefined ?
                                        index.initialization.media :
                                        undefined,
@@ -213,7 +215,7 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
     this._index = { indexRange: index.indexRange,
                     indexTimeOffset,
                     initialization: { mediaURLs, range },
-                    mediaURLs: createIndexURLs(representationBaseURLs,
+                    mediaURLs: createIndexURLs(urlSources,
                                                index.media,
                                                representationId,
                                                representationBitrate),

package/src/parsers/manifest/dash/common/indexes/get_init_segment.ts

@@ -25,8 +25,10 @@ import { IEMSG } from "../../../../containers/isobmff";
  */
 export default function getInitSegment(
   index: { timescale: number;
-           initialization?: { mediaURLs: string[] | null; range?: [number, number] };
-           indexRange?: [number, number];
+           initialization?: { mediaURLs: string[] | null;
+                              range?: [number, number] | undefined; } |
+                            undefined;
+           indexRange?: [number, number] | undefined;
            indexTimeOffset : number; },
   isEMSGWhitelisted?: (inbandEvent: IEMSG) => boolean
 ) : ISegment {
@@ -45,6 +47,7 @@ export default function getInitSegment(
                                            undefined,
            indexRange: index.indexRange,
            mediaURLs: initialization?.mediaURLs ?? null,
+           complete: true,
            privateInfos,
            timestampOffset: -(index.indexTimeOffset / index.timescale) };
 }

package/src/parsers/manifest/dash/common/indexes/get_segments_from_timeline.ts

@@ -52,8 +52,9 @@ function getWantedRepeatIndex(
  * @returns {Array.<Object>}
  */
 export default function getSegmentsFromTimeline(
-  index : { mediaURLs : string[] | null;
-            startNumber? : number;
+  index : { availabilityTimeComplete? : boolean | undefined;
+            mediaURLs : string[] | null;
+            startNumber? : number | undefined;
             timeline : IIndexSegment[];
             timescale : number;
             indexTimeOffset : number; },
@@ -66,9 +67,7 @@ export default function getSegmentsFromTimeline(
   const scaledTo = toIndexTime(from + durationWanted, index);
   const { timeline, timescale, mediaURLs, startNumber } = index;
 
-  let currentNumber = startNumber != null ? startNumber :
-                                            undefined;
-
+  let currentNumber = startNumber ?? 1;
   const segments : ISegment[] = [];
 
   const timelineLength = timeline.length;
@@ -85,11 +84,13 @@ export default function getSegmentsFromTimeline(
     maxEncounteredDuration = Math.max(maxEncounteredDuration, duration);
 
     const repeat = calculateRepeat(timelineItem, timeline[i + 1], maximumTime);
+    const complete = index.availabilityTimeComplete !== false ||
+                     i !== timelineLength - 1 &&
+                     repeat !== 0;
     let segmentNumberInCurrentRange = getWantedRepeatIndex(start, duration, scaledUp);
     let segmentTime = start + segmentNumberInCurrentRange * duration;
     while (segmentTime < scaledTo && segmentNumberInCurrentRange <= repeat) {
-      const segmentNumber = currentNumber != null ?
-        currentNumber + segmentNumberInCurrentRange : undefined;
+      const segmentNumber = currentNumber + segmentNumberInCurrentRange;
 
       const detokenizedURLs = mediaURLs === null ?
         null :
@@ -106,6 +107,7 @@ export default function getSegmentsFromTimeline(
                         mediaURLs: detokenizedURLs,
                         number: segmentNumber,
                         timestampOffset: -(index.indexTimeOffset / timescale),
+                        complete,
                         privateInfos: { isEMSGWhitelisted } };
       segments.push(segment);
 
@@ -119,9 +121,7 @@ export default function getSegmentsFromTimeline(
       return segments;
     }
 
-    if (currentNumber != null) {
-      currentNumber += repeat + 1;
-    }
+    currentNumber += repeat + 1;
   }
 
   return segments;