@alessmicrosystems/mpegts.js 1.8.1

package/src/demux/h265.ts

@@ -0,0 +1,214 @@
+import Log from "../utils/logger";
+
+export enum H265NaluType {
+    kSliceIDR_W_RADL = 19,
+    kSliceIDR_N_LP = 20,
+    kSliceCRA_NUT = 21,
+    kSliceVPS = 32,
+    kSliceSPS = 33,
+    kSlicePPS = 34,
+    kSliceAUD = 35,
+    kSliceSEI = 39,
+    kSliceSEISuffix = 40,
+}
+
+export class H265NaluPayload {
+    type: H265NaluType;
+    data: Uint8Array;
+}
+
+export class H265NaluHVC1 {
+    type: H265NaluType;
+    data: Uint8Array;
+
+    constructor(nalu: H265NaluPayload) {
+        let nalu_size = nalu.data.byteLength;
+
+        this.type = nalu.type;
+        this.data = new Uint8Array(4 + nalu_size);  // 4 byte length-header + nalu payload
+
+        let v = new DataView(this.data.buffer);
+        // Fill 4 byte length-header
+        v.setUint32(0, nalu_size);
+        // Copy payload
+        this.data.set(nalu.data, 4);
+    }
+}
+
+export class H265AnnexBParser {
+
+    private readonly TAG: string = "H265AnnexBParser";
+
+    private data_: Uint8Array;
+    private current_startcode_offset_: number = 0;
+    private eof_flag_: boolean = false;
+
+    public constructor(data: Uint8Array) {
+        this.data_ = data;
+        this.current_startcode_offset_ = this.findNextStartCodeOffset(0);
+        if (this.eof_flag_) {
+            Log.e(this.TAG, "Could not find H265 startcode until payload end!");
+        }
+    }
+
+    private findNextStartCodeOffset(start_offset: number) {
+        let i = start_offset;
+        let data = this.data_;
+
+        while (true) {
+            if (i + 3 >= data.byteLength) {
+                this.eof_flag_ = true;
+                return data.byteLength;
+            }
+
+            // search 00 00 00 01 or 00 00 01
+            let uint32 = (data[i + 0] << 24)
+                        | (data[i + 1] << 16)
+                        | (data[i + 2] << 8)
+                        | (data[i + 3]);
+            let uint24 = (data[i + 0] << 16)
+                        | (data[i + 1] << 8)
+                        | (data[i + 2]);
+            if (uint32 === 0x00000001 || uint24 === 0x000001) {
+                return i;
+            } else {
+                i++;
+            }
+        }
+    }
+
+    public readNextNaluPayload(): H265NaluPayload | null {
+        let data = this.data_;
+        let nalu_payload: H265NaluPayload = null;
+
+        while (nalu_payload == null) {
+            if (this.eof_flag_) {
+                break;
+            }
+            // offset pointed to start code
+            let startcode_offset = this.current_startcode_offset_;
+
+            // nalu payload start offset
+            let offset = startcode_offset;
+            let u32 = (data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | (data[offset + 3]);
+            if (u32 === 0x00000001) {
+                offset += 4;
+            } else {
+                offset += 3;
+            }
+
+            let nalu_type: H265NaluType = (data[offset] >> 1) & 0x3F;
+            let forbidden_bit = (data[offset] & 0x80) >>> 7;
+
+            let next_startcode_offset = this.findNextStartCodeOffset(offset);
+            this.current_startcode_offset_ = next_startcode_offset;
+
+            if (forbidden_bit !== 0) {
+                // Log.e(this.TAG, `forbidden_bit near offset ${offset} should be 0 but has value ${forbidden_bit}`);
+                continue;
+            }
+
+            let payload_data = data.subarray(offset, next_startcode_offset);
+
+            nalu_payload = new H265NaluPayload();
+            nalu_payload.type = nalu_type;
+            nalu_payload.data = payload_data;
+        }
+
+        return nalu_payload;
+    }
+
+}
+
+export type HEVCDecoderConfigurationRecordType = {
+    configurationVersion: 1;
+} & VPSHEVCDecoderConfigurationRecordType & SPSHEVCDecoderConfigurationRecordType & PPSHEVCDecoderConfigurationRecordType;
+
+export type VPSHEVCDecoderConfigurationRecordType = {
+    num_temporal_layers: number;
+    temporal_id_nested: boolean;
+}
+
+export type SPSHEVCDecoderConfigurationRecordType = {
+    general_profile_space: number;
+    general_tier_flag: number;
+    general_level_idc: number;
+    general_profile_idc: number;
+    general_profile_compatibility_flags_1: number;
+    general_profile_compatibility_flags_2: number;
+    general_profile_compatibility_flags_3: number;
+    general_profile_compatibility_flags_4: number;
+    general_constraint_indicator_flags_1: number;
+    general_constraint_indicator_flags_2: number;
+    general_constraint_indicator_flags_3: number;
+    general_constraint_indicator_flags_4: number;
+    general_constraint_indicator_flags_5: number;
+    general_constraint_indicator_flags_6: number;
+    constant_frame_rate: number;
+    min_spatial_segmentation_idc: number;
+    chroma_format_idc: number,
+    bit_depth_luma_minus8: number,
+    bit_depth_chroma_minus8: number,
+}
+
+export type PPSHEVCDecoderConfigurationRecordType = {
+    parallelismType: number;
+}
+
+export class HEVCDecoderConfigurationRecord {
+
+    private data: Uint8Array;
+
+    // sps, pps: require Nalu without 4 byte length-header
+    public constructor(vps: Uint8Array, sps: Uint8Array, pps: Uint8Array, detail: HEVCDecoderConfigurationRecordType) {
+        let length = 23 + (3 + 2 + vps.byteLength) + (3 + 2 + sps.byteLength) + (3 + 2 + pps.byteLength);
+        let data = this.data = new Uint8Array(length);
+
+        data[0] = 0x01; // configurationVersion
+        data[1] = ((detail.general_profile_space & 0x03) << 6) | ((detail.general_tier_flag ? 1 : 0) << 5) | ((detail.general_profile_idc & 0x1F));
+        data[2] = detail.general_profile_compatibility_flags_1;
+        data[3] = detail.general_profile_compatibility_flags_2;
+        data[4] = detail.general_profile_compatibility_flags_3;
+        data[5] = detail.general_profile_compatibility_flags_4;
+        data[6] = detail.general_constraint_indicator_flags_1;
+        data[7] = detail.general_constraint_indicator_flags_2;
+        data[8] = detail.general_constraint_indicator_flags_3;
+        data[9] = detail.general_constraint_indicator_flags_4;
+        data[10] = detail.general_constraint_indicator_flags_5;
+        data[11] = detail.general_constraint_indicator_flags_6;
+        data[12] = detail.general_level_idc;
+        data[13] = 0xF0 | ((detail.min_spatial_segmentation_idc & 0x0F00) >> 8)
+        data[14] = (detail.min_spatial_segmentation_idc & 0xFF);
+        data[15] = 0xFC | (detail.parallelismType & 0x03);
+        data[16] = 0xFC | (detail.chroma_format_idc & 0x03);
+        data[17] = 0xF8 | (detail.bit_depth_luma_minus8 & 0x07);
+        data[18] = 0xF8 | (detail.bit_depth_chroma_minus8 & 0x07);
+        data[19] = 0;
+        data[20] = 0;
+        data[21] = ((detail.constant_frame_rate & 0x03) << 6) | ((detail.num_temporal_layers & 0x07) << 3) | ((detail.temporal_id_nested ? 1 : 0) << 2) | 3;
+        data[22] = 3;
+        data[23 + 0 + 0] = 0x80 | H265NaluType.kSliceVPS;
+        data[23 + 0 + 1] = 0;
+        data[23 + 0 + 2] = 1;
+        data[23 + 0 + 3] = (vps.byteLength & 0xFF00) >> 8;
+        data[23 + 0 + 4] = (vps.byteLength & 0x00FF) >> 0;
+        data.set(vps, 23 + 0 + 5);
+        data[23 + (5 + vps.byteLength) + 0] = 0x80 | H265NaluType.kSliceSPS;
+        data[23 + (5 + vps.byteLength) + 1] = 0;
+        data[23 + (5 + vps.byteLength) + 2] = 1;
+        data[23 + (5 + vps.byteLength) + 3] = (sps.byteLength & 0xFF00) >> 8;
+        data[23 + (5 + vps.byteLength) + 4] = (sps.byteLength & 0x00FF) >> 0;
+        data.set(sps, 23 + (5 + vps.byteLength) + 5);
+        data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 0] = 0x80 | H265NaluType.kSlicePPS;
+        data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 1] = 0;
+        data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 2] = 1;
+        data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 3] = (pps.byteLength & 0xFF00) >> 8;
+        data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 4] = (pps.byteLength & 0x00FF) >> 0;
+        data.set(pps, 23 + (5 + vps.byteLength + 5 + sps.byteLength) + 5);
+    }
+
+    public getData() {
+        return this.data;
+    }
+
+}

