@remotion/media-parser 4.0.237 → 4.0.239

package/dist/boxes/iso-base-media/make-track.js

@@ -6,6 +6,7 @@ const get_fps_1 = require("../../get-fps");
 const get_sample_aspect_ratio_1 = require("../../get-sample-aspect-ratio");
 const get_video_codec_1 = require("../../get-video-codec");
 const get_actual_number_of_channels_1 = require("./get-actual-number-of-channels");
+const get_video_codec_from_iso_track_1 = require("./get-video-codec-from-iso-track");
 const traversal_1 = require("./traversal");
 const makeBaseMediaTrack = (trakBox) => {
     var _a, _b, _c, _d;
@@ -99,7 +100,7 @@ const makeBaseMediaTrack = (trakBox) => {
             primaries: null,
             transferCharacteristics: null,
         },
-        codecWithoutConfig: (0, get_video_codec_1.getVideoCodecFromIsoTrak)(trakBox),
+        codecWithoutConfig: (0, get_video_codec_from_iso_track_1.getVideoCodecFromIsoTrak)(trakBox),
         fps: (0, get_fps_1.getFpsFromMp4TrakBox)(trakBox),
     };
     return track;

package/dist/boxes/iso-base-media/mdat/mdat.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdat = void 0;
+const convert_audio_or_video_sample_1 = require("../../../convert-audio-or-video-sample");
 const get_tracks_1 = require("../../../get-tracks");
 const get_sample_positions_from_track_1 = require("../get-sample-positions-from-track");
 const traversal_1 = require("../traversal");
@@ -76,35 +77,28 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
             break;
         }
         const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
-        const timestamp = (samplesWithIndex.samplePosition.cts * 1000000) /
-            samplesWithIndex.track.timescale;
-        const duration = (samplesWithIndex.samplePosition.duration * 1000000) /
-            samplesWithIndex.track.timescale;
-        const cts = (samplesWithIndex.samplePosition.cts * 1000000) /
-            samplesWithIndex.track.timescale;
-        const dts = (samplesWithIndex.samplePosition.dts * 1000000) /
-            samplesWithIndex.track.timescale;
+        const { cts, dts, duration } = samplesWithIndex.samplePosition;
         if (samplesWithIndex.track.type === 'audio') {
-            await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
+            await options.parserState.onAudioSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
                 data: bytes,
-                timestamp,
+                timestamp: cts,
                 duration,
                 cts,
                 dts,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
-            });
+            }, samplesWithIndex.track.timescale));
         }
         if (samplesWithIndex.track.type === 'video') {
-            await options.parserState.onVideoSample(samplesWithIndex.track.trackId, {
+            await options.parserState.onVideoSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
                 data: bytes,
-                timestamp,
+                timestamp: cts,
                 duration,
                 cts,
                 dts,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
-            });
+            }, samplesWithIndex.track.timescale));
         }
         const remaining = size - (data.counter.getOffset() - fileOffset);
         data.removeBytesRead();

package/dist/boxes/iso-base-media/process-box.js

@@ -396,8 +396,8 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         if (transformedTrack) {
             await (0, register_track_1.registerTrack)({
                 options,
-                state: options.parserState,
                 track: transformedTrack,
+                container: 'mp4',
             });
         }
         return {

package/dist/boxes/riff/parse-box.js

@@ -98,8 +98,8 @@ const parseRiffBody = async ({ iterator, structure, maxOffset, options, }) => {
                 });
                 await (0, register_track_1.registerTrack)({
                     options,
-                    state: options.parserState,
                     track: audioTrack,
+                    container: 'avi',
                 });
             }
             if (options.onVideoTrack && strf.type === 'strf-box-video') {
@@ -110,8 +110,8 @@ const parseRiffBody = async ({ iterator, structure, maxOffset, options, }) => {
                 });
                 (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
                     options,
-                    state: options.parserState,
                     track: videoTrack,
+                    container: 'avi',
                 });
             }
             options.nextTrackIndex++;

