@invintusmedia/tomp4 1.4.1 → 1.4.3

package/dist/tomp4.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invintusmedia/tomp4",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "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/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 ─────────────────────────────────────────────
@@ -112,7 +114,11 @@ function clipSegment(parser, startTime, endTime, options = {}) {
     if (videoAUs[i].pts >= startPts) { targetIdx = i; break; }
   }
 
-  const needsSmartRender = startTime !== undefined && targetIdx > keyframeIdx;
+  // Smart rendering is available but currently disabled for HLS output
+  // because the JS H.264 encoder's CAVLC output has bugs at high resolutions
+  // (works at 288x160 but fails at 1080p). Fall back to keyframe-accurate.
+  // TODO: Fix CAVLC encoding for high-resolution frames to re-enable.
+  const needsSmartRender = false;
 
   let clippedVideo, clippedAudio, startOffset;
 
@@ -245,16 +251,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 +270,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 +289,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 +561,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.1';
+toMp4.version = '1.4.3';
 
 // Export
 export {