@remotion/media-parser 4.0.209 → 4.0.211

package/dist/create/matroska-cues.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaCues = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const createMatroskaCues = (cues) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Cues',
+        minVintWidth: null,
+        value: cues.map((cue) => {
+            return {
+                type: 'CuePoint',
+                value: [
+                    {
+                        type: 'CueTime',
+                        minVintWidth: null,
+                        value: {
+                            value: cue.time,
+                            byteLength: null,
+                        },
+                    },
+                    {
+                        type: 'CueTrackPositions',
+                        value: [
+                            {
+                                type: 'CueTrack',
+                                minVintWidth: null,
+                                value: {
+                                    value: cue.trackNumber,
+                                    byteLength: null,
+                                },
+                            },
+                            {
+                                type: 'CueClusterPosition',
+                                minVintWidth: null,
+                                value: {
+                                    value: cue.clusterPosition,
+                                    byteLength: null,
+                                },
+                            },
+                        ],
+                        minVintWidth: null,
+                    },
+                ],
+                minVintWidth: null,
+            };
+        }),
+    });
+};
+exports.createMatroskaCues = createMatroskaCues;

package/dist/create/matroska-info.js

@@ -25,7 +25,7 @@ const makeMatroskaInfo = ({ timescale }) => {
                 value: '@remotion/media-parser',
                 minVintWidth: null,
             },
-            ...(0, make_duration_with_padding_1.makeDurationWithPadding)(0),
+            (0, make_duration_with_padding_1.makeDurationWithPadding)(0),
         ],
         minVintWidth: null,
     });

package/dist/create/matroska-seek.d.ts

@@ -0,0 +1,6 @@
+import type { MatroskaElement } from '../boxes/webm/segments/all-segments';
+export type Seek = {
+    hexString: MatroskaElement;
+    byte: number;
+};
+export declare const createMatroskaSeekHead: (seeks: Seek[]) => import("../boxes/webm/segments/all-segments").BytesAndOffset[];

package/dist/create/matroska-seek.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaSeekHead = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const createMatroskaSeekHead = (seeks) => {
+    return (0, make_header_1.padMatroskaBytes)((0, make_header_1.makeMatroskaBytes)({
+        type: 'SeekHead',
+        minVintWidth: null,
+        value: seeks.map((seek) => {
+            return {
+                type: 'Seek',
+                minVintWidth: null,
+                value: [
+                    {
+                        type: 'SeekID',
+                        minVintWidth: null,
+                        value: seek.hexString,
+                    },
+                    {
+                        type: 'SeekPosition',
+                        minVintWidth: null,
+                        value: {
+                            value: seek.byte,
+                            byteLength: null,
+                        },
+                    },
+                ],
+            };
+        }),
+    }), 200);
+};
+exports.createMatroskaSeekHead = createMatroskaSeekHead;

package/dist/create/matroska-segment.d.ts

@@ -1,2 +1,3 @@
 import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
+export declare const MATROSKA_SEGMENT_MIN_VINT_WIDTH = 8;
 export declare const createMatroskaSegment: (children: BytesAndOffset[]) => BytesAndOffset;

package/dist/create/matroska-segment.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMatroskaSegment = void 0;
+exports.createMatroskaSegment = exports.MATROSKA_SEGMENT_MIN_VINT_WIDTH = void 0;
 const make_header_1 = require("../boxes/webm/make-header");
+exports.MATROSKA_SEGMENT_MIN_VINT_WIDTH = 8;
 const createMatroskaSegment = (children) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'Segment',
         value: children,
-        minVintWidth: 8,
+        minVintWidth: exports.MATROSKA_SEGMENT_MIN_VINT_WIDTH,
     });
 };
 exports.createMatroskaSegment = createMatroskaSegment;

package/dist/create/matroska-trackentry.d.ts

@@ -1,32 +1,27 @@
 import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
-export type MatroskaColorParams = {
-    transferChracteristics: 'bt709' | 'smpte170m' | 'iec61966-2-1' | null;
-    matrixCoefficients: 'bt709' | 'bt470bg' | 'rgb' | 'smpte170m' | null;
-    primaries: 'bt709' | 'smpte170m' | 'bt470bg' | null;
-    fullRange: boolean | null;
-};
-export declare const makeMatroskaColorBytes: ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }: MatroskaColorParams) => BytesAndOffset;
+import type { MediaParserAudioCodec, MediaParserVideoCodec, VideoTrackColorParams } from '../get-tracks';
 export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
