@invintusmedia/tomp4 1.0.6 → 1.0.8

package/dist/tomp4.js

@@ -1,5 +1,5 @@
 /**
- * toMp4.js v1.0.6
+ * toMp4.js v1.0.8
  * Convert MPEG-TS and fMP4 to standard MP4
  * https://github.com/TVWIT/toMp4.js
  * MIT License
@@ -59,7 +59,9 @@
   }
   
   /**
-   * Clip access units to a time range, snapping to keyframes
+   * Clip access units to a time range, snapping to keyframes for decode
+   * but using edit list for precise playback timing
+   * 
    * @param {Array} videoAUs - Video access units
    * @param {Array} audioAUs - Audio access units  
    * @param {number} startTime - Start time in seconds
@@ -71,48 +73,73 @@
     const startPts = startTime * PTS_PER_SECOND;
     const endPts = endTime * PTS_PER_SECOND;
     
-    // Find keyframe at or before startTime
-    let startIdx = 0;
+    // Find keyframe at or before startTime (needed for decoding)
+    let keyframeIdx = 0;
     for (let i = 0; i < videoAUs.length; i++) {
       if (videoAUs[i].pts > startPts) break;
-      if (isKeyframe(videoAUs[i])) startIdx = i;
+      if (isKeyframe(videoAUs[i])) keyframeIdx = i;
     }
     
-    // Find first frame after endTime
+    // Find first frame at or after endTime
     let endIdx = videoAUs.length;
-    for (let i = startIdx; i < videoAUs.length; i++) {
+    for (let i = keyframeIdx; i < videoAUs.length; i++) {
       if (videoAUs[i].pts >= endPts) {
         endIdx = i;
         break;
       }
     }
     
-    // Clip video
-    const clippedVideo = videoAUs.slice(startIdx, endIdx);
+    // Clip video starting from keyframe (for proper decoding)
+    const clippedVideo = videoAUs.slice(keyframeIdx, endIdx);
+    
+    if (clippedVideo.length === 0) {
+      return {
+        video: [],
+        audio: [],
+        actualStartTime: startTime,
+        actualEndTime: endTime,
+        offset: 0,
+        preroll: 0
+      };
+    }
+    
+    // Get PTS of keyframe and requested start
+    const keyframePts = clippedVideo[0].pts;
+    const lastFramePts = clippedVideo[clippedVideo.length - 1].pts;
     
-    // Get actual PTS range from clipped video
-    const actualStartPts = clippedVideo.length > 0 ? clippedVideo[0].pts : 0;
-    const actualEndPts = clippedVideo.length > 0 ? clippedVideo[clippedVideo.length - 1].pts : 0;
+    // Pre-roll: time between keyframe and requested start
+    // This is the time the decoder needs to process but player shouldn't display
+    const prerollPts = Math.max(0, startPts - keyframePts);
     
-    // Clip audio to match video time range
-    const clippedAudio = audioAUs.filter(au => au.pts >= actualStartPts && au.pts <= actualEndPts);
+    // Clip audio to the REQUESTED time range (not from keyframe)
+    // Audio doesn't need keyframe pre-roll
+    const audioStartPts = startPts;
+    const audioEndPts = Math.min(endPts, lastFramePts + 90000); // Include audio slightly past last video
+    const clippedAudio = audioAUs.filter(au => au.pts >= audioStartPts && au.pts < audioEndPts);
     
-    // Normalize timestamps so clip starts at 0
-    const offset = actualStartPts;
+    // Normalize video timestamps so keyframe starts at 0
+    const offset = keyframePts;
     for (const au of clippedVideo) {
       au.pts -= offset;
       au.dts -= offset;
     }
+    
+    // Normalize audio timestamps so it starts at 0 (matching video playback start after preroll)
+    // Audio doesn't have preroll, so it should start at PTS 0 to sync with video after edit list
+    const audioOffset = audioStartPts;  // Use requested start, not keyframe
     for (const au of clippedAudio) {
-      au.pts -= offset;
+      au.pts -= audioOffset;
     }
     
     return {
       video: clippedVideo,
       audio: clippedAudio,
-      actualStartTime: actualStartPts / PTS_PER_SECOND,
-      actualEndTime: actualEndPts / PTS_PER_SECOND,
-      offset
+      actualStartTime: keyframePts / PTS_PER_SECOND,  // Where decode starts (keyframe)
+      actualEndTime: lastFramePts / PTS_PER_SECOND,
+      requestedStartTime: startTime,                   // Where playback should start
+      requestedEndTime: endTime,
+      offset,
+      preroll: prerollPts  // Edit list will use this to skip pre-roll frames during playback
     };
   }
   
@@ -246,6 +273,9 @@
     
     log(`Processing...`, { phase: 'convert', percent: 70 });
     
+    // Track preroll for edit list (used for precise clipping)
+    let clipPreroll = 0;
+    
     // Apply time range clipping if specified
     if (options.startTime !== undefined || options.endTime !== undefined) {
       const startTime = options.startTime || 0;
@@ -260,17 +290,23 @@
       
       parser.videoAccessUnits = clipResult.video;
       parser.audioAccessUnits = clipResult.audio;
+      clipPreroll = clipResult.preroll;
       
       // Update PTS arrays to match
       parser.videoPts = clipResult.video.map(au => au.pts);
       parser.videoDts = clipResult.video.map(au => au.dts);
       parser.audioPts = clipResult.audio.map(au => au.pts);
       
-      log(`Clipped: ${clipResult.actualStartTime.toFixed(2)}s - ${clipResult.actualEndTime.toFixed(2)}s (${clipResult.video.length} video, ${clipResult.audio.length} audio frames)`, { phase: 'convert', percent: 80 });
+      const prerollMs = (clipPreroll / 90).toFixed(0);
+      const endTimeStr = clipResult.requestedEndTime === Infinity ? 'end' : clipResult.requestedEndTime.toFixed(2) + 's';
+      const clipDuration = clipResult.requestedEndTime === Infinity 
+        ? (clipResult.actualEndTime - clipResult.requestedStartTime).toFixed(2)
+        : (clipResult.requestedEndTime - clipResult.requestedStartTime).toFixed(2);
+      log(`Clipped: ${clipResult.requestedStartTime.toFixed(2)}s - ${endTimeStr} (${clipDuration}s, ${prerollMs}ms preroll)`, { phase: 'convert', percent: 80 });
     }
     
     log(`Building MP4...`, { phase: 'convert', percent: 85 });
-    const muxer = new MP4Muxer(parser);
+    const muxer = new MP4Muxer(parser, { preroll: clipPreroll });
     const { width, height } = muxer.getVideoDimensions();
     log(`Dimensions: ${width}x${height}`);
     
@@ -720,7 +756,7 @@
   toMp4.isMpegTs = isMpegTs;
   toMp4.isFmp4 = isFmp4;
   toMp4.isStandardMp4 = isStandardMp4;
-  toMp4.version = '1.0.6';
+  toMp4.version = '1.0.8';
 
   return toMp4;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invintusmedia/tomp4",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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",
@@ -20,6 +20,7 @@
   "scripts": {
     "build": "node build.js",
     "dev": "npx serve . -p 3000",
+    "test": "node tests/clip.test.js",
     "release": "npm run build && git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag v$(node -p \"require('./package.json').version\") && git push && git push --tags",
     "release:patch": "npm version patch --no-git-tag-version && npm run release",
     "release:minor": "npm version minor --no-git-tag-version && npm run release",

package/src/index.js

@@ -316,7 +316,7 @@ toMp4.transcode = transcode;
 toMp4.isWebCodecsSupported = isWebCodecsSupported;
 
 // Version (injected at build time for dist, read from package.json for ESM)
-toMp4.version = '1.0.6';
+toMp4.version = '1.0.8';
 
 // Export
 export { 

package/src/muxers/mp4.js

@@ -149,13 +149,16 @@ export function parseSPS(sps) {
 export class MP4Muxer {
   /**
    * @param {TSParser} parser - Parser with video/audio access units
+   * @param {Object} [options] - Muxer options
+   * @param {number} [options.preroll=0] - Pre-roll time in 90kHz ticks (for edit list)
    */
