@editframe/assets 0.18.3-beta.0 → 0.18.8-beta.0

package/src/tasks/generateTrackFragmentIndex.ts

@@ -1,9 +1,9 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { MP4File } from "../MP4File.js";
 import debug from "debug";
-import { mp4FileWritable } from "../mp4FileWritable.js";
 import { basename } from "node:path";
-import { Probe, type TrackFragmentIndex } from "../Probe.js";
+import { Probe } from "../Probe.js";
+import { generateFragmentIndex } from "../generateFragmentIndex.js";
+import type { TrackFragmentIndex } from "../Probe.js";
 
 export const generateTrackFragmentIndexFromPath = async (
   absolutePath: string,
@@ -29,109 +29,38 @@ export const generateTrackFragmentIndexFromPath = async (
     }
   }
 
-  const readStream = probe.createConformingReadstream();
-
-  const mp4File = new MP4File();
-
-  log(`Generating track fragment index for ${absolutePath}`);
-  readStream.pipe(mp4FileWritable(mp4File));
-  await new Promise((resolve, reject) => {
-    readStream.on("end", resolve);
-    readStream.on("error", reject);
-  });
+  log(`Generating track fragment index for ${absolutePath} using single-track approach`);
 
+  // FIXED: Generate fragment indexes from individual single-track files
+  // This ensures byte offsets match the actual single-track files that clients will request
   const trackFragmentIndexes: Record<number, TrackFragmentIndex> = {};
-  const trackByteOffsets: Record<number, number> = {};
-  for await (const fragment of mp4File.fragmentIterator()) {
-    const track = mp4File
-      .getInfo()
-      .tracks.find((track) => track.id === fragment.track);
 
-    if (!track) {
-      throw new Error("Track not found");
+  // Process each audio/video stream as a separate track
+  for (let streamIndex = 0; streamIndex < probe.streams.length; streamIndex++) {
+    const stream = probe.streams[streamIndex]!;
+
+    // Only process audio and video streams
+    if (stream.codec_type !== 'audio' && stream.codec_type !== 'video') {
+      continue;
     }
 
-    if (fragment.segment === "init") {
-      trackByteOffsets[fragment.track] = fragment.data.byteLength;
-      if (track?.type === "video") {
-        const videoTrack = mp4File
-          .getInfo()
-          .videoTracks.find((track) => track.id === fragment.track);
-        if (!videoTrack) {
-          throw new Error("Video track not found");
-        }
-        trackFragmentIndexes[fragment.track] = {
-          track: fragment.track,
-          type: "video",
-          width: videoTrack.video.width,
-          height: videoTrack.video.height,
-          timescale: track.timescale,
-          sample_count: videoTrack.nb_samples,
-          codec: videoTrack.codec,
-          duration: videoTrack.duration,
-          startTimeOffsetMs: startTimeOffsetMs, // Add FFmpeg start_time offset
-          initSegment: {
-            offset: 0,
-            size: fragment.data.byteLength,
-          },
-          segments: [],
-        };
-      }
-      if (track?.type === "audio") {
-        const audioTrack = mp4File
-          .getInfo()
-          .audioTracks.find((track) => track.id === fragment.track);
-        if (!audioTrack) {
-          throw new Error("Audio track not found");
-        }
-        trackFragmentIndexes[fragment.track] = {
-          track: fragment.track,
-          type: "audio",
-          channel_count: audioTrack.audio.channel_count,
-          sample_rate: audioTrack.audio.sample_rate,
-          sample_size: audioTrack.audio.sample_size,
-          sample_count: audioTrack.nb_samples,
-          timescale: track.timescale,
-          codec: audioTrack.codec,
-          duration: audioTrack.duration,
-          initSegment: {
-            offset: 0,
-            size: fragment.data.byteLength,
-          },
-          segments: [],
-        };
-      }
-    } else {
-      const fragmentIndex = trackFragmentIndexes[fragment.track];
-      if (trackByteOffsets[fragment.track] === undefined) {
-        throw new Error("Fragment index not found");
-      }
-      if (!fragmentIndex) {
-        throw new Error("Fragment index not found");
-      }
+    const trackId = streamIndex + 1; // Convert to 1-based track ID
+    log(`Processing track ${trackId} (${stream.codec_type})`);
 
-      // Detect composition time offset from first video segment if no timing offset was found from metadata
-      if (fragmentIndex.type === "video" &&
-        fragmentIndex.segments.length === 0 &&
-        fragmentIndex.startTimeOffsetMs === undefined &&
-        fragment.cts > fragment.dts) {
-        // Calculate composition time offset in milliseconds
-        const compositionOffsetMs = ((fragment.cts - fragment.dts) / fragmentIndex.timescale) * 1000;
-        fragmentIndex.startTimeOffsetMs = compositionOffsetMs;
-        log(`Detected composition time offset from first video segment: ${compositionOffsetMs}ms (CTS=${fragment.cts}, DTS=${fragment.dts}, timescale=${fragmentIndex.timescale})`);
-      }
+    // Generate single-track file and its fragment index
+    const trackStream = probe.createTrackReadstream(streamIndex);
+    const trackIdMapping = { 1: trackId }; // Map single-track ID 1 to original track ID
 
-      fragmentIndex.duration += fragment.duration;
-      fragmentIndex.segments.push({
-        cts: fragment.cts,
-        dts: fragment.dts,
-        duration: fragment.duration,
-        offset: trackByteOffsets[fragment.track]!,
-        size: fragment.data.byteLength,
-      });
-      trackByteOffsets[fragment.track]! += fragment.data.byteLength;
-    }
+    const singleTrackIndexes = await generateFragmentIndex(
+      trackStream,
+      startTimeOffsetMs,
+      trackIdMapping
+    );
+
+    // Merge the single-track index into the combined result
+    Object.assign(trackFragmentIndexes, singleTrackIndexes);
   }
+
   return trackFragmentIndexes;
 };