@editframe/assets 0.17.6-beta.0 → 0.18.7-beta.0

package/src/tasks/generateTrackFragmentIndex.test.ts

@@ -0,0 +1,115 @@
+import { test, describe, assert } from "vitest";
+import { generateTrackFragmentIndexFromPath } from "./generateTrackFragmentIndex";
+
+describe("generateTrackFragmentIndex (updated with Mediabunny)", () => {
+  test("should generate fragment index using Mediabunny backend", async () => {
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/10s-bars.mp4");
+
+    // Should have multiple tracks
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    assert.isAbove(trackIds.length, 0, "Should have tracks");
+
+    for (const trackId of trackIds) {
+      const track = fragmentIndex[trackId]!;
+
+      // Verify track structure
+      assert.oneOf(track.type, ['video', 'audio'], `Track ${trackId} should be video or audio`);
+      assert.isNumber(track.track, `Track ${trackId} should have track number`);
+      assert.isNumber(track.timescale, `Track ${trackId} should have timescale`);
+      assert.isNumber(track.duration, `Track ${trackId} should have duration`);
+      assert.isNumber(track.sample_count, `Track ${trackId} should have sample_count`);
+      assert.isString(track.codec, `Track ${trackId} should have codec`);
+
+      // Verify init segment
+      assert.equal(track.initSegment.offset, 0, `Track ${trackId} init should start at 0`);
+      assert.isAbove(track.initSegment.size, 0, `Track ${trackId} init should have size`);
+
+      // Verify segments
+      assert.isArray(track.segments, `Track ${trackId} should have segments array`);
+      assert.isAbove(track.segments.length, 0, `Track ${trackId} should have segments`);
+
+      // Check each segment
+      for (const segment of track.segments) {
+        assert.isNumber(segment.cts, `Track ${trackId} segment should have cts`);
+        assert.isNumber(segment.dts, `Track ${trackId} segment should have dts`);
+        assert.isNumber(segment.duration, `Track ${trackId} segment should have duration`);
+        assert.isNumber(segment.offset, `Track ${trackId} segment should have offset`);
+        assert.isNumber(segment.size, `Track ${trackId} segment should have size`);
+      }
+
+      // Type-specific checks
+      if (track.type === 'video') {
+        assert.isNumber(track.width, `Video track ${trackId} should have width`);
+        assert.isNumber(track.height, `Video track ${trackId} should have height`);
+      } else if (track.type === 'audio') {
+        assert.isNumber(track.channel_count, `Audio track ${trackId} should have channel_count`);
+        assert.isNumber(track.sample_rate, `Audio track ${trackId} should have sample_rate`);
+        assert.isNumber(track.sample_size, `Audio track ${trackId} should have sample_size`);
+      }
+
+      console.log(`Track ${trackId} (${track.type}): ${track.segments.length} segments, ${track.sample_count} samples`);
+    }
+  }, 20000);
+
+  test("should handle single track files", async () => {
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/frame-count.mp4");
+
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    assert.equal(trackIds.length, 1, "Should have exactly one track");
+
+    const track = fragmentIndex[trackIds[0]!]!;
+    assert.equal(track.type, "video", "Should be video track");
+    assert.isAbove(track.segments.length, 0, "Should have segments");
+
+    console.log(`Single track: ${track.segments.length} segments, ${track.sample_count} samples`);
+  }, 15000);
+
+  test("should generate consistent results with original implementation", async () => {
+    // Test that the new implementation produces similar structure to the old one
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/bars-n-tone.mp4");
+
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    assert.equal(trackIds.length, 2, "Should have video and audio tracks");
+
+    // Should have both video and audio
+    const videoTrack = Object.values(fragmentIndex).find(t => t.type === 'video');
+    const audioTrack = Object.values(fragmentIndex).find(t => t.type === 'audio');
+
+    assert.exists(videoTrack, "Should have video track");
+    assert.exists(audioTrack, "Should have audio track");
+
+    // Video track checks
+    assert.isAbove(videoTrack.width, 0, "Video should have width");
+    assert.isAbove(videoTrack.height, 0, "Video should have height");
+    assert.isAbove(videoTrack.segments.length, 0, "Video should have segments");
+
+    // Audio track checks  
+    assert.isAbove(audioTrack.channel_count, 0, "Audio should have channels");
+    assert.isAbove(audioTrack.sample_rate, 0, "Audio should have sample rate");
+    assert.isAbove(audioTrack.segments.length, 0, "Audio should have segments");
+
+    console.log(`Consistent results: video ${videoTrack.segments.length} segments, audio ${audioTrack.segments.length} segments`);
+  }, 20000);
+
+  test("should preserve timing offset detection", async () => {
+    // Test with a file that might have timing offsets
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/frame-count.mp4");
+
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    const track = fragmentIndex[trackIds[0]!]!;
+
+    if (track.type === 'video' && track.startTimeOffsetMs !== undefined) {
+      assert.isNumber(track.startTimeOffsetMs, "Should have timing offset");
+      console.log(`Detected timing offset: ${track.startTimeOffsetMs}ms`);
+    } else {
+      console.log("No timing offset detected (expected for this file)");
+    }
+
+    // Should still have valid timing data
+    assert.isAbove(track.duration, 0, "Should have positive duration");
+    for (const segment of track.segments) {
+      assert.isAbove(segment.duration, 0, "Each segment should have positive duration");
+    }
+  }, 15000);
+});
+

