@remotion/media-parser 4.0.237 → 4.0.239

package/dist/boxes/transport-stream/parse-pat.js

@@ -0,0 +1,49 @@
+"use strict";
+// https://en.wikipedia.org/wiki/Program-specific_information
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePat = void 0;
+const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
+const parsePatTable = (iterator, tableId) => {
+    iterator.getUint16(); // table ID extension
+    iterator.startReadingBits();
+    iterator.getBits(7); // reserved
+    iterator.getBits(1); // current / next indicator;
+    const sectionNumber = iterator.getBits(8);
+    const lastSectionNumber = iterator.getBits(8);
+    if (tableId !== 0) {
+        throw new Error('Invalid table ID: ' + tableId);
+    }
+    const tables = [];
+    for (let i = sectionNumber; i <= lastSectionNumber; i++) {
+        const programNumber = iterator.getBits(16); // program number
+        iterator.getBits(3); // reserved
+        const programMapIdentifier = iterator.getBits(13); // program map PID
+        tables.push({
+            type: 'transport-stream-program-association-table',
+            programNumber,
+            programMapIdentifier,
+        });
+    }
+    iterator.stopReadingBits();
+    return {
+        type: 'transport-stream-pat-box',
+        tableId: tableId.toString(16),
+        pat: tables,
+    };
+};
+const parsePat = (iterator) => {
+    iterator.startReadingBits();
+    const tableId = iterator.getBits(8);
+    iterator.getBits(1); // syntax indicator
+    iterator.getBits(1); // private bit
+    iterator.getBits(4);
+    const sectionLength = iterator.getBits(10);
+    if (sectionLength > 1021) {
+        throw new Error('Invalid section length');
+    }
+    iterator.stopReadingBits();
+    const tables = parsePatTable(iterator, tableId);
+    (0, discard_rest_of_packet_1.discardRestOfPacket)(iterator);
+    return tables;
+};
+exports.parsePat = parsePat;

package/dist/boxes/transport-stream/parse-pes.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export type PacketPes = {
+    streamId: number;
+    dts: number | null;
+    pts: number;
+    priority: number;
+};
+export declare const parsePes: (iterator: BufferIterator) => PacketPes;

package/dist/boxes/transport-stream/parse-pes.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePes = void 0;
+const parsePes = (iterator) => {
+    const ident = iterator.getUint24();
+    if (ident !== 0x000001) {
+        throw new Error(`Unexpected PES packet start code: ${ident.toString(16)}`);
+    }
+    const streamId = iterator.getUint8();
+    iterator.getUint16(); // PES packet length, is most of the time 0, so useless
+    iterator.startReadingBits();
+    const markerBits = iterator.getBits(2);
+    if (markerBits !== 0b10) {
+        throw new Error(`Invalid marker bits: ${markerBits}`);
+    }
+    const scrambled = iterator.getBits(2);
+    if (scrambled !== 0b00) {
+        throw new Error(`Only supporting non-scrambled streams`);
+    }
+    const priority = iterator.getBits(1);
+    iterator.getBits(1); // data alignment indicator
+    iterator.getBits(1); // copy right
+    iterator.getBits(1); // original or copy
+    const ptsPresent = iterator.getBits(1);
+    const dtsPresent = iterator.getBits(1);
+    if (!ptsPresent && dtsPresent) {
+        throw new Error(`DTS is present but not PTS, this is not allowed in the spec`);
+    }
+    iterator.getBits(1); // escr flag
+    iterator.getBits(1); // es rate flag
+    iterator.getBits(1); // dsm trick mode flag
+    iterator.getBits(1); // additional copy info flag
+    iterator.getBits(1); // crc flag
+    iterator.getBits(1); // extension flag
+    const pesHeaderLength = iterator.getBits(8);
+    const offset = iterator.counter.getOffset();
+    let pts = null;
+    if (!ptsPresent) {
+        throw new Error(`PTS is required`);
+    }
+    const fourBits = iterator.getBits(4);
+    if (fourBits !== 0b0011 && fourBits !== 0b0010) {
+        throw new Error(`Invalid PTS marker bits: ${fourBits}`);
+    }
+    const pts1 = iterator.getBits(3);
+    iterator.getBits(1); // marker bit
+    const pts2 = iterator.getBits(15);
+    iterator.getBits(1); // marker bit
+    const pts3 = iterator.getBits(15);
+    iterator.getBits(1); // marker bit
+    pts = (pts1 << 30) | (pts2 << 15) | pts3;
+    let dts = null;
+    if (dtsPresent) {
+        const _fourBits = iterator.getBits(4);
+        if (_fourBits !== 0b0001) {
+            throw new Error(`Invalid DTS marker bits: ${_fourBits}`);
+        }
+        const dts1 = iterator.getBits(3);
+        iterator.getBits(1); // marker bit
+        const dts2 = iterator.getBits(15);
+        iterator.getBits(1); // marker bit
+        const dts3 = iterator.getBits(15);
+        iterator.getBits(1); // marker bit
+        dts = (dts1 << 30) | (dts2 << 15) | dts3;
+    }
+    iterator.stopReadingBits();
+    iterator.discard(pesHeaderLength - (iterator.counter.getOffset() - offset));
+    const packet = {
+        dts,
+        pts,
+        streamId,
+        priority,
+    };
+    return packet;
+};
+exports.parsePes = parsePes;