-  constructor(parser) {
+  constructor(parser, options = {}) {
     this.parser = parser;
     this.videoTimescale = 90000;
     this.audioTimescale = parser.audioSampleRate || 48000;
     this.audioSampleDuration = 1024;
     this.videoDimensions = null;
+    this.preroll = options.preroll || 0;  // Pre-roll for precise clipping
   }
   
   getVideoDimensions() {
@@ -265,7 +268,7 @@ export class MP4Muxer {
     const data = new Uint8Array(96);
     const view = new DataView(data.buffer);
     view.setUint32(8, this.videoTimescale);
-    view.setUint32(12, this.calculateVideoDuration());
+    view.setUint32(12, this.calculatePlaybackDuration());  // Use playback duration for movie header
     view.setUint32(16, 0x00010000);
     view.setUint16(20, 0x0100);
     view.setUint32(32, 0x00010000);
@@ -283,6 +286,15 @@ export class MP4Muxer {
     return Math.round(lastDts - firstDts + avgDuration);
   }
   
+  /**
+   * Calculate playback duration (total duration minus pre-roll)
+   * This is what the player should report as the video length
+   */
+  calculatePlaybackDuration() {
+    const totalDuration = this.calculateVideoDuration();
+    return this.preroll > 0 ? Math.max(0, totalDuration - this.preroll) : totalDuration;
+  }
+  
   buildVideoTrak() {
     const edts = this.buildVideoEdts();
     if (edts) {
@@ -297,18 +309,25 @@ export class MP4Muxer {
     const firstAU = this.parser.videoAccessUnits[0];
     const firstVideoPts = firstAU.pts;
     
-    if (firstVideoPts === 0) return null;
+    // Use preroll for precise clipping, or firstVideoPts for timestamp normalization
+    const mediaTime = this.preroll > 0 ? this.preroll : firstVideoPts;
+    
+    // If no offset needed, skip edit list
+    if (mediaTime === 0) return null;
     
-    const duration = this.calculateVideoDuration();
-    const mediaTime = firstVideoPts;
+    // Calculate playback duration (total duration minus pre-roll)
+    const totalDuration = this.calculateVideoDuration();
+    const playbackDuration = this.preroll > 0 
+      ? Math.max(0, totalDuration - this.preroll)
+      : totalDuration;
     
     const elstData = new Uint8Array(16);
     const view = new DataView(elstData.buffer);
-    view.setUint32(0, 1);
-    view.setUint32(4, duration);
-    view.setInt32(8, mediaTime);
-    view.setUint16(12, 1);
-    view.setUint16(14, 0);
+    view.setUint32(0, 1);                    // entry_count
+    view.setUint32(4, playbackDuration);     // segment_duration (what player reports)
+    view.setInt32(8, mediaTime);             // media_time (where to start in media)
+    view.setUint16(12, 1);                   // media_rate_integer
+    view.setUint16(14, 0);                   // media_rate_fraction
     
     const elst = createFullBox('elst', 0, 0, elstData);
     return createBox('edts', elst);
@@ -319,7 +338,7 @@ export class MP4Muxer {
     const data = new Uint8Array(80);
     const view = new DataView(data.buffer);
     view.setUint32(8, 256);
-    view.setUint32(16, this.calculateVideoDuration());
+    view.setUint32(16, this.calculatePlaybackDuration());  // Use playback duration for track header
     view.setUint16(32, 0);
     view.setUint32(36, 0x00010000);
     view.setUint32(52, 0x00010000);
@@ -494,15 +513,19 @@ export class MP4Muxer {
     if (this.parser.audioPts.length === 0) return null;
     
     const firstAudioPts = this.parser.audioPts[0];
+    
+    // When clipping with preroll, audio is normalized to start at PTS 0
+    // (matching video playback start after edit list), so no edit list needed
     if (firstAudioPts === 0) return null;
     
+    // For non-clipped content, handle any timestamp offset
     const mediaTime = Math.round(firstAudioPts * this.audioTimescale / 90000);
-    const duration = this.audioSampleSizes.length * this.audioSampleDuration;
+    const audioDuration = this.audioSampleSizes.length * this.audioSampleDuration;
     
     const elstData = new Uint8Array(16);
     const view = new DataView(elstData.buffer);
     view.setUint32(0, 1);
-    view.setUint32(4, Math.round(duration * this.videoTimescale / this.audioTimescale));
+    view.setUint32(4, Math.round(audioDuration * this.videoTimescale / this.audioTimescale));
     view.setInt32(8, mediaTime);
     view.setUint16(12, 1);
     view.setUint16(14, 0);
@@ -515,8 +538,8 @@ export class MP4Muxer {
     const data = new Uint8Array(80);
     const view = new DataView(data.buffer);
     view.setUint32(8, 257);
-    const audioDuration = this.audioSampleSizes.length * this.audioSampleDuration;
-    view.setUint32(16, Math.round(audioDuration * this.videoTimescale / this.audioTimescale));
+    // Use playback duration to match video track (for proper sync with preroll)
+    view.setUint32(16, this.calculatePlaybackDuration());
     view.setUint16(32, 0x0100);
     view.setUint32(36, 0x00010000); view.setUint32(52, 0x00010000); view.setUint32(68, 0x40000000);
     return createFullBox('tkhd', 0, 3, data);

package/src/muxers/mpegts.js

@@ -354,3 +354,4 @@ export class TSMuxer {
 export default TSMuxer;
 
 
+

package/src/ts-to-mp4.js

@@ -38,7 +38,9 @@ function isKeyframe(accessUnit) {
 }
 
 /**
- * Clip access units to a time range, snapping to keyframes
+ * Clip access units to a time range, snapping to keyframes for decode
+ * but using edit list for precise playback timing
+ * 
  * @param {Array} videoAUs - Video access units
  * @param {Array} audioAUs - Audio access units  
  * @param {number} startTime - Start time in seconds
@@ -50,48 +52,73 @@ function clipAccessUnits(videoAUs, audioAUs, startTime, endTime) {
   const startPts = startTime * PTS_PER_SECOND;
   const endPts = endTime * PTS_PER_SECOND;
   
-  // Find keyframe at or before startTime
-  let startIdx = 0;
+  // Find keyframe at or before startTime (needed for decoding)
+  let keyframeIdx = 0;
   for (let i = 0; i < videoAUs.length; i++) {
     if (videoAUs[i].pts > startPts) break;
-    if (isKeyframe(videoAUs[i])) startIdx = i;
+    if (isKeyframe(videoAUs[i])) keyframeIdx = i;
   }
   
-  // Find first frame after endTime
+  // Find first frame at or after endTime
   let endIdx = videoAUs.length;
-  for (let i = startIdx; i < videoAUs.length; i++) {
+  for (let i = keyframeIdx; i < videoAUs.length; i++) {
     if (videoAUs[i].pts >= endPts) {
       endIdx = i;
       break;
     }
   }
   
-  // Clip video
-  const clippedVideo = videoAUs.slice(startIdx, endIdx);
+  // Clip video starting from keyframe (for proper decoding)
+  const clippedVideo = videoAUs.slice(keyframeIdx, endIdx);
+  
+  if (clippedVideo.length === 0) {
+    return {
+      video: [],
+      audio: [],
+      actualStartTime: startTime,
+      actualEndTime: endTime,
+      offset: 0,
+      preroll: 0
+    };
+  }
+  
+  // Get PTS of keyframe and requested start
+  const keyframePts = clippedVideo[0].pts;
+  const lastFramePts = clippedVideo[clippedVideo.length - 1].pts;
   
-  // Get actual PTS range from clipped video
-  const actualStartPts = clippedVideo.length > 0 ? clippedVideo[0].pts : 0;
-  const actualEndPts = clippedVideo.length > 0 ? clippedVideo[clippedVideo.length - 1].pts : 0;
+  // Pre-roll: time between keyframe and requested start
+  // This is the time the decoder needs to process but player shouldn't display
+  const prerollPts = Math.max(0, startPts - keyframePts);
   
-  // Clip audio to match video time range
-  const clippedAudio = audioAUs.filter(au => au.pts >= actualStartPts && au.pts <= actualEndPts);
+  // Clip audio to the REQUESTED time range (not from keyframe)
+  // Audio doesn't need keyframe pre-roll
+  const audioStartPts = startPts;
+  const audioEndPts = Math.min(endPts, lastFramePts + 90000); // Include audio slightly past last video
+  const clippedAudio = audioAUs.filter(au => au.pts >= audioStartPts && au.pts < audioEndPts);
   
-  // Normalize timestamps so clip starts at 0
-  const offset = actualStartPts;
+  // Normalize video timestamps so keyframe starts at 0
+  const offset = keyframePts;
   for (const au of clippedVideo) {
     au.pts -= offset;
     au.dts -= offset;
   }
+  
+  // Normalize audio timestamps so it starts at 0 (matching video playback start after preroll)
+  // Audio doesn't have preroll, so it should start at PTS 0 to sync with video after edit list
+  const audioOffset = audioStartPts;  // Use requested start, not keyframe
   for (const au of clippedAudio) {
-    au.pts -= offset;
+    au.pts -= audioOffset;
   }
   
   return {
     video: clippedVideo,
     audio: clippedAudio,
-    actualStartTime: actualStartPts / PTS_PER_SECOND,
-    actualEndTime: actualEndPts / PTS_PER_SECOND,
-    offset
+    actualStartTime: keyframePts / PTS_PER_SECOND,  // Where decode starts (keyframe)
+    actualEndTime: lastFramePts / PTS_PER_SECOND,
+    requestedStartTime: startTime,                   // Where playback should start
+    requestedEndTime: endTime,
+    offset,
+    preroll: prerollPts  // Edit list will use this to skip pre-roll frames during playback
   };
 }
 
@@ -225,6 +252,9 @@ export function convertTsToMp4(tsData, options = {}) {
   
   log(`Processing...`, { phase: 'convert', percent: 70 });
   
+  // Track preroll for edit list (used for precise clipping)
+  let clipPreroll = 0;
+  
   // Apply time range clipping if specified
   if (options.startTime !== undefined || options.endTime !== undefined) {
     const startTime = options.startTime || 0;
@@ -239,17 +269,23 @@ export function convertTsToMp4(tsData, options = {}) {
     
     parser.videoAccessUnits = clipResult.video;
     parser.audioAccessUnits = clipResult.audio;
+    clipPreroll = clipResult.preroll;
     
     // Update PTS arrays to match
     parser.videoPts = clipResult.video.map(au => au.pts);
     parser.videoDts = clipResult.video.map(au => au.dts);
     parser.audioPts = clipResult.audio.map(au => au.pts);
     
-    log(`Clipped: ${clipResult.actualStartTime.toFixed(2)}s - ${clipResult.actualEndTime.toFixed(2)}s (${clipResult.video.length} video, ${clipResult.audio.length} audio frames)`, { phase: 'convert', percent: 80 });
+    const prerollMs = (clipPreroll / 90).toFixed(0);
+    const endTimeStr = clipResult.requestedEndTime === Infinity ? 'end' : clipResult.requestedEndTime.toFixed(2) + 's';
+    const clipDuration = clipResult.requestedEndTime === Infinity 
+      ? (clipResult.actualEndTime - clipResult.requestedStartTime).toFixed(2)
+      : (clipResult.requestedEndTime - clipResult.requestedStartTime).toFixed(2);
+    log(`Clipped: ${clipResult.requestedStartTime.toFixed(2)}s - ${endTimeStr} (${clipDuration}s, ${prerollMs}ms preroll)`, { phase: 'convert', percent: 80 });
   }
   
   log(`Building MP4...`, { phase: 'convert', percent: 85 });
-  const muxer = new MP4Muxer(parser);
+  const muxer = new MP4Muxer(parser, { preroll: clipPreroll });
   const { width, height } = muxer.getVideoDimensions();
   log(`Dimensions: ${width}x${height}`);