-    color: MatroskaColorParams;
+    color: VideoTrackColorParams;
     width: number;
     height: number;
 }) => BytesAndOffset;
 export type MakeTrackAudio = {
     trackNumber: number;
-    codecId: string;
+    codec: MediaParserAudioCodec;
     numberOfChannels: number;
     sampleRate: number;
     type: 'audio';
+    codecPrivate: Uint8Array | null;
 };
 export type MakeTrackVideo = {
-    color: MatroskaColorParams;
+    color: VideoTrackColorParams;
     width: number;
     height: number;
-    defaultDuration: number;
     trackNumber: number;
-    codecId: string;
+    codec: MediaParserVideoCodec;
     type: 'video';
+    codecPrivate: Uint8Array | null;
 };
-export declare const makeMatroskaAudioTrackEntryBytes: ({ trackNumber, codecId, numberOfChannels: audioChannels, sampleRate, }: MakeTrackAudio) => BytesAndOffset;
-export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, defaultDuration, trackNumber, codecId, }: MakeTrackVideo) => BytesAndOffset;
+export declare const makeMatroskaAudioTrackEntryBytes: ({ trackNumber, codec, numberOfChannels, sampleRate, codecPrivate, }: MakeTrackAudio) => BytesAndOffset;
+export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, trackNumber, codec, codecPrivate, }: MakeTrackVideo) => BytesAndOffset;
 export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset[];

package/dist/create/matroska-trackentry.js

@@ -1,81 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaAudioTrackEntryBytes = exports.makeMatroskaVideoBytes = exports.makeMatroskaColorBytes = void 0;
+exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaAudioTrackEntryBytes = exports.makeMatroskaVideoBytes = void 0;
+const color_1 = require("../boxes/webm/color");
 const make_header_1 = require("../boxes/webm/make-header");
-const makeMatroskaColorBytes = ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }) => {
-    const rangeValue = transferChracteristics && matrixCoefficients
-        ? 3
-        : fullRange === true
-            ? 2
-            : fullRange === false
-                ? 1
-                : 0;
-    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
-    // 5.1.4.1.28.27
-    const primariesValue = primaries === 'bt709'
-        ? 1
-        : primaries === 'smpte170m'
-            ? 6
-            : primaries === 'bt470bg'
-                ? 5
-                : 2;
-    const transferChracteristicsValue = transferChracteristics === 'bt709'
-        ? 1
-        : transferChracteristics === 'smpte170m'
-            ? 6
-            : transferChracteristics === 'iec61966-2-1'
-                ? 13
-                : 2;
-    if (matrixCoefficients === 'rgb') {
-        throw new Error('Cannot encode Matroska in RGB');
-    }
-    const matrixCoefficientsValue = matrixCoefficients === 'bt709'
-        ? 1
-        : matrixCoefficients === 'bt470bg'
-            ? 5
-            : matrixCoefficients === 'smpte170m'
-                ? 6
-                : 2;
-    return (0, make_header_1.makeMatroskaBytes)({
-        type: 'Colour',
-        minVintWidth: null,
-        value: [
-            {
-                type: 'TransferCharacteristics',
-                value: {
-                    value: transferChracteristicsValue,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'MatrixCoefficients',
-                value: {
-                    value: matrixCoefficientsValue,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'Primaries',
-                value: {
-                    value: primariesValue,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'Range',
-                value: {
-                    value: rangeValue,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-        ],
-    });
-};
-exports.makeMatroskaColorBytes = makeMatroskaColorBytes;
 const makeMatroskaVideoBytes = ({ color, width, height, }) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'Video',
@@ -106,13 +33,67 @@ const makeMatroskaVideoBytes = ({ color, width, height, }) => {
                 },
                 minVintWidth: null,
             },
-            (0, exports.makeMatroskaColorBytes)(color),
+            (0, color_1.makeMatroskaColorBytes)(color),
         ],
         minVintWidth: null,
     });
 };
 exports.makeMatroskaVideoBytes = makeMatroskaVideoBytes;