package/dist/boxes/transport-stream/parse-pmt.d.ts

@@ -0,0 +1,11 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { TransportStreamPMTBox } from './boxes';
+export type TransportStreamEntry = {
+    streamType: number;
+    pid: number;
+};
+export type TransportStreamProgramMapTable = {
+    type: 'transport-stream-program-map-table';
+    streams: TransportStreamEntry[];
+};
+export declare const parsePmt: (iterator: BufferIterator) => TransportStreamPMTBox;

package/dist/boxes/transport-stream/parse-pmt.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePmt = void 0;
+const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
+const parsePmtTable = ({ iterator, tableId, sectionLength, }) => {
+    const start = iterator.counter.getOffset();
+    iterator.getUint16(); // table ID extension
+    iterator.startReadingBits();
+    iterator.getBits(7); // reserved
+    iterator.getBits(1); // current / next indicator;
+    const sectionNumber = iterator.getBits(8);
+    const lastSectionNumber = iterator.getBits(8);
+    const tables = [];
+    for (let i = sectionNumber; i <= lastSectionNumber; i++) {
+        iterator.getBits(3); // reserved
+        iterator.getBits(13); // PCR PID
+        iterator.getBits(4); // reserved
+        const programInfoLength = iterator.getBits(12);
+        const streams = [];
+        while (true) {
+            const streamType = iterator.getBits(8);
+            iterator.getBits(3); // reserved
+            const elementaryPid = iterator.getBits(13);
+            iterator.getBits(4); // reserved
+            const esInfoLength = iterator.getBits(12);
+            iterator.getBits(esInfoLength * 8);
+            streams.push({ streamType, pid: elementaryPid });
+            iterator.getBits(programInfoLength * 8); // program descriptor
+            const remaining = sectionLength - (iterator.counter.getOffset() - start);
+            if (remaining <= 4) {
+                break;
+            }
+        }
+        tables.push({
+            type: 'transport-stream-program-map-table',
+            streams,
+        });
+    }
+    if (tables.length !== 1) {
+        throw new Error('Does not PMT table with more than 1 entry, uncommon');
+    }
+    iterator.stopReadingBits();
+    return {
+        type: 'transport-stream-pmt-box',
+        tableId,
+        streams: tables[0].streams,
+    };
+};
+const parsePmt = (iterator) => {
+    iterator.startReadingBits();
+    const tableId = iterator.getBits(8);
+    iterator.getBits(1); // syntax indicator
+    iterator.getBits(1); // private bit
+    iterator.getBits(4);
+    const sectionLength = iterator.getBits(10);
+    if (sectionLength > 1021) {
+        throw new Error('Invalid section length');
+    }
+    iterator.stopReadingBits();
+    const tables = parsePmtTable({ iterator, tableId, sectionLength });
+    (0, discard_rest_of_packet_1.discardRestOfPacket)(iterator);
+    return tables;
+};
+exports.parsePmt = parsePmt;

