@remotion/media-parser 4.0.250 → 4.0.252

package/dist/esm/node.mjs

@@ -0,0 +1,113 @@
+// src/writers/node.ts
+import fs from "node:fs";
+
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
+// src/writers/node.ts
+var createContent = (filename) => {
+  return async ({ logLevel }) => {
+    let writPromise = Promise.resolve();
+    const remove = async () => {
+      Log.verbose(logLevel, "Removing file", filename);
+      await fs.promises.unlink(filename).catch(() => {
+      });
+    };
+    await remove();
+    if (!fs.existsSync(filename)) {
+      Log.verbose(logLevel, "Creating file", filename);
+      fs.writeFileSync(filename, "");
+    }
+    const writeStream = fs.openSync(filename, "w");
+    let written = 0;
+    const write = async (data) => {
+      await new Promise((resolve, reject) => {
+        fs.write(writeStream, data, 0, data.length, undefined, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          Log.verbose(logLevel, "Wrote", data.length, "bytes to", filename);
+          resolve();
+        });
+      });
+      written += data.byteLength;
+    };
+    const updateDataAt = (position, data) => {
+      return new Promise((resolve, reject) => {
+        fs.write(writeStream, data, 0, data.length, position, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          Log.verbose(logLevel, "Wrote", data.length, "bytes to", filename, "at position", position);
+          resolve();
+        });
+      });
+    };
+    const writer = {
+      write: (arr) => {
+        writPromise = writPromise.then(() => write(arr));
+        return writPromise;
+      },
+      updateDataAt: (position, data) => {
+        writPromise = writPromise.then(() => updateDataAt(position, data));
+        return writPromise;
+      },
+      getWrittenByteCount: () => written,
+      remove,
+      finish: async () => {
+        await writPromise;
+        try {
+          Log.verbose(logLevel, "Closing file", filename);
+          fs.closeSync(writeStream);
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      },
+      getBlob: async () => {
+        const file = await fs.promises.readFile(filename);
+        return new Blob([file]);
+      }
+    };
+    return writer;
+  };
+};
+var nodeWriter = (path) => {
+  return { createContent: createContent(path) };
+};
+export {
+  nodeWriter
+};

package/dist/file-types/detect-file-type.d.ts

@@ -12,6 +12,7 @@ export declare const isTransportStream: (data: Uint8Array) => boolean;
 export declare const isMp3: (data: Uint8Array) => boolean;
 export declare const isGif: (data: Uint8Array) => boolean;
 export declare const isAac: (data: Uint8Array) => boolean;
+export declare const isFlac: (data: Uint8Array) => boolean;
 export type RiffType = {
     type: 'riff';
 };
