rx-player 3.33.0 → 3.33.1

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

@@ -1,278 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import log from "../../../log";
-import assert from "../../../utils/assert";
-import {
-  be4toi,
-  be8toi,
-} from "../../../utils/byte_parsing";
-
-/**
- * From a given buffer representing ISOBMFF data, browses inner boxes in
- * `childNames`, each element being a child box of the one before it.
- * Returns `null` if one of the child (or if the parent) is not found.
- * @param {Uint8Array} buf
- * @param {number[]} childNames
- * @returns {Uint8Array|null}
- */
-function getChildBox(
-  buf : Uint8Array,
-  childNames : number[]
-) : Uint8Array | null {
-  let currBox = buf;
-  for (const childName of childNames) {
-    const box = getBoxContent(currBox, childName);
-    if (box === null) {
-      return null;
-    }
-    currBox = box;
-  }
-  return currBox;
-}
-
-/**
- * Returns the content of a box based on its name.
- * `null` if not found.
- * @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}
- */
-function getBoxContent(buf : Uint8Array, boxName : number) : Uint8Array|null {
-  const offsets = getBoxOffsets(buf, boxName);
-  return offsets !== null ? buf.subarray(offsets[1], offsets[2]) :
-                            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 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}
- */
-function getBox(buf : Uint8Array, boxName : number) : Uint8Array|null {
-  const offsets = getBoxOffsets(buf, boxName);
-  return offsets !== null ? buf.subarray(offsets[0], offsets[2]) :
-                            null;
-}
-
-/**
- * Returns byte offsets for the start of the box, the start of its content and
- * the end of the box (not inclusive).
- *
- * `null` if not found.
- *
- * If found, the tuple returned has three elements, all numbers:
- *   1. The starting byte corresponding to the start of the box (from its size)
- *   2. The beginning of the box content - meaning the first byte after the
- *      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 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}
- */
-function getBoxOffsets(
-  buf : Uint8Array,
-  boxName : number
-) : [ number /* start byte */,
-      number /* First byte after the size and name (where the content begins)*/,
-      number /* end byte, not included. */] |
-    null {
-  const len = buf.length;
-
-  let boxBaseOffset = 0;
-  let name : number;
-  let lastBoxSize : number = 0;
-  let lastOffset;
-  while (boxBaseOffset + 8 <= len) {
-    lastOffset = boxBaseOffset;
-    lastBoxSize = be4toi(buf, lastOffset);
-    lastOffset += 4;
-
-    name = be4toi(buf, lastOffset);
-    lastOffset += 4;
-
-    if (lastBoxSize === 0) {
-      lastBoxSize = len - boxBaseOffset;
-    } else if (lastBoxSize === 1) {
-      if (lastOffset + 8 > len) {
-        return null;
-      }
-      lastBoxSize = be8toi(buf, lastOffset);
-      lastOffset += 8;
-    }
-
-    if (lastBoxSize < 0) {
-      throw new Error("ISOBMFF: Size out of range");
-    }
-    if (name === boxName) {
-      if (boxName  === 0x75756964 /* === "uuid" */) {
-        lastOffset += 16; // Skip uuid name
-      }
-      return [boxBaseOffset, lastOffset, boxBaseOffset + lastBoxSize];
-    } else {
-      boxBaseOffset += lastBoxSize;
-    }
-  }
-  return null;
-}
-
-/**
- * Gives the content of a specific UUID box.
- * `undefined` if that box is not found.
- *
- * If found, the returned Uint8Array contains just the box's content: the box
- * without its name and size.
- * @param {Uint8Array} buf
- * @param {Number} id1
- * @param {Number} id2
- * @param {Number} id3
- * @param {Number} id4
- * @returns {Uint8Array|undefined}
- */
-function getUuidContent(
-  buf : Uint8Array,
-  id1 : number,
-  id2 : number,
-  id3 : number,
-  id4 : number
-) : Uint8Array | undefined {
-  const len = buf.length;
-
-  let boxSize : number;
-  for (let boxBaseOffset = 0; boxBaseOffset < len; boxBaseOffset += boxSize) {
-    let currentOffset = boxBaseOffset;
-    boxSize = be4toi(buf, currentOffset);
-    currentOffset += 4;
-
-    const boxName = be4toi(buf, currentOffset);
-    currentOffset += 4;
-
-    if (boxSize === 0) {
-      boxSize = len - boxBaseOffset;
-    } else if (boxSize === 1) {
-      if (currentOffset + 8 > len) {
-        return undefined;
-      }
-      boxSize = be8toi(buf, currentOffset);
-      currentOffset += 8;
-    }
-
-    if (
-      boxName  === 0x75756964 /* === "uuid" */ &&
-      currentOffset + 16 <= len &&
-      be4toi(buf, currentOffset) === id1 &&
-      be4toi(buf, currentOffset + 4) === id2 &&
-      be4toi(buf, currentOffset + 8) === id3 &&
-      be4toi(buf, currentOffset + 12) === id4
-    ) {
-      currentOffset += 16;
-      return buf.subarray(currentOffset, boxBaseOffset + boxSize);
-    }
-  }
-}
-
-/**
- * For the next encountered box, return byte offsets corresponding to:
- *   1. the starting byte offset for the next box (should always be equal to
- *       `0`).
- *   2. The beginning of the box content - meaning the first byte after the
- *      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.
- *
- * `null` if no box is found.
- * @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
-
-) : [ 0 /* start byte */,
-      number /* First byte after the size and name (where the content begins)*/,
-      number /* end byte, not included. */] |
-    null {
-  const len = buf.length;
-  if (len < 8) {
-    log.warn("ISOBMFF: box inferior to 8 bytes, cannot find offsets");
-    return null;
-  }
-  let lastOffset = 0;
-  let boxSize = be4toi(buf, lastOffset);
-  lastOffset += 4;
-
-  const name = be4toi(buf, lastOffset);
-  lastOffset += 4;
-
-  if (boxSize === 0) {
-    boxSize = len;
-  } else if (boxSize === 1) {
-    if (lastOffset + 8 > len) {
-      log.warn("ISOBMFF: box too short, cannot find offsets");
-      return null;
-    }
-    boxSize = be8toi(buf, lastOffset);
-    lastOffset += 8;
-  }
-
-  if (boxSize < 0) {
-    throw new Error("ISOBMFF: Size out of range");
-  }
-  if (name  === 0x75756964 /* === "uuid" */) {
-    lastOffset += 16; // Skip uuid name
-  }
-  return [0, lastOffset, boxSize];
-}
-
-export {
-  getBox,
-  getBoxContent,
-  getBoxesContent,
-  getBoxOffsets,
-  getChildBox,
-  getNextBoxOffsets,
-  getUuidContent,
-};

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

