@remotion/media-parser 4.0.271 → 4.0.273

package/dist/fields.d.ts

@@ -0,0 +1,63 @@
+export type ParseMediaFields = {
+    dimensions: boolean;
+    durationInSeconds: boolean;
+    slowDurationInSeconds: boolean;
+    structure: boolean;
+    fps: boolean;
+    slowFps: boolean;
+    videoCodec: boolean;
+    audioCodec: boolean;
+    tracks: boolean;
+    rotation: boolean;
+    unrotatedDimensions: boolean;
+    internalStats: boolean;
+    size: boolean;
+    name: boolean;
+    container: boolean;
+    isHdr: boolean;
+    metadata: boolean;
+    location: boolean;
+    mimeType: boolean;
+    keyframes: boolean;
+    slowKeyframes: boolean;
+    slowNumberOfFrames: boolean;
+    slowVideoBitrate: boolean;
+    slowAudioBitrate: boolean;
+    images: boolean;
+    sampleRate: boolean;
+    numberOfAudioChannels: boolean;
+    m3uStreams: boolean;
+    seekingInfo: boolean;
+};
+export type AllOptions<Fields extends ParseMediaFields> = {
+    dimensions: Fields['dimensions'];
+    durationInSeconds: Fields['durationInSeconds'];
+    slowDurationInSeconds: Fields['slowDurationInSeconds'];
+    slowFps: Fields['slowFps'];
+    structure: Fields['structure'];
+    fps: Fields['fps'];
+    videoCodec: Fields['videoCodec'];
+    audioCodec: Fields['audioCodec'];
+    tracks: Fields['tracks'];
+    rotation: Fields['rotation'];
+    unrotatedDimensions: Fields['unrotatedDimensions'];
+    internalStats: Fields['internalStats'];
+    size: Fields['size'];
+    name: Fields['name'];
+    container: Fields['container'];
+    isHdr: Fields['isHdr'];
+    metadata: Fields['metadata'];
+    location: Fields['location'];
+    mimeType: Fields['mimeType'];
+    keyframes: Fields['keyframes'];
+    slowKeyframes: Fields['slowKeyframes'];
+    slowNumberOfFrames: Fields['slowNumberOfFrames'];
+    images: Fields['images'];
+    sampleRate: Fields['sampleRate'];
+    numberOfAudioChannels: Fields['numberOfAudioChannels'];
+    slowVideoBitrate: Fields['slowVideoBitrate'];
+    slowAudioBitrate: Fields['slowAudioBitrate'];
+    m3uStreams: Fields['m3uStreams'];
+    seekingInfo: Fields['seekingInfo'];
+};
+export type Options<Fields extends ParseMediaFields> = Partial<AllOptions<Fields>>;

package/dist/fields.js

@@ -0,0 +1 @@
+export {};

package/dist/get-seeking-info.d.ts

@@ -0,0 +1,5 @@
+import type { SeekingInfo } from './seeking-info';
+import type { ParserState } from './state/parser-state';
+export declare const getSeekingInfo: (state: ParserState) => SeekingInfo | null;
+export declare const hasSeekingInfo: (state: ParserState) => boolean;
+export declare const getSeekingByte: (info: SeekingInfo, time: number) => number;

package/dist/get-seeking-info.js

@@ -0,0 +1,24 @@
+import { getSeekingByteFromIsoBaseMedia, getSeekingInfoFromMp4, } from './containers/iso-base-media/get-seeking-from-mp4';
+export const getSeekingInfo = (state) => {
+    const structure = state.getStructureOrNull();
+    if (!structure) {
+        return null;
+    }
+    if (structure.type === 'iso-base-media') {
+        return getSeekingInfoFromMp4(state);
+    }
+    return null;
+};
+export const hasSeekingInfo = (state) => {
+    const structure = state.getStructureOrNull();
+    if (structure && structure.type === 'iso-base-media') {
+        return Boolean(getSeekingInfoFromMp4(state));
+    }
+    return false;
+};
+export const getSeekingByte = (info, time) => {
+    if (info.type === 'iso-base-media-seeking-info') {
+        return getSeekingByteFromIsoBaseMedia(info, time).offset;
+    }
+    throw new Error(`Unknown seeking info type: ${info.type}`);
+};

package/dist/index.d.ts