@@ -36,7 +37,10 @@ export type WavType = {
 export type GifType = {
     type: 'gif';
 };
+export type FlacType = {
+    type: 'flac';
+};
 export type UnknownType = {
     type: 'unknown';
 };
-export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | UnknownType;
+export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | FlacType | UnknownType;

package/dist/file-types/detect-file-type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAac = exports.isGif = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
+exports.isFlac = exports.isAac = exports.isGif = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
 const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
 const matchesPattern = (pattern) => {
     return (data) => {
@@ -63,3 +63,8 @@ const isAac = (data) => {
     return (0, exports.matchesPattern)(aacPattern)(data.subarray(0, 2));
 };
 exports.isAac = isAac;
+const isFlac = (data) => {
+    const flacPattern = new Uint8Array([0x66, 0x4c, 0x61, 0x43]);
+    return (0, exports.matchesPattern)(flacPattern)(data.subarray(0, 4));
+};
+exports.isFlac = isFlac;

package/dist/file-types/index.js

@@ -17,6 +17,9 @@ const detectFileType = (data) => {
     if ((0, detect_file_type_1.isAac)(data)) {
         return { type: 'aac' };
     }
+    if ((0, detect_file_type_1.isFlac)(data)) {
+        return { type: 'flac' };
+    }
     const webp = (0, webp_1.isWebp)(data);
     if (webp) {
         return webp;

package/dist/get-audio-codec.d.ts

@@ -1,10 +1,9 @@
-import type { MoovBox } from './boxes/iso-base-media/moov/moov';
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { MoovBox } from './containers/iso-base-media/moov/moov';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import { type MediaParserAudioCodec } from './get-tracks';
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
 export declare const getAudioCodec: (parserState: ParserState) => MediaParserAudioCodec | null;
-export declare const hasAudioCodec: (boxes: Structure, state: ParserState) => boolean;
+export declare const hasAudioCodec: (state: ParserState) => boolean;
 type AudioCodecInfo = {
     format: string;
     primarySpecificator: number | null;

package/dist/get-audio-codec.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioCodecFromTrack = exports.getAudioCodecStringFromTrak = exports.getAudioCodecFromIso = exports.isLpcmAudioCodec = exports.getAudioCodecFromTrak = exports.getSampleRate = exports.getNumberOfChannelsFromTrak = exports.getCodecPrivateFromTrak = exports.hasAudioCodec = exports.getAudioCodec = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
+const traversal_1 = require("./containers/iso-base-media/traversal");
 const get_fps_1 = require("./get-fps");
 const get_tracks_1 = require("./get-tracks");
 const getAudioCodec = (parserState) => {
@@ -22,8 +22,8 @@ const getAudioCodec = (parserState) => {
     return null;
 };
 exports.getAudioCodec = getAudioCodec;
-const hasAudioCodec = (boxes, state) => {
-    return (0, get_tracks_1.getHasTracks)(boxes, state);
+const hasAudioCodec = (state) => {
+    return (0, get_tracks_1.getHasTracks)(state);
 };
 exports.hasAudioCodec = hasAudioCodec;
 const getCodecSpecificatorFromEsdsBox = ({ child, }) => {
@@ -195,6 +195,9 @@ const getAudioCodecFromAudioCodecInfo = (codec) => {
     if (codec.format === 'sowt') {
         return 'aiff';
     }
+    if (codec.format === 'ac-3') {
+        return 'ac3';
+    }
     if (codec.format === 'mp4a') {
         if (codec.primarySpecificator === 0x40) {
             return 'aac';

package/dist/get-container.d.ts

@@ -1,4 +1,4 @@
-import type { ParseMediaContainer } from './options';
+import type { MediaParserContainer } from './options';
 import type { Structure } from './parse-result';
-export declare const getContainer: (segments: Structure) => ParseMediaContainer;
+export declare const getContainer: (segments: Structure) => MediaParserContainer;
 export declare const hasContainer: (boxes: Structure) => boolean;

package/dist/get-container.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasContainer = exports.getContainer = void 0;
-const traversal_1 = require("./boxes/riff/traversal");
+const traversal_1 = require("./containers/riff/traversal");
 const getContainer = (segments) => {
     if (segments.type === 'iso-base-media') {
         return 'mp4';
@@ -15,12 +15,21 @@ const getContainer = (segments) => {
     if (segments.type === 'mp3') {
         return 'mp3';
     }
+    if (segments.type === 'wav') {
+        return 'wav';
+    }
+    if (segments.type === 'flac') {
+        return 'flac';
+    }
     if (segments.type === 'riff') {
         if ((0, traversal_1.isRiffAvi)(segments)) {
             return 'avi';
         }
         throw new Error('Unknown RIFF container ' + segments.type);
     }
+    if (segments.type === 'aac') {
+        return 'aac';
+    }
     throw new Error('Unknown container ' + segments);
 };
 exports.getContainer = getContainer;

package/dist/get-dimensions.d.ts

@@ -1,4 +1,3 @@
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
 export type Dimensions = {
     width: number;
@@ -9,5 +8,5 @@ export type ExpandedDimensions = Dimensions & {
     unrotatedWidth: number;
     unrotatedHeight: number;
 };
-export declare const getDimensions: (boxes: Structure, state: ParserState) => ExpandedDimensions | null;
-export declare const hasDimensions: (boxes: Structure, state: ParserState) => boolean;
+export declare const getDimensions: (state: ParserState) => ExpandedDimensions | null;
+export declare const hasDimensions: (state: ParserState) => boolean;

package/dist/get-dimensions.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDimensions = exports.getDimensions = void 0;
 const get_tracks_1 = require("./get-tracks");
-const getDimensions = (boxes, state) => {
+const is_audio_structure_1 = require("./is-audio-structure");
+const getDimensions = (state) => {
+    const structure = state.getStructureOrNull();
+    if (structure && (0, is_audio_structure_1.isAudioStructure)(structure)) {
+        return null;
+    }
     const { videoTracks } = (0, get_tracks_1.getTracks)(state);
     if (!videoTracks.length) {
-        if (boxes.type === 'mp3') {
-            return null;
-        }
-        throw new Error('Expected video track');
+        return null;
     }
     const firstVideoTrack = videoTracks[0];
     return {
@@ -20,11 +22,13 @@ const getDimensions = (boxes, state) => {
     };
 };
 exports.getDimensions = getDimensions;
-// TODO: An audio track should return 'hasDimensions' = true on an audio file
-// and stop parsing
-const hasDimensions = (boxes, state) => {
+const hasDimensions = (state) => {
+    const structure = state.getStructureOrNull();
+    if (structure && (0, is_audio_structure_1.isAudioStructure)(structure)) {
+        return true;
+    }
     try {
-        return (0, exports.getDimensions)(boxes, state) !== null;
+        return (0, exports.getDimensions)(state) !== null;
     }
     catch (_a) {
         return false;

package/dist/get-duration.d.ts

@@ -1,10 +1,10 @@
-import type { AnySegment, Structure } from './parse-result';
+import type { AnySegment } from './parse-result';
 import type { ParserState } from './state/parser-state';
 export declare const isMatroska: (boxes: AnySegment[]) => {
     type: "Segment";
-    value: import("./boxes/webm/segments/all-segments").PossibleEbml[];
+    value: import("./containers/webm/segments/all-segments").PossibleEbml[];
     minVintWidth: number | null;
 } | undefined;
-export declare const getDuration: (structure: Structure, parserState: ParserState) => number | null;
-export declare const hasDuration: (structure: Structure, parserState: ParserState) => boolean;
-export declare const hasSlowDuration: (structure: Structure, parserState: ParserState) => boolean;
+export declare const getDuration: (parserState: ParserState) => number | null;
+export declare const hasDuration: (parserState: ParserState) => boolean;
+export declare const hasSlowDuration: (parserState: ParserState) => boolean;

package/dist/get-duration.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasSlowDuration = exports.hasDuration = exports.getDuration = exports.isMatroska = void 0;
-const get_sample_positions_from_track_1 = require("./boxes/iso-base-media/get-sample-positions-from-track");
-const traversal_1 = require("./boxes/iso-base-media/traversal");
-const get_duration_1 = require("./boxes/mp3/get-duration");
-const traversal_2 = require("./boxes/riff/traversal");
+const get_duration_from_flac_1 = require("./containers/flac/get-duration-from-flac");
+const get_sample_positions_from_track_1 = require("./containers/iso-base-media/get-sample-positions-from-track");
+const traversal_1 = require("./containers/iso-base-media/traversal");
+const get_duration_1 = require("./containers/mp3/get-duration");
+const get_duration_2 = require("./containers/riff/get-duration");
+const get_duration_from_wav_1 = require("./containers/wav/get-duration-from-wav");
 const get_tracks_1 = require("./get-tracks");
 const getDurationFromMatroska = (segments) => {
     const mainSegment = segments.find((s) => s.type === 'Segment');
@@ -35,8 +37,9 @@ const isMatroska = (boxes) => {
     return matroskaBox;
 };
 exports.isMatroska = isMatroska;
-const getDurationFromIsoBaseMedia = (structure, parserState) => {
-    const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
+const getDurationFromIsoBaseMedia = (parserState) => {
+    const structure = parserState.getIsoStructure();
+    const moovBox = (0, traversal_1.getMoovBox)(parserState);
     if (!moovBox) {
         return null;
     }
@@ -66,29 +69,16 @@ const getDurationFromIsoBaseMedia = (structure, parserState) => {
     const highestTimestamp = Math.max(...allSamples);
     return highestTimestamp;
 };
-const getDurationFromAvi = (structure) => {
-    const strl = (0, traversal_2.getStrlBoxes)(structure);
-    const lengths = [];
-    for (const s of strl) {
-        const strh = (0, traversal_2.getStrhBox)(s.children);
-        if (!strh) {
-            throw new Error('No strh box');
-        }
-        const samplesPerSecond = strh.rate / strh.scale;
-        const streamLength = strh.length / samplesPerSecond;
-        lengths.push(streamLength);
-    }
-    return Math.max(...lengths);
-};
-const getDuration = (structure, parserState) => {
+const getDuration = (parserState) => {
+    const structure = parserState.getStructure();
     if (structure.type === 'matroska') {
         return getDurationFromMatroska(structure.boxes);
     }
     if (structure.type === 'iso-base-media') {
-        return getDurationFromIsoBaseMedia(structure, parserState);
+        return getDurationFromIsoBaseMedia(parserState);
     }
     if (structure.type === 'riff') {
-        return getDurationFromAvi(structure);
+        return (0, get_duration_2.getDurationFromAvi)(structure);
     }
     if (structure.type === 'transport-stream') {
         return null;
@@ -96,20 +86,29 @@ const getDuration = (structure, parserState) => {
     if (structure.type === 'mp3') {
         return (0, get_duration_1.getDurationFromMp3)(parserState);
     }
+    if (structure.type === 'wav') {
+        return (0, get_duration_from_wav_1.getDurationFromWav)(parserState);
+    }
+    if (structure.type === 'aac') {
+        return null;
+    }
+    if (structure.type === 'flac') {
+        return (0, get_duration_from_flac_1.getDurationFromFlac)(parserState);
+    }
     throw new Error('Has no duration ' + structure);
 };
 exports.getDuration = getDuration;
 // `duration` just grabs from metadata, and otherwise returns null
 // Therefore just checking if we have tracks
-const hasDuration = (structure, parserState) => {
-    return (0, get_tracks_1.getHasTracks)(structure, parserState);
+const hasDuration = (parserState) => {
+    return (0, get_tracks_1.getHasTracks)(parserState);
 };
 exports.hasDuration = hasDuration;
 // `slowDuration` does through everything, and therefore is false
 // Unless it it somewhere in the metadata and is non-null
-const hasSlowDuration = (structure, parserState) => {
+const hasSlowDuration = (parserState) => {
     try {
-        return (0, exports.getDuration)(structure, parserState) !== null;
+        return (0, exports.getDuration)(parserState) !== null;
     }
     catch (_a) {
         return false;

package/dist/get-fields-from-callbacks.js

@@ -26,6 +26,10 @@ const getFieldsFromCallback = ({ fields, callbacks, }) => {
         slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
         keyframes: Boolean(callbacks.onKeyframes),
         images: Boolean(callbacks.onImages),
+        numberOfAudioChannels: Boolean(callbacks.onNumberOfAudioChannels),
+        sampleRate: Boolean(callbacks.onSampleRate),
+        slowAudioBitrate: Boolean(callbacks.onSlowAudioBitrate),
+        slowVideoBitrate: Boolean(callbacks.onSlowVideoBitrate),
         ...fields,
     };
     return newFields;

package/dist/get-fps.d.ts

@@ -1,5 +1,5 @@
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { Structure } from './parse-result';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
+import type { ParserState } from './state/parser-state';
 type TimescaleAndDuration = {
     timescale: number;
     duration: number;
@@ -8,7 +8,7 @@ export declare const trakBoxContainsAudio: (trakBox: TrakBox) => boolean;
 export declare const trakBoxContainsVideo: (trakBox: TrakBox) => boolean;
 export declare const getTimescaleAndDuration: (trakBox: TrakBox) => TimescaleAndDuration | null;
 export declare const getFpsFromMp4TrakBox: (trakBox: TrakBox) => number | null;
-export declare const getFps: (segments: Structure) => number | null;
-export declare const hasFpsSuitedForSlowFps: (boxes: Structure) => boolean;
-export declare const hasFps: (boxes: Structure) => boolean;
+export declare const getFps: (state: ParserState) => number | null;
+export declare const hasFpsSuitedForSlowFps: (state: ParserState) => boolean;
+export declare const hasFps: (state: ParserState) => boolean;
 export {};

package/dist/get-fps.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasFps = exports.hasFpsSuitedForSlowFps = exports.getFps = exports.getFpsFromMp4TrakBox = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = exports.trakBoxContainsAudio = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
-const traversal_2 = require("./boxes/riff/traversal");
+const traversal_1 = require("./containers/iso-base-media/traversal");
+const traversal_2 = require("./containers/riff/traversal");
+const is_audio_structure_1 = require("./is-audio-structure");
 const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     let totalSamples = 0;
     for (const sample of sttsBox.sampleDistribution) {
@@ -60,8 +61,8 @@ const getFpsFromMp4TrakBox = (trakBox) => {
     });
 };
 exports.getFpsFromMp4TrakBox = getFpsFromMp4TrakBox;
-const getFpsFromIsoMaseMedia = (structure) => {
-    const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
+const getFpsFromIsoMaseMedia = (state) => {
+    const moovBox = (0, traversal_1.getMoovBox)(state);
     if (!moovBox) {
         return null;
     }
@@ -86,9 +87,10 @@ const getFpsFromAvi = (structure) => {
     }
     return null;
 };
-const getFps = (segments) => {
+const getFps = (state) => {
+    const segments = state.getStructure();
     if (segments.type === 'iso-base-media') {
-        return getFpsFromIsoMaseMedia(segments);
+        return getFpsFromIsoMaseMedia(state);
     }
     if (segments.type === 'riff') {
         return getFpsFromAvi(segments);
@@ -101,31 +103,39 @@ const getFps = (segments) => {
     if (segments.type === 'transport-stream') {
         return null;
     }
-    if (segments.type === 'mp3') {
+    if (segments.type === 'mp3' ||
+        segments.type === 'wav' ||
+        segments.type === 'flac' ||
+        segments.type === 'aac') {
         return null;
     }
-    throw new Error('Cannot get fps, not implemented');
+    throw new Error('Cannot get fps, not implemented: ' + segments);
 };
 exports.getFps = getFps;
-const hasFpsSuitedForSlowFps = (boxes) => {
+const hasFpsSuitedForSlowFps = (state) => {
     try {
-        return (0, exports.getFps)(boxes) !== null;
+        return (0, exports.getFps)(state) !== null;
     }
     catch (_a) {
         return false;
     }
 };
 exports.hasFpsSuitedForSlowFps = hasFpsSuitedForSlowFps;
-const hasFps = (boxes) => {
+const hasFps = (state) => {
     // Matroska and Transport stream has no FPS metadata
     // Not bothering to parse
     // Users should use `slowFps` field
-    if (boxes.type === 'matroska') {
+    // same goes for audio
+    const structure = state.getStructure();
+    if ((0, is_audio_structure_1.isAudioStructure)(structure)) {
         return true;
     }
-    if (boxes.type === 'transport-stream') {
+    if (structure.type === 'matroska') {
         return true;
     }
-    return (0, exports.hasFpsSuitedForSlowFps)(boxes);
+    if (structure.type === 'transport-stream') {
+        return true;
+    }
+    return (0, exports.hasFpsSuitedForSlowFps)(state);
 };
 exports.hasFps = hasFps;

package/dist/get-is-hdr.d.ts

@@ -1,4 +1,3 @@
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
 export declare const getIsHdr: (state: ParserState) => boolean;
-export declare const hasHdr: (boxes: Structure, state: ParserState) => boolean;
+export declare const hasHdr: (state: ParserState) => boolean;

package/dist/get-is-hdr.js

@@ -12,7 +12,7 @@ const getIsHdr = (state) => {
     return videoTracks.some((track) => isVideoTrackHdr(track));
 };
 exports.getIsHdr = getIsHdr;
-const hasHdr = (boxes, state) => {
-    return (0, get_tracks_1.getHasTracks)(boxes, state);
+const hasHdr = (state) => {
+    return (0, get_tracks_1.getHasTracks)(state);
 };
 exports.hasHdr = hasHdr;

package/dist/get-keyframes.d.ts

@@ -1,5 +1,4 @@
 import type { MediaParserKeyframe } from './options';
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getKeyframes: (structure: Structure) => MediaParserKeyframe[] | null;
-export declare const hasKeyframes: (structure: Structure, parserState: ParserState) => boolean;
+export declare const getKeyframes: (state: ParserState) => MediaParserKeyframe[] | null;
+export declare const hasKeyframes: (parserState: ParserState) => boolean;

package/dist/get-keyframes.js

@@ -1,18 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasKeyframes = exports.getKeyframes = void 0;
-const get_keyframes_1 = require("./boxes/iso-base-media/get-keyframes");
+const get_keyframes_1 = require("./containers/iso-base-media/get-keyframes");
 const get_tracks_1 = require("./get-tracks");
-const getKeyframes = (structure) => {
+const getKeyframes = (state) => {
+    const structure = state.getStructure();
     if (structure.type === 'iso-base-media') {
-        return (0, get_keyframes_1.getKeyframesFromIsoBaseMedia)(structure);
+        return (0, get_keyframes_1.getKeyframesFromIsoBaseMedia)(state);
     }
     return null;
 };
 exports.getKeyframes = getKeyframes;
-const hasKeyframes = (structure, parserState) => {
+const hasKeyframes = (parserState) => {
+    const structure = parserState.getStructure();
     if (structure.type === 'iso-base-media') {
-        return (0, get_tracks_1.getHasTracks)(structure, parserState);
+        return (0, get_tracks_1.getHasTracks)(parserState);
     }
     // Has, but will be null
     return true;

package/dist/get-location.d.ts

@@ -1,4 +1,4 @@
-import type { Structure } from './parse-result';
+import type { ParserState } from './state/parser-state';
 export type MediaParserLocation = {
     latitude: number;
     longitude: number;
@@ -10,4 +10,4 @@ export declare function parseLocation(locationString: string): {
     longitude: number;
     altitude: number | null;
 } | null;
-export declare const getLocation: (structure: Structure) => MediaParserLocation | null;
+export declare const getLocation: (state: ParserState) => MediaParserLocation | null;

package/dist/get-location.js

@@ -19,8 +19,8 @@ function parseLocation(locationString) {
         altitude,
     };
 }
-const getLocation = (structure) => {
-    const metadata = (0, get_metadata_1.getMetadata)(structure);
+const getLocation = (state) => {
+    const metadata = (0, get_metadata_1.getMetadata)(state);
     const locationEntry = metadata.find((entry) => entry.key === 'com.apple.quicktime.location.ISO6709');
     const horizontalAccuracy = metadata.find((entry) => entry.key === 'com.apple.quicktime.location.accuracy.horizontal');
     if (locationEntry) {

package/dist/get-number-of-audio-channels.d.ts

@@ -0,0 +1,3 @@
+import type { ParserState } from './state/parser-state';
+export declare const getNumberOfAudioChannels: (state: ParserState) => number | null;
+export declare const hasNumberOfAudioChannels: (state: ParserState) => boolean;

package/dist/get-number-of-audio-channels.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNumberOfAudioChannels = exports.getNumberOfAudioChannels = void 0;
+const getNumberOfAudioChannels = (state) => {
+    var _a, _b;
+    return ((_b = (_a = state.callbacks.tracks.getTracks().find((track) => {
+        return track.type === 'audio';
+    })) === null || _a === void 0 ? void 0 : _a.numberOfChannels) !== null && _b !== void 0 ? _b : null);
+};
+exports.getNumberOfAudioChannels = getNumberOfAudioChannels;
+const hasNumberOfAudioChannels = (state) => {
+    return state.callbacks.tracks.hasAllTracks();
+};
+exports.hasNumberOfAudioChannels = hasNumberOfAudioChannels;

package/dist/get-sample-aspect-ratio.d.ts

@@ -1,11 +1,11 @@
-import type { Av1CBox } from './boxes/iso-base-media/stsd/av1c';
-import type { AvccBox } from './boxes/iso-base-media/stsd/avcc';
-import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
-import type { HvccBox } from './boxes/iso-base-media/stsd/hvcc';
-import type { PaspBox } from './boxes/iso-base-media/stsd/pasp';
-import type { VideoSample } from './boxes/iso-base-media/stsd/samples';
-import type { TkhdBox } from './boxes/iso-base-media/tkhd';
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { Av1CBox } from './containers/iso-base-media/stsd/av1c';
+import type { AvccBox } from './containers/iso-base-media/stsd/avcc';
+import type { ColorParameterBox } from './containers/iso-base-media/stsd/colr';
+import type { HvccBox } from './containers/iso-base-media/stsd/hvcc';
+import type { PaspBox } from './containers/iso-base-media/stsd/pasp';
+import type { VideoSample } from './containers/iso-base-media/stsd/samples';
+import type { TkhdBox } from './containers/iso-base-media/tkhd';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import type { Dimensions } from './get-dimensions';
 type AspectRatio = {
     numerator: number;