@amazon/vinyl-transmux 1.0.0

package/dist/types/current/mp4/mp4.js

@@ -0,0 +1,338 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * ISO BMFF (MP4) box writing utilities.
+ *
+ * Provides functions to construct the fMP4 boxes required by MSE:
+ * - `ftyp`: file type
+ * - `moov` / `mvhd` / `trak` / `mdia` / `minf` / `stbl`: track metadata
+ * - `moof` / `mdat`: media fragments
+ *
+ * @module
+ */
+import { BufferWriter } from '@amazon/vinyl-util';
+/** ISO 14496-12 identity matrix in 16.16 / 2.30 fixed point. */
+const UNITY_MATRIX = [
+    0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000,
+];
+/** 90 kHz timescale from ISO 13818-1 (MPEG system clock). */
+export const MPEG_TIMESCALE = 90000;
+/** ISO 639-2/T packed language code for 'und' (undetermined). */
+const LANGUAGE_UNDETERMINED = 0x55c4;
+/**
+ * Writes a generic MP4 box (atom). The size field is automatically computed.
+ */
+export function box(type, ...payloads) {
+    let size = 8;
+    for (const p of payloads)
+        size += p.byteLength;
+    const writer = new BufferWriter(size);
+    writer.writeUint32(size);
+    writer.writeString(type);
+    for (const p of payloads)
+        writer.writeBytes(p);
+    return writer.toUint8Array();
+}
+/**
+ * Writes a full box with version and flags.
+ */
+export function fullBox(type, version, flags, payload) {
+    const size = 12 + payload.byteLength;
+    const writer = new BufferWriter(size);
+    writer.writeUint32(size);
+    writer.writeString(type);
+    writer.writeUint8(version);
+    // 24-bit flags
+    writer.writeUint8((flags >> 16) & 0xff);
+    writer.writeUint8((flags >> 8) & 0xff);
+    writer.writeUint8(flags & 0xff);
+    writer.writeBytes(payload);
+    return writer.toUint8Array();
+}
+const DEFAULT_FTYP = {
+    majorBrand: 'isom',
+    minorVersion: 0x200,
+    compatibleBrands: ['isom', 'iso6', 'mp41'],
+};
+/**
+ * Generates the ftyp box.
+ */
+export function ftyp(options) {
+    const { majorBrand, minorVersion, compatibleBrands } = {
+        ...DEFAULT_FTYP,
+        ...options,
+    };
+    const writer = new BufferWriter(8 + compatibleBrands.length * 4);
+    writer.writeString(majorBrand);
+    writer.writeUint32(minorVersion);
+    for (const brand of compatibleBrands)
+        writer.writeString(brand);
+    return box('ftyp', writer.toUint8Array());
+}
+/**
+ * Generates a moov box from pre-built track boxes.
+ */
+export function moov(...traks) {
+    const trakAndMvex = [];
+    for (let i = 0; i < traks.length; i++) {
+        trakAndMvex.push(traks[i], mvex(i + 1));
+    }
+    return box('moov', mvhd(), ...trakAndMvex);
+}
+const DEFAULT_MVHD = {
+    timescale: MPEG_TIMESCALE,
+    duration: 0,
+    rate: 1.0,
+    volume: 1.0,
+};
+function mvhd(options) {
+    const { timescale, duration, rate, volume } = {
+        ...DEFAULT_MVHD,
+        ...options,
+    };
+    const writer = new BufferWriter(96);
+    writer.writeUint32(0); // creation_time
+    writer.writeUint32(0); // modification_time
+    writer.writeUint32(timescale);
+    writer.writeUint32(duration);
+    writer.writeUint32(rate * 0x10000); // 16.16 fixed point
+    writer.writeUint16(volume * 0x100); // 8.8 fixed point
+    // 10 bytes reserved
+    for (let i = 0; i < 10; i++)
+        writer.writeUint8(0);
+    for (const v of UNITY_MATRIX)
+        writer.writeUint32(v);
+    // 6 x uint32 pre_defined
+    for (let i = 0; i < 6; i++)
+        writer.writeUint32(0);
+    writer.writeUint32(0xffffffff); // next_track_ID
+    return fullBox('mvhd', 0, 0, writer.toUint8Array());
+}
+export function audioTrak(options) {
+    return box('trak', tkhd(options.trackId, 0, 0, options.channelCount > 0 ? 1.0 : 0), box('mdia', mdhd(options.sampleRate), hdlr('soun', 'SoundHandler'), box('minf', smhd(), dinf(), audioStbl(options.sampleEntry))));
+}
+export function videoTrak(options) {
+    return box('trak', tkhd(options.trackId, options.width, options.height, 0), box('mdia', mdhd(options.timescale ?? MPEG_TIMESCALE), hdlr('vide', 'VideoHandler'), box('minf', vmhd(), dinf(), videoStbl(options.sampleEntry))));
+}
+function tkhd(trackId, width, height, volume) {
+    const writer = new BufferWriter(80);
+    writer.writeUint32(0); // creation_time
+    writer.writeUint32(0); // modification_time
+    writer.writeUint32(trackId);
+    writer.writeUint32(0); // reserved
+    writer.writeUint32(0); // duration
+    writer.writeUint32(0); // reserved
+    writer.writeUint32(0); // reserved
+    writer.writeUint16(0); // layer
+    writer.writeUint16(0); // alternate_group
+    writer.writeUint16(volume * 0x100); // volume (8.8 fixed point)
+    writer.writeUint16(0); // reserved
+    // unity matrix
+    for (const v of UNITY_MATRIX)
+        writer.writeUint32(v);
+    writer.writeUint32(width * 0x10000); // width (16.16 fixed point)
+    writer.writeUint32(height * 0x10000); // height (16.16 fixed point)
+    return fullBox('tkhd', 0, 0x000003, writer.toUint8Array());
+}
+function mdhd(timescale) {
+    const writer = new BufferWriter(20);
+    writer.writeUint32(0); // creation_time
+    writer.writeUint32(0); // modification_time
+    writer.writeUint32(timescale);
+    writer.writeUint32(0); // duration
+    writer.writeUint16(LANGUAGE_UNDETERMINED);
+    writer.writeUint16(0); // pre_defined
+    return fullBox('mdhd', 0, 0, writer.toUint8Array());
+}
+function hdlr(handlerType, name) {
+    const writer = new BufferWriter(21 + name.length);
+    writer.writeUint32(0); // pre_defined
+    writer.writeString(handlerType);
+    writer.writeUint32(0); // reserved
+    writer.writeUint32(0); // reserved
+    writer.writeUint32(0); // reserved
+    writer.writeString(name);
+    writer.writeUint8(0); // null terminator
+    return fullBox('hdlr', 0, 0, writer.toUint8Array());
+}
+function smhd() {
+    const writer = new BufferWriter(4);
+    writer.writeUint16(0); // balance
+    writer.writeUint16(0); // reserved
+    return fullBox('smhd', 0, 0, writer.toUint8Array());
+}
+function vmhd() {
+    const writer = new BufferWriter(8);
+    writer.writeUint16(0); // graphicsmode
+    writer.writeUint16(0); // opcolor
+    writer.writeUint16(0);
+    writer.writeUint16(0);
+    return fullBox('vmhd', 0, 0x000001, writer.toUint8Array());
+}
+function dinf() {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(1); // entry_count
+    const urlBox = fullBox('url ', 0, 0x000001, new Uint8Array(0));
+    return box('dinf', fullBox('dref', 0, 0, concatUint8(writer.toUint8Array(), urlBox)));
+}
+function audioStbl(sampleEntry) {
+    return box('stbl', stsd(sampleEntry), stts(), stsc(), stsz(), stco());
+}
+function videoStbl(sampleEntry) {
+    return box('stbl', stsd(sampleEntry), stts(), stsc(), stsz(), stco());
+}
+function stsd(sampleEntry) {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(1); // entry_count
+    return fullBox('stsd', 0, 0, concatUint8(writer.toUint8Array(), sampleEntry));
+}
+function stts() {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(0); // entry_count
+    return fullBox('stts', 0, 0, writer.toUint8Array());
+}
+function stsc() {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(0); // entry_count
+    return fullBox('stsc', 0, 0, writer.toUint8Array());
+}
+function stsz() {
+    const writer = new BufferWriter(8);
+    writer.writeUint32(0); // sample_size
+    writer.writeUint32(0); // sample_count
+    return fullBox('stsz', 0, 0, writer.toUint8Array());
+}
+function stco() {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(0); // entry_count
+    return fullBox('stco', 0, 0, writer.toUint8Array());
+}
+function mvex(trackId) {
+    return box('mvex', trex(trackId));
+}
+function trex(trackId) {
+    const writer = new BufferWriter(20);
+    writer.writeUint32(trackId);
+    writer.writeUint32(1); // default_sample_description_index
+    writer.writeUint32(0); // default_sample_duration
+    writer.writeUint32(0); // default_sample_size
+    writer.writeUint32(0); // default_sample_flags
+    return fullBox('trex', 0, 0, writer.toUint8Array());
+}
+/**
+ * Generates a moof (movie fragment) box.
+ */
+export function moof(options) {
+    return box('moof', mfhd(options.sequenceNumber), traf(options));
+}
+function mfhd(sequenceNumber) {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(sequenceNumber);
+    return fullBox('mfhd', 0, 0, writer.toUint8Array());
+}
+function traf(options) {
+    return box('traf', tfhd(options.trackId), tfdt(options.baseDecodeTime), trun(options.samples));
+}
+function tfhd(trackId) {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(trackId);
+    // flags: default-base-is-moof (0x020000)
+    return fullBox('tfhd', 0, 0x020000, writer.toUint8Array());
+}
+function tfdt(baseDecodeTime) {
+    const writer = new BufferWriter(4);
+    writer.writeUint32(baseDecodeTime);
+    return fullBox('tfdt', 0, 0, writer.toUint8Array());
+}
+function trun(samples) {
+    // flags: data-offset-present (0x01), sample-duration-present (0x100),
+    // sample-size-present (0x200), sample-flags-present (0x400)
+    const hasFlags = samples.some((s) => s.flags != null);
+    const hasCto = samples.some((s) => s.compositionTimeOffset != null);
+    let flags = 0x000001 | 0x000100 | 0x000200;
+    if (hasFlags)
+        flags |= 0x000400;
+    if (hasCto)
+        flags |= 0x000800;
+    let entrySize = 8; // duration + size
+    if (hasFlags)
+        entrySize += 4;
+    if (hasCto)
+        entrySize += 4;
+    const writer = new BufferWriter(8 + samples.length * entrySize);
+    writer.writeUint32(samples.length); // sample_count
+    writer.writeUint32(0); // data_offset (placeholder, patched later)
+    for (const sample of samples) {
+        writer.writeUint32(sample.duration);
+        writer.writeUint32(sample.size);
+        if (hasFlags)
+            writer.writeUint32(sample.flags ?? 0);
+        if (hasCto)
+            writer.writeInt32(sample.compositionTimeOffset ?? 0);
+    }
+    const result = fullBox('trun', hasCto ? 1 : 0, flags, writer.toUint8Array());
+    return result;
+}
+/**
+ * Generates an mdat box wrapping raw media data.
+ */
+export function mdat(data) {
+    return box('mdat', data);
+}
+/**
+ * Patches the trun data_offset field. The data_offset is the byte offset from
+ * the start of the moof to the first byte of the mdat payload.
+ */
+export function patchDataOffset(moofData, moofSize) {
+    // data_offset = moofSize + 8 (mdat header)
+    const dataOffset = moofSize + 8;
+    // Find trun box and patch the data_offset field.
+    // trun is inside moof > traf. Walk the box tree.
+    let pos = 8; // skip moof header
+    while (pos < moofData.length) {
+        const boxSize = ((moofData[pos] << 24) |
+            (moofData[pos + 1] << 16) |
+            (moofData[pos + 2] << 8) |
+            moofData[pos + 3]) >>>
+            0;
+        const boxType = String.fromCharCode(moofData[pos + 4], moofData[pos + 5], moofData[pos + 6], moofData[pos + 7]);
+        if (boxType === 'traf') {
+            // Recurse into traf
+            let trafPos = pos + 8;
+            while (trafPos < pos + boxSize) {
+                const innerSize = ((moofData[trafPos] << 24) |
+                    (moofData[trafPos + 1] << 16) |
+                    (moofData[trafPos + 2] << 8) |
+                    moofData[trafPos + 3]) >>>
+                    0;
+                const innerType = String.fromCharCode(moofData[trafPos + 4], moofData[trafPos + 5], moofData[trafPos + 6], moofData[trafPos + 7]);
+                if (innerType === 'trun') {
+                    // data_offset is at offset 12+4 = 16 from box start
+                    // (8 box header + 4 version/flags + 4 sample_count)
+                    const offsetPos = trafPos + 16;
+                    moofData[offsetPos] = (dataOffset >> 24) & 0xff;
+                    moofData[offsetPos + 1] = (dataOffset >> 16) & 0xff;
+                    moofData[offsetPos + 2] = (dataOffset >> 8) & 0xff;
+                    moofData[offsetPos + 3] = dataOffset & 0xff;
+                    return;
+                }
+                trafPos += innerSize;
+            }
+        }
+        pos += boxSize;
+    }
+}
+function concatUint8(...arrays) {
+    let total = 0;
+    for (const a of arrays)
+        total += a.byteLength;
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const a of arrays) {
+        result.set(a, offset);
+        offset += a.byteLength;
+    }
+    return result;
+}

