@remotion/media-parser 4.0.228 → 4.0.230

package/dist/boxes/iso-base-media/stsd/colr.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseColorParameterBox = void 0;
-const parseColorParameterBox = ({ iterator, }) => {
+const parse_icc_profile_1 = require("../parse-icc-profile");
+const parseColorParameterBox = ({ iterator, size, }) => {
     const byteString = iterator.getByteString(4);
     if (byteString === 'nclx') {
         const primaries = iterator.getUint16();
@@ -12,6 +13,7 @@ const parseColorParameterBox = ({ iterator, }) => {
         iterator.stopReadingBits();
         return {
             type: 'colr-box',
+            colorType: 'transfer-characteristics',
             fullRangeFlag,
             matrixIndex,
             primaries,
@@ -24,12 +26,22 @@ const parseColorParameterBox = ({ iterator, }) => {
         const matrixIndex = iterator.getUint16();
         return {
             type: 'colr-box',
+            colorType: 'transfer-characteristics',
             fullRangeFlag: false,
             matrixIndex,
             primaries,
             transfer,
         };
     }
+    if (byteString === 'prof') {
+        const profile = iterator.getSlice(size - 12);
+        return {
+            type: 'colr-box',
+            colorType: 'icc-profile',
+            profile,
+            parsed: (0, parse_icc_profile_1.parseIccProfile)(profile),
+        };
+    }
     throw new Error('Unexpected box type ' + byteString);
 };
 exports.parseColorParameterBox = parseColorParameterBox;

package/dist/boxes/iso-base-media/stsd/mebx.d.ts

@@ -8,11 +8,10 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, options, littleEndian, signal, }: {
+export declare const parseMebx: ({ iterator, offset, size, options, signal, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
-    littleEndian: boolean;
     signal: AbortSignal | null;
 }) => Promise<MebxBox>;

package/dist/boxes/iso-base-media/stsd/mebx.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const process_box_1 = require("../process-box");
-const parseMebx = async ({ iterator, offset, size, options, littleEndian, signal, }) => {
+const parseMebx = async ({ iterator, offset, size, options, signal, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
@@ -13,8 +13,8 @@ const parseMebx = async ({ iterator, offset, size, options, littleEndian, signal
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian,
         signal,
+        logLevel: 'info',
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/iso-base-media/stsd/samples.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 type SampleBase = {
@@ -48,15 +49,17 @@ export type Sample = AudioSample | VideoSample | UnknownSample;
 type SampleAndNext = {
     sample: Sample | null;
 };
-export declare const processSample: ({ iterator, options, signal, }: {
+export declare const processSample: ({ iterator, options, signal, logLevel, }: {
     iterator: BufferIterator;
     options: ParserContext;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<SampleAndNext>;
-export declare const parseSamples: ({ iterator, maxBytes, options, signal, }: {
+export declare const parseSamples: ({ iterator, maxBytes, options, signal, logLevel, }: {
     iterator: BufferIterator;
     maxBytes: number;
     options: ParserContext;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<Sample[]>;
 export {};

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -61,7 +61,7 @@ const audioTags = [
     'mp4a',
     'ac-3',
 ];
-const processSample = async ({ iterator, options, signal, }) => {
+const processSample = async ({ iterator, options, signal, logLevel, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getUint32();
@@ -105,8 +105,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -152,8 +152,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -203,8 +203,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -258,8 +258,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             })
             : (iterator.discard(bytesRemainingInBox),
                 { status: 'done', segments: [] });
@@ -294,7 +294,7 @@ const processSample = async ({ iterator, options, signal, }) => {
     throw new Error(`Unknown sample format ${boxFormat}`);
 };
 exports.processSample = processSample;
-const parseSamples = async ({ iterator, maxBytes, options, signal, }) => {
+const parseSamples = async ({ iterator, maxBytes, options, signal, logLevel, }) => {
     const samples = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
@@ -303,6 +303,7 @@ const parseSamples = async ({ iterator, maxBytes, options, signal, }) => {
             iterator,
             options,
             signal,
+            logLevel,
         });
         if (sample) {
             samples.push(sample);

package/dist/boxes/iso-base-media/stsd/stsd.js

@@ -16,6 +16,7 @@ const parseStsd = async ({ iterator, offset, size, options, signal, }) => {
         maxBytes: bytesRemainingInBox,
         options,
         signal,
+        logLevel: 'info',
     });
     if (boxes.length !== numberOfEntries) {
         throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);

package/dist/boxes/iso-base-media/to-date.d.ts

@@ -1 +1,2 @@
 export declare const toUnixTimestamp: (value: number) => number | null;
+export declare const fromUnixTimestamp: (value: number | null) => number;

package/dist/boxes/iso-base-media/to-date.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toUnixTimestamp = void 0;
+exports.fromUnixTimestamp = exports.toUnixTimestamp = void 0;
 const toUnixTimestamp = (value) => {
     if (value === 0) {
         return null;
@@ -9,3 +9,11 @@ const toUnixTimestamp = (value) => {
     return Math.floor(value + baseDate.getTime() / 1000) * 1000;
 };
 exports.toUnixTimestamp = toUnixTimestamp;
+const fromUnixTimestamp = (value) => {
+    if (value === null) {
+        return 0;
+    }
+    const baseDate = new Date('1904-01-01T00:00:00Z');
+    return Math.floor(value / 1000 - baseDate.getTime() / 1000);
+};
+exports.fromUnixTimestamp = fromUnixTimestamp;

package/dist/boxes/iso-base-media/trak/trak.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
@@ -6,10 +7,11 @@ export interface TrakBox extends BaseBox {
     type: 'trak-box';
     children: AnySegment[];
 }
-export declare const parseTrak: ({ data, size, offsetAtStart, options, signal, }: {
+export declare const parseTrak: ({ data, size, offsetAtStart, options, signal, logLevel, }: {
     data: BufferIterator;
     size: number;
     offsetAtStart: number;
     options: ParserContext;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<TrakBox>;

package/dist/boxes/iso-base-media/trak/trak.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
 const process_box_1 = require("../process-box");
-const parseTrak = async ({ data, size, offsetAtStart, options, signal, }) => {
+const parseTrak = async ({ data, size, offsetAtStart, options, signal, logLevel, }) => {
     const children = await (0, process_box_1.parseBoxes)({
         iterator: data,
         maxBytes: size - (data.counter.getOffset() - offsetAtStart),
@@ -10,8 +10,8 @@ const parseTrak = async ({ data, size, offsetAtStart, options, signal, }) => {
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
         signal,
+        logLevel,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/webm/av1-codec-private.js

@@ -61,7 +61,7 @@ const parseAv1PrivateData = (data, colrAtom) => {
                 : '0'
             : '0';
     str += '.';
-    if (colrAtom) {
+    if (colrAtom && colrAtom.colorType === 'transfer-characteristics') {
         str += colrAtom.primaries.toString().padStart(2, '0');
         str += '.';
         str += colrAtom.transfer.toString().padStart(2, '0');

package/dist/boxes/webm/ebml.d.ts

@@ -1,2 +1,2 @@
-export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 5 | 3 | 6 | 4;
+export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 3 | 4 | 5 | 6;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

package/dist/boxes/webm/get-sample-from-block.d.ts

@@ -1,15 +1,15 @@
 import type { ParserContext } from '../../parser-context';
-import type { AudioSample, VideoSample } from '../../webcodec-sample-types';
+import type { AudioOrVideoSample } from '../../webcodec-sample-types';
 import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
 type SampleResult = {
     type: 'video-sample';
-    videoSample: VideoSample;
+    videoSample: AudioOrVideoSample;
 } | {
     type: 'audio-sample';
-    audioSample: AudioSample;
+    audioSample: AudioOrVideoSample;
 } | {
     type: 'partial-video-sample';
-    partialVideoSample: Omit<VideoSample, 'type'>;
+    partialVideoSample: Omit<AudioOrVideoSample, 'type'>;
 } | {
     type: 'no-sample';
 };

package/dist/boxes/webm/get-sample-from-block.js

@@ -34,8 +34,8 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
     if (codec.startsWith('V_')) {
         const partialVideoSample = {
             data: iterator.getSlice(remainingNow),
-            cts: null,
-            dts: null,
+            cts: timecodeInMicroseconds,
+            dts: timecodeInMicroseconds,
             duration: undefined,
             trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
@@ -63,6 +63,9 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
             trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
             type: 'key',
+            duration: undefined,
+            cts: timecodeInMicroseconds,
+            dts: timecodeInMicroseconds,
         };
         iterator.destroy();
         return {

package/dist/boxes/webm/make-track.js

@@ -231,6 +231,7 @@ const getTrack = ({ timescale, track, }) => {
             codecWithoutConfig: getMatroskaVideoCodecWithoutConfigString({
                 codecSegment: codec,
             }),
+            fps: null,
         };
     }
     if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {

package/dist/buffer-iterator.d.ts

@@ -26,7 +26,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     isWebm: () => boolean;
     discard: (length: number) => void;
     getEightByteNumber: (littleEndian?: boolean) => number;
-    getFourByteNumber: (littleEndian?: boolean) => number;
+    getFourByteNumber: () => number;
     getSlice: (amount: number) => Uint8Array;
     getAtom: () => string;
     isRiff: () => boolean;

package/dist/buffer-iterator.js

@@ -132,14 +132,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         ]);
         return Number(bigInt);
     };
-    const getFourByteNumber = (littleEndian = false) => {
-        if (littleEndian) {
-            const one = getUint8();
-            const two = getUint8();
-            const three = getUint8();
-            const four = getUint8();
-            return (four << 24) | (three << 16) | (two << 8) | one;
-        }
+    const getFourByteNumber = () => {
         return ((getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8());
     };
     const getPaddedFourByteNumber = () => {

package/dist/create/iso-base-media/codec-specific/avc1.d.ts

@@ -0,0 +1,2 @@
+import type { Avc1Data } from './create-codec-specific-data';
+export declare const createAvc1Data: ({ avccBox, pasp, width, height, horizontalResolution, verticalResolution, compressorName, depth, }: Avc1Data) => Uint8Array;

package/dist/create/iso-base-media/codec-specific/avc1.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAvc1Data = void 0;
+const make_header_1 = require("../../../boxes/webm/make-header");
+const primitives_1 = require("../primitives");
+const createAvc1Data = ({ avccBox, pasp, width, height, horizontalResolution, verticalResolution, compressorName, depth, }) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('avc1'),
+        // reserved
+        new Uint8Array([0, 0, 0, 0, 0, 0]),
+        // data_reference_index
+        new Uint8Array([0, 1]),
+        // version
+        new Uint8Array([0, 0]),
+        // revisionLevel
+        new Uint8Array([0, 0]),
+        // vendor
+        new Uint8Array([0, 0, 0, 0]),
+        // temporalQuality
+        new Uint8Array([0, 0, 0, 0]),
+        // spatialQuality
+        new Uint8Array([0, 0, 0, 0]),
+        // width
+        (0, primitives_1.numberTo16BitUIntOrInt)(width),
+        // height
+        (0, primitives_1.numberTo16BitUIntOrInt)(height),
+        // horizontalResolution
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(horizontalResolution),
+        // verticalResolution
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(verticalResolution),
+        // dataSize
+        new Uint8Array([0, 0, 0, 0]),
+        // frame count per sample
+        (0, primitives_1.numberTo16BitUIntOrInt)(1),
+        // compressor name
+        (0, primitives_1.stringToPascalString)(compressorName),
+        // depth
+        (0, primitives_1.numberTo16BitUIntOrInt)(depth),
+        // colorTableId
+        (0, primitives_1.numberTo16BitUIntOrInt)(-1),
+        // avcc box
+        avccBox,
+        // pasp
+        pasp,
+    ]));
+};
+exports.createAvc1Data = createAvc1Data;

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.d.ts

@@ -0,0 +1,22 @@
+import type { MakeTrackAudio, MakeTrackVideo } from '../../make-track-info';
+export type Avc1Data = {
+    pasp: Uint8Array;
+    avccBox: Uint8Array;
+    width: number;
+    height: number;
+    horizontalResolution: number;
+    verticalResolution: number;
+    compressorName: string;
+    depth: number;
+    type: 'avc1-data';
+};
+export type Mp4aData = {
+    type: 'mp4a-data';
+    sampleRate: number;
+    channelCount: number;
+    maxBitrate: number;
+    avgBitrate: number;
+    codecPrivate: Uint8Array | null;
+};
+export type CodecSpecificData = Avc1Data | Mp4aData;
+export declare const createCodecSpecificData: (track: MakeTrackAudio | MakeTrackVideo) => Uint8Array;

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodecSpecificData = void 0;
+const create_avcc_1 = require("../trak/mdia/minf/stbl/stsd/create-avcc");
+const create_pasp_1 = require("../trak/mdia/minf/stbl/stsd/create-pasp");
+const avc1_1 = require("./avc1");
+const mp4a_1 = require("./mp4a");
+const createCodecSpecificData = (track) => {
+    if (track.type === 'video') {
+        return (0, avc1_1.createAvc1Data)({
+            avccBox: (0, create_avcc_1.createAvccBox)(track.codecPrivate),
+            compressorName: 'WebCodecs',
+            depth: 24,
+            horizontalResolution: 72,
+            verticalResolution: 72,
+            height: track.height,
+            width: track.width,
+            pasp: (0, create_pasp_1.createPasp)(1, 1),
+            type: 'avc1-data',
+        });
+    }
+    if (track.type === 'audio') {
+        return (0, mp4a_1.createMp4a)({
+            type: 'mp4a-data',
+            // TODO: Put in values based on real data,
+            // this seems to work though
+            avgBitrate: 128 * 1024,
+            maxBitrate: 128 * 1024,
+            channelCount: track.numberOfChannels,
+            sampleRate: track.sampleRate,
+            codecPrivate: track.codecPrivate,
+        });
+    }
+    throw new Error('Unsupported codec specific data ' + track);
+};
+exports.createCodecSpecificData = createCodecSpecificData;

package/dist/create/iso-base-media/codec-specific/mp4a.d.ts

@@ -0,0 +1,2 @@
+import type { Mp4aData } from './create-codec-specific-data';
+export declare const createMp4a: ({ sampleRate, channelCount, avgBitrate, maxBitrate, codecPrivate, }: Mp4aData) => Uint8Array;

package/dist/create/iso-base-media/codec-specific/mp4a.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMp4a = void 0;
+const make_header_1 = require("../../../boxes/webm/make-header");
+const primitives_1 = require("../primitives");
+const createMp4a = ({ sampleRate, channelCount, avgBitrate, maxBitrate, codecPrivate, }) => {
+    if (!codecPrivate) {
+        throw new Error('Need codecPrivate for mp4a');
+    }
+    const esdsAtom = (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('esds'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // tag = 'ES_DescrTag'
+        new Uint8Array([3]),
+        (0, primitives_1.addLeading128Size)((0, make_header_1.combineUint8Arrays)([
+            // ES_ID
+            (0, primitives_1.numberTo16BitUIntOrInt)(2),
+            // streamDependenceFlag, URL_Flag, OCRstreamFlag
+            new Uint8Array([0]),
+            // DecoderConfigDescrTag
+            new Uint8Array([4]),
+            (0, primitives_1.addLeading128Size)((0, make_header_1.combineUint8Arrays)([
+                // objectTypeIndication
+                new Uint8Array([0x40]),
+                // streamType, upStream
+                new Uint8Array([21]),
+                // reserved
+                new Uint8Array([0, 0, 0]),
+                // maxBitrate
+                (0, primitives_1.numberTo32BitUIntOrInt)(maxBitrate),
+                // avgBitrate
+                (0, primitives_1.numberTo32BitUIntOrInt)(avgBitrate),
+                // DecoderSpecificInfoTag
+                new Uint8Array([5]),
+                // codec private, for example [17, 144]
+                // audioObjectType = 2 = 'AAC LC'
+                // samplingFrequencyIndex = 3 = '48000 Hz'
+                // channelConfiguration = 2 = '2 channels'
+                /**
+                 * Byte 1 (17):  0001 0001
+                                                ^^^^^ ^^^^
+                                                |     |
+                                                |     +-- Start of samplingFrequencyIndex (3)
+                                                +-- audioConfigType (2)
+
+                    Byte 2 (144): 1001 0000
+                                                ^^^^ ^^^^
+                                                |    |
+                                                |    +-- Remaining bits/padding
+                                                +-- channelConfiguration (2)
+                    */
+                (0, primitives_1.addLeading128Size)(codecPrivate),
+            ])),
+            // SLConfigDescrTag
+            new Uint8Array([6]),
+            (0, primitives_1.addLeading128Size)(new Uint8Array([2])),
+        ])),
+    ]));
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('mp4a'),
+        // reserved
+        new Uint8Array([0, 0, 0, 0, 0, 0]),
+        // data_reference_index
+        (0, primitives_1.numberTo16BitUIntOrInt)(1),
+        // version
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // revision level
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // vendor
+        new Uint8Array([0, 0, 0, 0]),
+        // channelCount
+        (0, primitives_1.numberTo16BitUIntOrInt)(channelCount),
+        // sampleSize
+        (0, primitives_1.numberTo16BitUIntOrInt)(16),
+        // compressionId
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // packet size
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // sample rate
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(sampleRate),
+        // esds atom
+        esdsAtom,
+    ]));
+};
+exports.createMp4a = createMp4a;

package/dist/create/iso-base-media/create-colr.d.ts

@@ -0,0 +1,6 @@
+export declare const createColr: ({ fullRange, matrixIndex, primaries, transferFunction, }: {
+    fullRange: boolean;
+    matrixIndex: number;
+    primaries: number;
+    transferFunction: number;
+}) => Uint8Array;

package/dist/create/iso-base-media/create-colr.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createColr = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+// TODO: Not used in creation of MP4 yet
+const createColr = ({ fullRange, matrixIndex, primaries, transferFunction, }) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('colr'),
+        // colour_type
+        (0, primitives_1.stringsToUint8Array)('nclx'),
+        // primaries
+        // 1 = 'ITU-R BT.7090
+        new Uint8Array([0, primaries]),
+        // transfer_function
+        // 1 = 'ITU-R BT.7090
+        new Uint8Array([0, transferFunction]),
+        // matrix_index
+        // 1 = 'ITU-R BT.7090
+        new Uint8Array([0, matrixIndex]),
+        // full_range_flag
+        new Uint8Array([fullRange ? 1 : 0]),
+    ]));
+};
+exports.createColr = createColr;

package/dist/create/iso-base-media/create-ftyp.d.ts

@@ -0,0 +1,10 @@
+export declare const createFtyp: ({ majorBrand, minorBrand, compatibleBrands, }: {
+    majorBrand: string;
+    minorBrand: number;
+    compatibleBrands: string[];
+}) => Uint8Array;
+export declare const createIsoBaseMediaFtyp: ({ majorBrand, minorBrand, compatibleBrands, }: {
+    majorBrand: string;
+    minorBrand: number;
+    compatibleBrands: string[];
+}) => Uint8Array;

package/dist/create/iso-base-media/create-ftyp.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsoBaseMediaFtyp = exports.createFtyp = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createFtyp = ({ majorBrand, minorBrand, compatibleBrands, }) => {
+    const type = (0, primitives_1.stringsToUint8Array)('ftyp');
+    const majorBrandArr = (0, primitives_1.stringsToUint8Array)(majorBrand);
+    const minorBrandArr = (0, primitives_1.numberTo32BitUIntOrInt)(minorBrand);
+    const compatibleBrandsArr = (0, make_header_1.combineUint8Arrays)(compatibleBrands.map((b) => (0, primitives_1.stringsToUint8Array)(b)));
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        type,
+        majorBrandArr,
+        minorBrandArr,
+        compatibleBrandsArr,
+    ]));
+};
+exports.createFtyp = createFtyp;
+const createIsoBaseMediaFtyp = ({ majorBrand, minorBrand, compatibleBrands, }) => {
+    return (0, exports.createFtyp)({ compatibleBrands, majorBrand, minorBrand });
+};
+exports.createIsoBaseMediaFtyp = createIsoBaseMediaFtyp;

package/dist/create/iso-base-media/create-ilst.d.ts

@@ -0,0 +1 @@
+export declare const createIlst: (items: Uint8Array[]) => Uint8Array;

package/dist/create/iso-base-media/create-ilst.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIlst = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createIlst = (items) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // name
+        (0, primitives_1.stringsToUint8Array)('ilst'),
+        // items
+        ...items,
+    ]));
+};
+exports.createIlst = createIlst;

package/dist/create/iso-base-media/create-iso-base-media.d.ts

@@ -0,0 +1,2 @@
+import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
+export declare const createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, }: MediaFnGeneratorInput) => Promise<MediaFn>;