package/dist/boxes/transport-stream/parse-stream-packet.d.ts

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { TransportStreamStructure } from '../../parse-result';
+import type { ParserContext } from '../../parser-context';
+import type { PacketPes } from './parse-pes';
+import type { TransportStreamEntry } from './parse-pmt';
+import { type StreamBufferMap } from './process-stream-buffers';
+export declare const parseStream: ({ iterator, transportStreamEntry, streamBuffers, parserContext, programId, structure, nextPesHeader, }: {
+    iterator: BufferIterator;
+    transportStreamEntry: TransportStreamEntry;
+    streamBuffers: StreamBufferMap;
+    parserContext: ParserContext;
+    programId: number;
+    structure: TransportStreamStructure;
+    nextPesHeader: PacketPes;
+}) => Promise<void>;

package/dist/boxes/transport-stream/parse-stream-packet.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStream = void 0;
+const make_header_1 = require("../webm/make-header");
+const adts_header_1 = require("./adts-header");
+const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
+const find_separator_1 = require("./find-separator");
+const process_stream_buffers_1 = require("./process-stream-buffers");
+const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, options, structure, }) => {
+    var _a, _b;
+    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+    if (!streamBuffer) {
+        streamBuffers.set(transportStreamEntry.pid, {
+            buffer: restOfPacket,
+            pesHeader: nextPesHeader,
+        });
+        return;
+    }
+    const expectedLength = (_b = (_a = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer)) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
+    const bytesToTake = expectedLength
+        ? Math.min(restOfPacket.length, expectedLength - streamBuffer.buffer.byteLength)
+        : restOfPacket.length;
+    streamBuffer.buffer = (0, make_header_1.combineUint8Arrays)([
+        streamBuffer.buffer,
+        restOfPacket.slice(0, bytesToTake),
+    ]);
+    if (expectedLength === streamBuffer.buffer.byteLength) {
+        await (0, process_stream_buffers_1.processStreamBuffer)({
+            streamBuffer,
+            programId: transportStreamEntry.pid,
+            options,
+            structure,
+        });
+        const rest = restOfPacket.slice(bytesToTake);
+        streamBuffers.set(transportStreamEntry.pid, {
+            buffer: rest,
+            pesHeader: nextPesHeader,
+        });
+    }
+};
+const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, programId, parserContext, structure, }) => {
+    const indexOfSeparator = (0, find_separator_1.findNextSeparator)(restOfPacket, transportStreamEntry);
+    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+    if (indexOfSeparator === -1) {
+        if (streamBuffer) {
+            streamBuffer.buffer = (0, make_header_1.combineUint8Arrays)([
+                streamBuffer.buffer,
+                restOfPacket,
+            ]);
+            return;
+        }
+        streamBuffers.set(programId, {
+            pesHeader: nextPesHeader,
+            buffer: restOfPacket,
+        });
+        return;
+    }
+    if (streamBuffer) {
+        const packet = restOfPacket.slice(0, indexOfSeparator);
+        streamBuffer.buffer = (0, make_header_1.combineUint8Arrays)([streamBuffer.buffer, packet]);
+        await (0, process_stream_buffers_1.processStreamBuffer)({
+            options: parserContext,
+            streamBuffer,
+            programId,
+            structure,
+        });
+        const rest = restOfPacket.slice(indexOfSeparator);
+        streamBuffers.set(programId, {
+            pesHeader: nextPesHeader,
+            buffer: rest,
+        });
+        return;
+    }
+    if (indexOfSeparator !== 0) {
+        throw new Error('No stream buffer found but new separator is not at the beginning');
+    }
+    streamBuffers.set(programId, {
+        pesHeader: nextPesHeader,
+        buffer: restOfPacket.slice(indexOfSeparator),
+    });
+};
+const parseStream = ({ iterator, transportStreamEntry, streamBuffers, parserContext, programId, structure, nextPesHeader, }) => {
+    const restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
+    if (transportStreamEntry.streamType === 27) {
+        return parseAvcStream({
+            restOfPacket,
+            transportStreamEntry,
+            streamBuffers,
+            nextPesHeader,
+            parserContext,
+            programId,
+            structure,
+        });
+    }
+    if (transportStreamEntry.streamType === 15) {
+        return parseAdtsStream({
+            restOfPacket,
+            transportStreamEntry,
+            streamBuffers,
+            nextPesHeader,
+            options: parserContext,
+            structure,
+        });
+    }
+    throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
+};
+exports.parseStream = parseStream;

