rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

package/dist/_esm5.processed/parsers/containers/isobmff/utils.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,15 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../../log";
-import assert from "../../../utils/assert";
-import { be2toi, be3toi, be4toi, be8toi, concat, itobe4, itobe8, } from "../../../utils/byte_parsing";
-import { hexToBytes, readNullTerminatedString, } from "../../../utils/string_parsing";
-import { MAX_32_BIT_INT } from "./constants";
-import { createBox } from "./create_box";
-import { getPlayReadyKIDFromPrivateData } from "./drm";
-import { getBoxContent, getBoxOffsets, getChildBox, } from "./get_box";
-import { getEMSG, getMDIA, getTRAF, getTRAFs, } from "./read";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEmsgBoxes = exports.updateBoxLength = exports.patchPssh = exports.getSegmentsFromSidx = exports.getDurationFromTrun = exports.getTrackFragmentDecodeTime = exports.getPlayReadyKIDFromPrivateData = exports.getMDHDTimescale = exports.getKeyIdFromInitSegment = void 0;
+const log_1 = require("../../../log");
+const assert_1 = require("../../../utils/assert");
+const byte_parsing_1 = require("../../../utils/byte_parsing");
+const string_parsing_1 = require("../../../utils/string_parsing");
+const constants_1 = require("./constants");
+const create_box_1 = require("./create_box");
+const drm_1 = require("./drm");
+Object.defineProperty(exports, "getPlayReadyKIDFromPrivateData", { enumerable: true, get: function () { return drm_1.getPlayReadyKIDFromPrivateData; } });
+const get_box_1 = require("./get_box");
+const read_1 = require("./read");
 /**
  * Parse the sidx part (segment index) of an ISOBMFF buffer and construct a
  * corresponding Array of available segments.
@@ -32,59 +36,59 @@ import { getEMSG, getMDIA, getTRAF, getTRAFs, } from "./read";
  * @returns {Object|null} {Array.<Object>} - Information about each subsegment.
  */
 function getSegmentsFromSidx(buf, sidxOffsetInWholeSegment) {
-    var sidxOffsets = getBoxOffsets(buf, 0x73696478 /* "sidx" */);
+    const sidxOffsets = (0, get_box_1.getBoxOffsets)(buf, 0x73696478 /* "sidx" */);
     if (sidxOffsets === null) {
         return null;
     }
-    var offset = sidxOffsetInWholeSegment;
-    var boxSize = sidxOffsets[2] - sidxOffsets[0];
-    var cursor = sidxOffsets[1];
+    let offset = sidxOffsetInWholeSegment;
+    const boxSize = sidxOffsets[2] - sidxOffsets[0];
+    let cursor = sidxOffsets[1];
     /* version(8) */
     /* flags(24) */
     /* reference_ID(32); */
     /* timescale(32); */
-    var version = buf[cursor];
+    const version = buf[cursor];
     cursor += 4 + 4;
-    var timescale = be4toi(buf, cursor);
+    const timescale = (0, byte_parsing_1.be4toi)(buf, cursor);
     cursor += 4;
     /* earliest_presentation_time(32 / 64) */
     /* first_offset(32 / 64) */
-    var time;
+    let time;
     if (version === 0) {
-        time = be4toi(buf, cursor);
+        time = (0, byte_parsing_1.be4toi)(buf, cursor);
         cursor += 4;
-        offset += be4toi(buf, cursor) + boxSize;
+        offset += (0, byte_parsing_1.be4toi)(buf, cursor) + boxSize;
         cursor += 4;
     }
     else if (version === 1) {
-        time = be8toi(buf, cursor);
+        time = (0, byte_parsing_1.be8toi)(buf, cursor);
         cursor += 8;
-        offset += be8toi(buf, cursor) + boxSize;
+        offset += (0, byte_parsing_1.be8toi)(buf, cursor) + boxSize;
         cursor += 8;
     }
     else {
         return null;
     }
-    var segments = [];
+    const segments = [];
     /* reserved(16) */
     /* reference_count(16) */
     cursor += 2;
-    var count = be2toi(buf, cursor);
+    let count = (0, byte_parsing_1.be2toi)(buf, cursor);
     cursor += 2;
     while (--count >= 0) {
         /* reference_type(1) */
         /* reference_size(31) */
         /* segment_duration(32) */
         /* sap..(32) */
-        var refChunk = be4toi(buf, cursor);
+        const refChunk = (0, byte_parsing_1.be4toi)(buf, cursor);
         cursor += 4;
-        var refType = (refChunk & 0x80000000) >>> 31;
-        var refSize = (refChunk & 0x7FFFFFFF);
+        const refType = (refChunk & 0x80000000) >>> 31;
+        const refSize = (refChunk & 0x7FFFFFFF);
         // when set to 1 indicates that the reference is to a sidx, else to media
         if (refType === 1) {
             throw new Error("sidx with reference_type `1` not yet implemented");
         }
-        var duration = be4toi(buf, cursor);
+        const duration = (0, byte_parsing_1.be4toi)(buf, cursor);
         cursor += 4;
         // let sapChunk = be4toi(buf, cursor + 8);
         cursor += 4;
@@ -92,12 +96,16 @@ function getSegmentsFromSidx(buf, sidxOffsetInWholeSegment) {
         // let startsWithSap = (sapChunk & 0x80000000) >>> 31;
         // let sapType = (sapChunk & 0x70000000) >>> 28;
         // let sapDelta = sapChunk & 0x0FFFFFFF;
-        segments.push({ time: time, duration: duration, timescale: timescale, range: [offset, offset + refSize - 1] });
+        segments.push({ time,
+            duration,
+            timescale,
+            range: [offset, offset + refSize - 1] });
         time += duration;
         offset += refSize;
     }
     return segments;
 }
+exports.getSegmentsFromSidx = getSegmentsFromSidx;
 /**
  * Parse track Fragment Decode Time to get a precize initial time for this
  * segment (in the media timescale).
@@ -109,19 +117,20 @@ function getSegmentsFromSidx(buf, sidxOffsetInWholeSegment) {
  * @returns {Number | undefined}
  */
 function getTrackFragmentDecodeTime(buffer) {
-    var traf = getTRAF(buffer);
+    const traf = (0, read_1.getTRAF)(buffer);
     if (traf === null) {
         return undefined;
     }
-    var tfdt = getBoxContent(traf, 0x74666474 /* tfdt */);
+    const tfdt = (0, get_box_1.getBoxContent)(traf, 0x74666474 /* tfdt */);
     if (tfdt === null) {
         return undefined;
     }
-    var version = tfdt[0];
-    return version === 1 ? be8toi(tfdt, 4) :
-        version === 0 ? be4toi(tfdt, 4) :
+    const version = tfdt[0];
+    return version === 1 ? (0, byte_parsing_1.be8toi)(tfdt, 4) :
+        version === 0 ? (0, byte_parsing_1.be4toi)(tfdt, 4) :
             undefined;
 }
+exports.getTrackFragmentDecodeTime = getTrackFragmentDecodeTime;
 /**
  * Returns the "default sample duration" which is the default value for duration
  * of samples found in a "traf" ISOBMFF box.
@@ -131,16 +140,16 @@ function getTrackFragmentDecodeTime(buffer) {
  * @returns {number|undefined}
  */
 function getDefaultDurationFromTFHDInTRAF(traf) {
-    var tfhd = getBoxContent(traf, 0x74666864 /* tfhd */);
+    const tfhd = (0, get_box_1.getBoxContent)(traf, 0x74666864 /* tfhd */);
     if (tfhd === null) {
         return undefined;
     }
-    var cursor = /* version */ 1;
-    var flags = be3toi(tfhd, cursor);
+    let cursor = /* version */ 1;
+    const flags = (0, byte_parsing_1.be3toi)(tfhd, cursor);
     cursor += 3;
-    var hasBaseDataOffset = (flags & 0x000001) > 0;
-    var hasSampleDescriptionIndex = (flags & 0x000002) > 0;
-    var hasDefaultSampleDuration = (flags & 0x000008) > 0;
+    const hasBaseDataOffset = (flags & 0x000001) > 0;
+    const hasSampleDescriptionIndex = (flags & 0x000002) > 0;
+    const hasDefaultSampleDuration = (flags & 0x000008) > 0;
     if (!hasDefaultSampleDuration) {
         return undefined;
     }
@@ -151,7 +160,7 @@ function getDefaultDurationFromTFHDInTRAF(traf) {
     if (hasSampleDescriptionIndex) {
         cursor += 4;
     }
-    var defaultDuration = be4toi(tfhd, cursor);
+    const defaultDuration = (0, byte_parsing_1.be4toi)(tfhd, cursor);
     return defaultDuration;
 }
 /**
@@ -163,39 +172,38 @@ function getDefaultDurationFromTFHDInTRAF(traf) {
  * @returns {number | undefined}
  */
 function getDurationFromTrun(buffer) {
-    var trafs = getTRAFs(buffer);
+    const trafs = (0, read_1.getTRAFs)(buffer);
     if (trafs.length === 0) {
         return undefined;
     }
-    var completeDuration = 0;
-    for (var _i = 0, trafs_1 = trafs; _i < trafs_1.length; _i++) {
-        var traf = trafs_1[_i];
-        var trun = getBoxContent(traf, 0x7472756E /* trun */);
+    let completeDuration = 0;
+    for (const traf of trafs) {
+        const trun = (0, get_box_1.getBoxContent)(traf, 0x7472756E /* trun */);
         if (trun === null) {
             return undefined;
         }
-        var cursor = 0;
-        var version = trun[cursor];
+        let cursor = 0;
+        const version = trun[cursor];
         cursor += 1;
         if (version > 1) {
             return undefined;
         }
-        var flags = be3toi(trun, cursor);
+        const flags = (0, byte_parsing_1.be3toi)(trun, cursor);
         cursor += 3;
-        var hasSampleDuration = (flags & 0x000100) > 0;
-        var defaultDuration = 0;
+        const hasSampleDuration = (flags & 0x000100) > 0;
+        let defaultDuration = 0;
         if (!hasSampleDuration) {
             defaultDuration = getDefaultDurationFromTFHDInTRAF(traf);
             if (defaultDuration === undefined) {
                 return undefined;
             }
         }
-        var hasDataOffset = (flags & 0x000001) > 0;
-        var hasFirstSampleFlags = (flags & 0x000004) > 0;
-        var hasSampleSize = (flags & 0x000200) > 0;
-        var hasSampleFlags = (flags & 0x000400) > 0;
-        var hasSampleCompositionOffset = (flags & 0x000800) > 0;
-        var sampleCounts = be4toi(trun, cursor);
+        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 sampleCounts = (0, byte_parsing_1.be4toi)(trun, cursor);
         cursor += 4;
         if (hasDataOffset) {
             cursor += 4;
@@ -203,11 +211,11 @@ function getDurationFromTrun(buffer) {
         if (hasFirstSampleFlags) {
             cursor += 4;
         }
-        var i = sampleCounts;
-        var duration = 0;
+        let i = sampleCounts;
+        let duration = 0;
         while (i-- > 0) {
             if (hasSampleDuration) {
-                duration += be4toi(trun, cursor);
+                duration += (0, byte_parsing_1.be4toi)(trun, cursor);
                 cursor += 4;
             }
             else {
@@ -227,6 +235,7 @@ function getDurationFromTrun(buffer) {
     }
     return completeDuration;
 }
+exports.getDurationFromTrun = getDurationFromTrun;
 /**
  * Get timescale information from a movie header box. Found in init segments.
  * `undefined` if not found or not parsed.
@@ -236,32 +245,32 @@ function getDurationFromTrun(buffer) {
  * @returns {Number | undefined}
  */
 function getMDHDTimescale(buffer) {
-    var mdia = getMDIA(buffer);
+    const mdia = (0, read_1.getMDIA)(buffer);
     if (mdia === null) {
         return undefined;
     }
-    var mdhd = getBoxContent(mdia, 0x6D646864 /* "mdhd" */);
+    const mdhd = (0, get_box_1.getBoxContent)(mdia, 0x6D646864 /* "mdhd" */);
     if (mdhd === null) {
         return undefined;
     }
-    var cursor = 0;
-    var version = mdhd[cursor];
+    let cursor = 0;
+    const version = mdhd[cursor];
     cursor += 4;
-    return version === 1 ? be4toi(mdhd, cursor + 16) :
-        version === 0 ? be4toi(mdhd, cursor + 8) :
+    return version === 1 ? (0, byte_parsing_1.be4toi)(mdhd, cursor + 16) :
+        version === 0 ? (0, byte_parsing_1.be4toi)(mdhd, cursor + 8) :
             undefined;
 }
+exports.getMDHDTimescale = getMDHDTimescale;
 /**
  * Creates a PSSH box with the given systemId and data.
  * @param {Array.<Object>} psshInfo
  * @returns {Uint8Array}
  */
-function createPssh(_a) {
-    var systemId = _a.systemId, privateData = _a.privateData;
-    var _systemId = systemId.replace(/-/g, "");
-    assert(_systemId.length === 32);
-    return createBox("pssh", concat(4, // 4 initial zeroed bytes
-    hexToBytes(_systemId), itobe4(privateData.length), privateData));
+function createPssh({ systemId, privateData }) {
+    const _systemId = systemId.replace(/-/g, "");
+    (0, assert_1.default)(_systemId.length === 32);
+    return (0, create_box_1.createBox)("pssh", (0, byte_parsing_1.concat)(4, // 4 initial zeroed bytes
+    (0, string_parsing_1.hexToBytes)(_systemId), (0, byte_parsing_1.itobe4)(privateData.length), privateData));
 }
 /**
  * Update ISOBMFF given to add a "pssh" box in the "moov" box for every content
@@ -274,18 +283,19 @@ function patchPssh(buf, psshList) {
     if (psshList == null || psshList.length === 0) {
         return buf;
     }
-    var moovOffsets = getBoxOffsets(buf, 0x6D6F6F76 /* = "moov" */);
+    const moovOffsets = (0, get_box_1.getBoxOffsets)(buf, 0x6D6F6F76 /* = "moov" */);
     if (moovOffsets === null) {
         return buf;
     }
-    var moov = buf.subarray(moovOffsets[0], moovOffsets[2]);
-    var moovArr = [moov];
-    for (var i = 0; i < psshList.length; i++) {
+    const moov = buf.subarray(moovOffsets[0], moovOffsets[2]);
+    const moovArr = [moov];
+    for (let i = 0; i < psshList.length; i++) {
         moovArr.push(createPssh(psshList[i]));
     }
-    var newmoov = updateBoxLength(concat.apply(void 0, moovArr));
-    return concat(buf.subarray(0, moovOffsets[0]), newmoov, buf.subarray(moovOffsets[2]));
+    const newmoov = updateBoxLength((0, byte_parsing_1.concat)(...moovArr));
+    return (0, byte_parsing_1.concat)(buf.subarray(0, moovOffsets[0]), newmoov, buf.subarray(moovOffsets[2]));
 }
+exports.patchPssh = patchPssh;
 /**
  * Returns a new version of the given box with the size updated
  * so it reflects its actual size.
@@ -299,22 +309,22 @@ function patchPssh(buf, psshList) {
  * @returns {Uint8Array}
  */
 function updateBoxLength(buf) {
-    var newLen = buf.length;
+    const newLen = buf.length;
     if (newLen < 4) {
         throw new Error("Cannot update box length: box too short");
     }
-    var oldSize = be4toi(buf, 0);
+    const oldSize = (0, byte_parsing_1.be4toi)(buf, 0);
     if (oldSize === 0) {
-        if (newLen > MAX_32_BIT_INT) {
-            var newBox = new Uint8Array(newLen + 8);
-            newBox.set(itobe4(1), 0);
+        if (newLen > constants_1.MAX_32_BIT_INT) {
+            const newBox = new Uint8Array(newLen + 8);
+            newBox.set((0, byte_parsing_1.itobe4)(1), 0);
             newBox.set(buf.subarray(4, 8), 4);
-            newBox.set(itobe8(newLen + 8), 8);
+            newBox.set((0, byte_parsing_1.itobe8)(newLen + 8), 8);
             newBox.set(buf.subarray(8, newLen), 16);
             return newBox;
         }
         else {
-            buf.set(itobe4(newLen), 0);
+            buf.set((0, byte_parsing_1.itobe4)(newLen), 0);
             return buf;
         }
     }
@@ -322,57 +332,64 @@ function updateBoxLength(buf) {
         if (newLen < 16) {
             throw new Error("Cannot update box length: box too short");
         }
-        buf.set(itobe8(newLen), 8);
+        buf.set((0, byte_parsing_1.itobe8)(newLen), 8);
         return buf;
     }
-    else if (newLen <= MAX_32_BIT_INT) {
-        buf.set(itobe4(newLen), 0);
+    else if (newLen <= constants_1.MAX_32_BIT_INT) {
+        buf.set((0, byte_parsing_1.itobe4)(newLen), 0);
         return buf;
     }
     else {
-        var newBox = new Uint8Array(newLen + 8);
-        newBox.set(itobe4(1), 0);
+        const newBox = new Uint8Array(newLen + 8);
+        newBox.set((0, byte_parsing_1.itobe4)(1), 0);
         newBox.set(buf.subarray(4, 8), 4);
-        newBox.set(itobe8(newLen + 8), 8);
+        newBox.set((0, byte_parsing_1.itobe8)(newLen + 8), 8);
         newBox.set(buf.subarray(8, newLen), 16);
         return newBox;
     }
 }
+exports.updateBoxLength = updateBoxLength;
 /**
  * Parse EMSG boxes from ISOBMFF data.
  * @param {Uint8Array} buffer
  * @returns {Array.<Object> | undefined}
  */
 function parseEmsgBoxes(buffer) {
-    var emsgs = [];
-    var offset = 0;
+    const emsgs = [];
+    let offset = 0;
     while (offset < buffer.length) {
-        var emsg = getEMSG(buffer, offset);
+        const emsg = (0, read_1.getEMSG)(buffer, offset);
         if (emsg === null) {
             break;
         }
-        var length_1 = emsg.length;
-        offset += length_1;
-        var version = emsg[0];
+        const length = emsg.length;
+        offset += length;
+        const version = emsg[0];
         if (version !== 0) {
-            log.warn("ISOBMFF: EMSG version " + version.toString() + " not supported.");
+            log_1.default.warn("ISOBMFF: EMSG version " + version.toString() + " not supported.");
         }
         else {
-            var position = 4; // skip version + flags
-            var _a = readNullTerminatedString(emsg, position), schemeIdEnd = _a.end, schemeIdUri = _a.string;
+            let position = 4; // skip version + flags
+            const { end: schemeIdEnd, string: schemeIdUri } = (0, string_parsing_1.readNullTerminatedString)(emsg, position);
             position = schemeIdEnd; // skip schemeIdUri
-            var _b = readNullTerminatedString(emsg, position), valueEnd = _b.end, value = _b.string;
+            const { end: valueEnd, string: value } = (0, string_parsing_1.readNullTerminatedString)(emsg, position);
             position = valueEnd; // skip value
-            var timescale = be4toi(emsg, position);
+            const timescale = (0, byte_parsing_1.be4toi)(emsg, position);
             position += 4; // skip timescale
-            var presentationTimeDelta = be4toi(emsg, position);
+            const presentationTimeDelta = (0, byte_parsing_1.be4toi)(emsg, position);
             position += 4; // skip presentationTimeDelta
-            var eventDuration = be4toi(emsg, position);
+            const eventDuration = (0, byte_parsing_1.be4toi)(emsg, position);
             position += 4; // skip eventDuration
-            var id = be4toi(emsg, position);
+            const id = (0, byte_parsing_1.be4toi)(emsg, position);
             position += 4; // skip id
-            var messageData = emsg.subarray(position, length_1);
-            var emsgData = { schemeIdUri: schemeIdUri, value: value, timescale: timescale, presentationTimeDelta: presentationTimeDelta, eventDuration: eventDuration, id: id, messageData: messageData };
+            const messageData = emsg.subarray(position, length);
+            const emsgData = { schemeIdUri,
+                value,
+                timescale,
+                presentationTimeDelta,
+                eventDuration,
+                id,
+                messageData };
             emsgs.push(emsgData);
         }
     }
@@ -381,12 +398,13 @@ function parseEmsgBoxes(buffer) {
     }
     return emsgs;
 }
+exports.parseEmsgBoxes = parseEmsgBoxes;
 /**
  * @param {Uint8Array} segment
  * @returns {Uint8Array|null}
  */
 function getKeyIdFromInitSegment(segment) {
-    var stsd = getChildBox(segment, [0x6D6F6F76 /* moov */,
+    const stsd = (0, get_box_1.getChildBox)(segment, [0x6D6F6F76 /* moov */,
         0x7472616B /* trak */,
         0x6D646961 /* mdia */,
         0x6D696E66 /* minf */,
@@ -395,9 +413,9 @@ function getKeyIdFromInitSegment(segment) {
     if (stsd === null) {
         return null;
     }
-    var stsdSubBoxes = stsd.subarray(8);
-    var encBox = getBoxContent(stsdSubBoxes, 0x656E6376 /* encv */);
-    var encContentOffset = 0;
+    const stsdSubBoxes = stsd.subarray(8);
+    let encBox = (0, get_box_1.getBoxContent)(stsdSubBoxes, 0x656E6376 /* encv */);
+    let encContentOffset = 0;
     if (encBox === null) {
         encContentOffset = 8 + // sample entry header
             8 + // reserved
@@ -406,7 +424,7 @@ function getKeyIdFromInitSegment(segment) {
             2 + // predefined
             2 + // reserved
             4; // samplerate
-        encBox = getBoxContent(stsdSubBoxes, 0x656E6361 /* enca */);
+        encBox = (0, get_box_1.getBoxContent)(stsdSubBoxes, 0x656E6361 /* enca */);
     }
     else {
         encContentOffset = 8 + // sample entry header
@@ -423,7 +441,7 @@ function getKeyIdFromInitSegment(segment) {
         // There's no encryption data here
         return null;
     }
-    var tenc = getChildBox(encBox.subarray(encContentOffset), [0x73696e66 /* sinf */,
+    const tenc = (0, get_box_1.getChildBox)(encBox.subarray(encContentOffset), [0x73696e66 /* sinf */,
         0x73636869 /* schi */,
         0x74656e63 /* tenc */]);
     if (tenc === null || tenc.byteLength < 24) {
@@ -431,4 +449,4 @@ function getKeyIdFromInitSegment(segment) {
     }
     return tenc.subarray(8, 24);
 }
-export { getKeyIdFromInitSegment, getMDHDTimescale, getPlayReadyKIDFromPrivateData, getTrackFragmentDecodeTime, getDurationFromTrun, getSegmentsFromSidx, patchPssh, updateBoxLength, parseEmsgBoxes, };
+exports.getKeyIdFromInitSegment = getKeyIdFromInitSegment;

package/dist/_esm5.processed/parsers/containers/matroska/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,4 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { getSegmentsFromCues, getTimeCodeScale, } from "./utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeCodeScale = exports.getSegmentsFromCues = void 0;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getSegmentsFromCues", { enumerable: true, get: function () { return utils_1.getSegmentsFromCues; } });
+Object.defineProperty(exports, "getTimeCodeScale", { enumerable: true, get: function () { return utils_1.getTimeCodeScale; } });