or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

captions.mdcodecs.mdflv.mdindex.mdmp2t.mdmp4.mdtools.md
tile.json

mp2t.mddocs/

Transport Stream Processing

MPEG-2 Transport Stream parsing and processing capabilities. The mp2t module handles packet parsing, PES reconstruction, metadata extraction, and caption processing from transport streams used in broadcast and streaming applications.

Capabilities

Transport Packet Stream

Stream class that splits incoming binary data into MPEG-2 Transport Stream packets.

/**
 * Splits binary data into MPEG-2 Transport Stream packets
 * Handles sync byte detection and packet boundary identification
 */
class TransportPacketStream {
  constructor();
  
  /** Process binary transport stream data */
  push(data: Uint8Array): void;
  
  /** Flush any remaining packet data */
  flush(): void;
  
  /** End current timeline */
  endTimeline(): void;
  
  /** Reset stream state */
  reset(): void;
  
  /** Register event listeners */
  on(event: 'data', callback: (packet: Uint8Array) => void): void;
  on(event: 'done', callback: () => void): void;
}

Usage Examples:

const muxjs = require("mux.js");

// Create transport packet stream
const packetStream = new muxjs.mp2t.TransportPacketStream();

// Handle parsed packets
packetStream.on('data', (packet) => {
  console.log(`Transport packet: ${packet.length} bytes`);
  // Each packet is exactly 188 bytes (MP2T_PACKET_LENGTH)
  
  // Process individual packet
  processTransportPacket(packet);
});

// Process raw transport stream data
packetStream.push(transportStreamData);
packetStream.flush();

Transport Parse Stream

Stream class that parses transport stream packets into structured data with PAT/PMT information.

/**
 * Parses transport packets into structured data
 * Extracts PAT (Program Association Table) and PMT (Program Map Table) information
 */
class TransportParseStream {
  constructor();
  
  /** Parse transport packet */
  push(packet: Uint8Array): void;
  
  /** Program Map Table PID */
  pmtPid: number;
  
  /** Program map table information */
  programMapTable: {
    video: number | null;
    audio: number | null;
    'timed-metadata': { [pid: number]: number };
  };
  
  /** Register event listeners */
  on(event: 'data', callback: (parsedPacket: ParsedPacket) => void): void;
}

interface ParsedPacket {
  pid: number;
  type: 'pat' | 'pmt' | 'pes';
  payloadUnitStartIndicator: boolean;
  data?: Uint8Array;
  streamType?: number;
  programMapTable?: ProgramMapTable;
}

interface ProgramMapTable {
  video: number | null;
  audio: number | null;
  'timed-metadata': { [pid: number]: number };
}

Usage Examples:

const muxjs = require("mux.js");

// Create parse stream
const parseStream = new muxjs.mp2t.TransportParseStream();

// Handle parsed packets
parseStream.on('data', (parsed) => {
  console.log(`Packet PID: ${parsed.pid}, Type: ${parsed.type}`);
  
  switch (parsed.type) {
    case 'pat':
      console.log('Program Association Table');
      break;
    case 'pmt':
      console.log('Program Map Table:', parsed.programMapTable);
      break;
    case 'pes':
      console.log(`PES packet, stream type: ${parsed.streamType}`);
      break;
  }
});

// Connect to packet stream
const packetStream = new muxjs.mp2t.TransportPacketStream();
packetStream.pipe(parseStream);

Elementary Stream

Stream class that reconstructs Program Elementary Stream (PES) packets from parsed transport stream packets.

/**
 * Reconstructs PES packets from transport stream packets
 * Handles video, audio, and timed metadata streams
 */
class ElementaryStream {
  constructor();
  
  /** Process parsed transport data */
  push(data: ParsedPacket): void;
  
  /** Flush buffered streams */
  flush(): void;
  
  /** Reset stream state */
  reset(): void;
  
  /** Register event listeners */
  on(event: 'data', callback: (pesPacket: PESPacket) => void): void;
}

interface PESPacket {
  type: 'video' | 'audio' | 'timed-metadata' | 'metadata';
  data?: Uint8Array;
  pts?: number;
  dts?: number;
  packetLength?: number;
  dataAlignmentIndicator?: boolean;
  trackId?: number;
  tracks?: Track[];
}

Usage Examples:

const muxjs = require("mux.js");

// Create elementary stream
const elementaryStream = new muxjs.mp2t.ElementaryStream();

// Handle PES packets
elementaryStream.on('data', (pesPacket) => {
  console.log(`PES packet type: ${pesPacket.type}`);
  
  if (pesPacket.pts !== undefined) {
    console.log(`PTS: ${pesPacket.pts}`);
  }
  if (pesPacket.dts !== undefined) {
    console.log(`DTS: ${pesPacket.dts}`);
  }
  
  // Process based on type
  switch (pesPacket.type) {
    case 'video':
      processVideoPacket(pesPacket);
      break;
    case 'audio':
      processAudioPacket(pesPacket);
      break;
    case 'metadata':
      console.log('Track metadata:', pesPacket.tracks);
      break;
  }
});

// Create full pipeline
const packetStream = new muxjs.mp2t.TransportPacketStream();
const parseStream = new muxjs.mp2t.TransportParseStream();

packetStream
  .pipe(parseStream)
  .pipe(elementaryStream);

Caption Stream Processing

Comprehensive caption processing for CEA-608 and CEA-708 closed captions.