package/dist/boxes/transport-stream/parse-transport-stream.d.ts

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../options';
+import type { ParseResult, TransportStreamStructure } from '../../parse-result';
+import type { ParserContext } from '../../parser-context';
+import type { NextPesHeaderStore } from './next-pes-header-store';
+import { type StreamBufferMap } from './process-stream-buffers';
+export declare const parseTransportStream: ({ iterator, parserContext, structure, streamBuffers, fields, nextPesHeaderStore, }: {
+    iterator: BufferIterator;
+    parserContext: ParserContext;
+    structure: TransportStreamStructure;
+    streamBuffers: StreamBufferMap;
+    fields: Options<ParseMediaFields>;
+    nextPesHeaderStore: NextPesHeaderStore;
+}) => Promise<ParseResult<TransportStreamStructure>>;

package/dist/boxes/transport-stream/parse-transport-stream.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTransportStream = void 0;
+const has_all_info_1 = require("../../has-all-info");
+const parse_packet_1 = require("./parse-packet");
+const process_stream_buffers_1 = require("./process-stream-buffers");
+const parseTransportStream = async ({ iterator, parserContext, structure, streamBuffers, fields, nextPesHeaderStore, }) => {
+    if (iterator.bytesRemaining() === 0) {
+        await (0, process_stream_buffers_1.processFinalStreamBuffers)({
+            streamBufferMap: streamBuffers,
+            parserContext,
+            structure,
+        });
+        return Promise.resolve({
+            status: 'done',
+            segments: structure,
+        });
+    }
+    while (true) {
+        if ((0, has_all_info_1.hasAllInfo)({
+            fields,
+            state: parserContext.parserState,
+            structure,
+        })) {
+            break;
+        }
+        if (iterator.bytesRemaining() < 188) {
+            return Promise.resolve({
+                status: 'incomplete',
+                segments: structure,
+                skipTo: null,
+                continueParsing: () => {
+                    return (0, exports.parseTransportStream)({
+                        iterator,
+                        parserContext,
+                        structure,
+                        streamBuffers,
+                        fields,
+                        nextPesHeaderStore,
+                    });
+                },
+            });
+        }
+        const packet = await (0, parse_packet_1.parsePacket)({
+            iterator,
+            structure,
+            streamBuffers,
+            parserContext,
+            nextPesHeaderStore,
+        });
+        if (packet) {
+            structure.boxes.push(packet);
+            break;
+        }
+    }
+    return Promise.resolve({
+        segments: structure,
+        status: 'incomplete',
+        continueParsing() {
+            return (0, exports.parseTransportStream)({
+                iterator,
+                parserContext,
+                structure,
+                streamBuffers,
+                fields,
+                nextPesHeaderStore,
+            });
+        },
+        skipTo: null,
+    });
+};
+exports.parseTransportStream = parseTransportStream;

package/dist/boxes/transport-stream/process-stream-buffers.d.ts

