@invintusmedia/tomp4 1.2.0 → 1.3.0

package/dist/tomp4.js

@@ -1,5 +1,5 @@
 /**
- * toMp4.js v1.2.0
+ * toMp4.js v1.3.0
  * Convert MPEG-TS and fMP4 to standard MP4
  * https://github.com/TVWIT/toMp4.js
  * MIT License
@@ -111,24 +111,23 @@
     // This is the time the decoder needs to process but player shouldn't display
     const prerollPts = Math.max(0, startPts - keyframePts);
   
-    // 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
+    // Clip audio from KEYFRAME time (same as video) so A/V stays in sync
+    // even on players that ignore edit lists. The edit list will skip the
+    // audio preroll on compliant players, just like it does for video.
+    const audioStartPts = keyframePts;
+    const audioEndPts = Math.min(endPts, lastFramePts + 90000);
     const clippedAudio = audioAUs.filter(au => au.pts >= audioStartPts && au.pts < audioEndPts);
   
-    // Normalize video timestamps so keyframe starts at 0
+    // Normalize both video and audio to the same base (keyframe PTS)
+    // so they share a common timeline regardless of edit list support
     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 -= audioOffset;
+      au.pts -= offset;
     }
   
     return {
@@ -323,144 +322,644 @@
   // ============================================
   /**
    * fMP4 to Standard MP4 Converter
-   * 
-   * Converts a fragmented MP4 file to a standard MP4 container
-   * by extracting samples from fragments and rebuilding the moov box.
-   * 
+   *
+   * Converts fragmented MP4 data to standard MP4 and supports
+   * sample-level clipping for fMP4 inputs.
+   *
    * @module fmp4/converter
    */
   
   import {
-      parseBoxes, findBox, parseChildBoxes, createBox,
-      parseTfhd, parseTrun
+      parseBoxes,
+      findBox,
+      parseChildBoxes,
+      createBox,
+      parseTfhd,
+      parseTfdt,
+      parseTrun,
+      getMovieTimescale,
   } from './utils.js';
   