package/dist/boxes/riff/parse-movi.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMovi = exports.handleChunk = void 0;
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
-const timescale_1 = require("./timescale");
 const traversal_1 = require("./traversal");
 const getStrhForIndex = (structure, trackId) => {
     const boxes = (0, traversal_1.getStrlBoxes)(structure);
@@ -24,29 +25,26 @@ const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = options.parserState.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
-        const timestamp = Math.floor(timeInSec * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE);
-        const duration = Math.floor((1 / samplesPerSecond) * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE);
+        const timestamp = Math.floor(timeInSec);
+        const duration = Math.floor(1 / samplesPerSecond);
         const data = iterator.getSlice(ckSize);
         const infos = (0, parse_avc_1.parseAvc)(data);
-        const keyOrDelta = infos.find((i) => i.type === 'keyframe' || i.type === 'delta-frame');
-        if (!keyOrDelta) {
-            throw new Error('expected avc to contain info about key or delta');
-        }
+        const keyOrDelta = (0, key_1.getKeyFrameOrDeltaFromAvcInfo)(infos);
         const avcProfile = infos.find((i) => i.type === 'avc-profile');
         const ppsProfile = infos.find((i) => i.type === 'avc-pps');
         if (avcProfile && ppsProfile) {
             await options.parserState.onProfile({ pps: ppsProfile, sps: avcProfile });
             options.parserState.tracks.setIsDone();
         }
-        await options.parserState.onVideoSample(trackId, {
+        await options.parserState.onVideoSample(trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
             cts: timestamp,
             dts: timestamp,
             data,
             duration,
             timestamp,
             trackId,
-            type: keyOrDelta.type === 'keyframe' ? 'key' : 'delta',
-        });
+            type: keyOrDelta,
+        }, 1));
         return;
     }
     const audioChunk = ckId.match(/^([0-9]{2})wb$/);
@@ -56,9 +54,9 @@ const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = options.parserState.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
-        const timestamp = timeInSec * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
-        const duration = (1 / samplesPerSecond) * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
-        await options.parserState.onAudioSample(trackId, {
+        const timestamp = timeInSec;
+        const duration = 1 / samplesPerSecond;
+        await options.parserState.onAudioSample(trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
             cts: timestamp,
             dts: timestamp,
             data: iterator.getSlice(ckSize),
@@ -66,7 +64,7 @@ const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
             timestamp,
             trackId,
             type: 'key',
-        });
+        }, 1));
     }
 };
 exports.handleChunk = handleChunk;

package/dist/boxes/transport-stream/adts-header.d.ts

@@ -0,0 +1,7 @@
+export declare const readAdtsHeader: (buffer: Uint8Array) => {
+    frameLength: number;
+    codecPrivate: Uint8Array;
+    channelConfiguration: number;
+    sampleRate: number;
+    audioObjectType: number;
+} | null;

package/dist/boxes/transport-stream/adts-header.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAdtsHeader = void 0;
+const aac_codecprivate_1 = require("../../aac-codecprivate");
+const buffer_iterator_1 = require("../../buffer-iterator");
+const readAdtsHeader = (buffer) => {
+    if (buffer.byteLength < 9) {
+        return null;
+    }
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(buffer, buffer.byteLength);
+    iterator.startReadingBits();
+    const bits = iterator.getBits(12);
+    if (bits !== 0xfff) {
+        throw new Error('Invalid ADTS header ');
+    }
+    // MPEG Version, set to 0 for MPEG-4 and 1 for MPEG-2.
+    const id = iterator.getBits(1);
+    if (id !== 0) {
+        throw new Error('Only supporting MPEG-4 for .ts');
+    }
+    const layer = iterator.getBits(2);
+    if (layer !== 0) {
+        throw new Error('Only supporting layer 0 for .ts');
+    }
+    const protectionAbsent = iterator.getBits(1); // protection absent
+    const audioObjectType = iterator.getBits(2); // 1 = 'AAC-LC'
+    const samplingFrequencyIndex = iterator.getBits(4);
+    const sampleRate = (0, aac_codecprivate_1.getSampleRateFromSampleFrequencyIndex)(samplingFrequencyIndex);
+    iterator.getBits(1); // private bit
+    const channelConfiguration = iterator.getBits(3);
+    const codecPrivate = (0, aac_codecprivate_1.createAacCodecPrivate)({
+        audioObjectType,
+        sampleRate,
+        channelConfiguration,
+    });
+    iterator.getBits(1); // originality
+    iterator.getBits(1); // home
+    iterator.getBits(1); // copyright bit
+    iterator.getBits(1); // copy start
+    const frameLength = iterator.getBits(13); // frame length
+    iterator.getBits(11); // buffer fullness
+    iterator.getBits(2); // number of AAC frames minus 1
+    if (!protectionAbsent) {
+        iterator.getBits(16); // crc
+    }
+    iterator.stopReadingBits();
+    iterator.destroy();
+    return {
+        frameLength,
+        codecPrivate,
+        channelConfiguration,
+        sampleRate,
+        audioObjectType,
+    };
+};
+exports.readAdtsHeader = readAdtsHeader;

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

