@remotion/media-parser 4.0.231 → 4.0.232

package/dist/parse-result.d.ts

@@ -25,24 +25,38 @@ import type { TkhdBox } from './boxes/iso-base-media/tkhd';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { TrunBox } from './boxes/iso-base-media/trun';
 import type { VoidBox } from './boxes/iso-base-media/void-box';
+import type { RiffBox } from './boxes/riff/riff-box';
 import type { MatroskaSegment } from './boxes/webm/segments';
 export interface RegularBox extends BaseBox {
     boxType: string;
     boxSize: number;
-    children: AnySegment[];
+    children: IsoBaseMediaBox[];
     offset: number;
     type: 'regular-box';
 }
 export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | ColorParameterBox | TfdtBox | TfhdBox;
-export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
-export type ParseResult = {
+export type AnySegment = MatroskaSegment | IsoBaseMediaBox | RiffBox;
+export type IsoBaseMediaStructure = {
+    type: 'iso-base-media';
+    boxes: IsoBaseMediaBox[];
+};
+export type RiffStructure = {
+    type: 'riff';
+    boxes: RiffBox[];
+};
+export type MatroskaStructure = {
+    type: 'matroska';
+    boxes: MatroskaSegment[];
+};
+export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure;
+export type ParseResult<TStructure extends Structure> = {
     status: 'done';
-    segments: AnySegment[];
+    segments: TStructure;
 } | {
     status: 'incomplete';
-    segments: AnySegment[];
+    segments: TStructure;
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult>;
+    continueParsing: () => Promise<ParseResult<TStructure>>;
 };
 export type MatroskaParseResult = {
     status: 'done';

package/dist/parse-video.d.ts

@@ -1,6 +1,6 @@
 import type { BufferIterator } from './buffer-iterator';
 import { type LogLevel } from './log';
-import type { IsoBaseMediaBox, ParseResult } from './parse-result';
+import type { IsoBaseMediaBox, ParseResult, Structure } from './parse-result';
 import type { ParserContext } from './parser-context';
 export type PartialMdatBox = {
     type: 'partial-mdat-box';
@@ -20,4 +20,4 @@ export declare const parseVideo: ({ iterator, options, signal, logLevel, }: {
     options: ParserContext;
     signal: AbortSignal | null;
     logLevel: LogLevel;
-}) => Promise<ParseResult>;
+}) => Promise<ParseResult<Structure>>;

package/dist/parse-video.js

@@ -2,30 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVideo = void 0;
 const process_box_1 = require("./boxes/iso-base-media/process-box");
+const parse_box_1 = require("./boxes/riff/parse-box");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
 const log_1 = require("./log");
 const parseVideo = ({ iterator, options, signal, logLevel, }) => {
     if (iterator.bytesRemaining() === 0) {
-        return Promise.resolve({
-            status: 'incomplete',
-            segments: [],
-            continueParsing: () => {
-                return (0, exports.parseVideo)({
-                    iterator,
-                    options,
-                    signal,
-                    logLevel,
-                });
-            },
-            skipTo: null,
-        });
+        return Promise.reject(new Error('no bytes'));
     }
     if (iterator.isRiff()) {
-        throw new Error('AVI files are not yet supported');
+        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options }));
     }
     if (iterator.isIsoBaseMedia()) {
         log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
-        return (0, process_box_1.parseBoxes)({
+        return (0, process_box_1.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: Infinity,
             allowIncompleteBoxes: true,
@@ -38,7 +27,7 @@ const parseVideo = ({ iterator, options, signal, logLevel, }) => {
     }
     if (iterator.isWebm()) {
         log_1.Log.verbose(logLevel, 'Detected Matroska container');
-        return Promise.resolve((0, parse_webm_header_1.parseWebm)(iterator, options));
+        return (0, parse_webm_header_1.parseWebm)(iterator, options);
     }
     if (iterator.isMp3()) {
         return Promise.reject(new Error('MP3 files are not yet supported'));

package/dist/parser-context.d.ts

@@ -7,4 +7,5 @@ export type ParserContext = {
     parserState: ParserState;
     nullifySamples: boolean;
     supportsContentRange: boolean;
+    nextTrackIndex: number;
 };

package/dist/parser-state.d.ts

@@ -1,13 +1,21 @@
+import type { AvcPPs, AvcProfileInfo } from './boxes/avc/parse-avc';
 import type { OnTrackEntrySegment } from './boxes/webm/segments';
 import type { TrackInfo } from './boxes/webm/segments/track-entry';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from './webcodec-sample-types';
 export type InternalStats = {};
+export type SpsAndPps = {
+    sps: AvcProfileInfo;
+    pps: AvcPPs;
+};
+type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
 export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, signal, }: {
     hasAudioCallbacks: boolean;
     hasVideoCallbacks: boolean;
     signal: AbortSignal | undefined;
 }) => {
     onTrackEntrySegment: OnTrackEntrySegment;
+    onProfile: (profile: SpsAndPps) => Promise<void>;
+    registerOnAvcProfileCallback: (callback: AvcProfileInfoCallback) => void;
     getTrackInfoByNumber: (id: number) => TrackInfo;
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     setTimestampOffset: (byteOffset: number, timestamp: number) => void;
@@ -18,5 +26,8 @@ export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, s
     getInternalStats: () => {};
     getTimescale: () => number;
     setTimescale: (newTimescale: number) => void;
+    getSamplesForTrack: (trackId: number) => number;
+    getAvcProfile: () => SpsAndPps | null;
 };
 export type ParserState = ReturnType<typeof makeParserState>;
+export {};

package/dist/parser-state.js

@@ -59,8 +59,23 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
         }
         return timestampMap.get(byteOffset);
     };
+    const samplesForTrack = {};
+    const profileCallbacks = [];
+    const registerOnAvcProfileCallback = (callback) => {
+        profileCallbacks.push(callback);
+    };
+    let avcProfile = null;
+    const onProfile = async (profile) => {
+        avcProfile = profile;
+        for (const callback of profileCallbacks) {
+            await callback(profile);
+        }
+        profileCallbacks.length = 0;
+    };
     return {
         onTrackEntrySegment,
+        onProfile,
+        registerOnAvcProfileCallback,
         getTrackInfoByNumber: (id) => trackEntries[id],
         registerVideoSampleCallback: async (id, callback) => {
             var _a;
@@ -94,6 +109,10 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new Error('Aborted');
             }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            samplesForTrack[trackId]++;
             const callback = audioSampleCallbacks[trackId];
             if (callback) {
                 await callback(audioSample);
@@ -111,6 +130,10 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new Error('Aborted');
             }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            samplesForTrack[trackId]++;
             const callback = videoSampleCallbacks[trackId];
             if (callback) {
                 await callback(videoSample);
@@ -127,6 +150,13 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
         getInternalStats: () => ({}),
         getTimescale,
         setTimescale,
+        getSamplesForTrack: (trackId) => {
+            var _a;
+            return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
+        },
+        getAvcProfile: () => {
+            return avcProfile;
+        },
     };
 };
 exports.makeParserState = makeParserState;

package/dist/readers/from-node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeReader = void 0;
 const fs_1 = require("fs");
 const promises_1 = require("node:fs/promises");
+const path_1 = require("path");
 const stream_1 = require("stream");
 exports.nodeReader = {
     read: async (src, range, signal) => {
@@ -37,7 +38,7 @@ exports.nodeReader = {
                 },
             },
             contentLength: stats.size,
-            name: src.split('/').pop(),
+            name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
         };
     },