-  // ============================================
-  // Moov Rebuilding Functions
-  // ============================================
+  function createFullBox(type, version, flags, ...payloads) {
+      const header = new Uint8Array(4);
+      header[0] = version;
+      header[1] = (flags >> 16) & 0xff;
+      header[2] = (flags >> 8) & 0xff;
+      header[3] = flags & 0xff;
+      return createBox(type, header, ...payloads);
+  }
+  
+  function sumSampleDurations(samples) {
+      let total = 0;
+      for (const sample of samples) total += sample.duration || 0;
+      return total;
+  }
+  
+  function toMovieTimescale(value, trackTimescale, movieTimescale) {
+      if (!trackTimescale || !movieTimescale) return value;
+      return Math.round((value * movieTimescale) / trackTimescale);
+  }
+  
+  function isSyncSample(sample) {
+      const flags = sample.flags;
+      if (flags === undefined || flags === null) return true;
+      return ((flags >> 16) & 0x1) === 0;
+  }
+  
+  function parseTrex(trexData) {
+      const view = new DataView(trexData.buffer, trexData.byteOffset, trexData.byteLength);
+      return {
+          trackId: view.getUint32(12),
+          defaultSampleDuration: view.getUint32(20),
+          defaultSampleSize: view.getUint32(24),
+          defaultSampleFlags: view.getUint32(28),
+      };
+  }
+  
+  function extractTrexDefaults(moovBox) {
+      const defaults = new Map();
+      const moovChildren = parseChildBoxes(moovBox);
+      const mvex = findBox(moovChildren, 'mvex');
+      if (!mvex) return defaults;
+  
+      const mvexChildren = parseChildBoxes(mvex);
+      for (const child of mvexChildren) {
+          if (child.type !== 'trex') continue;
+          const trex = parseTrex(child.data);
+          defaults.set(trex.trackId, trex);
+      }
+      return defaults;
+  }
+  
+  function extractTrackMetadata(moovBox) {
+      const trackMetadata = new Map();
+      const trackOrder = [];
+      const moovChildren = parseChildBoxes(moovBox);
+  
+      for (const child of moovChildren) {
+          if (child.type !== 'trak') continue;
+          const trakChildren = parseChildBoxes(child);
+  
+          let trackId = null;
+          let timescale = 0;
+          let handlerType = 'unknown';
+  
+          for (const trakChild of trakChildren) {
+              if (trakChild.type === 'tkhd') {
+                  const view = new DataView(trakChild.data.buffer, trakChild.data.byteOffset, trakChild.data.byteLength);
+                  trackId = trakChild.data[8] === 0 ? view.getUint32(20) : view.getUint32(28);
+              } else if (trakChild.type === 'mdia') {
+                  const mdiaChildren = parseChildBoxes(trakChild);
+                  for (const mdiaChild of mdiaChildren) {
+                      if (mdiaChild.type === 'mdhd') {
+                          const view = new DataView(mdiaChild.data.buffer, mdiaChild.data.byteOffset, mdiaChild.data.byteLength);
+                          timescale = mdiaChild.data[8] === 0 ? view.getUint32(20) : view.getUint32(28);
+                      } else if (mdiaChild.type === 'hdlr' && mdiaChild.data.byteLength >= 20) {
+                          handlerType = String.fromCharCode(
+                              mdiaChild.data[16],
+                              mdiaChild.data[17],
+                              mdiaChild.data[18],
+                              mdiaChild.data[19],
+                          );
+                      }
+                  }
+              }
+          }
+  
+          if (trackId !== null) {
+              trackMetadata.set(trackId, {
+                  trackId,
+                  timescale: timescale || 90000,
+                  handlerType,
+              });
+              trackOrder.push(trackId);
+          }
+      }
+  
+      return { trackMetadata, trackOrder };
+  }
+  
+  function cloneSample(sample) {
+      return {
+          duration: sample.duration || 0,
+          size: sample.size || 0,
+          flags: sample.flags,
+          compositionTimeOffset: sample.compositionTimeOffset || 0,
+          dts: sample.dts || 0,
+          pts: sample.pts || 0,
+          byteOffset: sample.byteOffset || 0,
+      };
+  }
+  
+  function normalizeSamples(samples, baseDts) {
+      return samples.map((sample) => {
+          const next = cloneSample(sample);
+          next.dts -= baseDts;
+          next.pts -= baseDts;
+          return next;
+      });
+  }
+  
+  function clipVideoSamples(samples, startTick, endTick) {
+      if (!samples.length) {
+          return { samples: [], mediaTime: 0, playbackDuration: 0 };
+      }
+  
+      let requestedStartIndex = samples.length;
+      for (let i = 0; i < samples.length; i++) {
+          const sampleEnd = (samples[i].pts || 0) + (samples[i].duration || 0);
+          if (sampleEnd > startTick) {
+              requestedStartIndex = i;
+              break;
+          }
+      }
+      if (requestedStartIndex >= samples.length) {
+          return { samples: [], mediaTime: 0, playbackDuration: 0 };
+      }
+  
+      let decodeStartIndex = requestedStartIndex;
+      for (let i = requestedStartIndex; i >= 0; i--) {
+          if (isSyncSample(samples[i])) {
+              decodeStartIndex = i;
+              break;
+          }
+      }
+  
+      let endIndex = samples.length;
+      if (Number.isFinite(endTick)) {
+          for (let i = decodeStartIndex; i < samples.length; i++) {
+              if ((samples[i].pts || 0) >= endTick) {
+                  endIndex = i;
+                  break;
+              }
+          }
+      }
+      if (endIndex <= decodeStartIndex) {
+          return { samples: [], mediaTime: 0, playbackDuration: 0 };
+      }
+  
+      const selected = samples.slice(decodeStartIndex, endIndex);
+      const decodeStartDts = selected[0].dts || 0;
+      const mediaTime = Math.max(0, startTick - decodeStartDts);
+      const normalized = normalizeSamples(selected, decodeStartDts);
+      const decodeDuration = sumSampleDurations(normalized);
+      const maxPlayable = Math.max(0, decodeDuration - mediaTime);
+      const requested = Number.isFinite(endTick) ? Math.max(0, endTick - startTick) : maxPlayable;
+      const playbackDuration = Math.min(requested, maxPlayable);
+  
+      return {
+          samples: normalized,
+          mediaTime,
+          playbackDuration,
+      };
+  }
+  
+  function clipNonVideoSamples(samples, startTick, endTick) {
+      if (!samples.length) {
+          return { samples: [], mediaTime: 0, playbackDuration: 0 };
+      }
+  
+      let startIndex = 0;
+      while (startIndex < samples.length && (samples[startIndex].pts || 0) < startTick) {
+          startIndex++;
+      }
+      if (startIndex >= samples.length) {
+          return { samples: [], mediaTime: 0, playbackDuration: 0 };
+      }
+  
+      let endIndex = samples.length;
+      if (Number.isFinite(endTick)) {
+          for (let i = startIndex; i < samples.length; i++) {
+              if ((samples[i].pts || 0) >= endTick) {
+                  endIndex = i;
+                  break;
+              }
+          }
+      }
+      if (endIndex <= startIndex) {
+          return { samples: [], mediaTime: 0, playbackDuration: 0 };
+      }
+  
+      const selected = samples.slice(startIndex, endIndex);
+      const decodeStartDts = selected[0].dts || 0;
+      const normalized = normalizeSamples(selected, decodeStartDts);
+      const decodeDuration = sumSampleDurations(normalized);
+      const requested = Number.isFinite(endTick) ? Math.max(0, endTick - startTick) : decodeDuration;
+      const playbackDuration = Math.min(requested, decodeDuration);
+  
+      return {
+          samples: normalized,
+          mediaTime: 0,
+          playbackDuration,
+      };
+  }
+  
+  function applyClipToTracks(tracks, options = {}) {
+      const hasStart = Number.isFinite(options.startTime);
+      const hasEnd = Number.isFinite(options.endTime);
+      if (!hasStart && !hasEnd) {
+          for (const [, track] of tracks) {
+              if (!track.samples.length) continue;
+              const baseDts = track.samples[0].dts || 0;
+              track.samples = normalizeSamples(track.samples, baseDts);
+              track.mediaTime = 0;
+              track.playbackDuration = sumSampleDurations(track.samples);
+          }
+          return tracks;
+      }
+  
+      const startSec = hasStart ? Math.max(0, options.startTime) : 0;
+      const endSec = hasEnd ? Math.max(startSec, options.endTime) : Infinity;
+  
+      let videoTrackId = null;
+      for (const [trackId, track] of tracks) {
+          if (track.handlerType === 'vide' && track.samples.length > 0) {
+              videoTrackId = trackId;
+              break;
+          }
+      }
+  
+      // First pass: clip video to determine preroll duration
+      const clipped = new Map();
+      let videoPrerollSec = 0;
+  
+      if (videoTrackId !== null) {
+          const vTrack = tracks.get(videoTrackId);
+          if (vTrack && vTrack.samples.length) {
+              const startTick = Math.round(startSec * vTrack.timescale);
+              const endTick = Number.isFinite(endSec) ? Math.round(endSec * vTrack.timescale) : Infinity;
+              const clip = clipVideoSamples(vTrack.samples, startTick, endTick);
+  
+              if (clip.samples.length) {
+                  videoPrerollSec = clip.mediaTime / vTrack.timescale;
+                  clipped.set(videoTrackId, {
+                      ...vTrack,
+                      samples: clip.samples,
+                      mediaTime: clip.mediaTime,
+                      playbackDuration: clip.playbackDuration,
+                      chunkOffsets: [],
+                  });
+              }
+          }
+      }
+  
+      // Second pass: clip non-video tracks, including audio from the video's
+      // decode start (keyframe) so A/V stays in sync without edit lists
+      for (const [trackId, track] of tracks) {
+          if (!track.samples.length || trackId === videoTrackId) continue;
+  
+          const adjustedStartSec = Math.max(0, startSec - videoPrerollSec);
+          const startTick = Math.round(adjustedStartSec * track.timescale);
+          const endTick = Number.isFinite(endSec) ? Math.round(endSec * track.timescale) : Infinity;
+          const clip = clipNonVideoSamples(track.samples, startTick, endTick);
+  
+          if (!clip.samples.length) continue;
+  
+          // Audio preroll matches video preroll so both tracks share the same timeline
+          const audioPreroll = Math.round(videoPrerollSec * track.timescale);
+          const totalDur = sumSampleDurations(clip.samples);
+          const playbackDuration = Math.max(0, totalDur - audioPreroll);
+  
+          clipped.set(trackId, {
+              ...track,
+              samples: clip.samples,
+              mediaTime: audioPreroll,
+              playbackDuration,
+              chunkOffsets: [],
+          });
+      }
+  
+      return clipped;
+  }
+  
+  function collectTrackSamples(boxes, trackMetadata, trexDefaults) {
+      const tracks = new Map();
+      const mdatChunks = [];
+      let combinedMdatOffset = 0;
+  
+      for (let i = 0; i < boxes.length; i++) {
+          const box = boxes[i];
+          if (box.type === 'moof') {
+              const moofChildren = parseChildBoxes(box);
+              const moofStart = box.offset;
+  
+              let nextMdatOffset = -1;
+              for (let j = i + 1; j < boxes.length; j++) {
+                  if (boxes[j].type === 'mdat') {
+                      nextMdatOffset = boxes[j].offset;
+                      break;
+                  }
+                  if (boxes[j].type === 'moof') break;
+              }
+              if (nextMdatOffset < 0) continue;
+  
+              const mdatContentStartAbs = nextMdatOffset + 8;
+  
+              for (const child of moofChildren) {
+                  if (child.type !== 'traf') continue;
+  
+                  const trafChildren = parseChildBoxes(child);
+                  const tfhdBox = findBox(trafChildren, 'tfhd');
+                  if (!tfhdBox) continue;
+  
+                  const tfhdView = new DataView(tfhdBox.data.buffer, tfhdBox.data.byteOffset, tfhdBox.data.byteLength);
+                  const trackId = tfhdView.getUint32(12);
+                  const tfhd = parseTfhd(tfhdBox.data, trexDefaults.get(trackId) || {});
+                  const tfdtBox = findBox(trafChildren, 'tfdt');
+                  let decodeTime = tfdtBox ? parseTfdt(tfdtBox.data) : 0;
+                  let runDataCursorAbs = null;
+  
+                  if (!tracks.has(trackId)) {
+                      const meta = trackMetadata.get(trackId) || {};
+                      tracks.set(trackId, {
+                          trackId,
+                          timescale: meta.timescale || 90000,
+                          handlerType: meta.handlerType || 'unknown',
+                          samples: [],
+                          chunkOffsets: [],
+                          mediaTime: 0,
+                          playbackDuration: 0,
+                      });
+                  }
+                  const track = tracks.get(trackId);
+  
+                  for (const trafChild of trafChildren) {
+                      if (trafChild.type !== 'trun') continue;
+                      const { samples, dataOffset, flags } = parseTrun(trafChild.data, tfhd);
+                      const runSize = samples.reduce((sum, sample) => sum + (sample.size || 0), 0);
+  
+                      let dataStartAbs;
+                      if (flags & 0x1) {
+                          const baseAbs = (tfhd.flags & 0x1) ? tfhd.baseDataOffset : moofStart;
+                          dataStartAbs = baseAbs + dataOffset;
+                      } else if (runDataCursorAbs !== null) {
+                          dataStartAbs = runDataCursorAbs;
+                      } else {
+                          dataStartAbs = mdatContentStartAbs;
+                      }
+  
+                      let sampleByteOffset = combinedMdatOffset + Math.max(0, dataStartAbs - mdatContentStartAbs);
+                      for (const sample of samples) {
+                          const dts = decodeTime;
+                          const pts = dts + (sample.compositionTimeOffset || 0);
+                          track.samples.push({
+                              ...sample,
+                              dts,
+                              pts,
+                              byteOffset: sampleByteOffset,
+                          });
+                          decodeTime += sample.duration || 0;
+                          sampleByteOffset += sample.size || 0;
+                      }
+  
+                      runDataCursorAbs = dataStartAbs + runSize;
+                  }
+              }
+          } else if (box.type === 'mdat') {
+              const data = box.data.subarray(8);
+              mdatChunks.push({ data, offset: combinedMdatOffset });
+              combinedMdatOffset += data.byteLength;
+          }
+      }
+  
+      const combinedMdat = new Uint8Array(combinedMdatOffset);
+      for (const chunk of mdatChunks) {
+          combinedMdat.set(chunk.data, chunk.offset);
+      }
+  
+      return { tracks, combinedMdat };
+  }
+  
+  function rebuildMdatContent(tracks, trackOrder, sourceMdat) {
+      const orderedTrackIds = trackOrder.filter((trackId) => tracks.has(trackId));
+      for (const trackId of tracks.keys()) {
+          if (!orderedTrackIds.includes(trackId)) orderedTrackIds.push(trackId);
+      }
+  
+      let totalSize = 0;
+      for (const trackId of orderedTrackIds) {
+          const track = tracks.get(trackId);
+          for (const sample of track.samples) totalSize += sample.size || 0;
+      }
+  
+      const mdatData = new Uint8Array(totalSize);
+      let writeOffset = 0;
+  
+      for (const trackId of orderedTrackIds) {
+          const track = tracks.get(trackId);
+          if (!track || !track.samples.length) {
+              if (track) track.chunkOffsets = [];
+              continue;
+          }
+  
+          track.chunkOffsets = [{ offset: writeOffset, sampleCount: track.samples.length }];
+          for (const sample of track.samples) {
+              const start = sample.byteOffset || 0;
+              const end = start + (sample.size || 0);
+              if (start < 0 || end > sourceMdat.byteLength) {
+                  throw new Error(`Invalid sample byte range for track ${trackId}: ${start}-${end}`);
+              }
+              mdatData.set(sourceMdat.subarray(start, end), writeOffset);
+              sample.byteOffset = writeOffset;
+              writeOffset += sample.size || 0;
+          }
+      }
+  
+      return mdatData;
+  }
+  
+  function calculateMovieDuration(tracks, movieTimescale) {
+      let maxDuration = 0;
+      for (const [, track] of tracks) {
+          const fallback = Math.max(0, sumSampleDurations(track.samples) - (track.mediaTime || 0));
+          const playbackDuration = track.playbackDuration > 0 ? track.playbackDuration : fallback;
+          track.playbackDuration = playbackDuration;
+          track.movieDuration = toMovieTimescale(playbackDuration, track.timescale, movieTimescale);
+          maxDuration = Math.max(maxDuration, track.movieDuration);
+      }
+      return maxDuration;
+  }
   
   function rebuildMvhd(mvhdBox, duration) {
       const data = new Uint8Array(mvhdBox.data);
       const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
       const version = data[8];
       const durationOffset = version === 0 ? 24 : 32;
-      if (version === 0) view.setUint32(durationOffset, duration);
-      else { view.setUint32(durationOffset, 0); view.setUint32(durationOffset + 4, duration); }
+      if (version === 0) {
+          view.setUint32(durationOffset, duration);
+      } else {
+          view.setUint32(durationOffset, 0);
+          view.setUint32(durationOffset + 4, duration);
+      }
       return data;
   }
   
