rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/manifest/manifest.ts

@@ -15,7 +15,10 @@
  */
 
 import { IInitializationDataInfo } from "../core/eme";
-import { ICustomError } from "../errors";
+import {
+  ICustomError,
+  MediaError,
+} from "../errors";
 import { IParsedManifest } from "../parsers/manifest";
 import areArraysOfNumbersEqual from "../utils/are_arrays_of_numbers_equal";
 import arrayFind from "../utils/array_find";
@@ -80,18 +83,18 @@ interface ISupplementaryTextTrack {
 interface IManifestParsingOptions {
   /* eslint-disable import/no-deprecated */
   /** Text tracks to add manually to the Manifest instance. */
-  supplementaryTextTracks? : ISupplementaryTextTrack[];
+  supplementaryTextTracks? : ISupplementaryTextTrack[] | undefined;
   /** Image tracks to add manually to the Manifest instance. */
-  supplementaryImageTracks? : ISupplementaryImageTrack[];
+  supplementaryImageTracks? : ISupplementaryImageTrack[] | undefined;
   /* eslint-enable import/no-deprecated */
   /** External callback peforming an automatic filtering of wanted Representations. */
-  representationFilter? : IRepresentationFilter;
+  representationFilter? : IRepresentationFilter | undefined;
   /** Optional URL that points to a shorter version of the Manifest used
    * for updates only. When using this URL for refresh, the manifest will be
    * updated with the partial update type. If this URL is undefined, then the
    * manifest will be updated fully when it needs to be refreshed, and it will
    * fetched through the original URL. */
-  manifestUpdateUrl? : string;
+  manifestUpdateUrl? : string | undefined;
 }
 
 /** Representation affected by a `decipherabilityUpdate` event. */
@@ -194,7 +197,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
 
   /** Optional URL that points to a shorter version of the Manifest used
    * for updates only. */
-  public updateUrl?: string;
+  public updateUrl : string | undefined;
 
   /**
    * Suggested delay from the "live edge" (i.e. the position corresponding to
@@ -202,7 +205,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    * from.
    * This only applies to live contents.
    */
-  public suggestedPresentationDelay? : number;
+  public suggestedPresentationDelay : number | undefined;
 
   /**
    * Amount of time, in seconds, this Manifest is valid from the time when it
@@ -210,7 +213,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    * If no lifetime is set, this Manifest does not become invalid after an
    * amount of time.
    */
-  public lifetime? : number;
+  public lifetime : number | undefined;
 
   /**
    * Minimum time, in seconds, at which a segment defined in the Manifest
@@ -218,20 +221,20 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    * This is also used as an offset for live content to apply to a segment's
    * time.
    */
-  public availabilityStartTime? : number;
+  public availabilityStartTime : number | undefined;
 
   /**
    * It specifies the wall-clock time when the manifest was generated and published
    * at the origin server. It is present in order to identify different versions
    * of manifest instances.
    */
-  public publishTime?: number;
+  public publishTime: number | undefined;
 
   /**
    * Array containing every minor errors that happened when the Manifest has
    * been created, in the order they have happened.
    */
-  public parsingErrors : ICustomError[];
+  public contentWarnings : ICustomError[];
 
   /*
    * Difference between the server's clock in milliseconds and the return of the
@@ -268,7 +271,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
      *      segment, and `timeshiftDepth` would be the whole depth that will
      *      become available once enough segments have been generated.
      */
-    absoluteMinimumTime? : number;
+    absoluteMinimumTime? : number | undefined;
     /**
      * Some dynamic contents have the concept of a "window depth" (or "buffer
      * depth") which allows to set a minimum position for all reachable
@@ -316,7 +319,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    * Construct a Manifest instance from a parsed Manifest object (as returned by
    * Manifest parsers) and options.
    *
-   * Some minor errors can arise during that construction. `this.parsingErrors`
+   * Some minor errors can arise during that construction. `this.contentWarnings`
    * will contain all such errors, in the order they have been encountered.
    * @param {Object} parsedManifest
    * @param {Object} options
@@ -327,7 +330,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
             supplementaryImageTracks = [],
             representationFilter,
             manifestUpdateUrl } = options;
-    this.parsingErrors = [];
+    this.contentWarnings = [];
     this.id = generateNewManifestId();
     this.expired = parsedManifest.expired ?? null;
     this.transport = parsedManifest.transportType;
@@ -335,7 +338,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
 
     this.periods = parsedManifest.periods.map((parsedPeriod) => {
       const period = new Period(parsedPeriod, representationFilter);
-      this.parsingErrors.push(...period.parsingErrors);
+      this.contentWarnings.push(...period.contentWarnings);
       return period;
     }).sort((a, b) => a.start - b.start);
 
@@ -645,7 +648,12 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
                                                  media: url,
                                                }) }] },
                                            { isManuallyAdded: true });
-      this.parsingErrors.push(...newAdaptation.parsingErrors);
+      if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
+        const error =
+          new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR",
+                         "An Adaptation contains only incompatible codecs.");
+        this.contentWarnings.push(error);
+      }
       return newAdaptation;
     });
 
@@ -698,7 +706,12 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
                                                    media: url,
                                                  }) }] },
                                              { isManuallyAdded: true });
-        this.parsingErrors.push(...newAdaptation.parsingErrors);
+        if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
+          const error =
+            new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR",
+                           "An Adaptation contains only incompatible codecs.");
+          this.contentWarnings.push(error);
+        }
         return newAdaptation;
       }));
     }, []);
@@ -725,7 +738,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
     this.isLive = newManifest.isLive;
     this.isLastPeriodKnown = newManifest.isLastPeriodKnown;
     this.lifetime = newManifest.lifetime;
-    this.parsingErrors = newManifest.parsingErrors;
+    this.contentWarnings = newManifest.contentWarnings;
     this.suggestedPresentationDelay = newManifest.suggestedPresentationDelay;
     this.transport = newManifest.transport;
     this.publishTime = newManifest.publishTime;

package/src/manifest/period.ts

@@ -15,7 +15,6 @@
  */
 import {
   ICustomError,
-  isKnownError,
   MediaError,
 } from "../errors";
 import {
@@ -51,19 +50,19 @@ export default class Period {
    * Duration of this Period, in seconds.
    * `undefined` for still-running Periods.
    */
-  public duration? : number;
+  public duration : number | undefined;
 
   /**
    * Absolute end time of the Period, in seconds.
    * `undefined` for still-running Periods.
    */
-  public end? : number;
+  public end : number | undefined;
 
   /**
    * Array containing every errors that happened when the Period has been
    * created, in the order they have happened.
    */
-  public readonly parsingErrors : ICustomError[];
+  public readonly contentWarnings : ICustomError[];
 
   /** Array containing every stream event happening on the period */
   public streamEvents : IManifestStreamEvent[];
@@ -75,9 +74,9 @@ export default class Period {
    */
   constructor(
     args : IParsedPeriod,
-    representationFilter? : IRepresentationFilter
+    representationFilter? : IRepresentationFilter | undefined
   ) {
-    this.parsingErrors = [];
+    this.contentWarnings = [];
     this.id = args.id;
     this.adaptations = (Object.keys(args.adaptations) as IAdaptationType[])
       .reduce<IManifestAdaptations>((acc, type) => {
@@ -86,24 +85,18 @@ export default class Period {
           return acc;
         }
         const filteredAdaptations = adaptationsForType
-          .map((adaptation) : Adaptation|null => {
-            let newAdaptation : Adaptation|null = null;
-            try {
-              newAdaptation = new Adaptation(adaptation, { representationFilter });
-            } catch (err) {
-              if (isKnownError(err) &&
-                  err.code === "MANIFEST_UNSUPPORTED_ADAPTATION_TYPE")
-              {
-                this.parsingErrors.push(err);
-                return null;
-              }
-              throw err;
+          .map((adaptation) : Adaptation => {
+            const newAdaptation = new Adaptation(adaptation, { representationFilter });
+            if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
+              const error =
+                new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR",
+                               "An Adaptation contains only incompatible codecs.");
+              this.contentWarnings.push(error);
             }
-            this.parsingErrors.push(...newAdaptation.parsingErrors);
             return newAdaptation;
           })
           .filter((adaptation) : adaptation is Adaptation =>
-            adaptation !== null && adaptation.representations.length > 0
+            adaptation.representations.length > 0
           );
         if (filteredAdaptations.every(adaptation => !adaptation.isSupported) &&
             adaptationsForType.length > 0 &&

package/src/manifest/representation.ts

@@ -34,7 +34,7 @@ import {
  */
 class Representation {
   /** ID uniquely identifying the Representation in the Adaptation. */
-  public readonly id : string|number;
+  public readonly id : string;
 
   /**
    * Interface allowing to get information about segments available for this
@@ -55,7 +55,7 @@ class Representation {
    * A string describing the codec used for this Representation.
    * undefined if we do not know.
    */
-  public codec? : string;
+  public codec : string | undefined;
 
   /**
    * A string describing the mime-type for this Representation.
@@ -93,7 +93,7 @@ class Representation {
    *     Representation
    *   - if `undefined` there is no certainty on this matter
    */
-  public decipherable? : boolean;
+  public decipherable? : boolean  | undefined;
 
   /** `true` if the Representation is in a supported codec, false otherwise. */
   public isSupported : boolean;

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

@@ -38,12 +38,12 @@ export interface ISmoothInitSegmentPrivateInfos {
    * as found in the Manifest.
    */
   timescale : number;
-  codecPrivateData? : string;
-  bitsPerSample? : number;
-  channels? : number;
-  packetSize? : number;
-  samplingRate? : number;
-  protection? : { keyId : Uint8Array };
+  codecPrivateData? : string | undefined;
+  bitsPerSample? : number | undefined;
+  channels? : number | undefined;
+  packetSize? : number | undefined;
+  samplingRate? : number | undefined;
+  protection? : { keyId : Uint8Array } | undefined;
 }
 
 /**
@@ -78,7 +78,7 @@ export interface IMetaPlaylistPrivateInfos {
   /** The segment originally created by this transport's RepresentationIndex. */
   originalSegment : ISegment;
   contentStart : number;
-  contentEnd? : number;
+  contentEnd? : number | undefined;
 }
 
 /**
@@ -112,12 +112,12 @@ export interface ILocalManifestSegmentPrivateInfos {
  * exploited by the corresponding transport logic.
  */
 export interface IPrivateInfos {
-  smoothInitSegment? : ISmoothInitSegmentPrivateInfos;
-  smoothMediaSegment? : ISmoothSegmentPrivateInfos;
-  metaplaylistInfos? : IMetaPlaylistPrivateInfos;
-  localManifestInitSegment? : ILocalManifestInitSegmentPrivateInfos;
-  localManifestSegment? : ILocalManifestSegmentPrivateInfos;
-  isEMSGWhitelisted? : (evt: IEMSG) => boolean;
+  smoothInitSegment? : ISmoothInitSegmentPrivateInfos | undefined;
+  smoothMediaSegment? : ISmoothSegmentPrivateInfos | undefined;
+  metaplaylistInfos? : IMetaPlaylistPrivateInfos | undefined;
+  localManifestInitSegment? : ILocalManifestInitSegmentPrivateInfos | undefined;
+  localManifestSegment? : ILocalManifestSegmentPrivateInfos | undefined;
+  isEMSGWhitelisted? : ((evt: IEMSG) => boolean) | undefined;
 }
 
 /** Represent a single Segment from a Representation. */
@@ -149,24 +149,24 @@ export interface ISegment {
    * contain an index describing other Segments
    * TODO put in privateInfos?
    */
-  indexRange? : [number, number];
+  indexRange? : [number, number] | undefined;
   /**
    * Optional number of the Segment
    * TODO put in privateInfos?
    */
-  number? : number;
+  number? : number | undefined;
   /**
    * Allows to store supplementary information on a segment that can be later
    * exploited by the transport logic.
    */
-  privateInfos? : IPrivateInfos;
+  privateInfos? : IPrivateInfos | undefined;
   /** Optional byte range to retrieve the Segment from its URL(s) */
-  range? : [number, number];
+  range? : [number, number] | undefined;
   /**
    * Estimated time, in seconds, at which the concerned segment should be
    * offseted when decoded.
    */
-  timestampOffset? : number;
+  timestampOffset? : number | undefined;
   /**
    * Estimated start time for the segment, in seconds.
    * Note that some rounding errors and some differences between what the
@@ -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/types.ts

@@ -39,7 +39,7 @@ export interface IHDRInformation {
    * It is used to ask to the user agent if the color depth is supported by the
    * output device.
    */
-  colorDepth?: number;
+  colorDepth? : number | undefined;
   /**
    * It is the HDR eotf. It is the transfer function having the video signal as
    * input and converting it into the linear light output of the display. The
@@ -47,12 +47,106 @@ export interface IHDRInformation {
    *
    * It may be used here to ask the MediaSource if it supported.
    */
-  eotf?: string;
+  eotf? : string | undefined;
   /**
    * It is the video color space used for encoding. An HDR content may not have
    * a wide color gamut.
    *
    * It may be used to ask about output device color space support.
    */
-  colorSpace?: string;
+  colorSpace? : string | undefined;
+}
+
+/** Manifest, as documented in the API documentation. */
+export interface IExposedManifest {
+  periods : IExposedPeriod[];
+  /**
+   * @deprecated
+   */
+  adaptations : { audio? : IExposedAdaptation[];
+                  video? : IExposedAdaptation[];
+                  text? : IExposedAdaptation[];
+                  image? : IExposedAdaptation[]; };
+  isLive : boolean;
+  transport : string;
+}
+
+/** Period, as documented in the API documentation. */
+export interface IExposedPeriod {
+  id : string;
+  start : number;
+  end? : number | undefined;
+  adaptations : { audio? : IExposedAdaptation[];
+                  video? : IExposedAdaptation[];
+                  text? : IExposedAdaptation[];
+                  image? : IExposedAdaptation[]; };
+}
+
+/** Adaptation (represents a track), as documented in the API documentation. */
+export interface IExposedAdaptation {
+  /** String identifying the Adaptation, unique per Period. */
+  id : string;
+  type : "video" | "audio" | "text" | "image";
+  language? : string | undefined;
+  normalizedLanguage? : string | undefined;
+  isAudioDescription? : boolean | undefined;
+  isClosedCaption? : boolean | undefined;
+  isTrickModeTrack? : boolean | undefined;
+  representations : IExposedRepresentation[];
+
+  getAvailableBitrates() : number[];
+}
+
+/** Representation (represents a quality), as documented in the API documentation. */
+export interface IExposedRepresentation {
+  /** String identifying the Representation, unique per Adaptation. */
+  id : string;
+  bitrate : number;
+  /** Codec used by the segment in that Representation. */
+  codec? : string | undefined;
+  /**
+   * Whether we are able to decrypt this Representation / unable to decrypt it or
+   * if we don't know yet:
+   *   - if `true`, it means that we know we were able to decrypt this
+   *     Representation in the current content.
+   *   - if `false`, it means that we know we were unable to decrypt this
+   *     Representation
+   *   - if `undefined` there is no certainty on this matter
+   */
+  decipherable? : boolean | undefined;
+  /**
+   * This property makes the most sense for video Representations.
+   * It defines the height of the video, in pixels.
+   */
+  height? : number | undefined;
+  /**
+   * This property makes the most sense for video Representations.
+   * It defines the height of the video, in pixels.
+   */
+  width? : number | undefined;
+  /**
+   * The represesentation frame rate for this Representation. It defines either
+   * the number of frames per second as an integer (24), or as a ratio
+   * (24000 / 1000).
+   */
+  frameRate? : string | undefined;
+  /** If the track is HDR, gives the HDR characteristics of the content */
+  hdrInfo? : IHDRInformation;
+  index : IExposedRepresentationIndex;
+}
+
+interface IExposedRepresentationIndex {
+  getSegments(up : number, duration : number) : IExposedSegment[];
+}
+
+/** Segment, as documented in the API documentation. */
+export interface IExposedSegment {
+  id : string;
+  timescale : number;
+  duration? : number | undefined;
+  time : number;
+  isInit? : boolean | undefined;
+  range? : number[] | null | undefined;
+  indexRange? : number[] | null | undefined;
+  number? : number | undefined;
 }

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,