package/dist/types/current/mpegts/mpegts.d.ts

@@ -0,0 +1,68 @@
+/**
+ * MPEG-TS constants and packet-level parsing.
+ *
+ * An MPEG Transport Stream consists of fixed 188-byte packets. Each packet
+ * starts with a sync byte (0x47) and carries a 13-bit PID identifying the
+ * elementary stream. The PAT (PID 0) maps program numbers to PMT PIDs, and
+ * the PMT lists the elementary stream PIDs with their stream types.
+ *
+ * @module
+ */
+export declare const TS_PACKET_SIZE = 188;
+export declare const TS_SYNC_BYTE = 71;
+/** Well-known stream type identifiers from ISO/IEC 13818-1. */
+export declare const STREAM_TYPE_AAC = 15;
+export declare const STREAM_TYPE_H264 = 27;
+export declare const STREAM_TYPE_H265 = 36;
+export declare const STREAM_TYPE_ID3 = 21;
+export interface TsPacketHeader {
+    readonly pid: number;
+    readonly payloadUnitStartIndicator: boolean;
+    readonly adaptationFieldControl: number;
+    readonly continuityCounter: number;
+}
+export interface PmtEntry {
+    readonly pid: number;
+    readonly streamType: number;
+}
+/**
+ * Parses a single 188-byte TS packet header.
+ */
+export declare function parseTsPacketHeader(data: Uint8Array, offset: number): TsPacketHeader;
+/**
+ * Returns the offset of the payload within a TS packet.
+ */
+export declare function getPayloadOffset(data: Uint8Array, offset: number, adaptationFieldControl: number): number;
+/**
+ * Parses the PAT (Program Association Table) to find the PMT PID.
+ */
+export declare function parsePat(data: Uint8Array, offset: number): number;
+/**
+ * Parses the PMT (Program Map Table) to extract elementary stream entries.
+ */
+export declare function parsePmt(data: Uint8Array, offset: number): PmtEntry[];
+export interface DemuxedStream {
+    readonly streamType: number;
+    readonly pid: number;
+    readonly data: Uint8Array[];
+}
+/**
+ * Demuxes a complete MPEG-TS segment into elementary streams.
+ * Reassembles PES packets from TS packets for each PID.
+ */
+export declare function demuxTsSegment(segment: Uint8Array): DemuxedStream[];
+/**
+ * Concatenates an array of Uint8Arrays into a single Uint8Array.
+ */
+export declare function concatBuffers(buffers: Uint8Array[]): Uint8Array;
+/**
+ * Strips the PES header from raw PES packet data, returning the elementary
+ * stream payload.
+ */
+export declare function stripPesHeader(pesData: Uint8Array): Uint8Array;
+/**
+ * Extracts the PTS (Presentation Time Stamp) from a PES header.
+ * Returns the PTS in 90kHz clock ticks, or -1 if not present.
+ */
+export declare function parsePesPts(pesData: Uint8Array): number;
+//# sourceMappingURL=mpegts.d.ts.map