-const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChannels: audioChannels, sampleRate, }) => {
+const makeVideoCodecId = (codecId) => {
+    if (codecId === 'vp8') {
+        return 'V_VP8';
+    }
+    if (codecId === 'vp9') {
+        return 'V_VP9';
+    }
+    if (codecId === 'h264') {
+        return 'V_MPEG4/ISO/AVC';
+    }
+    if (codecId === 'av1') {
+        return 'V_AV1';
+    }
+    if (codecId === 'h265') {
+        return 'V_MPEGH/ISO/HEVC';
+    }
+    if (codecId === 'prores') {
+        return 'V_PRORES';
+    }
+    throw new Error(`Unknown codec: ${codecId}`);
+};
+const makeAudioCodecId = (codecId) => {
+    if (codecId === 'opus') {
+        return 'A_OPUS';
+    }
+    if (codecId === 'aac') {
+        return 'A_AAC';
+    }
+    if (codecId === 'mp3') {
+        return 'A_MPEG/L3';
+    }
+    if (codecId === 'vorbis') {
+        return 'A_VORBIS';
+    }
+    if (codecId === 'pcm-u8') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-s16') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-s24') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-s32') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'pcm-f32') {
+        return 'A_PCM/INT/LIT';
+    }
+    if (codecId === 'aiff') {
+        throw new Error('aiff is not supported in Matroska');
+    }
+    throw new Error(`Unknown codec: ${codecId}`);
+};
+const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codec, numberOfChannels, sampleRate, codecPrivate, }) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'TrackEntry',
         minVintWidth: null,
@@ -138,17 +119,9 @@ const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChanne
                 },
                 minVintWidth: null,
             },
-            {
-                type: 'TrackTimestampScale',
-                value: {
-                    value: 1,
-                    size: '64',
-                },
-                minVintWidth: null,
-            },
             {
                 type: 'CodecID',
-                value: codecId,
+                value: makeAudioCodecId(codec),
                 minVintWidth: null,
             },
             {
@@ -158,7 +131,7 @@ const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChanne
                         type: 'Channels',
                         minVintWidth: null,
                         value: {
-                            value: audioChannels,
+                            value: numberOfChannels,
                             byteLength: null,
                         },
                     },
@@ -181,11 +154,18 @@ const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChanne
                 ],
                 minVintWidth: null,
             },
-        ],
+            codecPrivate
+                ? {
+                    type: 'CodecPrivate',
+                    minVintWidth: null,
+                    value: codecPrivate,
+                }
+                : null,
+        ].filter(Boolean),
     });
 };
 exports.makeMatroskaAudioTrackEntryBytes = makeMatroskaAudioTrackEntryBytes;
-const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuration, trackNumber, codecId, }) => {
+const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, trackNumber, codec, codecPrivate, }) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'TrackEntry',
         minVintWidth: null,
@@ -226,7 +206,7 @@ const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuratio
             },
             {
                 type: 'CodecID',
-                value: codecId,
+                value: makeVideoCodecId(codec),
                 minVintWidth: null,
             },
             {
@@ -237,20 +217,19 @@ const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuratio
                 },
                 minVintWidth: null,
             },
-            {
-                type: 'DefaultDuration',
-                value: {
-                    value: defaultDuration,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
             (0, exports.makeMatroskaVideoBytes)({
                 color,
                 width,
                 height,
             }),
-        ],
+            codecPrivate
+                ? {
+                    type: 'CodecPrivate',
+                    minVintWidth: null,
+                    value: codecPrivate,
+                }
+                : null,
+        ].filter(Boolean),
     });
 };
 exports.makeMatroskaVideoTrackEntryBytes = makeMatroskaVideoTrackEntryBytes;
@@ -259,8 +238,6 @@ const makeMatroskaTracks = (tracks) => {
         type: 'Tracks',
         value: tracks,
         minVintWidth: null,
-    }), 
-    // TODO: That's too much padding
-    1000);
+    }), 500);
 };
 exports.makeMatroskaTracks = makeMatroskaTracks;

