rx-player 3.26.1 → 3.26.2

package/src/features/list/__tests__/smooth.test.ts

@@ -15,6 +15,7 @@
  */
 
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
 
 import SmoothFeature from "../../../transports/smooth";
 import addSmoothFeature from "../smooth";

package/src/index.ts

@@ -28,8 +28,8 @@ import logger from "./log";
 // set initial features according to environment variables
 initializeFeatures();
 
-if (__DEV__) {
-  logger.setLevel(__LOGGER_LEVEL__);
+if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+  logger.setLevel(__LOGGER_LEVEL__.CURRENT_LEVEL);
 }
 
 export default Player;

package/src/manifest/__tests__/manifest.test.ts

@@ -20,6 +20,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 
 describe("Manifest - Manifest", () => {

package/src/manifest/index.ts

@@ -19,7 +19,6 @@ import Adaptation, {
   IRepresentationInfos,
   SUPPORTED_ADAPTATIONS_TYPE,
 } from "./adaptation";
-import areSameContent from "./are_same_content";
 import Manifest, {
   IManifestParsingOptions,
   ISupplementaryImageTrack,
@@ -38,12 +37,19 @@ import {
   IAdaptationType,
   IHDRInformation,
 } from "./types";
+import {
+  areSameContent,
+  getLoggableSegmentId,
+  IBufferedChunkInfos,
+} from "./utils";
 
 export default Manifest;
 export * from "./types";
 export {
   // utils
   areSameContent,
+  getLoggableSegmentId,
+  IBufferedChunkInfos,
 
   // classes
   Period,

package/src/manifest/representation_index/__tests__/static.test.ts

@@ -26,6 +26,7 @@ describe("manifest - StaticRepresentationIndex", () => {
   it("should return a single segment with the maximum duration and the right url", () => {
     const staticRI = new StaticRepresentationIndex({ media: "foo" });
     expect(staticRI.getSegments()).toEqual([{ id: "0",
+                                              complete: true,
                                               isInit: false,
                                               number: 0,
                                               time: 0,

package/src/manifest/representation_index/static.ts

@@ -58,6 +58,7 @@ export default class StaticRepresentationIndex implements IRepresentationIndex {
               time: 0,
               end: Number.MAX_VALUE,
               duration: Number.MAX_VALUE,
+              complete: true,
               timescale: 1 }];
   }
 

package/src/manifest/representation_index/types.ts

@@ -187,9 +187,20 @@ export interface ISegment {
   end : number;
   /**
    * Estimated duration for the segment, in seconds.
-   * Note that some rounding errors and some differences between what the
-   * Manifest says and what the content really is might make that time not
-   * exact.
+   *
+   * Note that this may not reflect the exact segment duration:
+   *
+   *   1. In some very specific cases, segments might be generated and served
+   *      progressively. In this case, the full duration of a segment might not
+   *      be yet known and thus this property only reflect the currently known
+   *      `duration` of the segment, which may be inferior to its final duration.
+   *
+   *      You can know if we're in that case when the `complete` property of
+   *      this same segment is set to `false`.
+   *
+   *   2. some rounding errors and some differences between what the
+   *      Manifest says and what the content really is might make that time not
+   *      exact.
    *
    * `0` for initialization segments.
    */
@@ -202,6 +213,17 @@ export interface ISegment {
    * As both are always in seconds now, this property became unneeded.
    */
   timescale : 1;
+
+  /**
+   * If `false`, this segment's `duration` property may not be the duration of
+   * the full segment as it could still be in the process of being generated
+   * on the server-side (when this `ISegment` had been constructed).
+   *
+   * Note that if the `duration` is sure to be the final one, `complete`
+   * should be set to `true` even if the segment is still being
+   * generated.
+   */
+  complete : boolean;
 }
 
 /** Interface that should be implemented by any Representation's `index` value. */

package/src/manifest/{are_same_content.ts → utils.ts}

@@ -14,19 +14,17 @@
  * limitations under the License.
  */
 
+import isNullOrUndefined from "../utils/is_null_or_undefined";
 import Adaptation from "./adaptation";
 import Period from "./period";
 import Representation from "./representation";
 import { ISegment } from "./representation_index";
 
-/**
- * All information needed for a given chunk to know if it has the same content
- * than another chunk.
- */
-interface IBufferedChunkInfos { adaptation : Adaptation;
-                                period : Period;
-                                representation : Representation;
-                                segment : ISegment; }
+/** All information needed to identify a given segment. */
+export interface IBufferedChunkInfos { adaptation : Adaptation;
+                                       period : Period;
+                                       representation : Representation;
+                                       segment : ISegment; }
 
 /**
  * Check if two contents are the same
@@ -34,7 +32,7 @@ interface IBufferedChunkInfos { adaptation : Adaptation;
  * @param {Object} content2
  * @returns {boolean}
  */
-export default function areSameContent(
+export function areSameContent(
   content1: IBufferedChunkInfos,
   content2: IBufferedChunkInfos
 ): boolean {
@@ -43,3 +41,22 @@ export default function areSameContent(
           content1.adaptation.id === content2.adaptation.id &&
           content1.period.id === content2.period.id);
 }
+
+/**
+ * Get string describing a given ISegment, useful for log functions.
+ * @param {Object} content
+ * @returns {string|null|undefined}
+ */
+export function getLoggableSegmentId(
+  content : IBufferedChunkInfos | null | undefined
+) : string {
+  if (isNullOrUndefined(content)) {
+    return "";
+  }
+  const { period, adaptation, representation, segment } = content;
+  return `${adaptation.type} P: ${period.id} A: ${adaptation.id} ` +
+         `R: ${representation.id} S: ` +
+         (segment.isInit   ? "init" :
+          segment.complete ? `${segment.time}-${segment.duration}` :
+                             `${segment.time}`);
+}

package/src/minimal.ts

@@ -20,6 +20,7 @@
  * This allows to import a "minimal" player with a small bundle size and then
  * import only features that is needed.
  */
+
 import Player from "./core/api";
 import {
   addFeatures,
@@ -27,8 +28,8 @@ import {
 } from "./features";
 import logger from "./log";
 
-if (__DEV__) {
-  logger.setLevel(__LOGGER_LEVEL__);
+if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+  logger.setLevel(__LOGGER_LEVEL__.CURRENT_LEVEL);
 }
 
 /**

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

@@ -15,6 +15,7 @@
  */
 
 import log from "../../../log";
+import assert from "../../../utils/assert";
 import {
   be4toi,
   be8toi,
@@ -23,8 +24,8 @@ import {
 /**
  * Returns the content of a box based on its name.
  * `null` if not found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {UInt8Array|null}
  */
@@ -34,11 +35,36 @@ function getBoxContent(buf : Uint8Array, boxName : number) : Uint8Array|null {
                             null;
 }
 
+/**
+ * Reads the whole ISOBMFF and returns the content of all boxes with the given
+ * name, in order.
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
+ * generated from encoding the corresponding ASCII in big endian.
+ * @returns {Array.<Uint8Array>}
+ */
+function getBoxesContent(buf : Uint8Array, boxName : number) : Uint8Array[] {
+  const ret = [];
+  let currentBuf = buf;
+  while (true) {
+    const offsets = getBoxOffsets(currentBuf, boxName);
+    if (offsets === null) {
+      return ret;
+    }
+
+    // Guard against a (very highly improbable) infinite loop
+    assert(offsets[2] !== 0 && currentBuf.length !== 0);
+
+    ret.push(currentBuf.subarray(offsets[1], offsets[2]));
+    currentBuf = currentBuf.subarray(offsets[2]);
+  }
+}
+
 /**
  * Returns an ISOBMFF box - size and name included - based on its name.
  * `null` if not found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {UInt8Array|null}
  */
@@ -60,8 +86,8 @@ function getBox(buf : Uint8Array, boxName : number) : Uint8Array|null {
  *      size and the name of the box.
  *   3. The first byte after the end of the box, might be equal to `buf`'s
  *      length if we're considering the last box.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {Array.<number>|null}
  */
@@ -176,8 +202,8 @@ function getUuidContent(
  *      length if we're considering the last box.
  *
  * `null` if no box is found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  */
 function getNextBoxOffsets(buf : Uint8Array
@@ -221,6 +247,7 @@ function getNextBoxOffsets(buf : Uint8Array
 export {
   getBox,
   getBoxContent,
+  getBoxesContent,
   getBoxOffsets,
   getNextBoxOffsets,
   getUuidContent,

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__/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/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_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/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";
@@ -110,7 +111,7 @@ 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;
   /** Bitrate of the Representation concerned. */
@@ -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

@@ -45,6 +45,7 @@ export default function getInitSegment(
                                            undefined,
            indexRange: index.indexRange,
            mediaURLs: initialization?.mediaURLs ?? null,
+           complete: true,
            privateInfos,
            timestampOffset: -(index.indexTimeOffset / index.timescale) };
 }