-  function rebuildTkhd(tkhdBox, trackInfo, maxDuration) {
+  function rebuildTkhd(tkhdBox, trackInfo, maxMovieDuration) {
       const data = new Uint8Array(tkhdBox.data);
       const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
       const version = data[8];
-      let trackDuration = maxDuration;
-      if (trackInfo) { trackDuration = 0; for (const s of trackInfo.samples) trackDuration += s.duration || 0; }
-      if (version === 0) view.setUint32(28, trackDuration);
-      else { view.setUint32(36, 0); view.setUint32(40, trackDuration); }
+      const duration = trackInfo?.movieDuration ?? maxMovieDuration;
+      if (version === 0) view.setUint32(28, duration);
+      else {
+          view.setUint32(36, 0);
+          view.setUint32(40, duration);
+      }
       return data;
   }
   
-  function rebuildMdhd(mdhdBox, trackInfo, maxDuration) {
+  function rebuildMdhd(mdhdBox, trackInfo) {
       const data = new Uint8Array(mdhdBox.data);
       const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
       const version = data[8];
-      let trackDuration = 0;
-      if (trackInfo) for (const s of trackInfo.samples) trackDuration += s.duration || 0;
+      const duration = sumSampleDurations(trackInfo?.samples || []);
       const durationOffset = version === 0 ? 24 : 32;
-      if (version === 0) view.setUint32(durationOffset, trackDuration);
-      else { view.setUint32(durationOffset, 0); view.setUint32(durationOffset + 4, trackDuration); }
+      if (version === 0) {
+          view.setUint32(durationOffset, duration);
+      } else {
+          view.setUint32(durationOffset, 0);
+          view.setUint32(durationOffset + 4, duration);
+      }
       return data;
   }
   
   function rebuildStbl(stblBox, trackInfo) {
       const stblChildren = parseChildBoxes(stblBox);
       const newParts = [];
-      for (const child of stblChildren) if (child.type === 'stsd') { newParts.push(child.data); break; }
+      for (const child of stblChildren) {
+          if (child.type === 'stsd') {
+              newParts.push(child.data);
+              break;
+          }
+      }
+  
       const samples = trackInfo?.samples || [];
       const chunkOffsets = trackInfo?.chunkOffsets || [];
   
       // stts
       const sttsEntries = [];
-      let curDur = null, count = 0;
-      for (const s of samples) {
-          const d = s.duration || 0;
-          if (d === curDur) count++;
-          else { if (curDur !== null) sttsEntries.push({ count, duration: curDur }); curDur = d; count = 1; }
+      let currentDuration = null;
+      let currentCount = 0;
+      for (const sample of samples) {
+          const duration = sample.duration || 0;
+          if (duration === currentDuration) currentCount++;
+          else {
+              if (currentDuration !== null) {
+                  sttsEntries.push({ count: currentCount, duration: currentDuration });
+              }
+              currentDuration = duration;
+              currentCount = 1;
+          }
+      }
+      if (currentDuration !== null) {
+          sttsEntries.push({ count: currentCount, duration: currentDuration });
       }
-      if (curDur !== null) sttsEntries.push({ count, duration: curDur });
       const sttsData = new Uint8Array(8 + sttsEntries.length * 8);
       const sttsView = new DataView(sttsData.buffer);
       sttsView.setUint32(4, sttsEntries.length);
-      let off = 8;
-      for (const e of sttsEntries) { sttsView.setUint32(off, e.count); sttsView.setUint32(off + 4, e.duration); off += 8; }
+      let offset = 8;
+      for (const entry of sttsEntries) {
+          sttsView.setUint32(offset, entry.count);
+          sttsView.setUint32(offset + 4, entry.duration);
+          offset += 8;
+      }
       newParts.push(createBox('stts', sttsData));
   
       // stsc
       const stscEntries = [];
       if (chunkOffsets.length > 0) {
-          let currentSampleCount = chunkOffsets[0].sampleCount, firstChunk = 1;
+          let currentSampleCount = chunkOffsets[0].sampleCount;
+          let firstChunk = 1;
           for (let i = 1; i <= chunkOffsets.length; i++) {
               const sampleCount = i < chunkOffsets.length ? chunkOffsets[i].sampleCount : -1;
               if (sampleCount !== currentSampleCount) {
-                  stscEntries.push({ firstChunk, samplesPerChunk: currentSampleCount, sampleDescriptionIndex: 1 });
-                  firstChunk = i + 1; currentSampleCount = sampleCount;
+                  stscEntries.push({
+                      firstChunk,
+                      samplesPerChunk: currentSampleCount,
+                      sampleDescriptionIndex: 1,
+                  });
+                  firstChunk = i + 1;
+                  currentSampleCount = sampleCount;
               }
           }
-      } else stscEntries.push({ firstChunk: 1, samplesPerChunk: samples.length, sampleDescriptionIndex: 1 });
+      }
       const stscData = new Uint8Array(8 + stscEntries.length * 12);
       const stscView = new DataView(stscData.buffer);
       stscView.setUint32(4, stscEntries.length);
-      off = 8;
-      for (const e of stscEntries) { stscView.setUint32(off, e.firstChunk); stscView.setUint32(off + 4, e.samplesPerChunk); stscView.setUint32(off + 8, e.sampleDescriptionIndex); off += 12; }
+      offset = 8;
+      for (const entry of stscEntries) {
+          stscView.setUint32(offset, entry.firstChunk);
+          stscView.setUint32(offset + 4, entry.samplesPerChunk);
+          stscView.setUint32(offset + 8, entry.sampleDescriptionIndex);
+          offset += 12;
+      }
       newParts.push(createBox('stsc', stscData));
   
       // stsz
       const stszData = new Uint8Array(12 + samples.length * 4);
       const stszView = new DataView(stszData.buffer);
       stszView.setUint32(8, samples.length);
-      off = 12;
-      for (const s of samples) { stszView.setUint32(off, s.size || 0); off += 4; }
+      offset = 12;
+      for (const sample of samples) {
+          stszView.setUint32(offset, sample.size || 0);
+          offset += 4;
+      }
       newParts.push(createBox('stsz', stszData));
   
       // stco
-      const numChunks = chunkOffsets.length || 1;
-      const stcoData = new Uint8Array(8 + numChunks * 4);
+      const stcoData = new Uint8Array(8 + chunkOffsets.length * 4);
       const stcoView = new DataView(stcoData.buffer);
-      stcoView.setUint32(4, numChunks);
-      for (let i = 0; i < numChunks; i++) stcoView.setUint32(8 + i * 4, chunkOffsets[i]?.offset || 0);
+      stcoView.setUint32(4, chunkOffsets.length);
+      for (let i = 0; i < chunkOffsets.length; i++) {
+          stcoView.setUint32(8 + i * 4, chunkOffsets[i].offset || 0);
+      }
       newParts.push(createBox('stco', stcoData));
   
       // ctts
-      const hasCtts = samples.some(s => s.compositionTimeOffset);
+      const hasCtts = samples.some((sample) => sample.compositionTimeOffset);
       if (hasCtts) {
           const cttsEntries = [];
-          let curOff = null; count = 0;
-          for (const s of samples) {
-              const o = s.compositionTimeOffset || 0;
-              if (o === curOff) count++;
-              else { if (curOff !== null) cttsEntries.push({ count, offset: curOff }); curOff = o; count = 1; }
+          let currentOffset = null;
+          currentCount = 0;
+          for (const sample of samples) {
+              const compositionOffset = sample.compositionTimeOffset || 0;
+              if (compositionOffset === currentOffset) currentCount++;
+              else {
+                  if (currentOffset !== null) {
+                      cttsEntries.push({ count: currentCount, offset: currentOffset });
+                  }
+                  currentOffset = compositionOffset;
+                  currentCount = 1;
+              }
+          }
+          if (currentOffset !== null) {
+              cttsEntries.push({ count: currentCount, offset: currentOffset });
           }
-          if (curOff !== null) cttsEntries.push({ count, offset: curOff });
           const cttsData = new Uint8Array(8 + cttsEntries.length * 8);
           const cttsView = new DataView(cttsData.buffer);
           cttsView.setUint32(4, cttsEntries.length);
-          off = 8;
-          for (const e of cttsEntries) { cttsView.setUint32(off, e.count); cttsView.setInt32(off + 4, e.offset); off += 8; }
+          offset = 8;
+          for (const entry of cttsEntries) {
+              cttsView.setUint32(offset, entry.count);
+              cttsView.setInt32(offset + 4, entry.offset);
+              offset += 8;
+          }
           newParts.push(createBox('ctts', cttsData));
       }
   
-      // stss
+      // stss (video sync samples)
       const syncSamples = [];
       for (let i = 0; i < samples.length; i++) {
-          const flags = samples[i].flags;
-          if (flags !== undefined) { if (!((flags >> 16) & 0x1)) syncSamples.push(i + 1); }
+          if (isSyncSample(samples[i])) syncSamples.push(i + 1);
       }
       if (syncSamples.length > 0 && syncSamples.length < samples.length) {
           const stssData = new Uint8Array(8 + syncSamples.length * 4);
           const stssView = new DataView(stssData.buffer);
           stssView.setUint32(4, syncSamples.length);
-          off = 8;
-          for (const n of syncSamples) { stssView.setUint32(off, n); off += 4; }
+          offset = 8;
+          for (const sampleNumber of syncSamples) {
+              stssView.setUint32(offset, sampleNumber);
+              offset += 4;
+          }
           newParts.push(createBox('stss', stssData));
       }
   
@@ -477,169 +976,151 @@
       return createBox('minf', ...newParts);
   }
   
-  function rebuildMdia(mdiaBox, trackInfo, maxDuration) {
+  function rebuildMdia(mdiaBox, trackInfo) {
       const mdiaChildren = parseChildBoxes(mdiaBox);
       const newParts = [];
       for (const child of mdiaChildren) {
           if (child.type === 'minf') newParts.push(rebuildMinf(child, trackInfo));
-          else if (child.type === 'mdhd') newParts.push(rebuildMdhd(child, trackInfo, maxDuration));
+          else if (child.type === 'mdhd') newParts.push(rebuildMdhd(child, trackInfo));
           else newParts.push(child.data);
       }
       return createBox('mdia', ...newParts);
   }
   
-  function rebuildTrak(trakBox, trackIdMap, maxDuration) {
+  function rebuildTrak(trakBox, trackInfoMap, maxMovieDuration) {
       const trakChildren = parseChildBoxes(trakBox);
-      let trackId = 1;
+      let trackId = null;
       for (const child of trakChildren) {
-          if (child.type === 'tkhd') {
-              const view = new DataView(child.data.buffer, child.data.byteOffset, child.data.byteLength);
-              trackId = child.data[8] === 0 ? view.getUint32(20) : view.getUint32(28);
-          }
+          if (child.type !== 'tkhd') continue;
+          const view = new DataView(child.data.buffer, child.data.byteOffset, child.data.byteLength);
+          trackId = child.data[8] === 0 ? view.getUint32(20) : view.getUint32(28);
       }
-      const trackInfo = trackIdMap.get(trackId);
+      if (trackId === null) return null;
+  
+      const trackInfo = trackInfoMap.get(trackId);
+      if (!trackInfo || !trackInfo.samples.length) return null;
+  
       const newParts = [];
-      let hasEdts = false;
       for (const child of trakChildren) {
-          if (child.type === 'edts') { hasEdts = true; newParts.push(child.data); }
-          else if (child.type === 'mdia') newParts.push(rebuildMdia(child, trackInfo, maxDuration));
-          else if (child.type === 'tkhd') newParts.push(rebuildTkhd(child, trackInfo, maxDuration));
+          if (child.type === 'edts') continue;
+          if (child.type === 'mdia') newParts.push(rebuildMdia(child, trackInfo));
+          else if (child.type === 'tkhd') newParts.push(rebuildTkhd(child, trackInfo, maxMovieDuration));
           else newParts.push(child.data);
       }
-      if (!hasEdts && trackInfo) {
-          let trackDuration = 0;
-          for (const s of trackInfo.samples) trackDuration += s.duration || 0;
-          const elstData = new Uint8Array(20);
-          const elstView = new DataView(elstData.buffer);
-          elstView.setUint32(4, 1); elstView.setUint32(8, maxDuration); elstView.setInt32(12, 0); elstView.setInt16(16, 1);
-          const elst = createBox('elst', elstData);
-          const edts = createBox('edts', elst);
-          const tkhdIndex = newParts.findIndex(p => p.length >= 8 && String.fromCharCode(p[4], p[5], p[6], p[7]) === 'tkhd');
-          if (tkhdIndex >= 0) newParts.splice(tkhdIndex + 1, 0, edts);
-      }
+  
+      const elstPayload = new Uint8Array(16);
+      const elstView = new DataView(elstPayload.buffer);
+      elstView.setUint32(0, 1);
+      elstView.setUint32(4, trackInfo.movieDuration ?? maxMovieDuration);
+      elstView.setInt32(8, Math.max(0, Math.round(trackInfo.mediaTime || 0)));
+      elstView.setUint16(12, 1);
+      elstView.setUint16(14, 0);
+      const elst = createFullBox('elst', 0, 0, elstPayload);
+      const edts = createBox('edts', elst);
+  
+      const tkhdIndex = newParts.findIndex((part) =>
+          part.length >= 8 && String.fromCharCode(part[4], part[5], part[6], part[7]) === 'tkhd',
+      );
+      if (tkhdIndex >= 0) newParts.splice(tkhdIndex + 1, 0, edts);
+      else newParts.unshift(edts);
+  
       return createBox('trak', ...newParts);
   }
   
   function updateStcoOffsets(output, ftypSize, moovSize) {
       const mdatContentOffset = ftypSize + moovSize + 8;
       const view = new DataView(output.buffer, output.byteOffset, output.byteLength);
+  
       function scan(start, end) {
-          let pos = start;
-          while (pos + 8 <= end) {
-              const size = view.getUint32(pos);
+          let position = start;
+          while (position + 8 <= end) {
+              const size = view.getUint32(position);
               if (size < 8) break;
-              const type = String.fromCharCode(output[pos + 4], output[pos + 5], output[pos + 6], output[pos + 7]);
+              const type = String.fromCharCode(
+                  output[position + 4],
+                  output[position + 5],
+                  output[position + 6],
+                  output[position + 7],
+              );
+  
               if (type === 'stco') {
-                  const entryCount = view.getUint32(pos + 12);
+                  const entryCount = view.getUint32(position + 12);
                   for (let i = 0; i < entryCount; i++) {
-                      const entryPos = pos + 16 + i * 4;
-                      view.setUint32(entryPos, mdatContentOffset + view.getUint32(entryPos));
+                      const entryPos = position + 16 + i * 4;
+                      const relativeOffset = view.getUint32(entryPos);
+                      view.setUint32(entryPos, mdatContentOffset + relativeOffset);
                   }
-              } else if (['moov', 'trak', 'mdia', 'minf', 'stbl'].includes(type)) scan(pos + 8, pos + size);
-              pos += size;
+              } else if (['moov', 'trak', 'mdia', 'minf', 'stbl'].includes(type)) {
+                  scan(position + 8, position + size);
+              }
+  
+              position += size;
           }
       }
+  
       scan(0, output.byteLength);
   }
   
-  // ============================================
-  // Main Converter Function
-  // ============================================
-  
   /**
    * Convert fragmented MP4 to standard MP4
    * @param {Uint8Array} fmp4Data - fMP4 data
+   * @param {object} [options] - Optional clip settings
+   * @param {number} [options.startTime] - Clip start time (seconds)
+   * @param {number} [options.endTime] - Clip end time (seconds)
    * @returns {Uint8Array} Standard MP4 data
    */
-  function convertFmp4ToMp4(fmp4Data) {
+  // Shared rebuild functions — also used by mp4-clip.js for standard MP4 clipping
+  {
+      applyClipToTracks,
+      rebuildMdatContent,
+      calculateMovieDuration,
+      rebuildTrak,
+      rebuildMvhd,
+      updateStcoOffsets,
+  };
+  
+  function convertFmp4ToMp4(fmp4Data, options = {}) {
       const boxes = parseBoxes(fmp4Data);
       const ftyp = findBox(boxes, 'ftyp');
       const moov = findBox(boxes, 'moov');
       if (!ftyp || !moov) throw new Error('Invalid fMP4: missing ftyp or moov');
   
-      const moovChildren = parseChildBoxes(moov);
-      const originalTrackIds = [];
-      for (const child of moovChildren) {
-          if (child.type === 'trak') {
-              const trakChildren = parseChildBoxes(child);
-              for (const tc of trakChildren) {
-                  if (tc.type === 'tkhd') {
-                      const view = new DataView(tc.data.buffer, tc.data.byteOffset, tc.data.byteLength);
-                      originalTrackIds.push(tc.data[8] === 0 ? view.getUint32(20) : view.getUint32(28));
-                  }
-              }
-          }
-      }
+      const movieTimescale = getMovieTimescale(moov);
+      const { trackMetadata, trackOrder } = extractTrackMetadata(moov);
+      const trexDefaults = extractTrexDefaults(moov);
+      const { tracks, combinedMdat } = collectTrackSamples(boxes, trackMetadata, trexDefaults);
   
-      const tracks = new Map();
-      const mdatChunks = [];
-      let combinedMdatOffset = 0;
+      if (tracks.size === 0) throw new Error('Invalid fMP4: no track fragments found');
   
-      for (let i = 0; i < boxes.length; i++) {
-          const box = boxes[i];
-          if (box.type === 'moof') {
-              const moofChildren = parseChildBoxes(box);
-              const moofStart = box.offset;
-              let nextMdatOffset = 0;
-              for (let j = i + 1; j < boxes.length; j++) {
-                  if (boxes[j].type === 'mdat') { nextMdatOffset = boxes[j].offset; break; }
-                  if (boxes[j].type === 'moof') break;
-              }
-              for (const child of moofChildren) {
-                  if (child.type === 'traf') {
-                      const trafChildren = parseChildBoxes(child);
-                      const tfhd = findBox(trafChildren, 'tfhd');
-                      const trun = findBox(trafChildren, 'trun');
-                      if (tfhd && trun) {
-                          const tfhdInfo = parseTfhd(tfhd.data);
-                          const { samples, dataOffset } = parseTrun(trun.data, tfhdInfo);
-                          if (!tracks.has(tfhdInfo.trackId)) tracks.set(tfhdInfo.trackId, { samples: [], chunkOffsets: [] });
-                          const track = tracks.get(tfhdInfo.trackId);
-                          const chunkOffset = combinedMdatOffset + (moofStart + dataOffset) - (nextMdatOffset + 8);
-                          track.chunkOffsets.push({ offset: chunkOffset, sampleCount: samples.length });
-                          track.samples.push(...samples);
-                      }
-                  }
-              }
-          } else if (box.type === 'mdat') {
-              mdatChunks.push({ data: box.data.subarray(8), offset: combinedMdatOffset });
-              combinedMdatOffset += box.data.subarray(8).byteLength;
-          }
-      }
-  
-      const totalMdatSize = mdatChunks.reduce((sum, c) => sum + c.data.byteLength, 0);
-      const combinedMdat = new Uint8Array(totalMdatSize);
-      for (const chunk of mdatChunks) combinedMdat.set(chunk.data, chunk.offset);
-  
-      const trackIdMap = new Map();
-      const fmp4TrackIds = Array.from(tracks.keys()).sort((a, b) => a - b);
-      for (let i = 0; i < fmp4TrackIds.length && i < originalTrackIds.length; i++) {
-          trackIdMap.set(originalTrackIds[i], tracks.get(fmp4TrackIds[i]));
+      const clippedTracks = applyClipToTracks(tracks, options);
+      if (clippedTracks.size === 0) {
+          throw new Error('Clip range produced no samples');
       }
   
-      let maxDuration = 0;
-      for (const [, track] of tracks) {
-          let dur = 0;
-          for (const s of track.samples) dur += s.duration || 0;
-          maxDuration = Math.max(maxDuration, dur);
-      }
+      const rebuiltMdat = rebuildMdatContent(clippedTracks, trackOrder, combinedMdat);
+      const maxMovieDuration = calculateMovieDuration(clippedTracks, movieTimescale);
   
+      const moovChildren = parseChildBoxes(moov);
       const newMoovParts = [];
       for (const child of moovChildren) {
           if (child.type === 'mvex') continue;
-          if (child.type === 'trak') newMoovParts.push(rebuildTrak(child, trackIdMap, maxDuration));
-          else if (child.type === 'mvhd') newMoovParts.push(rebuildMvhd(child, maxDuration));
-          else newMoovParts.push(child.data);
+          if (child.type === 'trak') {
+              const trak = rebuildTrak(child, clippedTracks, maxMovieDuration);
+              if (trak) newMoovParts.push(trak);
+          } else if (child.type === 'mvhd') {
+              newMoovParts.push(rebuildMvhd(child, maxMovieDuration));
+          } else {
+              newMoovParts.push(child.data);
+          }
       }
   
       const newMoov = createBox('moov', ...newMoovParts);
-      const newMdat = createBox('mdat', combinedMdat);
+      const newMdat = createBox('mdat', rebuiltMdat);
       const output = new Uint8Array(ftyp.size + newMoov.byteLength + newMdat.byteLength);
       output.set(ftyp.data, 0);
       output.set(newMoov, ftyp.size);
       output.set(newMdat, ftyp.size + newMoov.byteLength);
       updateStcoOffsets(output, ftyp.size, newMoov.byteLength);
-  
       return output;
   }
   
@@ -705,7 +1186,7 @@
   toMp4.isMpegTs = isMpegTs;
   toMp4.isFmp4 = isFmp4;
   toMp4.isStandardMp4 = isStandardMp4;
-  toMp4.version = '1.2.0';
+  toMp4.version = '1.3.0';
 
   return toMp4;
 });