@invintusmedia/tomp4 1.0.0

package/src/ts-to-mp4.js

@@ -0,0 +1,1154 @@
+/**
+ * MPEG-TS to MP4 Converter
+ * Pure JavaScript - no dependencies
+ * 
+ * SUPPORTED (remux only, no transcoding):
+ * ───────────────────────────────────────
+ * Video:
+ *   ✅ H.264/AVC  (0x1B)
+ *   ✅ H.265/HEVC (0x24)
+ * 
+ * Audio:
+ *   ✅ AAC        (0x0F)
+ *   ✅ AAC-LATM   (0x11)
+ * 
+ * NOT SUPPORTED (requires transcoding):
+ * ─────────────────────────────────────
+ *   ❌ MPEG-1 Video (0x01)
+ *   ❌ MPEG-2 Video (0x02)
+ *   ❌ MPEG-1 Audio (0x03)
+ *   ❌ MPEG-2 Audio (0x04)
+ *   ❌ AC-3/Dolby   (0x81)
+ *   ❌ E-AC-3       (0x87)
+ */
+
+// Stream type info
+const STREAM_TYPES = {
+  0x01: { name: 'MPEG-1 Video', supported: false },
+  0x02: { name: 'MPEG-2 Video', supported: false },
+  0x03: { name: 'MPEG-1 Audio (MP3)', supported: false },
+  0x04: { name: 'MPEG-2 Audio', supported: false },
+  0x0F: { name: 'AAC', supported: true },
+  0x11: { name: 'AAC-LATM', supported: true },
+  0x1B: { name: 'H.264/AVC', supported: true },
+  0x24: { name: 'H.265/HEVC', supported: true },
+  0x81: { name: 'AC-3 (Dolby)', supported: false },
+  0x87: { name: 'E-AC-3', supported: false }
+};
+
+// ============================================
+// MP4 BOX HELPERS
+// ============================================
+function createBox(type, ...payloads) {
+  let size = 8;
+  for (const p of payloads) size += p.byteLength;
+  const result = new Uint8Array(size);
+  const view = new DataView(result.buffer);
+  view.setUint32(0, size);
+  result[4] = type.charCodeAt(0);
+  result[5] = type.charCodeAt(1);
+  result[6] = type.charCodeAt(2);
+  result[7] = type.charCodeAt(3);
+  let offset = 8;
+  for (const p of payloads) {
+    result.set(p, offset);
+    offset += p.byteLength;
+  }
+  return result;
+}
+
+function createFullBox(type, version, flags, ...payloads) {
+  const header = new Uint8Array(4);
+  header[0] = version;
+  header[1] = (flags >> 16) & 0xFF;
+  header[2] = (flags >> 8) & 0xFF;
+  header[3] = flags & 0xFF;
+  return createBox(type, header, ...payloads);
+}
+
+// ============================================
+// MPEG-TS PARSER
+// ============================================
+const TS_PACKET_SIZE = 188;
+const TS_SYNC_BYTE = 0x47;
+const PAT_PID = 0x0000;
+
+class TSParser {
+  constructor() {
+    this.pmtPid = null;
+    this.videoPid = null;
+    this.audioPid = null;
+    this.videoStreamType = null;
+    this.audioStreamType = null;
+    this.videoPesBuffer = [];
+    this.audioPesBuffer = [];
+    this.videoAccessUnits = [];
+    this.audioAccessUnits = [];
+    this.videoPts = [];
+    this.videoDts = [];
+    this.audioPts = [];
+    this.lastAudioPts = null; // Track running audio timestamp
+    this.adtsPartial = null; // Partial ADTS frame from previous PES
+    this.audioSampleRate = null; // Detected from ADTS header
+    this.audioChannels = null;
+    this.debug = { packets: 0, patFound: false, pmtFound: false };
+  }
+  
+  parse(data) {
+    let offset = 0;
+    // Find first sync byte
+    while (offset < data.byteLength && data[offset] !== TS_SYNC_BYTE) offset++;
+    if (offset > 0) this.debug.skippedBytes = offset;
+    
+    // Parse all packets
+    while (offset + TS_PACKET_SIZE <= data.byteLength) {
+      if (data[offset] !== TS_SYNC_BYTE) {
+        // Try to resync
+        const nextSync = data.indexOf(TS_SYNC_BYTE, offset + 1);
+        if (nextSync === -1) break;
+        offset = nextSync;
+        continue;
+      }
+      this.parsePacket(data.subarray(offset, offset + TS_PACKET_SIZE));
+      this.debug.packets++;
+      offset += TS_PACKET_SIZE;
+    }
+  }
+  
+  parsePacket(packet) {
+    const pid = ((packet[1] & 0x1F) << 8) | packet[2];
+    const payloadStart = (packet[1] & 0x40) !== 0;
+    const adaptationField = (packet[3] & 0x30) >> 4;
+    let payloadOffset = 4;
+    if (adaptationField === 2 || adaptationField === 3) {
+      const adaptLen = packet[4];
+      payloadOffset = 5 + adaptLen;
+      if (payloadOffset >= TS_PACKET_SIZE) return; // Invalid adaptation field
+    }
+    if (adaptationField === 2) return; // No payload
+    if (payloadOffset >= packet.length) return;
+    
+    const payload = packet.subarray(payloadOffset);
+    if (payload.length === 0) return;
+    
+    if (pid === PAT_PID) this.parsePAT(payload);
+    else if (pid === this.pmtPid) this.parsePMT(payload);
+    else if (pid === this.videoPid) this.collectPES(payload, payloadStart, 'video');
+    else if (pid === this.audioPid) this.collectPES(payload, payloadStart, 'audio');
+  }
+  
+  parsePAT(payload) {
+    if (payload.length < 12) return;
+    let offset = payload[0] + 1; // pointer field
+    if (offset + 8 > payload.length) return;
+    
+    // table_id + section_syntax + section_length + transport_stream_id + version + section_number + last_section_number
+    offset += 8;
+    
+    while (offset + 4 <= payload.length - 4) { // -4 for CRC
+      const programNum = (payload[offset] << 8) | payload[offset + 1];
+      const pmtPid = ((payload[offset + 2] & 0x1F) << 8) | payload[offset + 3];
+      if (programNum !== 0 && pmtPid !== 0) {
+        this.pmtPid = pmtPid;
+        this.debug.patFound = true;
+        break;
+      }
+      offset += 4;
+    }
+  }
+  
+  parsePMT(payload) {
+    if (payload.length < 16) return;
+    let offset = payload[0] + 1; // pointer field
+    if (offset + 12 > payload.length) return;
+    
+    // table_id
+    offset++;
+    
+    const sectionLength = ((payload[offset] & 0x0F) << 8) | payload[offset + 1];
+    offset += 2;
+    
+    // program_number(2) + version(1) + section_number(1) + last_section(1)
+    offset += 5;
+    
+    // PCR_PID (2)
+    offset += 2;
+    
+    // program_info_length
+    if (offset + 2 > payload.length) return;
+    const programInfoLength = ((payload[offset] & 0x0F) << 8) | payload[offset + 1];
+    offset += 2 + programInfoLength;
+    
+    // Calculate end of stream entries (before CRC)
+    const sectionEnd = Math.min(payload.length - 4, 1 + payload[0] + 3 + sectionLength - 4);
+    
+    while (offset + 5 <= sectionEnd) {
+      const streamType = payload[offset];
+      const elementaryPid = ((payload[offset + 1] & 0x1F) << 8) | payload[offset + 2];
+      const esInfoLength = ((payload[offset + 3] & 0x0F) << 8) | payload[offset + 4];
+      
+      // Track ANY video stream we find (we'll validate codec support later)
+      // Video types: 0x01=MPEG-1, 0x02=MPEG-2, 0x1B=H.264, 0x24=HEVC
+      if (!this.videoPid && (streamType === 0x01 || streamType === 0x02 || streamType === 0x1B || streamType === 0x24)) {
+        this.videoPid = elementaryPid;
+        this.videoStreamType = streamType;
+        this.debug.pmtFound = true;
+      }
+      // Track ANY audio stream we find (we'll validate codec support later)
+      // Audio types: 0x03=MPEG-1, 0x04=MPEG-2, 0x0F=AAC, 0x11=AAC-LATM, 0x81=AC3, 0x87=EAC3
+      else if (!this.audioPid && (streamType === 0x03 || streamType === 0x04 || streamType === 0x0F || streamType === 0x11 || streamType === 0x81 || streamType === 0x87)) {
+        this.audioPid = elementaryPid;
+        this.audioStreamType = streamType;
+      }
+      
+      offset += 5 + esInfoLength;
+    }
+  }
+  
+  collectPES(payload, isStart, type) {
+    const buffer = type === 'video' ? this.videoPesBuffer : this.audioPesBuffer;
+    if (isStart) {
+      if (type === 'audio') this.debug.audioPesStarts = (this.debug.audioPesStarts || 0) + 1;
+      if (buffer.length > 0) this.processPES(this.concatenateBuffers(buffer), type);
+      buffer.length = 0;
+    }
+    buffer.push(payload.slice());
+  }
+  
+  processPES(pesData, type) {
+    if (pesData.length < 9) return;
+    if (pesData[0] !== 0 || pesData[1] !== 0 || pesData[2] !== 1) return;
+    const flags = pesData[7];
+    const headerDataLength = pesData[8];
+    let pts = null, dts = null;
+    if (flags & 0x80) pts = this.parsePTS(pesData, 9);
+    if (flags & 0x40) dts = this.parsePTS(pesData, 14);
+    const payload = pesData.subarray(9 + headerDataLength);
+    if (type === 'video') this.processVideoPayload(payload, pts, dts);
+    else this.processAudioPayload(payload, pts);
+  }
+  
+  parsePTS(data, offset) {
+    return ((data[offset] & 0x0E) << 29) |
+      ((data[offset + 1]) << 22) |
+      ((data[offset + 2] & 0xFE) << 14) |
+      ((data[offset + 3]) << 7) |
+      ((data[offset + 4] & 0xFE) >> 1);
+  }
+  
+  processVideoPayload(payload, pts, dts) {
+    const nalUnits = this.extractNALUnits(payload);
+    if (nalUnits.length > 0 && pts !== null) {
+      this.videoAccessUnits.push({ nalUnits, pts, dts: dts !== null ? dts : pts });
+      this.videoPts.push(pts);
+      this.videoDts.push(dts !== null ? dts : pts);
+    }
+  }
+  
+  extractNALUnits(data) {
+    const nalUnits = [];
+    let i = 0;
+    while (i < data.length - 3) {
+      if (data[i] === 0 && data[i + 1] === 0) {
+        let startCodeLen = 0;
+        if (data[i + 2] === 1) startCodeLen = 3;
+        else if (data[i + 2] === 0 && i + 3 < data.length && data[i + 3] === 1) startCodeLen = 4;
+        if (startCodeLen > 0) {
+          let end = i + startCodeLen;
+          while (end < data.length - 2) {
+            if (data[end] === 0 && data[end + 1] === 0 && 
+                (data[end + 2] === 1 || (data[end + 2] === 0 && end + 3 < data.length && data[end + 3] === 1))) break;
+            end++;
+          }
+          if (end >= data.length - 2) end = data.length;
+          const nalUnit = data.subarray(i + startCodeLen, end);
+          if (nalUnit.length > 0) nalUnits.push(nalUnit);
+          i = end;
+          continue;
+        }
+      }
+      i++;
+    }
+    return nalUnits;
+  }
+  
+  processAudioPayload(payload, pts) {
+    const frames = this.extractADTSFrames(payload);
+    
+    // Debug: track audio PES processing
+    this.debug.audioPesCount = (this.debug.audioPesCount || 0) + 1;
+    this.debug.audioFramesInPes = (this.debug.audioFramesInPes || 0) + frames.length;
+    
+    // Use provided PTS or continue from last known PTS
+    if (pts !== null) {
+      this.lastAudioPts = pts;
+    } else if (this.lastAudioPts !== null) {
+      pts = this.lastAudioPts;
+    } else {
+      // No PTS available yet, skip these frames
+      this.debug.audioSkipped = (this.debug.audioSkipped || 0) + frames.length;
+      return;
+    }
+    
+    // Calculate PTS increment based on detected sample rate (or default 48000)
+    const sampleRate = this.audioSampleRate || 48000;
+    const ptsIncrement = Math.round(1024 * 90000 / sampleRate);
+    
+    for (const frame of frames) {
+      this.audioAccessUnits.push({ data: frame.data, pts });
+      this.audioPts.push(pts);
+      pts += ptsIncrement;
+      this.lastAudioPts = pts;
+    }
+  }
+  
+  extractADTSFrames(data) {
+    // ADTS sample rate table
+    const SAMPLE_RATES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+    
+    const frames = [];
+    let i = 0;
+    
+    // Check for leftover partial frame from previous PES
+    if (this.adtsPartial && this.adtsPartial.length > 0) {
+      const combined = new Uint8Array(this.adtsPartial.length + data.length);
+      combined.set(this.adtsPartial);
+      combined.set(data, this.adtsPartial.length);
+      data = combined;
+      this.adtsPartial = null;
+    }
+    
+    while (i < data.length - 7) {
+      if (data[i] === 0xFF && (data[i + 1] & 0xF0) === 0xF0) {
+        const protectionAbsent = data[i + 1] & 0x01;
+        const frameLength = ((data[i + 3] & 0x03) << 11) | (data[i + 4] << 3) | ((data[i + 5] & 0xE0) >> 5);
+        
+        // Extract sample rate and channel config from first valid frame
+        if (!this.audioSampleRate && frameLength > 0) {
+          const samplingFreqIndex = ((data[i + 2] & 0x3C) >> 2);
+          const channelConfig = ((data[i + 2] & 0x01) << 2) | ((data[i + 3] & 0xC0) >> 6);
+          if (samplingFreqIndex < SAMPLE_RATES.length) {
+            this.audioSampleRate = SAMPLE_RATES[samplingFreqIndex];
+            this.audioChannels = channelConfig;
+          }
+        }
+        
+        if (frameLength > 0) {
+          if (i + frameLength <= data.length) {
+            const headerSize = protectionAbsent ? 7 : 9;
+            frames.push({ header: data.subarray(i, i + headerSize), data: data.subarray(i + headerSize, i + frameLength) });
+            i += frameLength;
+            continue;
+          } else {
+            this.adtsPartial = data.slice(i);
+            break;
+          }
+        }
+      }
+      i++;
+    }
+    return frames;
+  }
+  
+  concatenateBuffers(buffers) {
+    const totalLength = buffers.reduce((sum, b) => sum + b.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const buf of buffers) { result.set(buf, offset); offset += buf.length; }
+    return result;
+  }
+  
+  finalize() {
+    if (this.videoPesBuffer.length > 0) this.processPES(this.concatenateBuffers(this.videoPesBuffer), 'video');
+    if (this.audioPesBuffer.length > 0) this.processPES(this.concatenateBuffers(this.audioPesBuffer), 'audio');
+    
+    // Normalize timestamps so both audio and video start at 0
+    // This fixes A/V sync issues when streams have different start times
+    this.normalizeTimestamps();
+  }
+  
+  normalizeTimestamps() {
+    // Find the minimum timestamp across all streams
+    let minPts = Infinity;
+    
+    if (this.videoPts.length > 0) {
+      minPts = Math.min(minPts, Math.min(...this.videoPts));
+    }
+    if (this.audioPts.length > 0) {
+      minPts = Math.min(minPts, Math.min(...this.audioPts));
+    }
+    
+    // If no valid timestamps, nothing to normalize
+    if (minPts === Infinity || minPts === 0) return;
+    
+    // Subtract minimum from all timestamps
+    for (let i = 0; i < this.videoPts.length; i++) {
+      this.videoPts[i] -= minPts;
+    }
+    for (let i = 0; i < this.videoDts.length; i++) {
+      this.videoDts[i] -= minPts;
+    }
+    for (let i = 0; i < this.audioPts.length; i++) {
+      this.audioPts[i] -= minPts;
+    }
+    
+    // Also update the access units
+    for (const au of this.videoAccessUnits) {
+      au.pts -= minPts;
+      au.dts -= minPts;
+    }
+    for (const au of this.audioAccessUnits) {
+      au.pts -= minPts;
+    }
+    
+    this.debug.timestampOffset = minPts;
+    this.debug.timestampNormalized = true;
+  }
+}
+
+// ============================================
+// MP4 BUILDER
+// ============================================
+// Parse H.264 SPS to extract video dimensions
+function parseSPS(sps) {
+  // Default fallback
+  const result = { width: 1920, height: 1080 };
+  if (!sps || sps.length < 4) return result;
+  
+  // Skip NAL header byte, start at profile_idc
+  let offset = 1;
+  const profile = sps[offset++];
+  offset++; // constraint flags
+  offset++; // level_idc
+  
+  // Exponential-Golomb decoder
+  let bitPos = offset * 8;
+  const getBit = () => (sps[Math.floor(bitPos / 8)] >> (7 - (bitPos++ % 8))) & 1;
+  const readUE = () => {
+    let zeros = 0;
+    while (bitPos < sps.length * 8 && getBit() === 0) zeros++;
+    let val = (1 << zeros) - 1;
+    for (let i = 0; i < zeros; i++) val += getBit() << (zeros - 1 - i);
+    return val;
+  };
+  const readSE = () => {
+    const val = readUE();
+    return (val & 1) ? (val + 1) >> 1 : -(val >> 1);
+  };
+  
+  try {
+    readUE(); // seq_parameter_set_id
+    
+    // High profile needs chroma_format_idc parsing
+    if (profile === 100 || profile === 110 || profile === 122 || profile === 244 ||
+        profile === 44 || profile === 83 || profile === 86 || profile === 118 || profile === 128) {
+      const chromaFormat = readUE();
+      if (chromaFormat === 3) getBit(); // separate_colour_plane_flag
+      readUE(); // bit_depth_luma_minus8
+      readUE(); // bit_depth_chroma_minus8
+      getBit(); // qpprime_y_zero_transform_bypass_flag
+      if (getBit()) { // seq_scaling_matrix_present_flag
+        for (let i = 0; i < (chromaFormat !== 3 ? 8 : 12); i++) {
+          if (getBit()) { // scaling_list_present
+            const size = i < 6 ? 16 : 64;
+            for (let j = 0; j < size; j++) readSE();
+          }
+        }
+      }
+    }
+    
+    readUE(); // log2_max_frame_num_minus4
+    const pocType = readUE();
+    if (pocType === 0) {
+      readUE(); // log2_max_pic_order_cnt_lsb_minus4
+    } else if (pocType === 1) {
+      getBit(); // delta_pic_order_always_zero_flag
+      readSE(); // offset_for_non_ref_pic
+      readSE(); // offset_for_top_to_bottom_field
+      const numRefFrames = readUE();
+      for (let i = 0; i < numRefFrames; i++) readSE();
+    }
+    
+    readUE(); // max_num_ref_frames
+    getBit(); // gaps_in_frame_num_value_allowed_flag
+    
+    const picWidthMbs = readUE() + 1;
+    const picHeightMapUnits = readUE() + 1;
+    const frameMbsOnly = getBit();
+    
+    if (!frameMbsOnly) getBit(); // mb_adaptive_frame_field_flag
+    getBit(); // direct_8x8_inference_flag
+    
+    let cropLeft = 0, cropRight = 0, cropTop = 0, cropBottom = 0;
+    if (getBit()) { // frame_cropping_flag
+      cropLeft = readUE();
+      cropRight = readUE();
+      cropTop = readUE();
+      cropBottom = readUE();
+    }
+    
+    // Calculate dimensions
+    const mbWidth = 16;
+    const mbHeight = frameMbsOnly ? 16 : 32;
+    result.width = picWidthMbs * mbWidth - (cropLeft + cropRight) * 2;
+    result.height = (2 - frameMbsOnly) * picHeightMapUnits * mbHeight / (frameMbsOnly ? 1 : 2) - (cropTop + cropBottom) * 2;
+    
+  } catch (e) {
+    // Fall back to defaults on parse error
+  }
+  
+  return result;
+}
+
+class MP4Builder {
+  constructor(parser) {
+    this.parser = parser;
+    this.videoTimescale = 90000;
+    // Use detected sample rate or default to 48000
+    this.audioTimescale = parser.audioSampleRate || 48000;
+    this.audioSampleDuration = 1024;
+    this.videoDimensions = null;
+  }
+  
+  getVideoDimensions() {
+    if (this.videoDimensions) return this.videoDimensions;
+    
+    // Find SPS NAL unit
+    for (const au of this.parser.videoAccessUnits) {
+      for (const nalUnit of au.nalUnits) {
+        const nalType = nalUnit[0] & 0x1F;
+        if (nalType === 7) {
+          this.videoDimensions = parseSPS(nalUnit);
+          return this.videoDimensions;
+        }
+      }
+    }
+    
+    // Fallback
+    this.videoDimensions = { width: 1920, height: 1080 };
+    return this.videoDimensions;
+  }
+  
+  build() {
+    const mdatContent = this.buildMdatContent();
+    const moov = this.buildMoov(mdatContent.byteLength);
+    const ftyp = this.buildFtyp();
+    const mdatOffset = ftyp.byteLength + moov.byteLength + 8;
+    this.updateChunkOffsets(moov, mdatOffset);
+    const mdat = createBox('mdat', mdatContent);
+    const result = new Uint8Array(ftyp.byteLength + moov.byteLength + mdat.byteLength);
+    result.set(ftyp, 0);
+    result.set(moov, ftyp.byteLength);
+    result.set(mdat, ftyp.byteLength + moov.byteLength);
+    return result;
+  }
+  
+  buildFtyp() {
+    const data = new Uint8Array(16);
+    data[0] = 'i'.charCodeAt(0); data[1] = 's'.charCodeAt(0); data[2] = 'o'.charCodeAt(0); data[3] = 'm'.charCodeAt(0);
+    data[7] = 1;
+    data[8] = 'i'.charCodeAt(0); data[9] = 's'.charCodeAt(0); data[10] = 'o'.charCodeAt(0); data[11] = 'm'.charCodeAt(0);
+    data[12] = 'a'.charCodeAt(0); data[13] = 'v'.charCodeAt(0); data[14] = 'c'.charCodeAt(0); data[15] = '1'.charCodeAt(0);
+    return createBox('ftyp', data);
+  }
+  
+  buildMdatContent() {
+    const chunks = [];
+    this.videoSampleSizes = [];
+    this.videoSampleOffsets = [];
+    let currentOffset = 0;
+    for (const au of this.parser.videoAccessUnits) {
+      this.videoSampleOffsets.push(currentOffset);
+      let sampleSize = 0;
+      for (const nalUnit of au.nalUnits) {
+        const prefixed = new Uint8Array(4 + nalUnit.length);
+        new DataView(prefixed.buffer).setUint32(0, nalUnit.length);
+        prefixed.set(nalUnit, 4);
+        chunks.push(prefixed);
+        sampleSize += prefixed.length;
+      }
+      this.videoSampleSizes.push(sampleSize);
+      currentOffset += sampleSize;
+    }
+    this.videoChunkOffset = 0;
+    this.audioChunkOffset = currentOffset;
+    this.audioSampleSizes = [];
+    for (const frame of this.parser.audioAccessUnits) {
+      chunks.push(frame.data);
+      this.audioSampleSizes.push(frame.data.length);
+      currentOffset += frame.data.length;
+    }
+    const totalSize = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const chunk of chunks) { result.set(chunk, offset); offset += chunk.length; }
+    return result;
+  }
+  
+  buildMoov(mdatSize) {
+    const mvhd = this.buildMvhd();
+    const videoTrak = this.buildVideoTrak();
+    const audioTrak = this.buildAudioTrak();
+    const udta = this.buildUdta();
+    return createBox('moov', mvhd, videoTrak, audioTrak, udta);
+  }
+  
+  buildUdta() {
+    const toolName = 'toMp4.js';
+    const toolBytes = new TextEncoder().encode(toolName);
+    const dataBox = new Uint8Array(16 + toolBytes.length);
+    const dataView = new DataView(dataBox.buffer);
+    dataView.setUint32(0, 16 + toolBytes.length);
+    dataBox[4] = 'd'.charCodeAt(0); dataBox[5] = 'a'.charCodeAt(0); dataBox[6] = 't'.charCodeAt(0); dataBox[7] = 'a'.charCodeAt(0);
+    dataView.setUint32(8, 1); dataView.setUint32(12, 0);
+    dataBox.set(toolBytes, 16);
+    const tooBox = createBox('©too', dataBox);
+    const ilst = createBox('ilst', tooBox);
+    const hdlrData = new Uint8Array(21);
+    hdlrData[4] = 'm'.charCodeAt(0); hdlrData[5] = 'd'.charCodeAt(0); hdlrData[6] = 'i'.charCodeAt(0); hdlrData[7] = 'r'.charCodeAt(0);
+    const metaHdlr = createFullBox('hdlr', 0, 0, hdlrData);
+    const meta = createFullBox('meta', 0, 0, new Uint8Array(0), metaHdlr, ilst);
+    return createBox('udta', meta);
+  }
+  
+  buildMvhd() {
+    const data = new Uint8Array(96);
+    const view = new DataView(data.buffer);
+    view.setUint32(8, this.videoTimescale);
+    view.setUint32(12, this.calculateVideoDuration());
+    view.setUint32(16, 0x00010000);
+    view.setUint16(20, 0x0100);
+    view.setUint32(32, 0x00010000);
+    view.setUint32(48, 0x00010000);
+    view.setUint32(64, 0x40000000);
+    view.setUint32(92, 258);
+    return createFullBox('mvhd', 0, 0, data);
+  }
+  
+  calculateVideoDuration() {
+    if (this.parser.videoDts.length < 2) return 0;
+    const firstDts = this.parser.videoDts[0];
+    const lastDts = this.parser.videoDts[this.parser.videoDts.length - 1];
+    const avgDuration = (lastDts - firstDts) / (this.parser.videoDts.length - 1);
+    return Math.round(lastDts - firstDts + avgDuration);
+  }
+  
+  buildVideoTrak() {
+    const edts = this.buildVideoEdts();
+    if (edts) {
+      return createBox('trak', this.buildVideoTkhd(), edts, this.buildVideoMdia());
+    }
+    return createBox('trak', this.buildVideoTkhd(), this.buildVideoMdia());
+  }
+  
+  // Build edit list to fix A/V sync
+  // The elst box tells the player where media actually starts
+  buildVideoEdts() {
+    // Get first video PTS (presentation time)
+    if (this.parser.videoAccessUnits.length === 0) return null;
+    
+    const firstAU = this.parser.videoAccessUnits[0];
+    const firstVideoPts = firstAU.pts;
+    
+    // If video starts at 0, no edit needed
+    if (firstVideoPts === 0) return null;
+    
+    // Create elst box: tells player to start at firstVideoPts in the media
+    // This compensates for CTTS offset making video appear to start late
+    const duration = this.calculateVideoDuration();
+    const mediaTime = firstVideoPts; // Start playback at this media time
+    
+    // elst entry: segment_duration (4), media_time (4), media_rate (4)
+    const elstData = new Uint8Array(16);
+    const view = new DataView(elstData.buffer);
+    view.setUint32(0, 1); // entry count
+    view.setUint32(4, duration); // segment duration in movie timescale
+    view.setInt32(8, mediaTime); // media time - where to start
+    view.setUint16(12, 1); // media rate integer (1.0)
+    view.setUint16(14, 0); // media rate fraction
+    
+    const elst = createFullBox('elst', 0, 0, elstData);
+    return createBox('edts', elst);
+  }
+  
+  buildVideoTkhd() {
+    const { width, height } = this.getVideoDimensions();
+    const data = new Uint8Array(80);
+    const view = new DataView(data.buffer);
+    view.setUint32(8, 256);
+    view.setUint32(16, this.calculateVideoDuration());
+    view.setUint16(32, 0);
+    view.setUint32(36, 0x00010000);
+    view.setUint32(52, 0x00010000);
+    view.setUint32(68, 0x40000000);
+    view.setUint32(72, width << 16);
+    view.setUint32(76, height << 16);
+    return createFullBox('tkhd', 0, 3, data);
+  }
+  
+  buildVideoMdia() {
+    return createBox('mdia', this.buildVideoMdhd(), this.buildVideoHdlr(), this.buildVideoMinf());
+  }
+  
+  buildVideoMdhd() {
+    const data = new Uint8Array(20);
+    const view = new DataView(data.buffer);
+    view.setUint32(8, this.videoTimescale);
+    view.setUint32(12, this.calculateVideoDuration());
+    view.setUint16(16, 0x55C4);
+    return createFullBox('mdhd', 0, 0, data);
+  }
+  
+  buildVideoHdlr() {
+    const data = new Uint8Array(21);
+    data[4] = 'v'.charCodeAt(0); data[5] = 'i'.charCodeAt(0); data[6] = 'd'.charCodeAt(0); data[7] = 'e'.charCodeAt(0);
+    return createFullBox('hdlr', 0, 0, data);
+  }
+  
+  buildVideoMinf() {
+    return createBox('minf', this.buildVmhd(), this.buildDinf(), this.buildVideoStbl());
+  }
+  
+  buildVmhd() { return createFullBox('vmhd', 0, 1, new Uint8Array(8)); }
+  
+  buildDinf() {
+    const urlBox = createFullBox('url ', 0, 1, new Uint8Array(0));
+    const dref = createFullBox('dref', 0, 0, new Uint8Array([0, 0, 0, 1]), urlBox);
+    return createBox('dinf', dref);
+  }
+  
+  buildVideoStbl() {
+    const boxes = [this.buildVideoStsd(), this.buildVideoStts(), this.buildVideoCtts(), this.buildVideoStsc(), this.buildVideoStsz(), this.buildVideoStco()];
+    const stss = this.buildVideoStss();
+    if (stss) boxes.push(stss);
+    return createBox('stbl', ...boxes);
+  }
+  
+  buildVideoStsd() {
+    const { width, height } = this.getVideoDimensions();
+    const avcC = this.buildAvcC();
+    const btrtData = new Uint8Array(12);
+    const btrtView = new DataView(btrtData.buffer);
+    btrtView.setUint32(4, 2000000); btrtView.setUint32(8, 2000000);
+    const btrt = createBox('btrt', btrtData);
+    const paspData = new Uint8Array(8);
+    const paspView = new DataView(paspData.buffer);
+    paspView.setUint32(0, 1); paspView.setUint32(4, 1);
+    const pasp = createBox('pasp', paspData);
+    const avc1Data = new Uint8Array(78 + avcC.byteLength + btrt.byteLength + pasp.byteLength);
+    const view = new DataView(avc1Data.buffer);
+    view.setUint16(6, 1); view.setUint16(24, width); view.setUint16(26, height);
+    view.setUint32(28, 0x00480000); view.setUint32(32, 0x00480000);
+    view.setUint16(40, 1); view.setUint16(74, 0x0018); view.setInt16(76, -1);
+    avc1Data.set(avcC, 78); avc1Data.set(btrt, 78 + avcC.byteLength); avc1Data.set(pasp, 78 + avcC.byteLength + btrt.byteLength);
+    const avc1 = createBox('avc1', avc1Data);
+    const stsdHeader = new Uint8Array(4);
+    new DataView(stsdHeader.buffer).setUint32(0, 1);
+    return createFullBox('stsd', 0, 0, stsdHeader, avc1);
+  }
+  
+  buildAvcC() {
+    let sps = null, pps = null;
+    for (const au of this.parser.videoAccessUnits) {
+      for (const nalUnit of au.nalUnits) {
+        const nalType = nalUnit[0] & 0x1F;
+        if (nalType === 7 && !sps) sps = nalUnit;
+        if (nalType === 8 && !pps) pps = nalUnit;
+        if (sps && pps) break;
+      }
+      if (sps && pps) break;
+    }
+    if (!sps || !pps) {
+      sps = new Uint8Array([0x67, 0x64, 0x00, 0x1f, 0xac, 0xd9, 0x40, 0x78, 0x02, 0x27, 0xe5, 0xc0, 0x44, 0x00, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc6, 0x58]);
+      pps = new Uint8Array([0x68, 0xeb, 0xe3, 0xcb, 0x22, 0xc0]);
+    }
+    const data = new Uint8Array(11 + sps.length + pps.length);
+    const view = new DataView(data.buffer);
+    data[0] = 1; data[1] = sps[1]; data[2] = sps[2]; data[3] = sps[3]; data[4] = 0xFF; data[5] = 0xE1;
+    view.setUint16(6, sps.length); data.set(sps, 8);
+    data[8 + sps.length] = 1; view.setUint16(9 + sps.length, pps.length); data.set(pps, 11 + sps.length);
+    return createBox('avcC', data);
+  }
+  
+  buildVideoStts() {
+    const entries = [];
+    let lastDuration = -1, count = 0;
+    for (let i = 0; i < this.parser.videoDts.length; i++) {
+      const duration = i < this.parser.videoDts.length - 1 
+        ? this.parser.videoDts[i + 1] - this.parser.videoDts[i] 
+        : (entries.length > 0 ? entries[entries.length - 1].duration : 3003);
+      if (duration === lastDuration) count++;
+      else { if (count > 0) entries.push({ count, duration: lastDuration }); lastDuration = duration; count = 1; }
+    }
+    if (count > 0) entries.push({ count, duration: lastDuration });
+    const data = new Uint8Array(4 + entries.length * 8);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, entries.length);
+    for (let i = 0; i < entries.length; i++) { view.setUint32(4 + i * 8, entries[i].count); view.setUint32(8 + i * 8, entries[i].duration); }
+    return createFullBox('stts', 0, 0, data);
+  }
+  
+  buildVideoCtts() {
+    const entries = [];
+    for (const au of this.parser.videoAccessUnits) {
+      const cts = au.pts - au.dts;
+      if (entries.length > 0 && entries[entries.length - 1].offset === cts) entries[entries.length - 1].count++;
+      else entries.push({ count: 1, offset: cts });
+    }
+    const data = new Uint8Array(4 + entries.length * 8);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, entries.length);
+    for (let i = 0; i < entries.length; i++) { view.setUint32(4 + i * 8, entries[i].count); view.setUint32(8 + i * 8, entries[i].offset); }
+    return createFullBox('ctts', 0, 0, data);
+  }
+  
+  buildVideoStsc() {
+    const data = new Uint8Array(4 + 12);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, 1); view.setUint32(4, 1); view.setUint32(8, this.videoSampleSizes.length); view.setUint32(12, 1);
+    return createFullBox('stsc', 0, 0, data);
+  }
+  
+  buildVideoStsz() {
+    const data = new Uint8Array(8 + this.videoSampleSizes.length * 4);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, 0); view.setUint32(4, this.videoSampleSizes.length);
+    for (let i = 0; i < this.videoSampleSizes.length; i++) view.setUint32(8 + i * 4, this.videoSampleSizes[i]);
+    return createFullBox('stsz', 0, 0, data);
+  }
+  
+  buildVideoStco() {
+    const data = new Uint8Array(8);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, 1); view.setUint32(4, 0);
+    return createFullBox('stco', 0, 0, data);
+  }
+  
+  buildVideoStss() {
+    const keyframes = [];
+    for (let i = 0; i < this.parser.videoAccessUnits.length; i++) {
+      for (const nalUnit of this.parser.videoAccessUnits[i].nalUnits) {
+        if ((nalUnit[0] & 0x1F) === 5) { keyframes.push(i + 1); break; }
+      }
+    }
+    if (keyframes.length === 0) return null;
+    const data = new Uint8Array(4 + keyframes.length * 4);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, keyframes.length);
+    for (let i = 0; i < keyframes.length; i++) view.setUint32(4 + i * 4, keyframes[i]);
+    return createFullBox('stss', 0, 0, data);
+  }
+  
+  buildAudioTrak() {
+    const edts = this.buildAudioEdts();
+    if (edts) {
+      return createBox('trak', this.buildAudioTkhd(), edts, this.buildAudioMdia());
+    }
+    return createBox('trak', this.buildAudioTkhd(), this.buildAudioMdia());
+  }
+  
+  // Build edit list for audio to sync with video
+  buildAudioEdts() {
+    if (this.parser.audioPts.length === 0) return null;
+    
+    const firstAudioPts = this.parser.audioPts[0];
+    
+    // If audio starts at 0, no edit needed
+    if (firstAudioPts === 0) return null;
+    
+    // Convert audio PTS (90kHz) to audio timescale (48kHz)
+    const mediaTime = Math.round(firstAudioPts * this.audioTimescale / 90000);
+    const duration = this.audioSampleSizes.length * this.audioSampleDuration;
+    
+    const elstData = new Uint8Array(16);
+    const view = new DataView(elstData.buffer);
+    view.setUint32(0, 1); // entry count
+    view.setUint32(4, Math.round(duration * this.videoTimescale / this.audioTimescale)); // segment duration in movie timescale
+    view.setInt32(8, mediaTime); // media time
+    view.setUint16(12, 1); // media rate integer
+    view.setUint16(14, 0); // media rate fraction
+    
+    const elst = createFullBox('elst', 0, 0, elstData);
+    return createBox('edts', elst);
+  }
+  
+  buildAudioTkhd() {
+    const data = new Uint8Array(80);
+    const view = new DataView(data.buffer);
+    view.setUint32(8, 257);
+    const audioDuration = this.audioSampleSizes.length * this.audioSampleDuration;
+    view.setUint32(16, Math.round(audioDuration * this.videoTimescale / this.audioTimescale));
+    view.setUint16(32, 0x0100);
+    view.setUint32(36, 0x00010000); view.setUint32(52, 0x00010000); view.setUint32(68, 0x40000000);
+    return createFullBox('tkhd', 0, 3, data);
+  }
+  
+  buildAudioMdia() { return createBox('mdia', this.buildAudioMdhd(), this.buildAudioHdlr(), this.buildAudioMinf()); }
+  
+  buildAudioMdhd() {
+    const data = new Uint8Array(20);
+    const view = new DataView(data.buffer);
+    view.setUint32(8, this.audioTimescale);
+    view.setUint32(12, this.audioSampleSizes.length * this.audioSampleDuration);
+    view.setUint16(16, 0x55C4);
+    return createFullBox('mdhd', 0, 0, data);
+  }
+  
+  buildAudioHdlr() {
+    const data = new Uint8Array(21);
+    data[4] = 's'.charCodeAt(0); data[5] = 'o'.charCodeAt(0); data[6] = 'u'.charCodeAt(0); data[7] = 'n'.charCodeAt(0);
+    return createFullBox('hdlr', 0, 0, data);
+  }
+  
+  buildAudioMinf() { return createBox('minf', this.buildSmhd(), this.buildDinf(), this.buildAudioStbl()); }
+  buildSmhd() { return createFullBox('smhd', 0, 0, new Uint8Array(4)); }
+  
+  buildAudioStbl() {
+    return createBox('stbl', this.buildAudioStsd(), this.buildAudioStts(), this.buildAudioStsc(), this.buildAudioStsz(), this.buildAudioStco());
+  }
+  
+  buildAudioStsd() {
+    const esds = this.buildEsds();
+    const channels = this.parser.audioChannels || 2;
+    const mp4aData = new Uint8Array(28 + esds.byteLength);
+    const view = new DataView(mp4aData.buffer);
+    view.setUint16(6, 1); 
+    view.setUint16(16, channels); // channel count
+    view.setUint16(18, 16); // sample size
+    view.setUint32(24, this.audioTimescale << 16);
+    mp4aData.set(esds, 28);
+    const mp4a = createBox('mp4a', mp4aData);
+    const stsdHeader = new Uint8Array(4);
+    new DataView(stsdHeader.buffer).setUint32(0, 1);
+    return createFullBox('stsd', 0, 0, stsdHeader, mp4a);
+  }
+  
+  buildEsds() {
+    // Build AudioSpecificConfig based on detected parameters
+    const SAMPLE_RATE_INDEX = {
+      96000: 0, 88200: 1, 64000: 2, 48000: 3, 44100: 4, 32000: 5,
+      24000: 6, 22050: 7, 16000: 8, 12000: 9, 11025: 10, 8000: 11, 7350: 12
+    };
+    
+    const sampleRate = this.audioTimescale;
+    const channels = this.parser.audioChannels || 2;
+    const samplingFreqIndex = SAMPLE_RATE_INDEX[sampleRate] ?? 4; // Default to 44100
+    
+    // AudioSpecificConfig: 5 bits objType + 4 bits freqIndex + 4 bits channels + 3 bits padding
+    // AAC-LC = 2
+    const audioConfig = ((2 << 11) | (samplingFreqIndex << 7) | (channels << 3)) & 0xFFFF;
+    const audioConfigHigh = (audioConfig >> 8) & 0xFF;
+    const audioConfigLow = audioConfig & 0xFF;
+    
+    const data = new Uint8Array([
+      0x00, 0x00, 0x00, 0x00,  // version/flags
+      0x03, 0x19,              // ES_Descriptor tag + length
+      0x00, 0x02,              // ES_ID
+      0x00,                    // flags
+      0x04, 0x11,              // DecoderConfigDescriptor tag + length
+      0x40,                    // objectTypeIndication (AAC)
+      0x15,                    // streamType (audio) + upstream + reserved
+      0x00, 0x00, 0x00,        // bufferSizeDB
+      0x00, 0x01, 0xF4, 0x00,  // maxBitrate
+      0x00, 0x01, 0xF4, 0x00,  // avgBitrate
+      0x05, 0x02,              // DecoderSpecificInfo tag + length
+      audioConfigHigh, audioConfigLow,  // AudioSpecificConfig
+      0x06, 0x01, 0x02         // SLConfigDescriptor
+    ]);
+    return createBox('esds', data);
+  }
+  
+  buildAudioStts() {
+    // Use actual PTS differences for accurate timing (like video does)
+    const audioPts = this.parser.audioPts;
+    
+    // If we don't have PTS data, fall back to constant duration
+    if (audioPts.length < 2) {
+      const data = new Uint8Array(12);
+      const view = new DataView(data.buffer);
+      view.setUint32(0, 1); 
+      view.setUint32(4, this.audioSampleSizes.length); 
+      view.setUint32(8, this.audioSampleDuration);
+      return createFullBox('stts', 0, 0, data);
+    }
+    
+    // Convert 90kHz PTS to audio timescale (48kHz)
+    // PTS is in 90kHz, we need durations in 48kHz
+    const entries = [];
+    let lastDuration = -1, count = 0;
+    
+    for (let i = 0; i < audioPts.length; i++) {
+      let duration;
+      if (i < audioPts.length - 1) {
+        // Calculate actual duration from PTS difference
+        const ptsDiff = audioPts[i + 1] - audioPts[i];
+        // Convert from 90kHz to 48kHz: duration = ptsDiff * 48000 / 90000
+        duration = Math.round(ptsDiff * this.audioTimescale / 90000);
+      } else {
+        // Last frame - use standard AAC frame duration
+        duration = this.audioSampleDuration;
+      }
+      
+      // Clamp to reasonable values (handle discontinuities)
+      if (duration <= 0 || duration > this.audioSampleDuration * 2) {
+        duration = this.audioSampleDuration;
+      }
+      
+      if (duration === lastDuration) {
+        count++;
+      } else {
+        if (count > 0) entries.push({ count, duration: lastDuration });
+        lastDuration = duration;
+        count = 1;
+      }
+    }
+    if (count > 0) entries.push({ count, duration: lastDuration });
+    
+    const data = new Uint8Array(4 + entries.length * 8);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, entries.length);
+    for (let i = 0; i < entries.length; i++) {
+      view.setUint32(4 + i * 8, entries[i].count);
+      view.setUint32(8 + i * 8, entries[i].duration);
+    }
+    return createFullBox('stts', 0, 0, data);
+  }
+  
+  buildAudioStsc() {
+    const data = new Uint8Array(4 + 12);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, 1); view.setUint32(4, 1); view.setUint32(8, this.audioSampleSizes.length); view.setUint32(12, 1);
+    return createFullBox('stsc', 0, 0, data);
+  }
+  
+  buildAudioStsz() {
+    const data = new Uint8Array(8 + this.audioSampleSizes.length * 4);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, 0); view.setUint32(4, this.audioSampleSizes.length);
+    for (let i = 0; i < this.audioSampleSizes.length; i++) view.setUint32(8 + i * 4, this.audioSampleSizes[i]);
+    return createFullBox('stsz', 0, 0, data);
+  }
+  
+  buildAudioStco() {
+    const data = new Uint8Array(8);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, 1); view.setUint32(4, 0);
+    return createFullBox('stco', 0, 0, data);
+  }
+  
+  updateChunkOffsets(moov, mdatOffset) { this.updateStcoInBox(moov, mdatOffset, 0); }
+  
+  updateStcoInBox(data, mdatOffset, trackIndex) {
+    let offset = 8;
+    while (offset < data.byteLength - 8) {
+      const view = new DataView(data.buffer, data.byteOffset + offset);
+      const size = view.getUint32(0);
+      const type = String.fromCharCode(data[offset+4], data[offset+5], data[offset+6], data[offset+7]);
+      if (size < 8 || offset + size > data.byteLength) break;
+      if (type === 'stco') {
+        view.setUint32(16, trackIndex === 0 ? mdatOffset + this.videoChunkOffset : mdatOffset + this.audioChunkOffset);
+        trackIndex++;
+      } else if (['moov', 'trak', 'mdia', 'minf', 'stbl'].includes(type)) {
+        trackIndex = this.updateStcoInBox(data.subarray(offset, offset + size), mdatOffset, trackIndex);
+      }
+      offset += size;
+    }
+    return trackIndex;
+  }
+}
+
+/**
+ * Get codec info for a stream type
+ */
+function getCodecInfo(streamType) {
+  return STREAM_TYPES[streamType] || { name: `Unknown (0x${streamType?.toString(16)})`, supported: false };
+}
+
+/**
+ * Convert MPEG-TS data to MP4
+ * 
+ * @param {Uint8Array} tsData - MPEG-TS data
+ * @param {object} options - Optional settings
+ * @param {function} options.onProgress - Progress callback
+ * @returns {Uint8Array} MP4 data
+ * @throws {Error} If codecs are unsupported or no video found
+ */
+export function convertTsToMp4(tsData, options = {}) {
+  const log = options.onProgress || (() => {});
+  
+  const parser = new TSParser();
+  parser.parse(tsData);
+  parser.finalize();
+  
+  const debug = parser.debug;
+  const videoInfo = getCodecInfo(parser.videoStreamType);
+  const audioInfo = getCodecInfo(parser.audioStreamType);
+  
+  // Log parsing results
+  log(`Parsed ${debug.packets} TS packets`);
+  log(`PAT: ${debug.patFound ? '✓' : '✗'}, PMT: ${debug.pmtFound ? '✓' : '✗'}`);
+  log(`Video: ${parser.videoPid ? `PID ${parser.videoPid}` : 'none'} → ${videoInfo.name}`);
+  const audioDetails = [];
+  if (parser.audioSampleRate) audioDetails.push(`${parser.audioSampleRate}Hz`);
+  if (parser.audioChannels) audioDetails.push(`${parser.audioChannels}ch`);
+  log(`Audio: ${parser.audioPid ? `PID ${parser.audioPid}` : 'none'} → ${audioInfo.name}${audioDetails.length ? ` (${audioDetails.join(', ')})` : ''}`);
+  
+  // Check for structural issues first
+  if (!debug.patFound) {
+    throw new Error('Invalid MPEG-TS: No PAT (Program Association Table) found. File may be corrupted or not MPEG-TS format.');
+  }
+  
+  if (!debug.pmtFound) {
+    throw new Error('Invalid MPEG-TS: No PMT (Program Map Table) found. File may be corrupted or missing stream info.');
+  }
+  
+  // Check for unsupported video codec BEFORE we report frame counts
+  if (parser.videoStreamType && !videoInfo.supported) {
+    throw new Error(
+      `Unsupported video codec: ${videoInfo.name}\n` +
+      `This library only supports H.264 and H.265 video.\n` +
+      `Your file needs to be transcoded to H.264 first.`
+    );
+  }
+  
+  // Check for unsupported audio codec
+  if (parser.audioStreamType && !audioInfo.supported) {
+    throw new Error(
+      `Unsupported audio codec: ${audioInfo.name}\n` +
+      `This library only supports AAC audio.\n` +
+      `Your file needs to be transcoded to AAC first.`
+    );
+  }
+  
+  // Check if we found any supported video
+  if (!parser.videoPid) {
+    throw new Error(
+      'No supported video stream found in MPEG-TS.\n' +
+      'This library supports: H.264/AVC, H.265/HEVC'
+    );
+  }
+  
+  log(`Frames: ${parser.videoAccessUnits.length} video, ${parser.audioAccessUnits.length} audio`);
+  if (debug.audioPesStarts) {
+    log(`Audio: ${debug.audioPesStarts} PES starts → ${debug.audioPesCount || 0} processed → ${debug.audioFramesInPes || 0} ADTS frames${debug.audioSkipped ? ` (${debug.audioSkipped} skipped)` : ''}`);
+  }
+  
+  if (parser.videoAccessUnits.length === 0) {
+    throw new Error('Video stream found but no frames could be extracted. File may be corrupted.');
+  }
+  
+  // Report timestamp normalization
+  if (debug.timestampNormalized) {
+    const offsetMs = (debug.timestampOffset / 90).toFixed(1);
+    log(`Timestamps normalized: -${offsetMs}ms offset`);
+  }
+  
+  const builder = new MP4Builder(parser);
+  const { width, height } = builder.getVideoDimensions();
+  log(`Dimensions: ${width}x${height}`);
+  
+  return builder.build();
+}
+
+export default convertTsToMp4;
+