@@ -940,6 +940,7 @@ export declare const MediaParserInternals: {
             hasFinishedManifest: () => boolean;
             setM3uStreamRun: (playlistUrl: string, run: import("./state/m3u-state").ExistingM3uRun | null) => void;
             setTracksDone: (playlistUrl: string) => boolean;
+            getTrackDone: (playlistUrl: string) => boolean;
             getM3uStreamRun: (playlistUrl: string) => import("./state/m3u-state").ExistingM3uRun;
             abortM3UStreamRuns: () => void;
             setAssociatedPlaylists: (playlists: import("./containers/m3u/get-streams").M3uAssociatedPlaylist[]) => void;
@@ -949,6 +950,8 @@ export declare const MediaParserInternals: {
                 addToStreamWithTrack: (src: string) => void;
                 addVideoStreamToConsider: (src: string, callback: import("./webcodec-sample-types").OnVideoSample) => void;
                 addAudioStreamToConsider: (src: string, callback: import("./webcodec-sample-types").OnAudioSample) => void;
+                hasAudioStreamToConsider: (src: string) => boolean;
+                hasVideoStreamToConsider: (src: string) => boolean;
                 addAudioSample: (src: string, sample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
                 addVideoSample: (src: string, sample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
                 getNextStreamToRun: (streams: string[]) => string;

package/dist/seeking-info.d.ts

@@ -0,0 +1,8 @@
+import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
+import type { MoovBox } from './containers/iso-base-media/moov/moov';
+export type IsoBaseMediaSeekingInfo = {
+    type: 'iso-base-media-seeking-info';
+    moovBox: MoovBox;
+    moofBoxes: IsoBaseMediaBox[];
+};
+export type SeekingInfo = IsoBaseMediaSeekingInfo;

package/dist/seeking-info.js

@@ -0,0 +1 @@
+export {};

package/dist/state/has-tracks-section.d.ts

@@ -1,8 +1,8 @@
 import type { Track } from '../get-tracks';
 import type { LogLevel } from '../log';
-import type { Options, ParseMediaFields } from '../options';
+import type { Options, ParseMediaFields, ParseMediaSrc } from '../options';
 import type { CanSkipTracksState } from './can-skip-tracks';
-export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksState) => {
+export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksState, src: ParseMediaSrc) => {
     hasAllTracks: () => boolean;
     getIsDone: () => boolean;
     setIsDone: (logLevel: LogLevel) => void;

package/dist/state/has-tracks-section.js

@@ -1,5 +1,5 @@
 import { Log } from '../log';
-export const makeTracksSectionState = (canSkipTracksState) => {
+export const makeTracksSectionState = (canSkipTracksState, src) => {
     const tracks = [];
     let doneWithTracks = false;
     return {
@@ -24,7 +24,9 @@ export const makeTracksSectionState = (canSkipTracksState) => {
                 return;
             }
             if (!doneWithTracks) {
-                throw new Error('Error in Media Parser: End of parsing has been reached, but no tracks have been found');
+                throw new Error('Error in Media Parser: End of parsing of ' +
+                    src +
+                    ' has been reached, but no tracks have been found ');
             }
         },
     };

package/dist/state/m3u-state.d.ts

@@ -31,6 +31,7 @@ export declare const m3uState: (logLevel: LogLevel) => {
     hasFinishedManifest: () => boolean;
     setM3uStreamRun: (playlistUrl: string, run: ExistingM3uRun | null) => void;
     setTracksDone: (playlistUrl: string) => boolean;
+    getTrackDone: (playlistUrl: string) => boolean;
     getM3uStreamRun: (playlistUrl: string) => ExistingM3uRun;
     abortM3UStreamRuns: () => void;
     setAssociatedPlaylists: (playlists: M3uAssociatedPlaylist[]) => void;
@@ -40,6 +41,8 @@ export declare const m3uState: (logLevel: LogLevel) => {
         addToStreamWithTrack: (src: string) => void;
         addVideoStreamToConsider: (src: string, callback: OnVideoSample) => void;
         addAudioStreamToConsider: (src: string, callback: OnAudioSample) => void;
+        hasAudioStreamToConsider: (src: string) => boolean;
+        hasVideoStreamToConsider: (src: string) => boolean;
         addAudioSample: (src: string, sample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
         addVideoSample: (src: string, sample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
         getNextStreamToRun: (streams: string[]) => string;

package/dist/state/m3u-state.js

@@ -62,7 +62,7 @@ export const m3uState = (logLevel) => {
         setHasEmittedDoneWithTracks: (src) => {
             hasEmittedDoneWithTracks[src] = true;
         },
-        hasEmittedDoneWithTracks: (src) => hasEmittedDoneWithTracks[src],
+        hasEmittedDoneWithTracks: (src) => hasEmittedDoneWithTracks[src] !== undefined,
         setReadyToIterateOverM3u: () => {
             readyToIterateOverM3u = true;
         },
@@ -94,6 +94,9 @@ export const m3uState = (logLevel) => {
             const selectedPlaylists = getSelectedPlaylists();
             return selectedPlaylists.every((url) => tracksDone[url]);
         },
+        getTrackDone: (playlistUrl) => {
+            return tracksDone[playlistUrl];
+        },
         getM3uStreamRun: (playlistUrl) => { var _a; return (_a = m3uStreamRuns[playlistUrl]) !== null && _a !== void 0 ? _a : null; },
         abortM3UStreamRuns: () => {
             const values = Object.values(m3uStreamRuns);

package/dist/state/parser-state.d.ts

@@ -226,6 +226,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         hasFinishedManifest: () => boolean;
         setM3uStreamRun: (playlistUrl: string, run: import("./m3u-state").ExistingM3uRun | null) => void;
         setTracksDone: (playlistUrl: string) => boolean;
+        getTrackDone: (playlistUrl: string) => boolean;
         getM3uStreamRun: (playlistUrl: string) => import("./m3u-state").ExistingM3uRun;
         abortM3UStreamRuns: () => void;
         setAssociatedPlaylists: (playlists: import("..").M3uAssociatedPlaylist[]) => void;
@@ -235,6 +236,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             addToStreamWithTrack: (src: string) => void;
             addVideoStreamToConsider: (src: string, callback: import("../webcodec-sample-types").OnVideoSample) => void;
             addAudioStreamToConsider: (src: string, callback: import("../webcodec-sample-types").OnAudioSample) => void;
+            hasAudioStreamToConsider: (src: string) => boolean;
+            hasVideoStreamToConsider: (src: string) => boolean;
             addAudioSample: (src: string, sample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
             addVideoSample: (src: string, sample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
             getNextStreamToRun: (streams: string[]) => string;

package/dist/state/parser-state.js

@@ -54,6 +54,7 @@ export const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers,
             emittedFields,
             slowDurationAndFpsState: slowDurationAndFps,
             structure,
+            src,
         }),
         getInternalStats: () => {
             var _a;

package/dist/state/sample-callbacks.d.ts

@@ -1,10 +1,10 @@
 import type { MediaParserController } from '../media-parser-controller';
-import type { AllOptions, Options, ParseMediaFields } from '../options';
+import type { AllOptions, Options, ParseMediaFields, ParseMediaSrc } from '../options';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
 import { type KeyframesState } from './keyframes';
 import type { SlowDurationAndFpsState } from './slow-duration-fps';
 import type { StructureState } from './structure';
-export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }: {
+export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, }: {
     controller: MediaParserController;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
@@ -13,6 +13,7 @@ export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVi
     emittedFields: AllOptions<ParseMediaFields>;
     slowDurationAndFpsState: SlowDurationAndFpsState;
     structure: StructureState;
+    src: ParseMediaSrc;
 }) => {
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;

package/dist/state/sample-callbacks.js

@@ -1,7 +1,7 @@
 import { makeCanSkipTracksState } from './can-skip-tracks';
 import { makeTracksSectionState } from './has-tracks-section';
 import { needsToIterateOverSamples } from './need-samples-for-fields';
-export const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }) => {
+export const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, }) => {
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
     const queuedAudioSamples = {};
@@ -12,7 +12,7 @@ export const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrac
         hasVideoTrackHandlers,
         structure,
     });
-    const tracksState = makeTracksSectionState(canSkipTracksState);
+    const tracksState = makeTracksSectionState(canSkipTracksState, src);
     const samplesForTrack = {};
     return {
         registerVideoSampleCallback: async (id, callback) => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.271";
+export declare const VERSION = "4.0.273";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Automatically generated on publish
-export const VERSION = '4.0.271';
+export const VERSION = '4.0.273';

package/package.json

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