@@ -0,0 +1,41 @@
+import type { TransportStreamProgramAssociationTableEntry } from './parse-pat';
+import type { TransportStreamEntry } from './parse-pmt';
+export type TransportStreamAdaptationField = {
+    adaptationFieldLength: number;
+    discontinuityIndicator: number;
+    randomAccessIndicator: number;
+    elementaryStreamPriorityIndicator: number;
+    pcrFlag: number;
+    opcrFlag: number;
+    splicingPointFlag: number;
+    transportPrivateDataFlag: number;
+    adaptationFieldExtensionFlag: number;
+};
+export type TransportStreamHeader = {
+    syncByte: number;
+    transportErrorIndicator: number;
+    payloadUnitStartIndicator: number;
+    transportPriority: number;
+    packetIdentifier: number;
+    transportScramblingControl: number;
+    adaptationFieldControl1: number;
+    adaptationFieldControl2: number;
+    continuityCounter: number;
+    adaptionField: TransportStreamAdaptationField | null;
+    pointerField: number | null;
+};
+export type TransportStreamGenericBox = {
+    header: TransportStreamHeader;
+    type: 'transport-stream-generic-box';
+};
+export type TransportStreamPATBox = {
+    type: 'transport-stream-pat-box';
+    tableId: string;
+    pat: TransportStreamProgramAssociationTableEntry[];
+};
+export type TransportStreamPMTBox = {
+    type: 'transport-stream-pmt-box';
+    tableId: number;
+    streams: TransportStreamEntry[];
+};
+export type TransportStreamBox = TransportStreamGenericBox | TransportStreamPATBox | TransportStreamPMTBox;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/boxes/transport-stream/discard-rest-of-packet.d.ts

@@ -0,0 +1,3 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export declare const discardRestOfPacket: (iterator: BufferIterator) => void;
+export declare const getRestOfPacket: (iterator: BufferIterator) => Uint8Array;

package/dist/boxes/transport-stream/discard-rest-of-packet.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRestOfPacket = exports.discardRestOfPacket = void 0;
+const discardRestOfPacket = (iterator) => {
+    const next188 = 188 - (iterator.counter.getOffset() % 188);
+    iterator.discard(next188);
+};
+exports.discardRestOfPacket = discardRestOfPacket;
+const getRestOfPacket = (iterator) => {
+    const next188 = 188 - (iterator.counter.getOffset() % 188);
+    return iterator.getSlice(next188);
+};
+exports.getRestOfPacket = getRestOfPacket;

package/dist/boxes/transport-stream/find-separator.d.ts

@@ -0,0 +1,2 @@
+import type { TransportStreamEntry } from './parse-pmt';
+export declare const findNextSeparator: (restOfPacket: Uint8Array, transportStreamEntry: TransportStreamEntry) => number;

