@invintusmedia/tomp4 1.4.0 → 1.4.2

package/dist/tomp4.js

@@ -1,5 +1,5 @@
 /**
- * toMp4.js v1.4.0
+ * toMp4.js v1.4.2
  * Convert MPEG-TS and fMP4 to standard MP4
  * https://github.com/TVWIT/toMp4.js
  * MIT License
@@ -1186,7 +1186,7 @@
   toMp4.isMpegTs = isMpegTs;
   toMp4.isFmp4 = isFmp4;
   toMp4.isStandardMp4 = isStandardMp4;
-  toMp4.version = '1.4.0';
+  toMp4.version = '1.4.2';
 
   return toMp4;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invintusmedia/tomp4",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Convert MPEG-TS, fMP4, and HLS streams to MP4 with clipping support - pure JavaScript, zero dependencies",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/codecs/h264-cavlc-tables.js

@@ -0,0 +1,628 @@
+/**
+ * H.264 CAVLC (Context-Adaptive Variable-Length Coding) Encoding Tables
+ *
+ * Complete VLC tables from ITU-T H.264 specification:
+ *   - Table 9-5:  coeff_token VLC tables (5 nC ranges + ChromaDC variants)
+ *   - Table 9-7:  total_zeros for 4x4 blocks (TotalCoeff 1-15)
+ *   - Table 9-8:  total_zeros for chroma DC 2x2 (TotalCoeff 1-3)
+ *   - Table 9-9:  total_zeros for chroma DC 2x4 (TotalCoeff 1-7)
+ *   - Table 9-10: run_before (zerosLeft 1-7+)
+ *
+ * Each entry is [bits, length] where:
+ *   - bits: the VLC codeword value (MSB-first integer)
+ *   - length: number of bits in the codeword
+ *
+ * Source: Verified against x264 (common/tables.c) and FFmpeg (libavcodec/h264_cavlc.c).
+ *
+ * @module codecs/h264-cavlc-tables
+ */
+
+// ══════════════════════════════════════════════════════════════════════════════
+// coeff_token for TotalCoeff=0 (no coefficients)
+// Indexed by nC table index (0-5):
+//   0: nC 0-1,  1: nC 2-3,  2: nC 4-7,  3: nC 8+,  4: nC=-1 (ChromaDC 2x2),  5: nC=-2 (ChromaDC 2x4)
+// Table 9-5 in the spec
+// ══════════════════════════════════════════════════════════════════════════════
+
+export const coeff0Token = [
+  [0x01, 1],  // nC 0-1:  "1"
+  [0x03, 2],  // nC 2-3:  "11"
+  [0x0f, 4],  // nC 4-7:  "1111"
+  [0x03, 6],  // nC 8+:   "000011"
+  [0x01, 2],  // ChromaDC 2x2: "01"
+  [0x01, 1],  // ChromaDC 2x4: "1"
+];
+
+// ══════════════════════════════════════════════════════════════════════════════
+// coeff_token VLC tables
+// coeffTokenTable[nC_table][totalCoeff-1][trailingOnes] = [bits, length]
+//
+// nC table index mapping:
+//   0: nC = 0,1      (Table 9-5a)
+//   1: nC = 2,3      (Table 9-5b)
+//   2: nC = 4,5,6,7  (Table 9-5c)
+//   3: nC >= 8       (Table 9-5d)  -- fixed 6-bit codes
+//   4: nC = -1       (Chroma DC 2x2, Table 9-5e)
+//   5: nC = -2       (Chroma DC 2x4/4x2, for 4:2:2)
+//
+// trailingOnes: 0..3 (but only 0..min(totalCoeff,3) are valid)
+// Invalid combinations have [0, 0] placeholder
+// ══════════════════════════════════════════════════════════════════════════════
+
+export const coeffTokenTable = [
+  // ── nC = 0,1 (table 0) ──
+  [
+    // totalCoeff=1
+    [[0x05, 6], [0x01, 2], [0, 0], [0, 0]],
+    // totalCoeff=2
+    [[0x07, 8], [0x04, 6], [0x01, 3], [0, 0]],
+    // totalCoeff=3
+    [[0x07, 9], [0x06, 8], [0x05, 7], [0x03, 5]],
+    // totalCoeff=4
+    [[0x07, 10], [0x06, 9], [0x05, 8], [0x03, 6]],
+    // totalCoeff=5
+    [[0x07, 11], [0x06, 10], [0x05, 9], [0x04, 7]],
+    // totalCoeff=6
+    [[0x0f, 13], [0x06, 11], [0x05, 10], [0x04, 8]],
+    // totalCoeff=7
+    [[0x0b, 13], [0x0e, 13], [0x05, 11], [0x04, 9]],
+    // totalCoeff=8
+    [[0x08, 13], [0x0a, 13], [0x0d, 13], [0x04, 10]],
+    // totalCoeff=9
+    [[0x0f, 14], [0x0e, 14], [0x09, 13], [0x04, 11]],
+    // totalCoeff=10
+    [[0x0b, 14], [0x0a, 14], [0x0d, 14], [0x0c, 13]],
+    // totalCoeff=11
+    [[0x0f, 15], [0x0e, 15], [0x09, 14], [0x0c, 14]],
+    // totalCoeff=12
+    [[0x0b, 15], [0x0a, 15], [0x0d, 15], [0x08, 14]],
+    // totalCoeff=13
+    [[0x0f, 16], [0x01, 15], [0x09, 15], [0x0c, 15]],
+    // totalCoeff=14
+    [[0x0b, 16], [0x0e, 16], [0x0d, 16], [0x08, 15]],
+    // totalCoeff=15
+    [[0x07, 16], [0x0a, 16], [0x09, 16], [0x0c, 16]],
+    // totalCoeff=16
+    [[0x04, 16], [0x06, 16], [0x05, 16], [0x08, 16]],
+  ],
+
+  // ── nC = 2,3 (table 1) ──
+  [
+    // totalCoeff=1
+    [[0x0b, 6], [0x02, 2], [0, 0], [0, 0]],
+    // totalCoeff=2
+    [[0x07, 6], [0x07, 5], [0x03, 3], [0, 0]],
+    // totalCoeff=3
+    [[0x07, 7], [0x0a, 6], [0x09, 6], [0x05, 4]],
+    // totalCoeff=4
+    [[0x07, 8], [0x06, 6], [0x05, 6], [0x04, 4]],
+    // totalCoeff=5
+    [[0x04, 8], [0x06, 7], [0x05, 7], [0x06, 5]],
+    // totalCoeff=6
+    [[0x07, 9], [0x06, 8], [0x05, 8], [0x08, 6]],
+    // totalCoeff=7
+    [[0x0f, 11], [0x06, 9], [0x05, 9], [0x04, 6]],
+    // totalCoeff=8
+    [[0x0b, 11], [0x0e, 11], [0x0d, 11], [0x04, 7]],
+    // totalCoeff=9
+    [[0x0f, 12], [0x0a, 11], [0x09, 11], [0x04, 9]],
+    // totalCoeff=10
+    [[0x0b, 12], [0x0e, 12], [0x0d, 12], [0x0c, 11]],
+    // totalCoeff=11
+    [[0x08, 12], [0x0a, 12], [0x09, 12], [0x08, 11]],
+    // totalCoeff=12
+    [[0x0f, 13], [0x0e, 13], [0x0d, 13], [0x0c, 12]],
+    // totalCoeff=13
+    [[0x0b, 13], [0x0a, 13], [0x09, 13], [0x0c, 13]],
+    // totalCoeff=14
+    [[0x07, 13], [0x0b, 14], [0x06, 13], [0x08, 13]],
+    // totalCoeff=15
+    [[0x09, 14], [0x08, 14], [0x0a, 14], [0x01, 13]],
+    // totalCoeff=16
+    [[0x07, 14], [0x06, 14], [0x05, 14], [0x04, 14]],
+  ],
+
+  // ── nC = 4,5,6,7 (table 2) ──
+  [
+    // totalCoeff=1
+    [[0x0f, 6], [0x0e, 4], [0, 0], [0, 0]],
+    // totalCoeff=2
+    [[0x0b, 6], [0x0f, 5], [0x0d, 4], [0, 0]],
+    // totalCoeff=3
+    [[0x08, 6], [0x0c, 5], [0x0e, 5], [0x0c, 4]],
+    // totalCoeff=4
+    [[0x0f, 7], [0x0a, 5], [0x0b, 5], [0x0b, 4]],
+    // totalCoeff=5
+    [[0x0b, 7], [0x08, 5], [0x09, 5], [0x0a, 4]],
+    // totalCoeff=6
+    [[0x09, 7], [0x0e, 6], [0x0d, 6], [0x09, 4]],
+    // totalCoeff=7
+    [[0x08, 7], [0x0a, 6], [0x09, 6], [0x08, 4]],
+    // totalCoeff=8
+    [[0x0f, 8], [0x0e, 7], [0x0d, 7], [0x0d, 5]],
+    // totalCoeff=9
+    [[0x0b, 8], [0x0e, 8], [0x0a, 7], [0x0c, 6]],
+    // totalCoeff=10
+    [[0x0f, 9], [0x0a, 8], [0x0d, 8], [0x0c, 7]],
+    // totalCoeff=11
+    [[0x0b, 9], [0x0e, 9], [0x09, 8], [0x0c, 8]],
+    // totalCoeff=12
+    [[0x08, 9], [0x0a, 9], [0x0d, 9], [0x08, 8]],
+    // totalCoeff=13
+    [[0x0d, 10], [0x07, 9], [0x09, 9], [0x0c, 9]],
+    // totalCoeff=14
+    [[0x09, 10], [0x0c, 10], [0x0b, 10], [0x0a, 10]],
+    // totalCoeff=15
+    [[0x05, 10], [0x08, 10], [0x07, 10], [0x06, 10]],
+    // totalCoeff=16
+    [[0x01, 10], [0x04, 10], [0x03, 10], [0x02, 10]],
+  ],
+
+  // ── nC >= 8 (table 3) ── fixed-length 6-bit codes
+  [
+    // totalCoeff=1
+    [[0x00, 6], [0x01, 6], [0, 0], [0, 0]],
+    // totalCoeff=2
+    [[0x04, 6], [0x05, 6], [0x06, 6], [0, 0]],
+    // totalCoeff=3
+    [[0x08, 6], [0x09, 6], [0x0a, 6], [0x0b, 6]],
+    // totalCoeff=4
+    [[0x0c, 6], [0x0d, 6], [0x0e, 6], [0x0f, 6]],
+    // totalCoeff=5
+    [[0x10, 6], [0x11, 6], [0x12, 6], [0x13, 6]],
+    // totalCoeff=6
+    [[0x14, 6], [0x15, 6], [0x16, 6], [0x17, 6]],
+    // totalCoeff=7
+    [[0x18, 6], [0x19, 6], [0x1a, 6], [0x1b, 6]],
+    // totalCoeff=8
+    [[0x1c, 6], [0x1d, 6], [0x1e, 6], [0x1f, 6]],
+    // totalCoeff=9
+    [[0x20, 6], [0x21, 6], [0x22, 6], [0x23, 6]],
+    // totalCoeff=10
+    [[0x24, 6], [0x25, 6], [0x26, 6], [0x27, 6]],
+    // totalCoeff=11
+    [[0x28, 6], [0x29, 6], [0x2a, 6], [0x2b, 6]],
+    // totalCoeff=12
+    [[0x2c, 6], [0x2d, 6], [0x2e, 6], [0x2f, 6]],
+    // totalCoeff=13
+    [[0x30, 6], [0x31, 6], [0x32, 6], [0x33, 6]],
+    // totalCoeff=14
+    [[0x34, 6], [0x35, 6], [0x36, 6], [0x37, 6]],
+    // totalCoeff=15
+    [[0x38, 6], [0x39, 6], [0x3a, 6], [0x3b, 6]],
+    // totalCoeff=16
+    [[0x3c, 6], [0x3d, 6], [0x3e, 6], [0x3f, 6]],
+  ],
+
+  // ── nC = -1: Chroma DC 2x2 (4:2:0) (table 4) ── maxCoeff=4
+  [
+    // totalCoeff=1
+    [[0x07, 6], [0x01, 1], [0, 0], [0, 0]],
+    // totalCoeff=2
+    [[0x04, 6], [0x06, 6], [0x01, 3], [0, 0]],
+    // totalCoeff=3
+    [[0x03, 6], [0x03, 7], [0x02, 7], [0x05, 6]],
+    // totalCoeff=4
+    [[0x02, 6], [0x03, 8], [0x02, 8], [0x00, 7]],
+  ],
+
+  // ── nC = -2: Chroma DC 2x4 (4:2:2) (table 5) ── maxCoeff=8
+  [
+    // totalCoeff=1
+    [[0x0f, 7], [0x01, 2], [0, 0], [0, 0]],
+    // totalCoeff=2
+    [[0x0e, 7], [0x0d, 7], [0x01, 3], [0, 0]],
+    // totalCoeff=3
+    [[0x07, 9], [0x0c, 7], [0x0b, 7], [0x01, 5]],
+    // totalCoeff=4
+    [[0x06, 9], [0x05, 9], [0x0a, 7], [0x01, 6]],
+    // totalCoeff=5
+    [[0x07, 10], [0x06, 10], [0x04, 9], [0x09, 7]],
+    // totalCoeff=6
+    [[0x07, 11], [0x06, 11], [0x05, 10], [0x08, 7]],
+    // totalCoeff=7
+    [[0x07, 12], [0x06, 12], [0x05, 11], [0x04, 10]],
+    // totalCoeff=8
+    [[0x07, 13], [0x05, 12], [0x04, 12], [0x04, 11]],
+  ],
+];
+
+/**
+ * Maps nC (predicted number of non-zero coefficients) to table index.
+ * nC < 0: use -1 → index 4 (ChromaDC 2x2) or -2 → index 5 (ChromaDC 2x4)
+ * nC 0-1: index 0
+ * nC 2-3: index 1
+ * nC 4-7: index 2
+ * nC >= 8: index 3
+ */
+export function nCtoTableIndex(nC) {
+  if (nC < 0) return nC === -1 ? 4 : 5;
+  if (nC <= 1) return 0;
+  if (nC <= 3) return 1;
+  if (nC <= 7) return 2;
+  return 3;
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// total_zeros VLC tables (Table 9-7 in the spec)
+// totalZerosTable[totalCoeff-1][totalZeros] = [bits, length]
+// For 4x4 blocks, TotalCoeff = 1..15
+// totalZeros range: 0..(16-TotalCoeff)
+// ══════════════════════════════════════════════════════════════════════════════
+
+export const totalZerosTable = [
+  // totalCoeff=1: totalZeros 0..15
+  [
+    [0x01, 1], [0x03, 3], [0x02, 3], [0x03, 4],
+    [0x02, 4], [0x03, 5], [0x02, 5], [0x03, 6],
+    [0x02, 6], [0x03, 7], [0x02, 7], [0x03, 8],
+    [0x02, 8], [0x03, 9], [0x02, 9], [0x01, 9],
+  ],
+  // totalCoeff=2: totalZeros 0..14
+  [
+    [0x07, 3], [0x06, 3], [0x05, 3], [0x04, 3],
+    [0x03, 3], [0x05, 4], [0x04, 4], [0x03, 4],
+    [0x02, 4], [0x03, 5], [0x02, 5], [0x03, 6],
+    [0x02, 6], [0x01, 6], [0x00, 6],
+  ],
+  // totalCoeff=3: totalZeros 0..13
+  [
+    [0x05, 4], [0x07, 3], [0x06, 3], [0x05, 3],
+    [0x04, 4], [0x03, 4], [0x04, 3], [0x03, 3],
+    [0x02, 4], [0x03, 5], [0x02, 5], [0x01, 6],
+    [0x01, 5], [0x00, 6],
+  ],
+  // totalCoeff=4: totalZeros 0..12
+  [
+    [0x03, 5], [0x07, 3], [0x05, 4], [0x04, 4],
+    [0x06, 3], [0x05, 3], [0x04, 3], [0x03, 4],
+    [0x03, 3], [0x02, 4], [0x02, 5], [0x01, 5],
+    [0x00, 5],
+  ],
+  // totalCoeff=5: totalZeros 0..11
+  [
+    [0x05, 4], [0x04, 4], [0x03, 4], [0x07, 3],
+    [0x06, 3], [0x05, 3], [0x04, 3], [0x03, 3],
+    [0x02, 4], [0x01, 5], [0x01, 4], [0x00, 5],
+  ],
+  // totalCoeff=6: totalZeros 0..10
+  [
+    [0x01, 6], [0x01, 5], [0x07, 3], [0x06, 3],
+    [0x05, 3], [0x04, 3], [0x03, 3], [0x02, 3],
+    [0x01, 4], [0x01, 3], [0x00, 6],
+  ],
+  // totalCoeff=7: totalZeros 0..9
+  [
+    [0x01, 6], [0x01, 5], [0x05, 3], [0x04, 3],
+    [0x03, 3], [0x03, 2], [0x02, 3], [0x01, 4],
+    [0x01, 3], [0x00, 6],
+  ],
+  // totalCoeff=8: totalZeros 0..8
+  [
+    [0x01, 6], [0x01, 4], [0x01, 5], [0x03, 3],
+    [0x03, 2], [0x02, 2], [0x02, 3], [0x01, 3],
+    [0x00, 6],
+  ],
+  // totalCoeff=9: totalZeros 0..7
+  [
+    [0x01, 6], [0x00, 6], [0x01, 4], [0x03, 2],
+    [0x02, 2], [0x01, 3], [0x01, 2], [0x01, 5],
+  ],
+  // totalCoeff=10: totalZeros 0..6
+  [
+    [0x01, 5], [0x00, 5], [0x01, 3], [0x03, 2],
+    [0x02, 2], [0x01, 2], [0x01, 4],
+  ],
+  // totalCoeff=11: totalZeros 0..5
+  [
+    [0x00, 4], [0x01, 4], [0x01, 3], [0x02, 3],
+    [0x01, 1], [0x03, 3],
+  ],
+  // totalCoeff=12: totalZeros 0..4
+  [
+    [0x00, 4], [0x01, 4], [0x01, 2], [0x01, 1],
+    [0x01, 3],
+  ],
+  // totalCoeff=13: totalZeros 0..3
+  [
+    [0x00, 3], [0x01, 3], [0x01, 1], [0x01, 2],
+  ],
+  // totalCoeff=14: totalZeros 0..2
+  [
+    [0x00, 2], [0x01, 2], [0x01, 1],
+  ],
+  // totalCoeff=15: totalZeros 0..1
+  [
+    [0x00, 1], [0x01, 1],
+  ],
+];
+
+// ══════════════════════════════════════════════════════════════════════════════
+// total_zeros for Chroma DC 2x2 (4:2:0) — Table 9-8 in the spec
+// totalZerosChromaDC2x2[totalCoeff-1][totalZeros] = [bits, length]
+// maxCoeff = 4, so totalCoeff = 1..3
+// ══════════════════════════════════════════════════════════════════════════════
+
+export const totalZerosChromaDC2x2 = [
+  // totalCoeff=1: totalZeros 0..3
+  [
+    [0x01, 1], [0x01, 2], [0x01, 3], [0x00, 3],
+  ],
+  // totalCoeff=2: totalZeros 0..2
+  [
+    [0x01, 1], [0x01, 2], [0x00, 2],
+  ],
+  // totalCoeff=3: totalZeros 0..1
+  [
+    [0x01, 1], [0x00, 1],
+  ],
+];
+
+// ══════════════════════════════════════════════════════════════════════════════
+// total_zeros for Chroma DC 2x4 (4:2:2) — Table 9-9 in the spec
+// totalZerosChromaDC2x4[totalCoeff-1][totalZeros] = [bits, length]
+// maxCoeff = 8, so totalCoeff = 1..7
+// ══════════════════════════════════════════════════════════════════════════════
+
+export const totalZerosChromaDC2x4 = [
+  // totalCoeff=1: totalZeros 0..7
+  [
+    [0x01, 1], [0x02, 3], [0x03, 3], [0x02, 4],
+    [0x03, 4], [0x01, 4], [0x01, 5], [0x00, 5],
+  ],
+  // totalCoeff=2: totalZeros 0..6
+  [
+    [0x00, 3], [0x01, 2], [0x01, 3], [0x04, 3],
+    [0x05, 3], [0x06, 3], [0x07, 3],
+  ],
+  // totalCoeff=3: totalZeros 0..5
+  [
+    [0x00, 3], [0x01, 3], [0x01, 2], [0x02, 2],
+    [0x06, 3], [0x07, 3],
+  ],
+  // totalCoeff=4: totalZeros 0..4
+  [
+    [0x06, 3], [0x00, 2], [0x01, 2], [0x02, 2],
+    [0x07, 3],
+  ],
+  // totalCoeff=5: totalZeros 0..3
+  [
+    [0x00, 2], [0x01, 2], [0x02, 2], [0x03, 2],
+  ],
+  // totalCoeff=6: totalZeros 0..2
+  [
+    [0x00, 2], [0x01, 2], [0x01, 1],
+  ],
+  // totalCoeff=7: totalZeros 0..1
+  [
+    [0x00, 1], [0x01, 1],
+  ],
+];
+
+// ══════════════════════════════════════════════════════════════════════════════
+// run_before VLC tables — Table 9-10 in the spec
+// runBeforeTable[min(zerosLeft,7)-1][runBefore] = [bits, length]
+//
+// zerosLeft=1..6 have individual tables
+// zerosLeft>=7 shares one table (index 6)
+// ══════════════════════════════════════════════════════════════════════════════
+
+export const runBeforeTable = [
+  // zerosLeft=1: runBefore 0..1
+  [
+    [0x01, 1], [0x00, 1],
+  ],
+  // zerosLeft=2: runBefore 0..2
+  [
+    [0x01, 1], [0x01, 2], [0x00, 2],
+  ],
+  // zerosLeft=3: runBefore 0..3
+  [
+    [0x03, 2], [0x02, 2], [0x01, 2], [0x00, 2],
+  ],
+  // zerosLeft=4: runBefore 0..4
+  [
+    [0x03, 2], [0x02, 2], [0x01, 2], [0x01, 3], [0x00, 3],
+  ],
+  // zerosLeft=5: runBefore 0..5
+  [
+    [0x03, 2], [0x02, 2], [0x03, 3], [0x02, 3], [0x01, 3], [0x00, 3],
+  ],
+  // zerosLeft=6: runBefore 0..6
+  [
+    [0x03, 2], [0x00, 3], [0x01, 3], [0x03, 3], [0x02, 3], [0x05, 3], [0x04, 3],
+  ],
+  // zerosLeft>=7: runBefore 0..14
+  [
+    [0x07, 3], [0x06, 3], [0x05, 3], [0x04, 3],
+    [0x03, 3], [0x02, 3], [0x01, 3], [0x01, 4],
+    [0x01, 5], [0x01, 6], [0x01, 7], [0x01, 8],
+    [0x01, 9], [0x01, 10], [0x01, 11],
+  ],
+];
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Level encoding (coefficient magnitude/sign)
+//
+// The H.264 CAVLC level encoding uses:
+//   1) level_prefix: unary code (N zeros followed by a 1)
+//   2) level_suffix: fixed-length code of length suffixLength
+//
+// The suffixLength starts at 0 (or 1 if totalCoeff>10 && trailingOnes<3)
+// and increases as larger levels are encountered.
+//
+// This function encodes a single coefficient level and returns
+// [bits, length, newSuffixLength].
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Thresholds for incrementing suffixLength.
+ * After encoding a level, if |level| > nextSuffix[suffixLength],
+ * increment suffixLength.
+ * From x264: {0, 3, 6, 12, 24, 48, 0xffff}
+ */
+const SUFFIX_THRESHOLD = [0, 3, 6, 12, 24, 48, 0x7fffffff];
+
+/**
+ * Encode a single coefficient level value using CAVLC level VLC.
+ *
+ * Algorithm from ITU-T H.264 Section 9.2.2 and verified against
+ * x264 (common/vlc.c x264_level_token / encoder/cavlc.c cavlc_block_residual_escape).
+ *
+ * @param {number} level - Signed coefficient level (non-zero)
+ * @param {number} suffixLength - Current suffix length (0-6)
+ * @param {boolean} firstAfterTrailing - True if this is the first level after
+ *   trailing ones and trailingOnes < 3. The spec says to subtract 1 from the
+ *   magnitude (since we know it must be > 1 in this case).
+ * @returns {{ bits: number, length: number, suffixLength: number }}
+ */
+export function encodeLevel(level, suffixLength, firstAfterTrailing) {
+  const sign = level < 0 ? 1 : 0;
+  let absLevel = Math.abs(level);
+
+  // level_code = 2*|level| - 2 + sign
+  // If firstAfterTrailing, the decoded level is offset by 1
+  // (since |level| > 1 is guaranteed), so we adjust:
+  let levelCode = (absLevel << 1) - 2 + sign;
+  if (firstAfterTrailing) {
+    levelCode -= 2;
+  }
+
+  let bits, length;
+
+  const prefix = levelCode >> suffixLength;
+
+  if (prefix < 14) {
+    // Normal case: prefix zeros + 1 + suffix bits
+    length = prefix + 1 + suffixLength;
+    bits = (1 << suffixLength) | (levelCode & ((1 << suffixLength) - 1));
+  } else if (suffixLength === 0 && prefix === 14) {
+    // Special case: suffixLength=0, prefix=14 uses 4-bit suffix
+    length = 15 + 4; // 19 bits total (14 zeros + 1 + 4 suffix bits)
+    bits = (1 << 4) | (levelCode - 14);
+  } else if (prefix === 14) {
+    // suffixLength > 0, prefix=14: normal encoding still applies
+    length = 14 + 1 + suffixLength;
+    bits = (1 << suffixLength) | (levelCode & ((1 << suffixLength) - 1));
+  } else {
+    // prefix >= 15: escape code (High Profile level codes)
+    let escapeLevelCode = levelCode;
+    escapeLevelCode -= 15 << suffixLength;
+    if (suffixLength === 0) {
+      escapeLevelCode -= 15;
+    }
+
+    let levelPrefix = 15;
+    // For very large values, extend the prefix (High Profile)
+    while (escapeLevelCode >= (1 << (levelPrefix - 3))) {
+      escapeLevelCode -= 1 << (levelPrefix - 3);
+      levelPrefix++;
+    }
+
+    // prefix unary code (levelPrefix zeros + 1) + (levelPrefix-3) suffix bits
+    length = levelPrefix + 1 + (levelPrefix - 3);
+    bits = (1 << (levelPrefix - 3)) | (escapeLevelCode & ((1 << (levelPrefix - 3)) - 1));
+  }
+
+  // Update suffixLength
+  let newSuffixLength = suffixLength;
+  if (newSuffixLength === 0) {
+    newSuffixLength = 1;
+  }
+  if (absLevel > SUFFIX_THRESHOLD[newSuffixLength]) {
+    newSuffixLength++;
+  }
+
+  return { bits, length, suffixLength: newSuffixLength };
+}
+
+/**
+ * Encode the full set of non-trailing-one levels for a residual block.
+ *
+ * @param {number[]} levels - Array of signed level values (non-trailing, in reverse scan order)
+ * @param {number} trailingOnes - Number of trailing ones (0-3)
+ * @param {number} totalCoeff - Total number of non-zero coefficients
+ * @returns {{ bits: number[], lengths: number[] }} - Arrays of VLC codewords
+ */
+export function encodeLevels(levels, trailingOnes, totalCoeff) {
+  const bits = [];
+  const lengths = [];
+
+  // Initial suffix length
+  let suffixLength = (totalCoeff > 10 && trailingOnes < 3) ? 1 : 0;
+
+  for (let i = 0; i < levels.length; i++) {
+    const firstAfterTrailing = (i === 0 && trailingOnes < 3);
+    const result = encodeLevel(levels[i], suffixLength, firstAfterTrailing);
+    bits.push(result.bits);
+    lengths.push(result.length);
+    suffixLength = result.suffixLength;
+  }
+
+  return { bits, lengths };
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Convenience: encode a full CAVLC residual block
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Write coeff_token to a bitstream writer.
+ *
+ * @param {number} totalCoeff - Total non-zero coefficients (0-16)
+ * @param {number} trailingOnes - Number of trailing +/-1 coefficients (0-3)
+ * @param {number} nC - Predicted number of non-zero coefficients
+ * @returns {[number, number]} [bits, length] for the coeff_token VLC
+ */
+export function getCoeffToken(totalCoeff, trailingOnes, nC) {
+  const tableIdx = nCtoTableIndex(nC);
+  if (totalCoeff === 0) {
+    return coeff0Token[tableIdx];
+  }
+  return coeffTokenTable[tableIdx][totalCoeff - 1][trailingOnes];
+}
+
+/**
+ * Get total_zeros VLC for a 4x4 block.
+ *
+ * @param {number} totalCoeff - 1..15
+ * @param {number} totalZeros - 0..(16-totalCoeff)
+ * @returns {[number, number]} [bits, length]
+ */
+export function getTotalZeros(totalCoeff, totalZeros) {
+  return totalZerosTable[totalCoeff - 1][totalZeros];
+}
+
+/**
+ * Get total_zeros VLC for chroma DC 2x2 block.
+ *
+ * @param {number} totalCoeff - 1..3
+ * @param {number} totalZeros - 0..(4-totalCoeff)
+ * @returns {[number, number]} [bits, length]
+ */
+export function getTotalZerosChromaDC(totalCoeff, totalZeros) {
+  return totalZerosChromaDC2x2[totalCoeff - 1][totalZeros];
+}
+
+/**
+ * Get total_zeros VLC for chroma DC 2x4 block (4:2:2).
+ *
+ * @param {number} totalCoeff - 1..7
+ * @param {number} totalZeros - 0..(8-totalCoeff)
+ * @returns {[number, number]} [bits, length]
+ */
+export function getTotalZerosChromaDC422(totalCoeff, totalZeros) {
+  return totalZerosChromaDC2x4[totalCoeff - 1][totalZeros];
+}
+
+/**
+ * Get run_before VLC.
+ *
+ * @param {number} zerosLeft - Remaining zeros to distribute (>= 1)
+ * @param {number} runBefore - Run of zeros before this coefficient
+ * @returns {[number, number]} [bits, length]
+ */
+export function getRunBefore(zerosLeft, runBefore) {
+  const idx = Math.min(zerosLeft, 7) - 1;
+  return runBeforeTable[idx][runBefore];
+}

package/src/codecs/h264-encoder.js

@@ -13,6 +13,7 @@
 
 import { forwardDCT4x4, forwardHadamard4x4, forwardHadamard2x2, quantize4x4, clip255 } from './h264-transform.js';
 import { scanOrder4x4 } from './h264-tables.js';
+import { getCoeffToken, getTotalZeros, getTotalZerosChromaDC, getRunBefore, encodeLevels } from './h264-cavlc-tables.js';
 
 // ── Bitstream Writer ──────────────────────────────────────
 
@@ -382,6 +383,9 @@ export class H264Encoder {
     const mbType = 1 + predMode + cbpChroma * 4 + (cbpLuma > 0 ? 12 : 0);
     bs.writeUE(mbType);
 
+    // intra_chroma_pred_mode = 0 (DC) — required for ALL intra MBs
+    bs.writeUE(0);
+
     // mb_qp_delta = 0 (first MB uses slice QP)
     bs.writeSE(0);
 
@@ -400,178 +404,99 @@ export class H264Encoder {
     // (The chroma prediction handles the base values)
   }
 
-  // ── CAVLC Block Encoding ────────────────────────────────
+  // ── CAVLC Block Encoding (using spec-correct tables) ────
 
+  /**
+   * Encode a residual block using CAVLC with the correct VLC tables
+   * from the H.264 spec (Tables 9-5 through 9-10).
+   *
+   * @param {BitstreamWriter} bs - Output bitstream
+   * @param {Int32Array} coeffs - Quantized coefficients in scan order
+   * @param {number} maxCoeff - Maximum coefficients (16 for 4x4, 15 for AC)
+   * @param {number} nC - Predicted number of non-zero coefficients
+   */
   _encodeCavlcBlock(bs, coeffs, maxCoeff, nC) {
-    // Count trailing ones and total non-zero coefficients
-    let totalCoeff = 0;
-    let trailingOnes = 0;
-    const levels = [];
+    // Step 1: Analyze coefficients in reverse scan order
+    // Find non-zero coefficients and count trailing ones
+    const nonZeroValues = []; // level values in reverse scan order
+    const nonZeroPositions = []; // scan positions
 
-    // Scan in reverse order to find trailing ones
     for (let i = maxCoeff - 1; i >= 0; i--) {
       if (coeffs[i] !== 0) {
-        totalCoeff++;
-        if (trailingOnes < 3 && Math.abs(coeffs[i]) === 1 && levels.length === 0) {
-          trailingOnes++;
-        }
-        levels.push(coeffs[i]);
-      } else if (levels.length > 0) {
-        levels.push(0); // placeholder for run counting
+        nonZeroValues.push(coeffs[i]);
+        nonZeroPositions.push(i);
       }
     }
 
-    // Determine nC range for table selection
-    const tableIdx = nC < 2 ? 0 : nC < 4 ? 1 : nC < 8 ? 2 : 3;
+    const totalCoeff = nonZeroValues.length;
 
-    // Write coeff_token
-    if (totalCoeff === 0 && trailingOnes === 0) {
-      // Special case: all zeros
-      const table = CAVLC_COEFF_TOKEN[Math.min(tableIdx, 1)];
-      const [code, len] = table[0][0]; // (0,0)
-      bs.writeBits(code, len);
-      return;
+    // Count trailing ones (T1s): consecutive +/-1 at the END of the non-zero list
+    // In reverse scan order, these are at the BEGINNING of nonZeroValues
+    let trailingOnes = 0;
+    for (let i = 0; i < Math.min(totalCoeff, 3); i++) {
+      if (Math.abs(nonZeroValues[i]) === 1) trailingOnes++;
+      else break;
     }
 
-    // Look up coeff_token
-    const tc = Math.min(totalCoeff, 16);
-    const to = Math.min(trailingOnes, 3);
-    const table = CAVLC_COEFF_TOKEN[Math.min(tableIdx, 1)];
-    if (table[tc] && table[tc][to]) {
-      const [code, len] = table[tc][to];
-      bs.writeBits(code, len);
-    } else {
-      // Fallback: write as zero block
-      const [code, len] = table[0][0];
-      bs.writeBits(code, len);
-      return;
-    }
+    // Step 2: Write coeff_token
+    const [ctBits, ctLen] = getCoeffToken(totalCoeff, trailingOnes, nC);
+    bs.writeBits(ctBits, ctLen);
 
-    // Write trailing ones signs
-    const nonZeroLevels = [];
-    for (let i = maxCoeff - 1; i >= 0; i--) {
-      if (coeffs[i] !== 0) nonZeroLevels.push(coeffs[i]);
-    }
+    if (totalCoeff === 0) return;
 
+    // Step 3: Write trailing ones sign flags (1 bit each, 0=positive, 1=negative)
     for (let i = 0; i < trailingOnes; i++) {
-      bs.writeBit(nonZeroLevels[i] < 0 ? 1 : 0);
+      bs.writeBit(nonZeroValues[i] < 0 ? 1 : 0);
     }
 
-    // Write remaining levels (after trailing ones)
-    let suffixLength = totalCoeff > 10 && trailingOnes < 3 ? 1 : 0;
-    for (let i = trailingOnes; i < totalCoeff; i++) {
-      let level = nonZeroLevels[i];
-      // Adjust level for trailing ones
-      if (i === trailingOnes && trailingOnes < 3) {
-        level = level > 0 ? level - 1 : level + 1;
-      }
-      const absLevel = Math.abs(level);
-      const sign = level < 0 ? 1 : 0;
-
-      // level_prefix: unary code
-      let levelCode = (absLevel - 1) * 2 + sign;
-      if (i === trailingOnes && trailingOnes < 3) {
-        levelCode = absLevel * 2 + sign;
-      }
-
-      const prefix = levelCode >> suffixLength;
-      // Write prefix as unary
-      for (let j = 0; j < Math.min(prefix, 15); j++) bs.writeBit(0);
-      bs.writeBit(1);
-
-      // Write suffix
-      if (suffixLength > 0 || prefix >= 14) {
-        const suffBits = prefix >= 15 ? 12 : suffixLength;
-        if (suffBits > 0) {
-          bs.writeBits(levelCode & ((1 << suffBits) - 1), suffBits);
-        }
+    // Step 4: Write remaining levels (non-trailing-ones, still in reverse scan order)
+    if (totalCoeff > trailingOnes) {
+      const remainingLevels = nonZeroValues.slice(trailingOnes);
+      const { bits: levelBits, lengths: levelLens } = encodeLevels(
+        remainingLevels, trailingOnes, totalCoeff
+      );
+      for (let i = 0; i < levelBits.length; i++) {
+        // Write prefix (zeros + 1)
+        const prefix = levelLens[i] - (levelLens[i] > 0 ? 0 : 0);
+        // encodeLevels returns {bits, length} — write directly
+        bs.writeBits(levelBits[i], levelLens[i]);
       }
-
-      // Update suffix length
-      if (suffixLength === 0) suffixLength = 1;
-      if (absLevel > (3 << (suffixLength - 1))) suffixLength++;
     }
 
-    // Write total_zeros
+    // Step 5: Write total_zeros (only if totalCoeff < maxCoeff)
     if (totalCoeff < maxCoeff) {
-      let totalZeros = 0;
-      let lastNonZero = -1;
+      // Count total zeros before (and between) the non-zero coefficients
+      let lastNonZeroPos = 0;
       for (let i = maxCoeff - 1; i >= 0; i--) {
-        if (coeffs[i] !== 0) { lastNonZero = i; break; }
+        if (coeffs[i] !== 0) { lastNonZeroPos = i; break; }
       }
-      for (let i = 0; i <= lastNonZero; i++) {
+      let totalZeros = 0;
+      for (let i = 0; i <= lastNonZeroPos; i++) {
         if (coeffs[i] === 0) totalZeros++;
       }
 
-      // Simplified: write total_zeros using the UE-like VLC (not exactly spec but functional)
-      // The actual tables are complex; for a working encoder we use a simplified approach
-      this._writeTotalZeros(bs, totalZeros, totalCoeff, maxCoeff);
-    }
-
-    // Write run_before for each coefficient (except the last one)
-    let zerosLeft = 0;
-    for (let i = maxCoeff - 1; i >= 0; i--) {
-      if (coeffs[i] === 0) zerosLeft++;
-    }
-    // Adjust to only count zeros before the last non-zero
-    zerosLeft = 0;
-    let found = 0;
-    for (let i = 0; i < maxCoeff && found < totalCoeff; i++) {
-      if (coeffs[i] !== 0) {
-        found++;
-      } else if (found < totalCoeff) {
-        zerosLeft++;
-      }
-    }
+      const [tzBits, tzLen] = getTotalZeros(totalCoeff, totalZeros);
+      bs.writeBits(tzBits, tzLen);
 
-    // Run_before encoding (simplified)
-    let remaining = zerosLeft;
-    let coeffIdx = 0;
-    for (let i = maxCoeff - 1; i >= 0 && coeffIdx < totalCoeff - 1; i--) {
-      if (coeffs[i] !== 0) {
-        // Count run before this coefficient
+      // Step 6: Write run_before for each coefficient (reverse scan order)
+      // except the last one (its position is implied)
+      let zerosLeft = totalZeros;
+      for (let i = 0; i < totalCoeff - 1 && zerosLeft > 0; i++) {
+        const pos = nonZeroPositions[i];
+        // Count consecutive zeros before this coefficient in scan order
         let run = 0;
-        for (let j = i - 1; j >= 0; j--) {
+        for (let j = pos - 1; j >= 0; j--) {
           if (coeffs[j] === 0) run++;
           else break;
         }
-        if (remaining > 0) {
-          this._writeRunBefore(bs, Math.min(run, remaining), remaining);
-          remaining -= run;
-        }
-        coeffIdx++;
-      }
-    }
-  }
+        run = Math.min(run, zerosLeft);
 
-  _writeTotalZeros(bs, totalZeros, totalCoeff, maxCoeff) {
-    // Simplified total_zeros encoding: truncated unary
-    // This isn't exactly spec-compliant VLC but produces valid decodable output
-    if (totalCoeff >= maxCoeff) return; // no zeros possible
-    const maxZeros = maxCoeff - totalCoeff;
-    if (totalZeros === 0) {
-      bs.writeBit(1);
-    } else if (totalZeros <= maxZeros) {
-      for (let i = 0; i < Math.min(totalZeros, 8); i++) bs.writeBit(0);
-      bs.writeBit(1);
-      if (totalZeros > 8) {
-        bs.writeBits(totalZeros - 8, 4);
+        const [rbBits, rbLen] = getRunBefore(zerosLeft, run);
+        bs.writeBits(rbBits, rbLen);
+        zerosLeft -= run;
       }
     }
   }
-
-  _writeRunBefore(bs, run, zerosLeft) {
-    // Simplified run_before encoding
-    if (zerosLeft <= 0 || run <= 0) return;
-    if (run <= 6 && zerosLeft > 6) {
-      for (let i = 0; i < run; i++) bs.writeBit(0);
-      bs.writeBit(1);
-    } else {
-      // Truncated unary for small values
-      for (let i = 0; i < Math.min(run, 6); i++) bs.writeBit(0);
-      if (run < zerosLeft) bs.writeBit(1);
-    }
-  }
 }
 
 export default H264Encoder;

package/src/hls-clip.js

@@ -23,6 +23,8 @@
 import { parseHls, isHlsUrl, parsePlaylistText, toAbsoluteUrl } from './hls.js';
 import { TSParser, getCodecInfo } from './parsers/mpegts.js';
 import { createInitSegment, createFragment } from './muxers/fmp4.js';
+import { convertFmp4ToMp4 } from './fmp4/converter.js';
+import { parseBoxes, findBox, parseChildBoxes, createBox } from './fmp4/utils.js';
 import { smartRender } from './codecs/smart-render.js';
 
 // ── constants ─────────────────────────────────────────────
@@ -245,16 +247,18 @@ class HlsClipResult {
     // Pre-clipped boundary segments are already in memory
     if (seg.data) return seg.data;
 
-    // Middle segment: fetch from CDN, remux TS → fMP4
+    // Middle segment: fetch from CDN
     const resp = await fetch(seg.originalUrl);
     if (!resp.ok) throw new Error(`Segment fetch failed: ${resp.status}`);
-    const tsData = new Uint8Array(await resp.arrayBuffer());
+    const rawData = new Uint8Array(await resp.arrayBuffer());
 
-    const parser = parseTs(tsData);
-    const audioTimescale = parser.audioSampleRate || 48000;
+    // fMP4 segments pass through unchanged (already correct format)
+    if (seg._sourceFormat === 'fmp4') return rawData;
+
+    // TS segments: remux to fMP4
+    const parser = parseTs(rawData);
+    const audioTimescale = seg._audioTimescale || parser.audioSampleRate || 48000;
 
-    // Normalize timestamps: subtract the segment's original start PTS,
-    // then add the segment's position in the clip timeline
     const firstVideoPts = parser.videoAccessUnits[0]?.pts ?? 0;
     for (const au of parser.videoAccessUnits) { au.pts -= firstVideoPts; au.dts -= firstVideoPts; }
     for (const au of parser.audioAccessUnits) { au.pts -= firstVideoPts; }
@@ -262,12 +266,7 @@ class HlsClipResult {
     const videoBaseTime = Math.round(seg.timelineOffset * PTS_PER_SECOND);
     const audioBaseTime = Math.round(seg.timelineOffset * audioTimescale);
 
-    const fragment = remuxToFragment(
-      parser, segmentIndex + 1,
-      videoBaseTime, audioBaseTime, audioTimescale
-    );
-
-    return fragment;
+    return remuxToFragment(parser, segmentIndex + 1, videoBaseTime, audioBaseTime, audioTimescale);
   }
 
   /**
@@ -286,6 +285,202 @@ class HlsClipResult {
   }
 }
 
+// ── format detection ──────────────────────────────────────
+
+function _detectSegmentFormat(data) {
+  if (data.length < 8) return 'unknown';
+  // Check for TS sync byte
+  if (data[0] === 0x47) return 'ts';
+  for (let i = 0; i < Math.min(188, data.length); i++) {
+    if (data[i] === 0x47 && i + 188 < data.length && data[i + 188] === 0x47) return 'ts';
+  }
+  // Check for fMP4 (moof, styp, or ftyp box)
+  const type = String.fromCharCode(data[4], data[5], data[6], data[7]);
+  if (['moof', 'styp', 'ftyp', 'mdat'].includes(type)) return 'fmp4';
+  return 'unknown';
+}
+
+// ── TS variant processing ─────────────────────────────────
+
+function _processTsVariant({ firstSegData, lastSegData, overlapping, isSingleSegment, startTime, endTime, firstSeg, lastSeg, log }) {
+  const firstParser = parseTs(firstSegData);
+  const lastParser = !isSingleSegment && lastSegData ? parseTs(lastSegData) : null;
+
+  const { sps, pps } = extractCodecInfo(firstParser);
+  if (!sps || !pps) throw new Error('Could not extract SPS/PPS from video');
+  const audioSampleRate = firstParser.audioSampleRate || 48000;
+  const audioChannels = firstParser.audioChannels || 2;
+  const hasAudio = firstParser.audioAccessUnits.length > 0;
+  const audioTimescale = audioSampleRate;
+
+  const initSegment = createInitSegment({
+    sps, pps, audioSampleRate, audioChannels, hasAudio,
+    videoTimescale: PTS_PER_SECOND, audioTimescale,
+  });
+
+  const clipSegments = [];
+  let timelineOffset = 0;
+
+  // First segment (smart-rendered)
+  const firstRelStart = startTime - firstSeg.startTime;
+  const firstRelEnd = isSingleSegment ? endTime - firstSeg.startTime : undefined;
+  const firstClipped = clipSegment(firstParser, firstRelStart, firstRelEnd);
+  if (!firstClipped) throw new Error('First segment clip produced no samples');
+
+  const firstFragment = createFragment({
+    videoSamples: firstClipped.videoSamples,
+    audioSamples: firstClipped.audioSamples,
+    sequenceNumber: 1,
+    videoTimescale: PTS_PER_SECOND, audioTimescale,
+    videoBaseTime: 0, audioBaseTime: 0, audioSampleDuration: 1024,
+  });
+
+  clipSegments.push({
+    duration: firstClipped.duration, data: firstFragment,
+    originalUrl: null, timelineOffset: 0, isBoundary: true,
+  });
+  timelineOffset += firstClipped.duration;
+
+  // Middle segments
+  for (let i = 1; i < overlapping.length - 1; i++) {
+    clipSegments.push({
+      duration: overlapping[i].duration, data: null,
+      originalUrl: overlapping[i].url, timelineOffset, isBoundary: false,
+      _sourceFormat: 'ts', _audioTimescale: audioTimescale,
+    });
+    timelineOffset += overlapping[i].duration;
+  }
+
+  // Last segment
+  if (!isSingleSegment && lastParser) {
+    const lastRelEnd = endTime - lastSeg.startTime;
+    const lastClipped = clipSegment(lastParser, undefined, lastRelEnd);
+    if (lastClipped && lastClipped.videoSamples.length > 0) {
+      const lastFragment = createFragment({
+        videoSamples: lastClipped.videoSamples,
+        audioSamples: lastClipped.audioSamples,
+        sequenceNumber: overlapping.length,
+        videoTimescale: PTS_PER_SECOND, audioTimescale,
+        videoBaseTime: Math.round(timelineOffset * PTS_PER_SECOND),
+        audioBaseTime: Math.round(timelineOffset * audioTimescale),
+        audioSampleDuration: 1024,
+      });
+      clipSegments.push({
+        duration: lastClipped.duration, data: lastFragment,
+        originalUrl: null, timelineOffset, isBoundary: true,
+      });
+    }
+  }
+
+  return { initSegment, clipSegments, audioTimescale };
+}
+
+// ── fMP4 variant processing ───────────────────────────────
+
+function _processFmp4Variant({ firstSegData, lastSegData, fmp4Init, overlapping, isSingleSegment, startTime, endTime, firstSeg, lastSeg, log }) {
+  // For fMP4 sources: the init segment already has the moov with codec info.
+  // We pass it through as-is. Boundary segments are clipped using the fMP4
+  // converter. Middle segments pass through unchanged.
+
+  if (!fmp4Init) throw new Error('fMP4 source requires an init segment (#EXT-X-MAP)');
+
+  // Use the source init segment directly (it has the correct moov)
+  const initSegment = fmp4Init;
+
+  // Detect audio timescale from the init segment's moov
+  let audioTimescale = 48000;
+  try {
+    const boxes = parseBoxes(fmp4Init);
+    const moov = findBox(boxes, 'moov');
+    if (moov) {
+      const moovChildren = parseChildBoxes(moov);
+      for (const child of moovChildren) {
+        if (child.type === 'trak') {
+          const trakChildren = parseChildBoxes(child);
+          for (const tc of trakChildren) {
+            if (tc.type === 'mdia') {
+              const mdiaChildren = parseChildBoxes(tc);
+              let isSoun = false;
+              for (const mc of mdiaChildren) {
+                if (mc.type === 'hdlr' && mc.data.byteLength >= 20) {
+                  const handler = String.fromCharCode(mc.data[16], mc.data[17], mc.data[18], mc.data[19]);
+                  if (handler === 'soun') isSoun = true;
+                }
+                if (mc.type === 'mdhd' && isSoun) {
+                  const v = new DataView(mc.data.buffer, mc.data.byteOffset, mc.data.byteLength);
+                  audioTimescale = mc.data[8] === 0 ? v.getUint32(20) : v.getUint32(28);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  } catch (e) { /* use default */ }
+
+  const clipSegments = [];
+  let timelineOffset = 0;
+
+  // First segment: clip using fMP4 converter
+  const firstRelStart = startTime - firstSeg.startTime;
+  const firstRelEnd = isSingleSegment ? endTime - firstSeg.startTime : undefined;
+
+  // Combine init + first segment for the converter
+  const firstCombined = new Uint8Array(fmp4Init.byteLength + firstSegData.byteLength);
+  firstCombined.set(fmp4Init, 0);
+  firstCombined.set(firstSegData, fmp4Init.byteLength);
+
+  try {
+    // Use convertFmp4ToMp4 with clipping, then re-fragment
+    // Actually, we can just pass the raw fMP4 segment through — for boundary
+    // segments, we trim at the keyframe level (no smart rendering for fMP4 yet).
+    // The segment already starts at a keyframe (HLS requirement).
+
+    // For the first segment, just pass through — the startTime cut is at keyframe
+    // For frame accuracy with fMP4, we'd need to add edit lists to the init segment
+    // or do smart rendering. For now, keyframe-accurate is the fMP4 path.
+    clipSegments.push({
+      duration: (firstRelEnd || firstSeg.duration) - firstRelStart,
+      data: firstSegData, // pass through the fMP4 segment
+      originalUrl: null, timelineOffset: 0, isBoundary: true,
+      _sourceFormat: 'fmp4',
+    });
+    timelineOffset += clipSegments[0].duration;
+  } catch (e) {
+    log('fMP4 first segment processing error: ' + e.message);
+    // Fallback: pass through as-is
+    clipSegments.push({
+      duration: firstSeg.duration, data: firstSegData,
+      originalUrl: null, timelineOffset: 0, isBoundary: true,
+      _sourceFormat: 'fmp4',
+    });
+    timelineOffset += firstSeg.duration;
+  }
+
+  // Middle segments: pass through unchanged (already fMP4!)
+  for (let i = 1; i < overlapping.length - 1; i++) {
+    clipSegments.push({
+      duration: overlapping[i].duration, data: null,
+      originalUrl: overlapping[i].url, timelineOffset, isBoundary: false,
+      _sourceFormat: 'fmp4',
+    });
+    timelineOffset += overlapping[i].duration;
+  }
+
+  // Last segment: pass through (truncation at end is handled by player)
+  if (!isSingleSegment && lastSegData) {
+    const lastRelEnd = endTime - lastSeg.startTime;
+    clipSegments.push({
+      duration: Math.min(lastRelEnd, lastSeg.duration),
+      data: lastSegData,
+      originalUrl: null, timelineOffset, isBoundary: true,
+      _sourceFormat: 'fmp4',
+    });
+  }
+
+  return { initSegment, clipSegments, audioTimescale };
+}
+
 // ── main function ─────────────────────────────────────────
 
 /**
@@ -362,107 +557,52 @@ export async function clipHls(source, options = {}) {
 
     log(`Segments: ${overlapping.length} (${firstSeg.startTime.toFixed(1)}s – ${lastSeg.endTime.toFixed(1)}s)`);
 
-    // Download and parse boundary segments to get codec info + pre-clip
+    // Download first boundary segment to detect format
     log('Downloading boundary segments...');
-    const firstTsData = new Uint8Array(await (await fetch(firstSeg.url)).arrayBuffer());
-    const firstParser = parseTs(firstTsData);
+    const firstSegData = new Uint8Array(await (await fetch(firstSeg.url)).arrayBuffer());
 
-    let lastParser = null;
-    let lastTsData = null;
-    if (!isSingleSegment) {
-      lastTsData = new Uint8Array(await (await fetch(lastSeg.url)).arrayBuffer());
-      lastParser = parseTs(lastTsData);
-    }
-
-    // Extract codec info from first segment
-    const { sps, pps } = extractCodecInfo(firstParser);
-    if (!sps || !pps) throw new Error('Could not extract SPS/PPS from video');
-    const audioSampleRate = firstParser.audioSampleRate || 48000;
-    const audioChannels = firstParser.audioChannels || 2;
-    const hasAudio = firstParser.audioAccessUnits.length > 0;
-    const audioTimescale = audioSampleRate;
-
-    // Create CMAF init segment
-    const initSegment = createInitSegment({
-      sps, pps, audioSampleRate, audioChannels, hasAudio,
-      videoTimescale: PTS_PER_SECOND,
-      audioTimescale,
-    });
+    // Detect source format: TS or fMP4
+    const sourceFormat = _detectSegmentFormat(firstSegData);
+    const isFmp4Source = sourceFormat === 'fmp4';
 
-    // Build the clip segment list
-    const clipSegments = [];
-    let timelineOffset = 0;
-
-    // ── First segment (clipped at start, possibly also at end) ──
-    // Convert absolute times to segment-relative times (TS PTS starts at ~0 per segment)
-    const firstRelStart = startTime - firstSeg.startTime;
-    const firstRelEnd = isSingleSegment ? endTime - firstSeg.startTime : undefined;
-    const firstClipped = clipSegment(firstParser, firstRelStart, firstRelEnd);
-    if (!firstClipped) throw new Error('First segment clip produced no samples');
-
-    const firstFragment = createFragment({
-      videoSamples: firstClipped.videoSamples,
-      audioSamples: firstClipped.audioSamples,
-      sequenceNumber: 1,
-      videoTimescale: PTS_PER_SECOND,
-      audioTimescale,
-      videoBaseTime: 0,
-      audioBaseTime: 0,
-      audioSampleDuration: 1024,
-    });
+    log(`Source format: ${isFmp4Source ? 'fMP4 (CMAF)' : 'MPEG-TS'}`);
 
-    clipSegments.push({
-      duration: firstClipped.duration,
-      data: firstFragment, // pre-clipped, in memory
-      originalUrl: null,
-      timelineOffset: 0,
-      isBoundary: true,
-    });
-    timelineOffset += firstClipped.duration;
+    // Download fMP4 init segment if needed
+    let fmp4Init = null;
+    if (isFmp4Source && initSegmentUrl) {
+      const initResp = await fetch(initSegmentUrl);
+      if (initResp.ok) {
+        fmp4Init = new Uint8Array(await initResp.arrayBuffer());
+      }
+    }
 
-    // ── Middle segments (pass-through, remuxed on demand) ──
-    for (let i = 1; i < overlapping.length - 1; i++) {
-      const seg = overlapping[i];
-      const segDuration = seg.duration;
-      clipSegments.push({
-        duration: segDuration,
-        data: null, // fetched on demand
-        originalUrl: seg.url,
-        timelineOffset,
-        isBoundary: false,
-      });
-      timelineOffset += segDuration;
+    let lastSegData = null;
+    if (!isSingleSegment) {
+      lastSegData = new Uint8Array(await (await fetch(lastSeg.url)).arrayBuffer());
     }
 
-    // ── Last segment (clipped at end, if different from first) ──
-    if (!isSingleSegment && lastParser) {
-      const lastRelEnd = endTime - lastSeg.startTime;
-      const lastClipped = clipSegment(lastParser, undefined, lastRelEnd);
-      if (lastClipped && lastClipped.videoSamples.length > 0) {
-        const lastDuration = lastClipped.duration;
-        const lastSeqNum = overlapping.length;
-        const lastVideoBaseTime = Math.round(timelineOffset * PTS_PER_SECOND);
-        const lastAudioBaseTime = Math.round(timelineOffset * audioTimescale);
-
-        const lastFragment = createFragment({
-          videoSamples: lastClipped.videoSamples,
-          audioSamples: lastClipped.audioSamples,
-          sequenceNumber: lastSeqNum,
-          videoTimescale: PTS_PER_SECOND,
-          audioTimescale,
-          videoBaseTime: lastVideoBaseTime,
-          audioBaseTime: lastAudioBaseTime,
-          audioSampleDuration: 1024,
-        });
-
-        clipSegments.push({
-          duration: lastClipped.duration,
-          data: lastFragment,
-          originalUrl: null,
-          timelineOffset,
-          isBoundary: true,
-        });
-      }
+    let initSegment, clipSegments, audioTimescale;
+
+    if (isFmp4Source) {
+      // ── fMP4 source path ────────────────────────────────
+      const result = _processFmp4Variant({
+        firstSegData, lastSegData, fmp4Init,
+        overlapping, isSingleSegment,
+        startTime, endTime, firstSeg, lastSeg, log,
+      });
+      initSegment = result.initSegment;
+      clipSegments = result.clipSegments;
+      audioTimescale = result.audioTimescale;
+    } else {
+      // ── TS source path (existing smart-render pipeline) ──
+      const result = _processTsVariant({
+        firstSegData, lastSegData,
+        overlapping, isSingleSegment,
+        startTime, endTime, firstSeg, lastSeg, log,
+      });
+      initSegment = result.initSegment;
+      clipSegments = result.clipSegments;
+      audioTimescale = result.audioTimescale;
     }
 
     const totalDuration = clipSegments.reduce((sum, s) => sum + s.duration, 0);

package/src/index.js

@@ -342,7 +342,7 @@ toMp4.TSParser = TSParser;
 toMp4.RemoteMp4 = RemoteMp4;
 
 // Version (injected at build time for dist, read from package.json for ESM)
-toMp4.version = '1.4.0';
+toMp4.version = '1.4.2';
 
 // Export
 export {