@@ -0,0 +1,19 @@
+import type { TransportStreamStructure } from '../../parse-result';
+import type { ParserContext } from '../../parser-context';
+import type { PacketPes } from './parse-pes';
+export type TransportStreamPacketBuffer = {
+    buffer: Uint8Array;
+    pesHeader: PacketPes;
+};
+export type StreamBufferMap = Map<number, TransportStreamPacketBuffer>;
+export declare const processStreamBuffer: ({ streamBuffer, options, programId, structure, }: {
+    streamBuffer: TransportStreamPacketBuffer;
+    options: ParserContext;
+    programId: number;
+    structure: TransportStreamStructure;
+}) => Promise<void>;
+export declare const processFinalStreamBuffers: ({ streamBufferMap, parserContext, structure, }: {
+    streamBufferMap: StreamBufferMap;
+    parserContext: ParserContext;
+    structure: TransportStreamStructure;
+}) => Promise<void>;

package/dist/boxes/transport-stream/process-stream-buffers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFinalStreamBuffers = exports.processStreamBuffer = void 0;
+const handle_aac_packet_1 = require("./handle-aac-packet");
+const handle_avc_packet_1 = require("./handle-avc-packet");
+const traversal_1 = require("./traversal");
+const processStreamBuffer = async ({ streamBuffer, options, programId, structure, }) => {
+    const stream = (0, traversal_1.getStreamForId)(structure, programId);
+    if (!stream) {
+        throw new Error('No stream found');
+    }
+    // 27 = AVC / H.264 Video
+    if (stream.streamType === 27) {
+        await (0, handle_avc_packet_1.handleAvcPacket)({ programId, streamBuffer, options });
+    }
+    // 15 = AAC / ADTS
+    else if (stream.streamType === 15) {
+        await (0, handle_aac_packet_1.handleAacPacket)({ streamBuffer, options, programId });
+    }
+    if (!options.parserState.tracks.hasAllTracks()) {
+        const tracksRegistered = options.parserState.tracks.getTracks().length;
+        const { streams } = (0, traversal_1.findProgramMapTableOrThrow)(structure);
+        if (streams.length === tracksRegistered) {
+            options.parserState.tracks.setIsDone();
+        }
+    }
+};
+exports.processStreamBuffer = processStreamBuffer;
+const processFinalStreamBuffers = async ({ streamBufferMap, parserContext, structure, }) => {
+    for (const [programId, buffer] of streamBufferMap) {
+        if (buffer.buffer.byteLength > 0) {
+            await (0, exports.processStreamBuffer)({
+                streamBuffer: buffer,
+                options: parserContext,
+                programId,
+                structure,
+            });
+            streamBufferMap.delete(programId);
+        }
+    }
+};
+exports.processFinalStreamBuffers = processFinalStreamBuffers;

package/dist/boxes/transport-stream/traversal.d.ts

@@ -0,0 +1,6 @@
+import type { TransportStreamStructure } from '../../parse-result';
+import type { TransportStreamProgramAssociationTableEntry } from './parse-pat';
+import type { TransportStreamEntry } from './parse-pmt';
+export declare const findProgramMapTableOrThrow: (structure: TransportStreamStructure) => import("./boxes").TransportStreamPMTBox;
+export declare const getProgramForId: (structure: TransportStreamStructure, packetIdentifier: number) => TransportStreamProgramAssociationTableEntry | null;
+export declare const getStreamForId: (structure: TransportStreamStructure, packetIdentifier: number) => TransportStreamEntry | null;