package/dist/boxes/transport-stream/find-separator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNextSeparator = void 0;
+function findSubarrayIndex(array, subarray) {
+    const subarrayLength = subarray.length;
+    const arrayLength = array.length;
+    for (let i = 0; i <= arrayLength - subarrayLength; i++) {
+        let match = true;
+        for (let j = 0; j < subarrayLength; j++) {
+            if (array[i + j] !== subarray[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match) {
+            if (subarray[i - 1] === 0) {
+                i--;
+            }
+            return i; // Return the starting index of the subarray
+        }
+    }
+    return -1; // Return -1 if subarray is not found
+}
+const findNextSeparator = (restOfPacket, transportStreamEntry) => {
+    if (transportStreamEntry.streamType === 27) {
+        return findSubarrayIndex(restOfPacket, new Uint8Array([0, 0, 1, 9]));
+    }
+    throw new Error(`Unsupported stream ID ${transportStreamEntry.streamType}`);
+};
+exports.findNextSeparator = findNextSeparator;

package/dist/boxes/transport-stream/get-tracks.d.ts

@@ -0,0 +1,5 @@
+import type { TransportStreamStructure } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+import type { AllTracks } from '../riff/get-tracks-from-avi';
+export declare const getTracksFromTransportStream: (structure: TransportStreamStructure, parserState: ParserState) => AllTracks;
+export declare const hasAllTracksFromTransportStream: (structure: TransportStreamStructure, parserState: ParserState) => boolean;

package/dist/boxes/transport-stream/get-tracks.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAllTracksFromTransportStream = exports.getTracksFromTransportStream = void 0;
+const truthy_1 = require("../../truthy");
+const traversal_1 = require("./traversal");
+const getTracksFromTransportStream = (structure, parserState) => {
+    const programMapTable = (0, traversal_1.findProgramMapTableOrThrow)(structure);
+    const parserTracks = parserState.tracks.getTracks();
+    const mapped = programMapTable.streams
+        .map((stream) => {
+        return parserTracks.find((track) => track.trackId === stream.pid);
+    })
+        .filter(truthy_1.truthy);
+    if (mapped.length !== programMapTable.streams.length) {
+        throw new Error('Not all tracks found');
+    }
+    return {
+        videoTracks: mapped.filter((track) => track.type === 'video'),
+        audioTracks: mapped.filter((track) => track.type === 'audio'),
+        otherTracks: [],
+    };
+};
+exports.getTracksFromTransportStream = getTracksFromTransportStream;
+const hasAllTracksFromTransportStream = (structure, parserState) => {
+    try {
+        (0, exports.getTracksFromTransportStream)(structure, parserState);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.hasAllTracksFromTransportStream = hasAllTracksFromTransportStream;

package/dist/boxes/transport-stream/handle-aac-packet.d.ts

@@ -0,0 +1,7 @@
+import type { ParserContext } from '../../parser-context';
+import type { TransportStreamPacketBuffer } from './process-stream-buffers';
+export declare const handleAacPacket: ({ streamBuffer, options, programId, }: {
+    streamBuffer: TransportStreamPacketBuffer;
+    options: ParserContext;
+    programId: number;
+}) => Promise<void>;

package/dist/boxes/transport-stream/handle-aac-packet.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAacPacket = void 0;
+const aac_codecprivate_1 = require("../../aac-codecprivate");
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const register_track_1 = require("../../register-track");
+const adts_header_1 = require("./adts-header");
+const handle_avc_packet_1 = require("./handle-avc-packet");
+const handleAacPacket = async ({ streamBuffer, options, programId, }) => {
+    var _a;
+    const adtsHeader = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer);
+    if (!adtsHeader) {
+        throw new Error('Invalid ADTS header - too short');
+    }
+    const { channelConfiguration, codecPrivate, sampleRate, audioObjectType } = adtsHeader;
+    const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+        return t.trackId === programId;
+    });
+    if (!isTrackRegistered) {
+        const track = {
+            type: 'audio',
+            codecPrivate,
+            trackId: programId,
+            trakBox: null,
+            timescale: handle_avc_packet_1.MPEG_TIMESCALE,
+            codecWithoutConfig: 'aac',
+            codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
+            // https://www.w3.org/TR/webcodecs-aac-codec-registration/
+            description: undefined,
+            numberOfChannels: channelConfiguration,
+            sampleRate,
+        };
+        await (0, register_track_1.registerTrack)({
+            track,
+            options,
+            container: 'transport-stream',
+        });
+    }
+    const sample = {
+        cts: streamBuffer.pesHeader.pts,
+        dts: (_a = streamBuffer.pesHeader.dts) !== null && _a !== void 0 ? _a : streamBuffer.pesHeader.pts,
+        timestamp: streamBuffer.pesHeader.pts,
+        duration: undefined,
+        data: new Uint8Array(streamBuffer.buffer),
+        trackId: programId,
+        type: 'key',
+    };
+    await options.parserState.onAudioSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, handle_avc_packet_1.MPEG_TIMESCALE));
+};
+exports.handleAacPacket = handleAacPacket;

package/dist/boxes/transport-stream/handle-avc-packet.d.ts

@@ -0,0 +1,8 @@
+import type { ParserContext } from '../../parser-context';
+import type { TransportStreamPacketBuffer } from './process-stream-buffers';
+export declare const MPEG_TIMESCALE = 90000;
+export declare const handleAvcPacket: ({ streamBuffer, programId, options, }: {
+    streamBuffer: TransportStreamPacketBuffer;
+    programId: number;
+    options: ParserContext;
+}) => Promise<void>;