package/src/tasks/generateTrackFragmentIndex.ts

@@ -1,105 +1,66 @@
 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 { generateTrackFragmentIndexMediabunny } from "../generateTrackFragmentIndexMediabunny.js";
+import type { TrackFragmentIndex } from "../Probe.js";
 
 export const generateTrackFragmentIndexFromPath = async (
   absolutePath: string,
 ) => {
   const log = debug("ef:generateTrackFragment");
   const probe = await Probe.probePath(absolutePath);
-  const readStream = probe.createConformingReadstream();
 
-  const mp4File = new MP4File();
+  // Extract timing offset from probe metadata (same logic as processISOBMFF.ts)
+  let startTimeOffsetMs: number | undefined;
 
-  log(`Generating track fragment index for ${absolutePath}`);
-  readStream.pipe(mp4FileWritable(mp4File));
-  await new Promise((resolve, reject) => {
-    readStream.on("end", resolve);
-    readStream.on("error", reject);
-  });
+  // First check format-level start_time
+  if (probe.format.start_time && Number(probe.format.start_time) !== 0) {
+    startTimeOffsetMs = Number(probe.format.start_time) * 1000;
+    log(`Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`);
+  } else {
+    // Check for video stream start_time (more common)
+    const videoStream = probe.streams.find(stream => stream.codec_type === 'video');
+    if (videoStream && videoStream.start_time && Number(videoStream.start_time) !== 0) {
+      startTimeOffsetMs = Number(videoStream.start_time) * 1000;
+      log(`Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`);
+    } else {
+      log("No format/stream timing offset found - will detect from composition time");
+    }
+  }
 
+  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]!;
 
-    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,
-          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");
-      }
-      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;
+    // Only process audio and video streams
+    if (stream.codec_type !== 'audio' && stream.codec_type !== 'video') {
+      continue;
     }
+
+    const trackId = streamIndex + 1; // Convert to 1-based track ID
+    log(`Processing track ${trackId} (${stream.codec_type})`);
+
+    // 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
+
+    const singleTrackIndexes = await generateTrackFragmentIndexMediabunny(
+      trackStream,
+      startTimeOffsetMs,
+      trackIdMapping
+    );
+
+    // Merge the single-track index into the combined result
+    Object.assign(trackFragmentIndexes, singleTrackIndexes);
   }
+
   return trackFragmentIndexes;
 };