package/dist/boxes/transport-stream/traversal.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreamForId = exports.getProgramForId = exports.findProgramMapTableOrThrow = void 0;
+const findProgramAssociationTableOrThrow = (structure) => {
+    const box = structure.boxes.find((b) => b.type === 'transport-stream-pat-box');
+    if (!box) {
+        throw new Error('No PAT box found');
+    }
+    return box;
+};
+const findProgramMapTableOrThrow = (structure) => {
+    const box = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
+    if (!box) {
+        throw new Error('No PMT box found');
+    }
+    return box;
+};
+exports.findProgramMapTableOrThrow = findProgramMapTableOrThrow;
+const getProgramForId = (structure, packetIdentifier) => {
+    const box = findProgramAssociationTableOrThrow(structure);
+    const entry = box.pat.find((e) => e.programMapIdentifier === packetIdentifier);
+    return entry !== null && entry !== void 0 ? entry : null;
+};
+exports.getProgramForId = getProgramForId;
+const getStreamForId = (structure, packetIdentifier) => {
+    const box = (0, exports.findProgramMapTableOrThrow)(structure);
+    const entry = box.streams.find((e) => e.pid === packetIdentifier);
+    return entry !== null && entry !== void 0 ? entry : null;
+};
+exports.getStreamForId = getStreamForId;

package/dist/boxes/webm/parse-ebml.js

@@ -117,9 +117,9 @@ const postprocessEbml = async ({ offset, ebml, parserContext, }) => {
         });
         if (track) {
             await (0, register_track_1.registerTrack)({
-                state: parserContext.parserState,
                 options: parserContext,
                 track,
+                container: 'webm',
             });
         }
     }

package/dist/buffer-iterator.d.ts

@@ -64,5 +64,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
         discardRest: () => void;
         expectNoMoreBytes: () => void;
     };
+    isTransportStream: () => boolean;
+    readExpGolomb: () => number;
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -223,6 +223,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const isMp3 = () => {
         return matchesPattern(mpegPattern)(data.subarray(0, 4));
     };
+    const isTransportStream = () => {
+        return data[0] === 0x47;
+    };
     const removeBytesRead = () => {
         if (!discardAllowed) {
             return;
@@ -262,6 +265,23 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             removeBytesRead();
         }
     };
+    const readExpGolomb = () => {
+        if (!bitReadingMode) {
+            throw new Error('Not in bit reading mode');
+        }
+        let zerosCount = 0;
+        // Step 1: Count the number of leading zeros
+        while (getBits(1) === 0) {
+            zerosCount++;
+        }
+        // Step 2: Read the suffix
+        let suffix = 0;
+        for (let i = 0; i < zerosCount; i++) {
+            suffix = (suffix << 1) | getBits(1);
+        }
+        // Step 3: Calculate the value
+        return (1 << zerosCount) - 1 + suffix;
+    };
     const peekB = (length) => {
         // eslint-disable-next-line no-console
         console.log([...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')));
@@ -286,9 +306,12 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     let bitIndex = 0;
     const stopReadingBits = () => {
         bitIndex = 0;
+        bitReadingMode = false;
     };
     let byteToShift = 0;
+    let bitReadingMode = false;
     const startReadingBits = () => {
+        bitReadingMode = true;
         byteToShift = getUint8();
     };
     const getBits = (bits) => {
@@ -514,6 +537,8 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         disallowDiscard,
         allowDiscard,
         startBox,
+        isTransportStream,
+        readExpGolomb,
     };
 };
 exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/convert-audio-or-video-sample.d.ts

@@ -0,0 +1,2 @@
+import type { AudioOrVideoSample } from './webcodec-sample-types';
+export declare const convertAudioOrVideoSampleToWebCodecsTimestamps: (sample: AudioOrVideoSample, timescale: number) => AudioOrVideoSample;

package/dist/convert-audio-or-video-sample.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAudioOrVideoSampleToWebCodecsTimestamps = void 0;
+const convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale) => {
+    var _a;
+    const { cts, dts, timestamp } = sample;
+    return {
+        cts: (cts * 1000000) / timescale,
+        dts: (dts * 1000000) / timescale,
+        timestamp: (timestamp * 1000000) / timescale,
+        duration: (((_a = sample.duration) !== null && _a !== void 0 ? _a : 0) * 1000000) / timescale,
+        data: sample.data,
+        trackId: sample.trackId,
+        type: sample.type,
+    };
+};
+exports.convertAudioOrVideoSampleToWebCodecsTimestamps = convertAudioOrVideoSampleToWebCodecsTimestamps;