package/dist/boxes/transport-stream/handle-avc-packet.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAvcPacket = exports.MPEG_TIMESCALE = void 0;
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const register_track_1 = require("../../register-track");
+const codec_private_1 = require("../avc/codec-private");
+const codec_string_1 = require("../avc/codec-string");
+const interpret_sps_1 = require("../avc/interpret-sps");
+const key_1 = require("../avc/key");
+const parse_avc_1 = require("../avc/parse-avc");
+const sps_and_pps_1 = require("../avc/sps-and-pps");
+exports.MPEG_TIMESCALE = 90000;
+const handleAvcPacket = async ({ streamBuffer, programId, options, }) => {
+    var _a;
+    const avc = (0, parse_avc_1.parseAvc)(streamBuffer.buffer);
+    const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+        return t.trackId === programId;
+    });
+    if (!isTrackRegistered) {
+        const spsAndPps = (0, sps_and_pps_1.getSpsAndPps)(avc);
+        const dimensions = (0, interpret_sps_1.getDimensionsFromSps)(spsAndPps.sps.spsData);
+        const sampleAspectRatio = (0, interpret_sps_1.getSampleAspectRatioFromSps)(spsAndPps.sps.spsData);
+        const track = {
+            rotation: 0,
+            trackId: programId,
+            type: 'video',
+            timescale: exports.MPEG_TIMESCALE,
+            codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(spsAndPps.sps),
+            codecPrivate: (0, codec_private_1.getAvccBoxContent)(spsAndPps),
+            fps: null,
+            codedWidth: dimensions.width,
+            codedHeight: dimensions.height,
+            height: dimensions.height,
+            width: dimensions.width,
+            displayAspectWidth: dimensions.width,
+            displayAspectHeight: dimensions.height,
+            trakBox: null,
+            codecWithoutConfig: 'h264',
+            description: undefined,
+            sampleAspectRatio: {
+                denominator: sampleAspectRatio.height,
+                numerator: sampleAspectRatio.width,
+            },
+            color: (0, interpret_sps_1.getVideoColorFromSps)(spsAndPps.sps.spsData),
+        };
+        await (0, register_track_1.registerTrack)({ track, options, container: 'transport-stream' });
+    }
+    // sample for webcodecs needs to be in nano seconds
+    const sample = {
+        cts: streamBuffer.pesHeader.pts,
+        dts: (_a = streamBuffer.pesHeader.dts) !== null && _a !== void 0 ? _a : streamBuffer.pesHeader.pts,
+        timestamp: streamBuffer.pesHeader.pts,
+        duration: undefined,
+        data: new Uint8Array(streamBuffer.buffer),
+        trackId: programId,
+        type: (0, key_1.getKeyFrameOrDeltaFromAvcInfo)(avc),
+    };
+    await options.parserState.onVideoSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, exports.MPEG_TIMESCALE));
+};
+exports.handleAvcPacket = handleAvcPacket;

package/dist/boxes/transport-stream/next-pes-header-store.d.ts

@@ -0,0 +1,6 @@
+import type { PacketPes } from './parse-pes';
+export declare const makeNextPesHeaderStore: () => {
+    setNextPesHeader: (pesHeader: PacketPes) => void;
+    getNextPesHeader: () => PacketPes;
+};
+export type NextPesHeaderStore = ReturnType<typeof makeNextPesHeaderStore>;