package/dist/types/current/mpegts/mpegts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpegts.d.ts","sourceRoot":"","sources":["../../../../src/mpegts/mpegts.ts"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AAEH,eAAO,MAAM,cAAc,MAAM,CAAA;AACjC,eAAO,MAAM,YAAY,KAAO,CAAA;AAEhC,+DAA+D;AAC/D,eAAO,MAAM,eAAe,KAAO,CAAA;AACnC,eAAO,MAAM,gBAAgB,KAAO,CAAA;AACpC,eAAO,MAAM,gBAAgB,KAAO,CAAA;AACpC,eAAO,MAAM,eAAe,KAAO,CAAA;AAEnC,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAA;IAC3C,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAA;IACvC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CACrC;AAED,MAAM,WAAW,QAAQ;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC9B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,GACf,cAAc,CAUhB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,sBAAsB,EAAE,MAAM,GAC/B,MAAM,CAOR;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAWjE;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE,CA6BrE;AAED,MAAM,WAAW,aAAa;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,CAAA;CAC9B;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,UAAU,GAAG,aAAa,EAAE,CAoEnE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,CAU/D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAS9D;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAiBvD"}

package/dist/types/current/mpegts/mpegts.js

@@ -0,0 +1,202 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * MPEG-TS constants and packet-level parsing.
+ *
+ * An MPEG Transport Stream consists of fixed 188-byte packets. Each packet
+ * starts with a sync byte (0x47) and carries a 13-bit PID identifying the
+ * elementary stream. The PAT (PID 0) maps program numbers to PMT PIDs, and
+ * the PMT lists the elementary stream PIDs with their stream types.
+ *
+ * @module
+ */
+export const TS_PACKET_SIZE = 188;
+export const TS_SYNC_BYTE = 0x47;
+/** Well-known stream type identifiers from ISO/IEC 13818-1. */
+export const STREAM_TYPE_AAC = 0x0f;
+export const STREAM_TYPE_H264 = 0x1b;
+export const STREAM_TYPE_H265 = 0x24;
+export const STREAM_TYPE_ID3 = 0x15;
+/**
+ * Parses a single 188-byte TS packet header.
+ */
+export function parseTsPacketHeader(data, offset) {
+    const byte1 = data[offset + 1];
+    const byte2 = data[offset + 2];
+    const byte3 = data[offset + 3];
+    return {
+        pid: ((byte1 & 0x1f) << 8) | byte2,
+        payloadUnitStartIndicator: (byte1 & 0x40) !== 0,
+        adaptationFieldControl: (byte3 >> 4) & 0x03,
+        continuityCounter: byte3 & 0x0f,
+    };
+}
+/**
+ * Returns the offset of the payload within a TS packet.
+ */
+export function getPayloadOffset(data, offset, adaptationFieldControl) {
+    let payloadOffset = offset + 4;
+    if (adaptationFieldControl >= 2) {
+        // Adaptation field present
+        payloadOffset += 1 + data[offset + 4];
+    }
+    return payloadOffset;
+}
+/**
+ * Parses the PAT (Program Association Table) to find the PMT PID.
+ */
+export function parsePat(data, offset) {
+    // Skip pointer field
+    const pointerField = data[offset];
+    let pos = offset + 1 + pointerField;
+    // Skip table_id(1), section_syntax_indicator+length(2), transport_stream_id(2),
+    // version/current(1), section_number(1), last_section_number(1)
+    pos += 8;
+    // First program entry: program_number(2) + PMT_PID(2)
+    // Skip program_number
+    pos += 2;
+    return ((data[pos] & 0x1f) << 8) | data[pos + 1];
+}
+/**
+ * Parses the PMT (Program Map Table) to extract elementary stream entries.
+ */
+export function parsePmt(data, offset) {
+    const pointerField = data[offset];
+    let pos = offset + 1 + pointerField;
+    // table_id(1)
+    pos += 1;
+    const sectionLength = ((data[pos] & 0x0f) << 8) | data[pos + 1];
+    pos += 2;
+    const sectionEnd = pos + sectionLength;
+    // transport_stream_id(2), version/current(1), section_number(1), last_section_number(1)
+    pos += 5;
+    // PCR_PID(2)
+    pos += 2;
+    // program_info_length
+    const programInfoLength = ((data[pos] & 0x0f) << 8) | data[pos + 1];
+    pos += 2 + programInfoLength;
+    const entries = [];
+    // -4 for CRC32
+    while (pos < sectionEnd - 4) {
+        const streamType = data[pos];
+        pos += 1;
+        const pid = ((data[pos] & 0x1f) << 8) | data[pos + 1];
+        pos += 2;
+        const esInfoLength = ((data[pos] & 0x0f) << 8) | data[pos + 1];
+        pos += 2 + esInfoLength;
+        entries.push({ pid, streamType });
+    }
+    return entries;
+}
+/**
+ * Demuxes a complete MPEG-TS segment into elementary streams.
+ * Reassembles PES packets from TS packets for each PID.
+ */
+export function demuxTsSegment(segment) {
+    let pmtPid = -1;
+    const pmtEntries = [];
+    const pesBuffers = new Map();
+    // First pass: find PAT and PMT
+    for (let i = 0; i + TS_PACKET_SIZE <= segment.length; i += TS_PACKET_SIZE) {
+        if (segment[i] !== TS_SYNC_BYTE)
+            continue;
+        const header = parseTsPacketHeader(segment, i);
+        const payloadStart = getPayloadOffset(segment, i, header.adaptationFieldControl);
+        if (header.adaptationFieldControl === 0 ||
+            header.adaptationFieldControl === 2)
+            continue;
+        if (header.pid === 0) {
+            pmtPid = parsePat(segment, payloadStart);
+        }
+        else if (header.pid === pmtPid && pmtEntries.length === 0) {
+            pmtEntries.push(...parsePmt(segment, payloadStart));
+        }
+    }
+    // Initialize buffers for known elementary streams
+    const pidToStreamType = new Map();
+    for (const entry of pmtEntries) {
+        pidToStreamType.set(entry.pid, entry.streamType);
+        pesBuffers.set(entry.pid, []);
+    }
+    // Second pass: collect PES data
+    for (let i = 0; i + TS_PACKET_SIZE <= segment.length; i += TS_PACKET_SIZE) {
+        if (segment[i] !== TS_SYNC_BYTE)
+            continue;
+        const header = parseTsPacketHeader(segment, i);
+        if (header.adaptationFieldControl === 0 ||
+            header.adaptationFieldControl === 2)
+            continue;
+        const buffers = pesBuffers.get(header.pid);
+        if (!buffers)
+            continue;
+        const payloadStart = getPayloadOffset(segment, i, header.adaptationFieldControl);
+        const payloadEnd = i + TS_PACKET_SIZE;
+        if (payloadStart < payloadEnd) {
+            buffers.push(segment.slice(payloadStart, payloadEnd));
+        }
+    }
+    const streams = [];
+    for (const [pid, buffers] of pesBuffers) {
+        if (buffers.length === 0)
+            continue;
+        streams.push({
+            pid,
+            streamType: pidToStreamType.get(pid),
+            data: buffers,
+        });
+    }
+    return streams;
+}
+/**
+ * Concatenates an array of Uint8Arrays into a single Uint8Array.
+ */
+export function concatBuffers(buffers) {
+    let totalLength = 0;
+    for (const buf of buffers)
+        totalLength += buf.byteLength;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const buf of buffers) {
+        result.set(buf, offset);
+        offset += buf.byteLength;
+    }
+    return result;
+}
+/**
+ * Strips the PES header from raw PES packet data, returning the elementary
+ * stream payload.
+ */
+export function stripPesHeader(pesData) {
+    // PES start code: 0x00 0x00 0x01
+    if (pesData[0] !== 0 || pesData[1] !== 0 || pesData[2] !== 1) {
+        // No PES header, return as-is (continuation data)
+        return pesData;
+    }
+    // PES header data length is at byte 8
+    const pesHeaderDataLength = pesData[8];
+    return pesData.subarray(9 + pesHeaderDataLength);
+}
+/**
+ * Extracts the PTS (Presentation Time Stamp) from a PES header.
+ * Returns the PTS in 90kHz clock ticks, or -1 if not present.
+ */
+export function parsePesPts(pesData) {
+    if (pesData[0] !== 0 || pesData[1] !== 0 || pesData[2] !== 1)
+        return -1;
+    const flags = pesData[7];
+    if ((flags & 0x80) === 0)
+        return -1;
+    // PTS is encoded in 5 bytes starting at byte 9
+    const byte9 = pesData[9];
+    const byte10 = pesData[10];
+    const byte11 = pesData[11];
+    const byte12 = pesData[12];
+    const byte13 = pesData[13];
+    return ((byte9 & 0x0e) * 0x20000000 + // (byte9 & 0x0E) << 29
+        ((byte10 & 0xff) << 22) +
+        ((byte11 & 0xfe) << 14) +
+        ((byte12 & 0xff) << 7) +
+        ((byte13 & 0xfe) >>> 1));
+}

