@remotion/media-parser 4.0.202 → 4.0.205

package/dist/parse-result.d.ts

@@ -19,8 +19,11 @@ import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
 import type { StssBox } from './boxes/iso-base-media/stsd/stss';
 import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
 import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
+import type { TfdtBox } from './boxes/iso-base-media/tfdt';
+import type { TfhdBox } from './boxes/iso-base-media/tfhd';
 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 { MatroskaSegment } from './boxes/webm/segments';
 export interface RegularBox extends BaseBox {
@@ -30,7 +33,7 @@ export interface RegularBox extends BaseBox {
     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 | ColorParameterBox;
+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 = {
     status: 'done';

package/dist/read-and-increment-offset.d.ts

@@ -0,0 +1,28 @@
+export declare class OffsetCounter {
+    #private;
+    constructor(initial: number);
+    increment(amount: number): void;
+    getOffset(): number;
+}
+export declare const getArrayBufferIterator: (data: ArrayBuffer, initialOffset: number) => {
+    view: DataView;
+    counter: OffsetCounter;
+    data: ArrayBuffer;
+    discard: (length: number) => void;
+    getSlice: (amount: number) => ArrayBuffer;
+    getAtom: () => string;
+    getMatroskaSegmentId: () => string;
+    getVint: (bytes: number) => number;
+    getUint8: () => number;
+    getEBML: () => number;
+    getInt8: () => number;
+    getUint16: () => number;
+    getInt16: () => number;
+    getUint32: () => number;
+    getFixedPoint1616Number: () => number;
+    getPascalString: () => number[];
+    getDecimalBytes(length: number): number;
+    getByteString(length: number): string;
+    getFloat64: () => number;
+};
+export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/read-and-increment-offset.js

@@ -0,0 +1,177 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OffsetCounter_offset;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
+class OffsetCounter {
+    constructor(initial) {
+        _OffsetCounter_offset.set(this, void 0);
+        __classPrivateFieldSet(this, _OffsetCounter_offset, initial, "f");
+    }
+    increment(amount) {
+        if (amount < 0) {
+            throw new Error('Cannot increment by a negative amount');
+        }
+        __classPrivateFieldSet(this, _OffsetCounter_offset, __classPrivateFieldGet(this, _OffsetCounter_offset, "f") + amount, "f");
+    }
+    getOffset() {
+        return __classPrivateFieldGet(this, _OffsetCounter_offset, "f");
+    }
+}
+exports.OffsetCounter = OffsetCounter;
+_OffsetCounter_offset = new WeakMap();
+const makeOffsetCounter = (initial) => {
+    return new OffsetCounter(initial);
+};
+const getArrayBufferIterator = (data, initialOffset) => {
+    const view = new DataView(data);
+    const counter = makeOffsetCounter(initialOffset);
+    const getSlice = (amount) => {
+        const value = data.slice(counter.getOffset(), counter.getOffset() + amount);
+        counter.increment(amount);
+        return value;
+    };
+    const getUint8 = () => {
+        const val = view.getUint8(counter.getOffset());
+        counter.increment(1);
+        return val;
+    };
+    const getUint32 = () => {
+        const val = view.getUint32(counter.getOffset());
+        counter.increment(4);
+        return val;
+    };
+    return {
+        view,
+        counter,
+        data,
+        discard: (length) => {
+            counter.increment(length);
+        },
+        getSlice,
+        getAtom: () => {
+            const atom = getSlice(4);
+            return new TextDecoder().decode(atom);
+        },
+        getMatroskaSegmentId: () => {
+            const first = getSlice(1);
+            const firstOneString = `0x${Array.from(new Uint8Array(first))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            // Catch void block
+            const knownIdsWithOneLength = ['0xec', '0xae'];
+            if (knownIdsWithOneLength.includes(firstOneString)) {
+                return firstOneString;
+            }
+            const firstTwo = getSlice(1);
+            const knownIdsWithTwoLength = ['0x4dbb', '0x53ac', '0xec01'];
+            const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithTwoLength.includes(firstTwoString)) {
+                return firstTwoString;
+            }
+            const knownIdsWithThreeLength = ['0x4d808c', '0x57418c', '0x448988'];
+            const firstThree = getSlice(1);
+            const firstThreeString = `${firstTwoString}${Array.from(new Uint8Array(firstThree))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithThreeLength.includes(firstThreeString)) {
+                return firstThreeString;
+            }
+            const segmentId = getSlice(1);
+            return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+        },
+        getVint: (bytes) => {
+            const slice = getSlice(bytes);
+            const d = [...Array.from(new Uint8Array(slice))];
+            const totalLength = d[0];
+            if (totalLength === 0) {
+                return 0;
+            }
+            // Calculate the actual length of the data based on the first set bit
+            let actualLength = 0;
+            while (((totalLength >> (7 - actualLength)) & 0x01) === 0) {
+                actualLength++;
+            }
+            actualLength += 1; // Include the first byte set as 1
+            // Combine the numbers to form the integer value
+            let value = 0;
+            // Mask the first byte properly then start combining
+            value = totalLength & (0xff >> actualLength);
+            for (let i = 1; i < actualLength; i++) {
+                value = (value << 8) | d[i];
+            }
+            return value;
+        },
+        getUint8,
+        getEBML: () => {
+            const val = getUint8();
+            // https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/#:~:text=The%20first%20four%20bytes%20(%201A,%E2%80%93%20read%20on%20for%20why).
+            // You drop the initial 0 bits and the first 1 bit to get the value. 0x81 is 0b10000001, so there are zero inital 0 bits, meaning length one byte, and the value is 1. The 0x9F value for length of the EBML header we saw earlier is 0b10011111, still one byte, value is 0b0011111, which is 31 (the python repl is very helpful for these conversions).
+            const actualValue = val & 0x7f; // 0x7F is binary 01111111, which masks out the first bit
+            return actualValue;
+        },
+        getInt8: () => {
+            const val = view.getInt8(counter.getOffset());
+            counter.increment(1);
+            return val;
+        },
+        getUint16: () => {
+            const val = view.getUint16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        getInt16: () => {
+            const val = view.getInt16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        getUint32,
+        // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
+        // A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
+        getFixedPoint1616Number: () => {
+            const val = getUint32();
+            return val / 2 ** 16;
+        },
+        getPascalString: () => {
+            const val = getSlice(32);
+            return [...Array.from(new Uint8Array(val))];
+        },
+        getDecimalBytes(length) {
+            const bytes = getSlice(length);
+            const numbers = [...Array.from(new Uint8Array(bytes))];
+            return numbers.reduce((acc, byte, index) => acc + (byte << (8 * (numbers.length - index - 1))), 0);
+        },
+        getByteString(length) {
+            const bytes = getSlice(length);
+            return new TextDecoder().decode(bytes);
+        },
+        getFloat64: () => {
+            const val = view.getFloat64(counter.getOffset());
+            counter.increment(8);
+            return val;
+        },
+    };
+};
+exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/samples-from-moof.d.ts

@@ -0,0 +1,6 @@
+import type { SamplePosition } from './get-sample-positions';
+import type { AnySegment } from './parse-result';
+export declare const getSamplesFromMoof: ({ moofBox, trackId, }: {
+    moofBox: AnySegment;
+    trackId: number;
+}) => SamplePosition[];

package/dist/samples-from-moof.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplesFromMoof = void 0;
+const traversal_1 = require("./traversal");
+const getSamplesFromTraf = (trafSegment, moofOffset) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (trafSegment.type !== 'regular-box' || trafSegment.boxType !== 'traf') {
+        throw new Error('Expected traf-box');
+    }
+    const tfhdBox = (0, traversal_1.getTfhdBox)(trafSegment);
+    const defaultSampleDuration = (_a = tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.defaultSampleDuration) !== null && _a !== void 0 ? _a : null;
+    const defaultSampleSize = (_b = tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.defaultSampleSize) !== null && _b !== void 0 ? _b : null;
+    const defaultSampleFlags = (_c = tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.defaultSampleFlags) !== null && _c !== void 0 ? _c : null;
+    const tfdtBox = (0, traversal_1.getTfdtBox)(trafSegment);
+    const trunBoxes = (0, traversal_1.getTrunBoxes)(trafSegment);
+    let time = 0;
+    let offset = 0;
+    let dataOffset = 0;
+    const samples = [];
+    for (const trunBox of trunBoxes) {
+        let i = -1;
+        if (trunBox.dataOffset) {
+            dataOffset = trunBox.dataOffset;
+            offset = 0;
+        }
+        for (const sample of trunBox.samples) {
+            i++;
+            const duration = (_d = sample.sampleDuration) !== null && _d !== void 0 ? _d : defaultSampleDuration;
+            if (duration === null) {
+                throw new Error('Expected duration');
+            }
+            const size = (_e = sample.sampleSize) !== null && _e !== void 0 ? _e : defaultSampleSize;
+            if (size === null) {
+                throw new Error('Expected size');
+            }
+            const isFirstSample = i === 0;
+            const sampleFlags = sample.sampleFlags
+                ? sample.sampleFlags
+                : isFirstSample && trunBox.firstSampleFlags !== null
+                    ? trunBox.firstSampleFlags
+                    : defaultSampleFlags;
+            if (sampleFlags === null) {
+                throw new Error('Expected sample flags');
+            }
+            const keyframe = !((sampleFlags >> 16) & 0x1);
+            const dts = time + ((_f = tfdtBox === null || tfdtBox === void 0 ? void 0 : tfdtBox.baseMediaDecodeTime) !== null && _f !== void 0 ? _f : 0);
+            const samplePosition = {
+                offset: offset + (moofOffset !== null && moofOffset !== void 0 ? moofOffset : 0) + (dataOffset !== null && dataOffset !== void 0 ? dataOffset : 0),
+                dts,
+                cts: dts,
+                duration,
+                isKeyframe: keyframe,
+                size,
+            };
+            samples.push(samplePosition);
+            offset += size;
+            time += duration;
+        }
+    }
+    return samples;
+};
+const getSamplesFromMoof = ({ moofBox, trackId, }) => {
+    if (moofBox.type !== 'regular-box') {
+        throw new Error('Expected moof-box');
+    }
+    const trafs = moofBox.children.filter((c) => c.type === 'regular-box' && c.boxType === 'traf');
+    const mapped = trafs.map((traf) => {
+        const tfhdBox = (0, traversal_1.getTfhdBox)(traf);
+        return (tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.trackId) === trackId
+            ? getSamplesFromTraf(traf, moofBox.offset)
+            : [];
+    });
+    return mapped.flat(1);
+};
+exports.getSamplesFromMoof = getSamplesFromMoof;

package/dist/traversal.d.ts

@@ -9,12 +9,16 @@ import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
 import type { StssBox } from './boxes/iso-base-media/stsd/stss';
 import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
 import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
+import type { TfdtBox } from './boxes/iso-base-media/tfdt';
+import type { TfhdBox } from './boxes/iso-base-media/tfhd';
 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 { AudioSegment, ClusterSegment, CodecIdSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, MainSegment, TimestampScaleSegment, TrackEntry, TrackTypeSegment, VideoSegment, WidthSegment } from './boxes/webm/segments/all-segments';
-import type { AnySegment, RegularBox } from './parse-result';
+import type { AnySegment, IsoBaseMediaBox, RegularBox } from './parse-result';
 export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
 export declare const getMoovBox: (segments: AnySegment[]) => MoovBox | null;
+export declare const getMoofBox: (main: AnySegment[]) => IsoBaseMediaBox | null;
 export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
 export declare const getTraks: (moovBox: MoovBox) => TrakBox[];
 export declare const getTkhdBox: (trakBox: TrakBox) => TkhdBox | null;
@@ -29,6 +33,9 @@ export declare const getCttsBox: (trakBox: TrakBox) => CttsBox | null;
 export declare const getStszBox: (trakBox: TrakBox) => StszBox | null;
 export declare const getStscBox: (trakBox: TrakBox) => StscBox | null;
 export declare const getStssBox: (trakBox: TrakBox) => StssBox | null;
+export declare const getTfdtBox: (segment: IsoBaseMediaBox) => TfdtBox | null;
+export declare const getTfhdBox: (segment: IsoBaseMediaBox) => TfhdBox | null;
+export declare const getTrunBoxes: (segment: IsoBaseMediaBox) => TrunBox[];
 export declare const getClusterSegment: (segment: MainSegment) => ClusterSegment | null;
 export declare const getTracksSegment: (segment: MainSegment) => {
     type: "Tracks";

package/dist/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasSkippedMdatProcessing = exports.getCodecSegment = exports.getTrackId = exports.getTrackTypeSegment = exports.getDisplayHeightSegment = exports.getDisplayWidthSegment = exports.getHeightSegment = exports.getWidthSegment = exports.getPrivateData = exports.getBitDepth = exports.getNumberOfChannels = exports.getSampleRate = exports.getAudioSegment = exports.getVideoSegment = exports.getTimescaleSegment = exports.getTracksSegment = exports.getClusterSegment = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoovBox = exports.getFtypBox = void 0;
+exports.hasSkippedMdatProcessing = exports.getCodecSegment = exports.getTrackId = exports.getTrackTypeSegment = exports.getDisplayHeightSegment = exports.getDisplayWidthSegment = exports.getHeightSegment = exports.getWidthSegment = exports.getPrivateData = exports.getBitDepth = exports.getNumberOfChannels = exports.getSampleRate = exports.getAudioSegment = exports.getVideoSegment = exports.getTimescaleSegment = exports.getTracksSegment = exports.getClusterSegment = exports.getTrunBoxes = exports.getTfhdBox = exports.getTfdtBox = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoofBox = exports.getMoovBox = exports.getFtypBox = void 0;
 const getFtypBox = (segments) => {
     const ftypBox = segments.find((s) => s.type === 'ftyp-box');
     if (!ftypBox || ftypBox.type !== 'ftyp-box') {
@@ -17,6 +17,14 @@ const getMoovBox = (segments) => {
     return moovBox;
 };
 exports.getMoovBox = getMoovBox;
+const getMoofBox = (main) => {
+    const moofBox = main.find((s) => s.type === 'regular-box' && s.boxType === 'moof');
+    if (!moofBox || moofBox.type !== 'regular-box') {
+        return null;
+    }
+    return moofBox;
+};
+exports.getMoofBox = getMoofBox;
 const getMvhdBox = (moovBox) => {
     const mvHdBox = moovBox.children.find((s) => s.type === 'mvhd-box');
     if (!mvHdBox || mvHdBox.type !== 'mvhd-box') {
@@ -150,6 +158,36 @@ const getStssBox = (trakBox) => {
     return stssBox;
 };
 exports.getStssBox = getStssBox;
+const getTfdtBox = (segment) => {
+    if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+        throw new Error('Expected traf-box');
+    }
+    const tfhdBox = segment.children.find((c) => c.type === 'tfdt-box');
+    if (!tfhdBox || tfhdBox.type !== 'tfdt-box') {
+        throw new Error('Expected tfhd-box');
+    }
+    return tfhdBox;
+};
+exports.getTfdtBox = getTfdtBox;
+const getTfhdBox = (segment) => {
+    if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+        throw new Error('Expected traf-box');
+    }
+    const tfhdBox = segment.children.find((c) => c.type === 'tfhd-box');
+    if (!tfhdBox || tfhdBox.type !== 'tfhd-box') {
+        throw new Error('Expected tfhd-box');
+    }
+    return tfhdBox;
+};
+exports.getTfhdBox = getTfhdBox;
+const getTrunBoxes = (segment) => {
+    if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+        throw new Error('Expected traf-box');
+    }
+    const trunBoxes = segment.children.filter((c) => c.type === 'trun-box');
+    return trunBoxes;
+};
+exports.getTrunBoxes = getTrunBoxes;
 const getClusterSegment = (segment) => {
     const clusterSegment = segment.value.find((b) => b.type === 'Cluster');
     return clusterSegment !== null && clusterSegment !== void 0 ? clusterSegment : null;

package/dist/understand-vorbis.d.ts

@@ -0,0 +1 @@
+declare const understand: (src: string) => Promise<void>;

package/dist/understand-vorbis.js

@@ -0,0 +1,12 @@
+"use strict";
+const understand = async (src) => {
+    const content = await Bun.file(src).arrayBuffer();
+    const firstBit = new DataView(content).getUint8(0);
+    const offset = new DataView(content).getUint8(1);
+    const offset2 = new DataView(content).getUint8(2);
+    const globalOffset = firstBit + 1;
+    const header = new TextDecoder().decode(content.slice(globalOffset, globalOffset + offset));
+    const comment = new TextDecoder().decode(content.slice(globalOffset + offset, globalOffset + offset2));
+    const rest = new TextDecoder().decode(content.slice(globalOffset + offset2 + offset, globalOffset + offset2 + offset + 50));
+    console.log({ firstBit, offset, offset2, header, comment, rest });
+};

package/dist/writers/web-fs.js

@@ -3,25 +3,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.webFsWriter = void 0;
 const createContent = async () => {
     const directoryHandle = await navigator.storage.getDirectory();
-    const fileHandle = await directoryHandle.getFileHandle('out.web', {
+    const filename = `media-parser-${Math.random().toString().replace('0.', '')}.webm`;
+    const fileHandle = await directoryHandle.getFileHandle(filename, {
         create: true,
     });
-    const f = await fileHandle.getFile();
     const writable = await fileHandle.createWritable();
-    return {
+    let written = 0;
+    const writer = {
         write: async (arr) => {
             await writable.write(arr);
+            written += arr.byteLength;
         },
         save: async () => {
+            await writable.close();
             const picker = await window.showSaveFilePicker({
                 suggestedName: `${Math.random().toString().replace('.', '')}.webm`,
             });
+            const newHandle = await directoryHandle.getFileHandle(filename, {
+                create: true,
+            });
+            const newFile = await newHandle.getFile();
             const pickerWriteable = await picker.createWritable();
-            const stream = f.stream();
+            const stream = newFile.stream();
             await stream.pipeTo(pickerWriteable);
-            await writable.close();
+            await directoryHandle.removeEntry(filename, {
+                recursive: true,
+            });
+        },
+        getWrittenByteCount: () => written,
+        updateDataAt: async (position, vint) => {
+            await writable.seek(position);
+            await writable.write(vint);
+            await writable.seek(written);
         },
     };
+    return writer;
 };
 exports.webFsWriter = {
     createContent,

package/dist/writers/writer.d.ts

@@ -1,6 +1,8 @@
-type Writer = {
+export type Writer = {
     write: (arr: Uint8Array) => Promise<void>;
     save: () => Promise<void>;
+    getWrittenByteCount: () => number;
+    updateDataAt: (position: number, vint: Uint8Array) => Promise<void>;
 };
 type CreateContent = () => Promise<Writer>;
 export type WriterInterface = {

package/package.json

@@ -3,11 +3,11 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.202",
+  "version": "4.0.205",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.202"
+    "@remotion/renderer": "4.0.205"
   },
   "publishConfig": {
     "access": "public"

package/src/boxes/iso-base-media/esds/decoder-specific-config.ts

@@ -51,11 +51,18 @@ export const parseDecoderSpecificConfig = (
 		iterator.discard(layerSize - read);
 	}
 
+	// Working around Chrome bug
+	// https://issues.chromium.org/issues/360083330#comment5
+	const patchedAsBytes =
+		bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136
+			? new Uint8Array([17, 144])
+			: bytes;
+
 	return {
 		type: 'audio-specific-config',
 		audioObjectType,
 		samplingFrequencyIndex,
 		channelConfiguration,
-		asBytes: bytes,
+		asBytes: patchedAsBytes,
 	};
 };

package/src/boxes/iso-base-media/get-sample-positions-from-track.ts

@@ -0,0 +1,69 @@
+import {getTimescaleAndDuration} from '../../get-fps';
+import type {SamplePosition} from '../../get-sample-positions';
+import {getSamplePositions} from '../../get-sample-positions';
+import type {IsoBaseMediaBox} from '../../parse-result';
+import {getSamplesFromMoof} from '../../samples-from-moof';
+import {
+	getCttsBox,
+	getStcoBox,
+	getStscBox,
+	getStssBox,
+	getStszBox,
+	getSttsBox,
+	getTkhdBox,
+} from '../../traversal';
+import type {TrakBox} from './trak/trak';
+
+export const getSamplePositionsFromTrack = (
+	trakBox: TrakBox,
+	moofBox: IsoBaseMediaBox | null,
+): SamplePosition[] => {
+	const stszBox = getStszBox(trakBox);
+	const stcoBox = getStcoBox(trakBox);
+	const stscBox = getStscBox(trakBox);
+	const stssBox = getStssBox(trakBox);
+	const sttsBox = getSttsBox(trakBox);
+	const tkhdBox = getTkhdBox(trakBox);
+	const cttsBox = getCttsBox(trakBox);
+
+	const timescaleAndDuration = getTimescaleAndDuration(trakBox);
+
+	if (!tkhdBox) {
+		throw new Error('Expected tkhd box in trak box');
+	}
+
+	if (!stszBox) {
+		throw new Error('Expected stsz box in trak box');
+	}
+
+	if (!stcoBox) {
+		throw new Error('Expected stco box in trak box');
+	}
+
+	if (!stscBox) {
+		throw new Error('Expected stsc box in trak box');
+	}
+
+	if (!sttsBox) {
+		throw new Error('Expected stts box in trak box');
+	}
+
+	if (!timescaleAndDuration) {
+		throw new Error('Expected timescale and duration in trak box');
+	}
+
+	let samplePositions = getSamplePositions({
+		stcoBox,
+		stscBox,
+		stszBox,
+		stssBox,
+		sttsBox,
+		cttsBox,
+	});
+
+	if (samplePositions.length === 0 && moofBox) {
+		samplePositions = getSamplesFromMoof({moofBox, trackId: tkhdBox.trackId});
+	}
+
+	return samplePositions;
+};