@@ -1,51 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import takePSSHOut, {
-  getPsshSystemID,
-} from "./take_pssh_out";
-
-export {
-  createBox,
-  createBoxWithChildren,
-} from "./create_box";
-export {
-  getBox,
-  getBoxContent,
-  getNextBoxOffsets,
-  getBoxOffsets,
-  getUuidContent,
-} from "./get_box";
-export {
-  getMDAT,
-  getMDIA,
-  getTRAF,
-} from "./read";
-export {
-  getMDHDTimescale,
-  getPlayReadyKIDFromPrivateData,
-  getTrackFragmentDecodeTime,
-  getDurationFromTrun,
-  getSegmentsFromSidx,
-  IEMSG,
-  ISidxSegment,
-  patchPssh,
-  updateBoxLength,
-} from "./utils";
-export {
-  getPsshSystemID,
-  takePSSHOut,
-};

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

@@ -1,105 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-  getBoxContent,
-  getBoxesContent,
-} from "./get_box";
-
-/**
- * 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}
- */
-function getTRAF(buffer : Uint8Array) : Uint8Array|null {
-  const moof = getBoxContent(buffer, 0x6D6F6F66 /* moof */);
-  if (moof === null) {
-    return null;
-  }
-  return getBoxContent(moof, 0x74726166 /* traf */);
-}
-
-/**
- * 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}
- */
-function getMDAT(buf : Uint8Array) : Uint8Array|null {
-  return getBoxContent(buf, 0x6D646174 /* "mdat" */);
-}
-
-/**
- * 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}
- */
-function getMDIA(buf : Uint8Array) : Uint8Array|null {
-  const moov = getBoxContent(buf, 0x6D6F6F76 /* moov */);
-  if (moov === null) {
-    return null;
-  }
-
-  const trak = getBoxContent(moov, 0x7472616B /* "trak" */);
-  if (trak === null) {
-    return null;
-  }
-
-  return getBoxContent(trak, 0x6D646961 /* "mdia" */);
-}
-
-/**
- * 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}
- */
-function getEMSG(buffer: Uint8Array, offset = 0) : Uint8Array|null {
-  return getBoxContent(buffer.subarray(offset), 0x656D7367 /* emsg */);
-}
-
-export {
-  getTRAF,
-  getTRAFs,
-  getMDAT,
-  getMDIA,
-  getEMSG,
-};

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

