@remotion/media-parser 4.0.272 → 4.0.273

package/dist/containers/iso-base-media/get-seeking-from-mp4.d.ts

@@ -0,0 +1,5 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { IsoBaseMediaSeekingInfo, SeekingInfo } from '../../seeking-info';
+import type { ParserState } from '../../state/parser-state';
+export declare const getSeekingInfoFromMp4: (state: ParserState) => SeekingInfo | null;
+export declare const getSeekingByteFromIsoBaseMedia: (info: IsoBaseMediaSeekingInfo, time: number) => SamplePosition;

package/dist/containers/iso-base-media/get-seeking-from-mp4.js

@@ -0,0 +1,50 @@
+import { getTracksFromMoovBox } from '../../get-tracks';
+import { getSamplePositionsFromTrack } from './get-sample-positions-from-track';
+import { getMoofBoxes, getMoovBoxFromState } from './traversal';
+export const getSeekingInfoFromMp4 = (state) => {
+    const structure = state.getIsoStructure();
+    const moovAtom = getMoovBoxFromState(state);
+    const moofBoxes = getMoofBoxes(structure.boxes);
+    if (!moovAtom) {
+        return null;
+    }
+    return {
+        type: 'iso-base-media-seeking-info',
+        moovBox: moovAtom,
+        moofBoxes,
+    };
+};
+export const getSeekingByteFromIsoBaseMedia = (info, time) => {
+    const tracks = getTracksFromMoovBox(info.moovBox);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    let byte = 0;
+    let sam = null;
+    for (const t of allTracks) {
+        const { timescale: ts, type } = t;
+        if (type !== 'video') {
+            continue;
+        }
+        const samplePositions = getSamplePositionsFromTrack({
+            trakBox: t.trakBox,
+            moofBoxes: info.moofBoxes,
+        });
+        for (const sample of samplePositions) {
+            const timestamp = sample.cts / ts;
+            if (timestamp <= time &&
+                byte < sample.offset &&
+                type === 'video' &&
+                sample.isKeyframe) {
+                byte = sample.offset;
+                sam = sample;
+            }
+        }
+    }
+    if (!sam) {
+        throw new Error('No sample found');
+    }
+    return sam;
+};

package/dist/esm/index.mjs

@@ -13001,7 +13001,7 @@ var downloadAndParseMedia = async (options) => {
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.272";
+var VERSION = "4.0.273";
 
 // src/index.ts
 var MediaParserInternals = {

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/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/version.d.ts

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

package/dist/version.js

@@ -1,2 +1,2 @@
 // Automatically generated on publish
-export const VERSION = '4.0.272';
+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.272",
+  "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.272",
-    "@remotion/eslint-config-internal": "4.0.272"
+    "@remotion/eslint-config-internal": "4.0.273",
+    "@remotion/example-videos": "4.0.273"
   },
   "publishConfig": {
     "access": "public"