package/dist/boxes/transport-stream/next-pes-header-store.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNextPesHeaderStore = void 0;
+const makeNextPesHeaderStore = () => {
+    let nextPesHeader = null;
+    return {
+        setNextPesHeader: (pesHeader) => {
+            nextPesHeader = pesHeader;
+        },
+        getNextPesHeader: () => {
+            if (!nextPesHeader) {
+                throw new Error('No next PES header found');
+            }
+            return nextPesHeader;
+        },
+    };
+};
+exports.makeNextPesHeaderStore = makeNextPesHeaderStore;

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

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { TransportStreamStructure } from '../../parse-result';
+import type { ParserContext } from '../../parser-context';
+import type { TransportStreamBox } from './boxes';
+import type { NextPesHeaderStore } from './next-pes-header-store';
+import { type StreamBufferMap } from './process-stream-buffers';
+export declare const parsePacket: ({ iterator, structure, streamBuffers, parserContext, nextPesHeaderStore, }: {
+    iterator: BufferIterator;
+    structure: TransportStreamStructure;
+    streamBuffers: StreamBufferMap;
+    parserContext: ParserContext;
+    nextPesHeaderStore: NextPesHeaderStore;
+}) => Promise<TransportStreamBox | null>;

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePacket = void 0;
+const parse_pat_1 = require("./parse-pat");
+const parse_pes_1 = require("./parse-pes");
+const parse_pmt_1 = require("./parse-pmt");
+const parse_stream_packet_1 = require("./parse-stream-packet");
+const traversal_1 = require("./traversal");
+const parsePacket = async ({ iterator, structure, streamBuffers, parserContext, nextPesHeaderStore, }) => {
+    const offset = iterator.counter.getOffset();
+    const syncByte = iterator.getUint8();
+    if (syncByte !== 0x47) {
+        throw new Error('Invalid sync byte');
+    }
+    iterator.startReadingBits();
+    iterator.getBits(1); // transport error indicator
+    const payloadUnitStartIndicator = iterator.getBits(1);
+    iterator.getBits(1); // transport priority
+    const programId = iterator.getBits(13);
+    iterator.getBits(2); // transport scrambling control
+    const adaptationFieldControl1 = iterator.getBits(1); // adaptation field control 1
+    iterator.getBits(1); // adaptation field control 2
+    iterator.getBits(4); // continuity counter
+    iterator.stopReadingBits();
+    if (adaptationFieldControl1 === 1) {
+        iterator.startReadingBits();
+        const adaptationFieldLength = iterator.getBits(8);
+        const headerOffset = iterator.counter.getOffset();
+        if (adaptationFieldLength > 0) {
+            iterator.getBits(1); // discontinuity indicator
+            iterator.getBits(1); // random access indicator
+            iterator.getBits(1); // elementary stream priority indicator
+            iterator.getBits(1); // PCR flag
+            iterator.getBits(1); // OPCR flag
+            iterator.getBits(1); // splicing point flag
+            iterator.getBits(1); // transport private data flag
+            iterator.getBits(1); // adaptation field extension flag
+        }
+        const remaining = adaptationFieldLength - (iterator.counter.getOffset() - headerOffset);
+        iterator.stopReadingBits();
+        const toDiscard = Math.max(0, remaining);
+        iterator.discard(toDiscard);
+    }
+    const read = iterator.counter.getOffset() - offset;
+    if (read === 188) {
+        return Promise.resolve(null);
+    }
+    const pat = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
+    const isPes = payloadUnitStartIndicator && (pat === null || pat === void 0 ? void 0 : pat.streams.find((e) => e.pid === programId));
+    if (isPes) {
+        const packetPes = (0, parse_pes_1.parsePes)(iterator);
+        nextPesHeaderStore.setNextPesHeader(packetPes);
+    }
+    else if (payloadUnitStartIndicator === 1) {
+        iterator.getUint8(); // pointerField
+    }
+    if (programId === 0) {
+        return Promise.resolve((0, parse_pat_1.parsePat)(iterator));
+    }
+    const program = (0, traversal_1.getProgramForId)(structure, programId);
+    if (program) {
+        const pmt = (0, parse_pmt_1.parsePmt)(iterator);
+        return Promise.resolve(pmt);
+    }
+    const stream = (0, traversal_1.getStreamForId)(structure, programId);
+    if (stream) {
+        await (0, parse_stream_packet_1.parseStream)({
+            iterator,
+            transportStreamEntry: stream,
+            streamBuffers,
+            nextPesHeader: nextPesHeaderStore.getNextPesHeader(),
+            parserContext,
+            programId,
+            structure,
+        });
+        return Promise.resolve(null);
+    }
+    throw new Error('Unknown packet identifier');
+};
+exports.parsePacket = parsePacket;

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

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { TransportStreamPATBox } from './boxes';
+export type TransportStreamProgramAssociationTableEntry = {
+    type: 'transport-stream-program-association-table';
+    programNumber: number;
+    programMapIdentifier: number;
+};
+export declare const parsePat: (iterator: BufferIterator) => TransportStreamPATBox;