@remotion/media-parser 4.0.209 → 4.0.210

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,
@@ -148,7 +129,7 @@ const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChanne
             },
             {
                 type: 'CodecID',
-                value: codecId,
+                value: makeAudioCodecId(codec),
                 minVintWidth: null,
             },
             {
@@ -158,7 +139,7 @@ const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChanne
                         type: 'Channels',
                         minVintWidth: null,
                         value: {
-                            value: audioChannels,
+                            value: numberOfChannels,
                             byteLength: null,
                         },
                     },
@@ -181,11 +162,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 +214,7 @@ const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuratio
             },
             {
                 type: 'CodecID',
-                value: codecId,
+                value: makeVideoCodecId(codec),
                 minVintWidth: null,
             },
             {
@@ -237,20 +225,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 +246,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
+};

package/dist/esm/from-fetch.mjs

@@ -0,0 +1,72 @@
+// src/readers/from-fetch.ts
+var fetchReader = {
+  read: async (src, range, signal) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `fetchReader`");
+    }
+    const resolvedUrl = typeof window !== "undefined" && typeof window.location !== "undefined" ? new URL(src, window.location.origin).toString() : src;
+    if (!resolvedUrl.startsWith("https://") && !resolvedUrl.startsWith("blob:") && !resolvedUrl.startsWith("http://")) {
+      return Promise.reject(new Error(resolvedUrl + " is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass `reader: nodeReader` to parseMedia()."));
+    }
+    const controller = new AbortController;
+    const res = await fetch(resolvedUrl, {
+      headers: range === null ? {} : typeof range === "number" ? {
+        Range: `bytes=${range}`
+      } : {
+        Range: `bytes=${`${range[0]}-${range[1]}`}`
+      },
+      signal: controller.signal,
+      cache: "no-store"
+    });
+    signal?.addEventListener("abort", () => {
+      controller.abort();
+    }, { once: true });
+    if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
+      throw new Error(`Server returned status code ${res.status} for ${src}`);
+    }
+    if (!res.body) {
+      throw new Error("No body");
+    }
+    const length = res.headers.get("content-length");
+    const contentLength = length === null ? null : parseInt(length, 10);
+    const contentDisposition = res.headers.get("content-disposition");
+    const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
+    const fallbackName = src.split("/").pop();
+    const reader = res.body.getReader();
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        reader.cancel().catch(() => {
+        });
+      }, { once: true });
+    }
+    return {
+      reader: {
+        reader,
+        abort: () => {
+          controller.abort();
+        }
+      },
+      contentLength,
+      name: name ?? fallbackName
+    };
+  },
+  getLength: async (src) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `fetchReader`");
+    }
+    const res = await fetch(src, {
+      method: "HEAD"
+    });
+    if (!res.body) {
+      throw new Error("No body");
+    }
+    const length = res.headers.get("content-length");
+    if (!length) {
+      throw new Error("No content-length");
+    }
+    return parseInt(length, 10);
+  }
+};
+export {
+  fetchReader
+};

package/dist/esm/from-node.mjs

@@ -0,0 +1,48 @@
+// src/readers/from-node.ts
+import {createReadStream} from "fs";
+import {stat} from "node:fs/promises";
+import {Readable} from "stream";
+var nodeReader = {
+  read: async (src, range, signal) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `nodeReader`");
+    }
+    const controller = new AbortController;
+    const stream = createReadStream(src, {
+      start: range === null ? 0 : typeof range === "number" ? range : range[0],
+      end: range === null ? Infinity : typeof range === "number" ? Infinity : range[1],
+      signal: controller.signal
+    });
+    signal?.addEventListener("abort", () => {
+      controller.abort();
+    }, { once: true });
+    const stats = await stat(src);
+    const reader = Readable.toWeb(stream).getReader();
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        reader.cancel().catch(() => {
+        });
+      }, { once: true });
+    }
+    return {
+      reader: {
+        reader,
+        abort: () => {
+          controller.abort();
+        }
+      },
+      contentLength: stats.size,
+      name: src.split("/").pop()
+    };
+  },
+  getLength: async (src) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `nodeReader`");
+    }
+    const stats = await stat(src);
+    return stats.size;
+  }
+};
+export {
+  nodeReader
+};

package/dist/esm/from-web-file.mjs

@@ -0,0 +1,48 @@
+// src/readers/from-web-file.ts
+var webFileReader = {
+  read: (file, range, signal) => {
+    if (typeof file === "string") {
+      throw new Error("`inputTypeFileReader` only supports `File` objects");
+    }
+    const part = range === null ? file : typeof range === "number" ? file.slice(range) : file.slice(range[0], range[1]);
+    const reader = new FileReader;
+    reader.readAsArrayBuffer(file);
+    const controller = new AbortController;
+    if (controller) {
+      controller.signal.addEventListener("abort", () => {
+        reader.abort();
+      }, { once: true });
+    }
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        controller.abort();
+      }, { once: true });
+    }
+    return new Promise((resolve, reject) => {
+      reader.onload = () => {
+        resolve({
+          reader: {
+            reader: part.stream().getReader(),
+            abort() {
+              controller.abort();
+            }
+          },
+          contentLength: file.size,
+          name: file.name
+        });
+      };
+      reader.onerror = (error) => {
+        reject(error);
+      };
+    });
+  },
+  getLength: (src) => {
+    if (typeof src === "string") {
+      throw new Error("`inputTypeFileReader` only supports `File` objects");
+    }
+    return Promise.resolve(src.size);
+  }
+};
+export {
+  webFileReader
+};