@invintusmedia/tomp4 1.4.0 → 1.4.1

package/dist/tomp4.js

@@ -1,5 +1,5 @@
 /**
- * toMp4.js v1.4.0
+ * toMp4.js v1.4.1
  * 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.1';
 
   return toMp4;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invintusmedia/tomp4",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "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/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.1';
 
 // Export
 export {