package/dist/emit-available-info.d.ts

@@ -0,0 +1,12 @@
+import type { AllParseMediaFields, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaResult } from './options';
+import type { ParseResult } from './parse-result';
+import type { ParserState } from './parser-state';
+export declare const emitAvailableInfo: ({ hasInfo, parseResult, moreFields, state, returnValue, contentLength, name, }: {
+    hasInfo: Record<keyof Options<ParseMediaFields>, boolean>;
+    parseResult: ParseResult;
+    moreFields: ParseMediaCallbacks<AllParseMediaFields>;
+    state: ParserState;
+    returnValue: ParseMediaResult<AllParseMediaFields>;
+    contentLength: number | null;
+    name: string;
+}) => void;

package/dist/emit-available-info.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitAvailableInfo = void 0;
+const get_audio_codec_1 = require("./get-audio-codec");
+const get_container_1 = require("./get-container");
+const get_dimensions_1 = require("./get-dimensions");
+const get_duration_1 = require("./get-duration");
+const get_fps_1 = require("./get-fps");
+const get_tracks_1 = require("./get-tracks");
+const get_video_codec_1 = require("./get-video-codec");
+const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValue, contentLength, name, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    const keys = Object.keys(hasInfo);
+    for (const key of keys) {
+        if (key === 'boxes') {
+            if (hasInfo.boxes && returnValue.boxes === undefined) {
+                (_a = moreFields.onBoxes) === null || _a === void 0 ? void 0 : _a.call(moreFields, parseResult.segments);
+                returnValue.boxes = parseResult.segments;
+            }
+            continue;
+        }
+        if (key === 'durationInSeconds') {
+            if (hasInfo.durationInSeconds &&
+                returnValue.durationInSeconds === undefined) {
+                const durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments, state);
+                (_b = moreFields.onDurationInSeconds) === null || _b === void 0 ? void 0 : _b.call(moreFields, durationInSeconds);
+                returnValue.durationInSeconds = durationInSeconds;
+            }
+            continue;
+        }
+        if (key === 'dimensions') {
+            if (hasInfo.dimensions && returnValue.dimensions === undefined) {
+                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+                const dimensions = {
+                    height: dimensionsQueried.height,
+                    width: dimensionsQueried.width,
+                };
+                (_c = moreFields.onDimensions) === null || _c === void 0 ? void 0 : _c.call(moreFields, dimensions);
+                returnValue.dimensions = dimensions;
+            }
+            continue;
+        }
+        if (key === 'unrotatedDimensions') {
+            if (returnValue.unrotatedDimensions === undefined &&
+                hasInfo.unrotatedDimensions) {
+                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+                const unrotatedDimensions = {
+                    height: dimensionsQueried.unrotatedHeight,
+                    width: dimensionsQueried.unrotatedWidth,
+                };
+                (_d = moreFields.onUnrotatedDimensions) === null || _d === void 0 ? void 0 : _d.call(moreFields, unrotatedDimensions);
+                returnValue.unrotatedDimensions = unrotatedDimensions;
+            }
+            continue;
+        }
+        if (key === 'rotation') {
+            if (returnValue.rotation === undefined && hasInfo.rotation) {
+                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+                const { rotation } = dimensionsQueried;
+                (_e = moreFields.onRotation) === null || _e === void 0 ? void 0 : _e.call(moreFields, rotation);
+                returnValue.rotation = rotation;
+            }
+            continue;
+        }
+        if (key === 'fps') {
+            if (returnValue.fps === undefined && hasInfo.fps) {
+                const fps = (0, get_fps_1.getFps)(parseResult.segments);
+                (_f = moreFields.onFps) === null || _f === void 0 ? void 0 : _f.call(moreFields, fps);
+                returnValue.fps = fps;
+            }
+            continue;
+        }
+        if (key === 'videoCodec') {
+            if (returnValue.videoCodec === undefined && hasInfo.videoCodec) {
+                const videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments);
+                (_g = moreFields.onVideoCodec) === null || _g === void 0 ? void 0 : _g.call(moreFields, videoCodec);
+                returnValue.videoCodec = videoCodec;
+            }
+            continue;
+        }
+        if (key === 'audioCodec') {
+            if (returnValue.audioCodec === undefined && hasInfo.audioCodec) {
+                const audioCodec = (0, get_audio_codec_1.getAudioCodec)(parseResult.segments, state);
+                (_h = moreFields.onAudioCodec) === null || _h === void 0 ? void 0 : _h.call(moreFields, audioCodec);
+                returnValue.audioCodec = audioCodec;
+            }
+            continue;
+        }
+        if (key === 'tracks') {
+            if (hasInfo.tracks &&
+                returnValue.videoTracks === undefined &&
+                returnValue.audioTracks === undefined) {
+                const { videoTracks, audioTracks } = (0, get_tracks_1.getTracks)(parseResult.segments, state);
+                (_j = moreFields.onTracks) === null || _j === void 0 ? void 0 : _j.call(moreFields, { videoTracks, audioTracks });
+                returnValue.videoTracks = videoTracks;
+                returnValue.audioTracks = audioTracks;
+            }
+            continue;
+        }
+        if (key === 'internalStats') {
+            if (hasInfo.internalStats && returnValue.internalStats === undefined) {
+                const internalStats = state.getInternalStats();
+                (_k = moreFields.onInternalStats) === null || _k === void 0 ? void 0 : _k.call(moreFields, internalStats);
+                returnValue.internalStats = internalStats;
+            }
+            continue;
+        }
+        if (key === 'size') {
+            if (returnValue.size === undefined && hasInfo.size) {
+                (_l = moreFields.onSize) === null || _l === void 0 ? void 0 : _l.call(moreFields, contentLength);
+                returnValue.size = contentLength;
+            }
+            continue;
+        }
+        if (key === 'name') {
+            if (returnValue.name === undefined && hasInfo.name) {
+                (_m = moreFields.onName) === null || _m === void 0 ? void 0 : _m.call(moreFields, name);
+                returnValue.name = name;
+            }
+            continue;
+        }
+        if (key === 'container') {
+            if (returnValue.container === undefined && hasInfo.container) {
+                const container = (0, get_container_1.getContainer)(parseResult.segments);
+                (_o = moreFields.onContainer) === null || _o === void 0 ? void 0 : _o.call(moreFields, container);
+                returnValue.container = container;
+            }
+            continue;
+        }
+        throw new Error(`Unhandled key: ${key}`);
+    }
+};
+exports.emitAvailableInfo = emitAvailableInfo;