package/dist/types/current/transmux/sampleEntry.d.ts

@@ -0,0 +1,25 @@
+export interface AudioTrackConfig {
+    readonly audioObjectType: number;
+    readonly samplingFrequencyIndex: number;
+    readonly channelConfiguration: number;
+    readonly sampleRate: number;
+    readonly audioSpecificConfig: Uint8Array;
+}
+export interface VideoTrackConfig {
+    readonly width: number;
+    readonly height: number;
+    readonly sps: Uint8Array;
+    readonly pps: Uint8Array;
+    readonly profileIdc: number;
+    readonly profileCompatibility: number;
+    readonly levelIdc: number;
+}
+/**
+ * Builds an mp4a sample entry box for AAC audio.
+ */
+export declare function mp4aSampleEntry(config: AudioTrackConfig): Uint8Array;
+/**
+ * Builds an avc1 sample entry box for H.264 video.
+ */
+export declare function avc1SampleEntry(config: VideoTrackConfig): Uint8Array;
+//# sourceMappingURL=sampleEntry.d.ts.map

package/dist/types/current/transmux/sampleEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampleEntry.d.ts","sourceRoot":"","sources":["../../../../src/transmux/sampleEntry.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAA;IACvC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,mBAAmB,EAAE,UAAU,CAAA;CAC3C;AAED,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC5B;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAapE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAkBpE"}