/**
 * Main caption stream processor
 */
class CaptionStream {
  constructor();
  push(data: Uint8Array): void;
  flush(): void;
  on(event: 'data', callback: (caption: CaptionData) => void): void;
}

/**
 * CEA-608 closed caption processor
 */
class Cea608Stream {
  constructor();
  push(data: CaptionData): void;
  flush(): void;
  on(event: 'data', callback: (caption: Cea608Caption) => void): void;
}

/**
 * CEA-708 closed caption processor  
 */
class Cea708Stream {
  constructor();
  push(data: CaptionData): void;
  flush(): void;
  on(event: 'data', callback: (caption: Cea708Caption) => void): void;
}

interface CaptionData {
  pts: number;
  dts: number;
  data: Uint8Array;
  stream: string;
}

interface Cea608Caption {
  startTime: number;
  endTime: number;
  text: string;
  line: number;
  position: number;
}

interface Cea708Caption {
  startTime: number;
  endTime: number;
  text: string;
  windowId: number;
  serviceNumber: number;
}

Metadata Stream Processing

Stream processor for extracting timed metadata from transport streams.

/**
 * Metadata stream processor for ID3 and other timed metadata
 */
class MetadataStream {
  constructor();
  
  /** Process metadata PES packet */
  push(data: PESPacket): void;
  
  /** Flush any buffered metadata */
  flush(): void;
  
  /** Register event listeners */
  on(event: 'data', callback: (metadata: MetadataFrame) => void): void;
}

interface MetadataFrame {
  pts: number;
  dts: number;
  data: Uint8Array;
  frames: ID3Frame[];
}

interface ID3Frame {
  id: string;
  data: Uint8Array;
  description?: string;
}

Timestamp Rollover Stream

Utility stream for handling PTS/DTS timestamp rollover scenarios in transport streams.

/**
 * Handles timestamp rollover for PTS/DTS values
 * PTS/DTS are 33-bit values that can rollover
 */
class TimestampRolloverStream {
  constructor();
  
  /** Process data with timestamp correction */
  push(data: TimestampedData): void;
  
  /** Flush stream */
  flush(): void;
  
  /** Register event listeners */
  on(event: 'data', callback: (correctedData: TimestampedData) => void): void;
}

interface TimestampedData {
  pts?: number;
  dts?: number;
  data: Uint8Array;
  type: string;
}

Constants

Transport stream processing constants and identifiers.

/** Program Association Table PID */
const PAT_PID: 0x0000;

/** Standard MPEG-2 Transport Stream packet length */
const MP2T_PACKET_LENGTH: 188;

/** H.264 video stream type identifier */
const H264_STREAM_TYPE: 0x1B;

/** ADTS/AAC audio stream type identifier */
const ADTS_STREAM_TYPE: 0x0F;

/** Metadata stream type identifier */
const METADATA_STREAM_TYPE: 0x15;

Usage Examples:

const muxjs = require("mux.js");

// Use constants for stream type checking
elementaryStream.on('data', (pesPacket) => {
  if (pesPacket.type === 'pes' && pesPacket.streamType) {
    switch (pesPacket.streamType) {
      case muxjs.mp2t.H264_STREAM_TYPE:
        console.log('H.264 video stream');
        break;
      case muxjs.mp2t.ADTS_STREAM_TYPE:
        console.log('ADTS audio stream');
        break;
      case muxjs.mp2t.METADATA_STREAM_TYPE:
        console.log('Metadata stream');
        break;
    }
  }
});

// Check packet length
console.log(`Expected packet length: ${muxjs.mp2t.MP2T_PACKET_LENGTH} bytes`);

Complete Processing Pipeline

Example showing full transport stream processing pipeline:

const muxjs = require("mux.js");

// Create processing pipeline
const packetStream = new muxjs.mp2t.TransportPacketStream();
const parseStream = new muxjs.mp2t.TransportParseStream();
const elementaryStream = new muxjs.mp2t.ElementaryStream();
const captionStream = new muxjs.mp2t.CaptionStream();
const metadataStream = new muxjs.mp2t.MetadataStream();
const timestampRollover = new muxjs.mp2t.TimestampRolloverStream();

// Connect pipeline
packetStream
  .pipe(parseStream)
  .pipe(elementaryStream);

// Handle different data types
elementaryStream.on('data', (pesPacket) => {
  switch (pesPacket.type) {
    case 'video':
    case 'audio':
      // Pass through timestamp rollover correction
      timestampRollover.push(pesPacket);
      break;
    case 'timed-metadata':
      metadataStream.push(pesPacket);
      break;
  }
});

// Handle corrected timestamps
timestampRollover.on('data', (correctedData) => {
  console.log('Corrected timestamps:', correctedData.pts, correctedData.dts);
});

// Handle metadata
metadataStream.on('data', (metadata) => {
  console.log('Metadata frames:', metadata.frames.length);
  metadata.frames.forEach(frame => {
    console.log(`ID3 frame: ${frame.id}`);
  });
});

// Process transport stream
packetStream.push(transportStreamData);
packetStream.flush();

Types

interface Track {
  id: number;
  codec: string;
  type: 'video' | 'audio';
  timelineStartInfo: {
    baseMediaDecodeTime: number;
  };
}

interface TransportPacket {
  pid: number;
  payloadUnitStartIndicator: boolean;
  data: Uint8Array;
}

interface StreamTypeMap {
  [pid: number]: number;
}