package/dist/esm/buffer.mjs

@@ -0,0 +1,57 @@
+// src/writers/buffer.ts
+var createContent = () => {
+  const buf = new ArrayBuffer(0, {
+    maxByteLength: 1e8
+  });
+  if (!buf.resize) {
+    throw new Error("Could not create buffer writer");
+  }
+  let data = new Uint8Array(buf);
+  const write = (newData) => {
+    const oldLength = buf.byteLength;
+    const newLength = oldLength + newData.byteLength;
+    buf.resize(newLength);
+    const newArray = new Uint8Array(buf);
+    newArray.set(newData, oldLength);
+    data = newArray;
+  };
+  const updateDataAt = (position, newData) => {
+    const newArray = new Uint8Array(buf);
+    newArray.set(newData, position);
+    data = newArray;
+  };
+  let writPromise = Promise.resolve();
+  let removed = false;
+  const writer = {
+    write: (arr) => {
+      writPromise = writPromise.then(() => write(arr));
+      return writPromise;
+    },
+    save: () => {
+      if (removed) {
+        return Promise.reject(new Error("Already called .remove() on the result"));
+      }
+      return Promise.resolve(new File([data], "hithere", {}));
+    },
+    remove() {
+      removed = true;
+      data = new Uint8Array(0);
+      return Promise.resolve();
+    },
+    getWrittenByteCount: () => buf.byteLength,
+    updateDataAt: (position, newData) => {
+      writPromise = writPromise.then(() => updateDataAt(position, newData));
+      return writPromise;
+    },
+    waitForFinish: async () => {
+      await writPromise;
+    }
+  };
+  return Promise.resolve(writer);
+};
+var bufferWriter = {
+  createContent
+};
+export {
+  bufferWriter
+};