package/dist/register-track.d.ts

@@ -0,0 +1,13 @@
+import type { Track, VideoTrack } from './get-tracks';
+import type { ParserContext } from './parser-context';
+import type { ParserState } from './parser-state';
+export declare const registerTrack: ({ state, options, track, }: {
+    state: ParserState;
+    options: ParserContext;
+    track: Track;
+}) => Promise<void>;
+export declare const registerVideoTrackWhenProfileIsAvailable: ({ options, state, track, }: {
+    state: ParserState;
+    options: ParserContext;
+    track: VideoTrack;
+}) => void;

package/dist/register-track.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVideoTrackWhenProfileIsAvailable = exports.registerTrack = void 0;
+const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
+const registerTrack = async ({ state, options, track, }) => {
+    if (track.type === 'video' && options.onVideoTrack) {
+        const callback = await options.onVideoTrack(track);
+        await state.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+    if (track.type === 'audio' && options.onAudioTrack) {
+        const callback = await options.onAudioTrack(track);
+        await state.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+};
+exports.registerTrack = registerTrack;
+const registerVideoTrackWhenProfileIsAvailable = ({ options, state, track, }) => {
+    state.registerOnAvcProfileCallback(async (profile) => {
+        await (0, exports.registerTrack)({
+            options,
+            state,
+            track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
+        });
+    });
+};
+exports.registerVideoTrackWhenProfileIsAvailable = registerVideoTrackWhenProfileIsAvailable;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.231";
+export declare const VERSION = "4.0.232";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.231';
+exports.VERSION = '4.0.232';

package/package.json

@@ -3,14 +3,14 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.231",
+  "version": "4.0.232",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.231",
-    "@remotion/eslint-config-internal": "4.0.231"
+    "@remotion/example-videos": "4.0.232",
+    "@remotion/eslint-config-internal": "4.0.232"
   },
   "publishConfig": {
     "access": "public"