package/src/demux/klv.ts

@@ -0,0 +1,40 @@
+export class KLVData {
+    pid: number;
+    stream_id: number;
+    pts?: number;
+    dts?: number;
+    access_units: AccessUnit[];
+    data: Uint8Array;
+    len: number;
+}
+
+type AccessUnit = {
+    service_id: number;
+    sequence_number: number;
+    flags: number;
+    data: Uint8Array;
+}
+
+export const klv_parse = (data: Uint8Array) => {
+    let result: AccessUnit[] = [];
+
+    let offset = 0;
+    while (offset + 5 < data.byteLength) {
+        let service_id = data[offset + 0];
+        let sequence_number = data[offset + 1];
+        let flags = data[offset + 2];
+        let au_size = (data[offset + 3] << 8) | (data[offset + 4] << 0);
+        let au_data = data.slice(offset + 5, offset + 5 + au_size);
+
+        result.push({
+            service_id,
+            sequence_number,
+            flags,
+            data: au_data
+        });
+
+        offset += 5 + au_size;
+    }
+
+    return result;
+}

package/src/demux/mp3.ts

@@ -0,0 +1,7 @@
+export class MP3Data {
+    object_type: number;
+    sample_rate: number;
+    channel_count: number;
+
+    data: Uint8Array;
+}

