@editframe/assets 0.11.0-beta.9 → 0.12.0-beta.10

package/dist/MP4File.d.ts

@@ -10,7 +10,6 @@ export declare class MP4File extends MP4Box.ISOFile {
         track: number;
         segment: "init";
         data: ArrayBuffer;
-        complete: false;
         cts?: undefined;
         dts?: undefined;
         duration?: undefined;
@@ -18,7 +17,6 @@ export declare class MP4File extends MP4Box.ISOFile {
         track: number;
         segment: number;
         data: ArrayBuffer;
-        complete: boolean;
         cts: number;
         dts: number;
         duration: number;

package/dist/MP4File.js

@@ -40,13 +40,13 @@ class MP4File extends MP4Box.ISOFile {
     await this.readyPromise;
     const trackInfo = {};
     for (const videoTrack of this.getInfo().videoTracks) {
-      trackInfo[videoTrack.id] = { index: 0, complete: false };
+      trackInfo[videoTrack.id] = { index: 0 };
       this.setSegmentOptions(videoTrack.id, null, {
         rapAlignement: true
       });
     }
     for (const audioTrack of this.getInfo().audioTracks) {
-      trackInfo[audioTrack.id] = { index: 0, complete: false };
+      trackInfo[audioTrack.id] = { index: 0 };
       const sampleRate = audioTrack.audio.sample_rate;
       const probablePacketSize = 1024;
       const probableFourSecondsOfSamples = Math.ceil(
@@ -61,21 +61,12 @@ class MP4File extends MP4Box.ISOFile {
       yield {
         track: initSegment.id,
         segment: "init",
-        data: initSegment.buffer,
-        complete: false
+        data: initSegment.buffer
       };
     }
     const fragmentStartSamples = {};
     let finishedReading = false;
-    const allTracksFinished = () => {
-      for (const fragmentedTrack of this.fragmentedTracks) {
-        if (!trackInfo[fragmentedTrack.id]?.complete) {
-          return false;
-        }
-      }
-      return true;
-    };
-    while (!(finishedReading && allTracksFinished())) {
+    do {
       for (const fragTrak of this.fragmentedTracks) {
         const trak = fragTrak.trak;
         if (trak.nextSample === void 0) {
@@ -84,6 +75,8 @@ class MP4File extends MP4Box.ISOFile {
         if (trak.samples === void 0) {
           throw new Error("trak.samples is undefined");
         }
+        log("trak.nextSample", fragTrak.id, trak.nextSample);
+        log("trak.samples.length", fragTrak.id, trak.samples.length);
         while (trak.nextSample < trak.samples.length) {
           let result = void 0;
           const fragTrakNextSample = trak.samples[trak.nextSample];
@@ -120,22 +113,20 @@ class MP4File extends MP4Box.ISOFile {
             if (!trackInfoForFrag) {
               throw new Error("trackInfoForFrag is undefined");
             }
-            if (trak.nextSample >= trak.samples.length) {
-              trackInfoForFrag.complete = true;
-            }
-            log(
-              `Yielding fragment #${trackInfoForFrag.index} for track=${fragTrak.id}`
-            );
             const startSample = fragmentStartSamples[fragTrak.id];
             const endSample = trak.samples[trak.nextSample - 1];
             if (!startSample || !endSample) {
               throw new Error("startSample or endSample is undefined");
             }
+            log(
+              `Yielding fragment #${trackInfoForFrag.index} for track=${fragTrak.id}`,
+              `startTime=${startSample.cts}`,
+              `endTime=${endSample.cts + endSample.duration}`
+            );
             yield {
               track: fragTrak.id,
               segment: trackInfoForFrag.index,
               data: fragTrak.segmentStream.buffer,
-              complete: trackInfoForFrag.complete,
               cts: startSample.cts,
               dts: startSample.dts,
               duration: endSample.cts - startSample.cts + endSample.duration
@@ -147,6 +138,68 @@ class MP4File extends MP4Box.ISOFile {
         }
       }
       finishedReading = await this.waitForMoreSamples();
+    } while (!finishedReading);
+    for (const fragTrak of this.fragmentedTracks) {
+      const trak = fragTrak.trak;
+      if (trak.nextSample === void 0) {
+        throw new Error("trak.nextSample is undefined");
+      }
+      if (trak.samples === void 0) {
+        throw new Error("trak.samples is undefined");
+      }
+      while (trak.nextSample < trak.samples.length) {
+        let result = void 0;
+        try {
+          result = this.createFragment(
+            fragTrak.id,
+            trak.nextSample,
+            fragTrak.segmentStream
+          );
+        } catch (error) {
+          console.error("Failed to createFragment", error);
+        }
+        if (result) {
+          fragTrak.segmentStream = result;
+          trak.nextSample++;
+        } else {
+          finishedReading = await this.waitForMoreSamples();
+          break;
+        }
+        const nextSample = trak.samples[trak.nextSample];
+        const emitSegment = (
+          // if rapAlignement is true, we emit a fragment when we have a rap sample coming up next
+          fragTrak.rapAlignement === true && nextSample?.is_sync || // if rapAlignement is false, we emit a fragment when we have the required number of samples
+          !fragTrak.rapAlignement && trak.nextSample % fragTrak.nb_samples === 0 || // if we have more samples than the number of samples requested, we emit the fragment
+          trak.nextSample >= trak.samples.length
+        );
+        if (emitSegment) {
+          const trackInfoForFrag = trackInfo[fragTrak.id];
+          if (!trackInfoForFrag) {
+            throw new Error("trackInfoForFrag is undefined");
+          }
+          const startSample = fragmentStartSamples[fragTrak.id];
+          const endSample = trak.samples[trak.nextSample - 1];
+          if (!startSample || !endSample) {
+            throw new Error("startSample or endSample is undefined");
+          }
+          log(
+            `Yielding fragment #${trackInfoForFrag.index} for track=${fragTrak.id}`,
+            `startTime=${startSample.cts}`,
+            `endTime=${endSample.cts + endSample.duration}`
+          );
+          yield {
+            track: fragTrak.id,
+            segment: trackInfoForFrag.index,
+            data: fragTrak.segmentStream.buffer,
+            cts: startSample.cts,
+            dts: startSample.dts,
+            duration: endSample.cts - startSample.cts + endSample.duration
+          };
+          trackInfoForFrag.index += 1;
+          fragTrak.segmentStream = null;
+          delete fragmentStartSamples[fragTrak.id];
+        }
+      }
     }
   }
   waitForMoreSamples() {

package/dist/Probe.js

@@ -84,8 +84,6 @@ class Probe {
     return new Probe(absolutePath, json);
   }
   static async probeStream(stream) {
-    const probeCommand = "ffprobe -i pipe:0 -v error -show_format -show_streams -of json";
-    log("Probing", probeCommand);
     const probe = spawn(
       "ffprobe",
       [
@@ -98,35 +96,52 @@ class Probe {
         "-of",
         "json"
       ],
-      {
-        stdio: ["pipe", "pipe", "pipe"]
-      }
+      { stdio: ["pipe", "pipe", "pipe"] }
     );
     const chunks = [];
+    const processExit = new Promise((_, reject) => {
+      probe.on("exit", (code) => {
+        if (code !== 0) {
+          reject(new Error(`ffprobe exited with code ${code}`));
+        }
+      });
+      probe.on("error", (err) => reject(err));
+    });
     probe.stderr.on("data", (data) => {
       log(data.toString());
     });
     probe.stdout.on("data", (data) => {
       chunks.push(data);
     });
-    stream.pipe(probe.stdin);
     probe.stdin.on("error", (error) => {
+      if (error.code === "EPIPE") {
+        log("ffprobe closed input pipe");
+        return;
+      }
       log("ffprobe stdin error", error);
     });
-    const json = await new Promise((resolve, reject) => {
-      probe.stdout.on("end", () => {
-        stream.unpipe(probe.stdin);
-        stream.destroy();
-        try {
-          const buffer = Buffer.concat(chunks).toString("utf8");
-          log("Got probe from stream", buffer);
-          resolve(JSON.parse(buffer));
-        } catch (error) {
-          reject(error);
-        }
-      });
-    });
-    return new Probe("pipe:0", json);
+    stream.pipe(probe.stdin);
+    try {
+      const json = await Promise.race([
+        new Promise((resolve, reject) => {
+          probe.stdout.on("end", () => {
+            try {
+              const buffer = Buffer.concat(chunks).toString("utf8");
+              log("Got probe from stream", buffer);
+              resolve(JSON.parse(buffer));
+            } catch (error) {
+              reject(error);
+            }
+          });
+        }),
+        processExit
+      ]);
+      return new Probe("pipe:0", json);
+    } finally {
+      stream.unpipe(probe.stdin);
+      probe.stdin.end();
+      stream.destroy();
+    }
   }
   get audioStreams() {
     return this.data.streams.filter(

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { AudioStreamSchema, VideoStreamSchema, Probe } from './Probe.ts';
-export type { StreamSchema, TrackSegment, TrackFragmentIndex, AudioTrackFragmentIndex, VideoTrackFragmentIndex, } from './Probe.ts';
+export type { StreamSchema, AudioStreamSchema, VideoStreamSchema, TrackSegment, TrackFragmentIndex, AudioTrackFragmentIndex, VideoTrackFragmentIndex, } from './Probe.ts';
+export { Probe } from './Probe.ts';
 export { md5FilePath, md5Directory, md5ReadStream, md5Buffer } from './md5.ts';
 export { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, } from './tasks/generateTrackFragmentIndex.ts';
 export { generateTrack, generateTrackFromPath } from './tasks/generateTrack.ts';

package/dist/index.js

@@ -1,4 +1,4 @@
-import { AudioStreamSchema, Probe, VideoStreamSchema } from "./Probe.js";
+import { Probe } from "./Probe.js";
 import { md5Buffer, md5Directory, md5FilePath, md5ReadStream } from "./md5.js";
 import { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath } from "./tasks/generateTrackFragmentIndex.js";
 import { generateTrack, generateTrackFromPath } from "./tasks/generateTrack.js";
@@ -6,10 +6,8 @@ import { findOrCreateCaptions, generateCaptionDataFromPath } from "./tasks/findO
 import { cacheImage } from "./tasks/cacheImage.js";
 import { VideoRenderOptions } from "./VideoRenderOptions.js";
 export {
-  AudioStreamSchema,
   Probe,
   VideoRenderOptions,
-  VideoStreamSchema,
   cacheImage,
   findOrCreateCaptions,
   generateCaptionDataFromPath,

package/dist/tasks/generateTrack.js

@@ -10,20 +10,37 @@ const generateTrackFromPath = async (absolutePath, trackId) => {
   const probe = await Probe.probePath(absolutePath);
   const readStream = probe.createConformingReadstream();
   const mp4File = new MP4File();
+  const trackStream = new PassThrough();
   log(`Generating track for ${absolutePath}`);
   readStream.pipe(mp4FileWritable(mp4File));
-  await new Promise((resolve, reject) => {
-    readStream.on("end", resolve);
-    readStream.on("error", reject);
-  });
-  const trackStream = new PassThrough();
-  for await (const fragment of mp4File.fragmentIterator()) {
-    if (fragment.track !== trackId) {
-      continue;
+  (async () => {
+    try {
+      let bytesWritten = 0;
+      for await (const fragment of mp4File.fragmentIterator()) {
+        log("Writing fragment", fragment);
+        if (fragment.track === trackId) {
+          const written = trackStream.write(
+            Buffer.from(fragment.data),
+            "binary"
+          );
+          if (!written) {
+            log(`Waiting for drain for track ${trackId}`);
+            await new Promise((resolve) => trackStream.once("drain", resolve));
+          }
+          bytesWritten += fragment.data.byteLength;
+        }
+        if (!readStream.readableEnded) {
+          await Promise.race([
+            new Promise((resolve) => readStream.once("end", resolve)),
+            new Promise((resolve) => readStream.once("data", resolve))
+          ]);
+        }
+      }
+      trackStream.end();
+    } catch (error) {
+      trackStream.destroy(error);
     }
-    trackStream.write(Buffer.from(fragment.data), "binary");
-  }
-  trackStream.end();
+  })();
   return trackStream;
 };
 const generateTrackTask = idempotentTask({
@@ -33,9 +50,9 @@ const generateTrackTask = idempotentTask({
 });
 const generateTrack = async (cacheRoot, absolutePath, url) => {
   try {
-    const trackId = new URL(
-      `http://localhost${url}` ?? "bad-url"
-    ).searchParams.get("trackId");
+    const trackId = new URL(`http://localhost${url}`).searchParams.get(
+      "trackId"
+    );
     if (trackId === null) {
       throw new Error(
         "No trackId provided. IT must be specified in the query string: ?trackId=0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.11.0-beta.9",
+  "version": "0.12.0-beta.10",
   "description": "",
   "exports": {
     ".": {

package/src/tasks/generateTrack.ts

@@ -14,24 +14,46 @@ export const generateTrackFromPath = async (
   const probe = await Probe.probePath(absolutePath);
   const readStream = probe.createConformingReadstream();
   const mp4File = new MP4File();
+  const trackStream = new PassThrough();
 
   log(`Generating track for ${absolutePath}`);
+
+  // Set up pipe and processing of fragments
   readStream.pipe(mp4FileWritable(mp4File));
 
-  await new Promise((resolve, reject) => {
-    readStream.on("end", resolve);
-    readStream.on("error", reject);
-  });
+  // Process fragments as they become available
+  (async () => {
+    try {
+      let bytesWritten = 0;
+      for await (const fragment of mp4File.fragmentIterator()) {
+        log("Writing fragment", fragment);
+        if (fragment.track === trackId) {
+          const written = trackStream.write(
+            Buffer.from(fragment.data),
+            "binary",
+          );
+          if (!written) {
+            log(`Waiting for drain for track ${trackId}`);
+            await new Promise((resolve) => trackStream.once("drain", resolve));
+          }
+          bytesWritten += fragment.data.byteLength;
+        }
+        // There is a race condition where the mp4file writable doesn't correctly wait for the whole readSTream
+        // Waiting for data/end events seems to fix it
+        // FIXME: This is a hack, we should fix the root issue in MP4File
+        if (!readStream.readableEnded) {
+          await Promise.race([
+            new Promise((resolve) => readStream.once("end", resolve)),
+            new Promise((resolve) => readStream.once("data", resolve)),
+          ]);
+        }
+      }
 
-  const trackStream = new PassThrough();
-
-  for await (const fragment of mp4File.fragmentIterator()) {
-    if (fragment.track !== trackId) {
-      continue;
+      trackStream.end();
+    } catch (error) {
+      trackStream.destroy(error as Error);
     }
-    trackStream.write(Buffer.from(fragment.data), "binary");
-  }
-  trackStream.end();
+  })();
 
   return trackStream;
 };
@@ -49,9 +71,9 @@ export const generateTrack = async (
   url: string,
 ) => {
   try {
-    const trackId = new URL(
-      `http://localhost${url}` ?? "bad-url",
-    ).searchParams.get("trackId");
+    const trackId = new URL(`http://localhost${url}`).searchParams.get(
+      "trackId",
+    );
     if (trackId === null) {
       throw new Error(
         "No trackId provided. IT must be specified in the query string: ?trackId=0",