@@ -1,101 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import log from "../../../log";
-import sliceUint8Array from "../../../utils/slice_uint8array";
-import { bytesToHex } from "../../../utils/string_parsing";
-import {
-  getBoxContent,
-  getBoxOffsets,
-} from "./get_box";
-
-/** Information related to a PSSH box. */
-export interface IISOBMFFPSSHInfo {
-  /** Corresponding DRM's system ID, as an hexadecimal string. */
-  systemId : string;
-  /** Additional data contained in the PSSH Box. */
-  data : Uint8Array;
-}
-
-/**
- * Replace every PSSH box from an ISOBMFF segment by FREE boxes and returns the
- * removed PSSH in an array.
- * Useful to manually manage encryption while avoiding the round-trip with the
- * browser's encrypted event.
- * @param {Uint8Array} data - the ISOBMFF segment
- * @returns {Array.<Uint8Array>} - The extracted PSSH boxes. In the order they
- * are encountered.
- */
-export default function takePSSHOut(data : Uint8Array) : IISOBMFFPSSHInfo[] {
-  let i = 0;
-  const moov = getBoxContent(data, 0x6D6F6F76 /* moov */);
-  if (moov === null) {
-    return [];
-  }
-
-  const psshBoxes : IISOBMFFPSSHInfo[] = [];
-  while (i < moov.length) {
-    let psshOffsets;
-    try {
-      psshOffsets = getBoxOffsets(moov, 0x70737368 /* pssh */);
-    } catch (e) {
-      const err = e instanceof Error ? e : "";
-      log.warn("Error while removing PSSH from ISOBMFF", err);
-      return psshBoxes;
-    }
-    if (psshOffsets == null) {
-      return psshBoxes;
-    }
-    const pssh = sliceUint8Array(moov, psshOffsets[0], psshOffsets[2]);
-    const systemId = getPsshSystemID(pssh, psshOffsets[1] - psshOffsets[0]);
-    if (systemId !== undefined) {
-      psshBoxes.push({ systemId, data: pssh });
-    }
-
-    // replace by `free` box.
-    moov[psshOffsets[0] + 4] = 0x66;
-    moov[psshOffsets[0] + 5] = 0x72;
-    moov[psshOffsets[0] + 6] = 0x65;
-    moov[psshOffsets[0] + 7] = 0x65;
-    i = psshOffsets[2];
-  }
-  return psshBoxes;
-}
-
-/**
- * Parse systemId from a "pssh" box into an hexadecimal string.
- * `undefined` if we could not extract a systemId.
- * @param {Uint8Array} buff - The pssh box
- * @param {number} initialDataOffset - offset of the first byte after the size
- * and name in this pssh box.
- * @returns {string|undefined}
- */
-export function getPsshSystemID(
-  buff : Uint8Array,
-  initialDataOffset : number
-) : string | undefined {
-  if (buff[initialDataOffset] > 1) {
-    log.warn("ISOBMFF: un-handled PSSH version");
-    return undefined;
-  }
-  const offset = initialDataOffset +
-                 4; /* version + flags */
-  if (offset + 16 > buff.length) {
-    return undefined;
-  }
-  const systemIDBytes = sliceUint8Array(buff, offset, offset + 16);
-  return bytesToHex(systemIDBytes);
-}