package/src/demux/mpeg4-audio.ts

@@ -0,0 +1,45 @@
+export enum MPEG4AudioObjectTypes {
+    kNull = 0,
+    kAACMain,
+    kAAC_LC,   // LC-AAC
+    kAAC_SSR,
+    kAAC_LTP,
+    kAAC_SBR,  // HE-AAC
+    kAAC_Scalable,
+
+    kLayer1 = 32,
+    kLayer2,
+    kLayer3,   // MP3
+}
+
+export enum MPEG4SamplingFrequencyIndex {
+    k96000Hz = 0,
+    k88200Hz,
+    k64000Hz,
+    k48000Hz,
+    k44100Hz,
+    k32000Hz,
+    k24000Hz,
+    k22050Hz,
+    k16000Hz,
+    k12000Hz,
+    k11025Hz,
+    k8000Hz,
+    k7350Hz,
+}
+
+export const MPEG4SamplingFrequencies = [
+    96000,
+    88200,
+    64000,
+    48000,
+    44100,
+    32000,
+    24000,
+    22050,
+    16000,
+    12000,
+    11025,
+    8000,
+    7350,
+];

package/src/demux/pat-pmt-pes.ts

@@ -0,0 +1,132 @@
+interface ProgramToPMTPIDMap {
+    [program: number]: number;
+}
+
+export class PAT {
+    version_number: number;
+    network_pid: number;
+    // program_number -> pmt_pid
+    program_pmt_pid: ProgramToPMTPIDMap = {};
+}
+
+export enum StreamType {
+    kMPEG1Audio = 0x03,
+    kMPEG2Audio = 0x04,
+    kPESPrivateData = 0x06,
+    kADTSAAC = 0x0F,
+    kLOASAAC = 0x11,
+    kAC3 = 0x81,
+    kEAC3 = 0x87,
+    kMetadata = 0x15,
+    kSCTE35 = 0x86,
+    kPGS = 0x90,
+    kH264 = 0x1b,
+    kH265 = 0x24
+}
+
+interface PIDToStreamTypeMap {
+    [pid: number]: StreamType;
+}
+
+export class PMT {
+    program_number: number;
+    version_number: number;
+    pcr_pid: number;
+    // pid -> stream_type
+    pid_stream_type: PIDToStreamTypeMap = {};
+
+    common_pids: {
+        h264: number | undefined,
+        h265: number | undefined,
+        av1: number | undefined,
+        adts_aac: number | undefined,
+        loas_aac: number | undefined,
+        opus: number | undefined,
+        ac3: number | undefined,
+        eac3: number | undefined,
+        mp3: number | undefined
+    } = {
+        h264: undefined,
+        h265: undefined,
+        av1: undefined,
+        adts_aac: undefined,
+        loas_aac: undefined,
+        opus: undefined,
+        ac3: undefined,
+        eac3: undefined,
+        mp3: undefined
+    };
+
+    pes_private_data_pids: {
+        [pid: number]: boolean
+    } = {};
+
+    timed_id3_pids: {
+        [pid: number]: boolean
+    } = {};
+
+    pgs_pids: {
+        [pid: number]: boolean;
+    } = {};
+    pgs_langs: {
+        [pid: number]: string;
+    } = {};
+
+    synchronous_klv_pids: {
+        [pid: number]: boolean
+    } = {};
+
+    asynchronous_klv_pids: {
+        [pid: number]: boolean
+    } = {};
+
+    scte_35_pids: {
+        [pid: number]: boolean
+    } = {};
+
+    smpte2038_pids: {
+        [oid: number]: boolean
+    } = {};
+
+    // All discovered audio streams (including secondary/alternate languages).
+    // Each entry: { pid, codec, lang? }
+    all_audio_pids: Array<{pid: number, codec: string, lang?: string}> = [];
+
+    // All subtitle/teletext streams discovered in the PMT.
+    // Each entry: { pid, type: 'pgs'|'timed_id3'|'teletext', lang? }
+    subtitle_pids: Array<{pid: number, type: string, lang?: string}> = [];
+
+    // Tracks which sections of this version have been parsed
+    parsed_sections: {[section_number: number]: boolean} = {};
+}
+
+export interface ProgramToPMTMap {
+    [program: number]: PMT;
+}
+
+export class PESData {
+    pid: number;
+    data: Uint8Array;
+    stream_type: StreamType;
+    file_position: number;
+    random_access_indicator: number;
+}
+
+export class SectionData {
+    pid: number;
+    data: Uint8Array;
+    file_position: number;
+    random_access_indicator: number;
+}
+
+export class SliceQueue {
+    slices: Uint8Array[] = [];
+    total_length: number = 0;
+    expected_length: number = 0;
+    file_position: number = 0;
+    random_access_indicator: 0;
+}
+
+export interface PIDToSliceQueues {
+    [pid: number]: SliceQueue;
+}

package/src/demux/pes-private-data.ts

@@ -0,0 +1,16 @@
+// ISO/IEC 13818-1 PES packets containing private data (stream_type=0x06)
+export class PESPrivateData {
+    pid: number;
+    stream_id: number;
+    pts?: number;
+    dts?: number;
+    nearest_pts?: number;
+    data: Uint8Array;
+    len: number;
+}
+
+export class PESPrivateDataDescriptor {
+    pid: number;
+    stream_type: number;
+    descriptor: Uint8Array;
+}

package/src/demux/pgs-data.ts

@@ -0,0 +1,11 @@
+// ISO/IEC 13818-1 PES packets containing private data (stream_type=0x06)
+export class PGSData {
+    pid: number;
+    stream_id: number;
+    pts?: number;
+    dts?: number;
+    lang: string;
+    data: Uint8Array;
+    len: number;
+}
+