fix(ffmpeg): reserve capacity before creating media inputs

pkg/download/engine/inject/ffmpeg/ffmpeg.js

@@ -1,6 +1,8 @@
 (function () {
   const create = __gopeed_ffmpeg_create;
   const read = __gopeed_ffmpeg_read;
+  const acquire = __gopeed_ffmpeg_acquire;
+  const start = __gopeed_ffmpeg_start;
   const push = __gopeed_ffmpeg_push;
   const end = __gopeed_ffmpeg_end;
   const cancel = __gopeed_ffmpeg_cancel;
@@ -9,8 +11,9 @@
     for (const stop of Array.from(active)) stop(new Error("extension engine closed"));
   };
 
-  function input(value, name) {
+  function input(value, name, allowStream) {
     if (value && typeof value.getReader === "function") {
+      if (!allowStream) throw new TypeError("stream inputs must be created by the inputs callback");
       if (value.locked) throw new TypeError(name + " stream is locked");
       return { stream: value, request: null };
     }
@@ -24,9 +27,11 @@
 
   function merge(options) {
     if (!options || typeof options !== "object") throw new TypeError("merge options are required");
-    const video = input(options.video, "video");
-    const audio = input(options.audio, "audio");
-    if (video.stream && video.stream === audio.stream) throw new TypeError("video and audio must be distinct streams");
+    const factory = options.inputs;
+    if (factory !== undefined && typeof factory !== "function") throw new TypeError("inputs must be a callback");
+    if (factory && (options.video !== undefined || options.audio !== undefined)) throw new TypeError("inputs cannot be combined with video/audio");
+    let video = factory ? null : input(options.video, "video", false);
+    let audio = factory ? null : input(options.audio, "audio", false);
     const args = options.args === undefined ? [] : options.args;
     if (!Array.isArray(args) || args.some(v => typeof v !== "string")) throw new TypeError("args must be a string array");
     const format = options.format === undefined ? "mp4" : options.format;
@@ -34,11 +39,20 @@
     const signal = options.signal;
     let id, controller, stopped = false;
     const readers = [];
+    const lifetime = new AbortController();
+    let ownedInputs;
+    function discardInputs(inputs, reason) {
+      for (const source of new Set([inputs && inputs.video, inputs && inputs.audio])) {
+        if (source && typeof source.cancel === "function" && !source.locked) Promise.resolve(source.cancel(reason)).catch(() => {});
+      }
+    }
 
     function stop(reason) {
       if (stopped) return;
       stopped = true;
       active.delete(shutdown);
+      lifetime.abort();
+      discardInputs(ownedInputs, reason);
       if (id) cancel(id);
       if (signal) signal.removeEventListener("abort", abort);
       for (const reader of readers) {
@@ -90,11 +104,21 @@
         if (stopped) return;
         try {
           if (!id) {
-            // Acquire both readers before starting native work.
+            id = create({ format, args });
+            await acquire(id);
+            if (stopped) return;
+            if (factory) {
+              const inputs = await factory({ signal: lifetime.signal });
+              if (stopped) { discardInputs(inputs, new Error("FFmpeg operation cancelled")); return; }
+              ownedInputs = inputs;
+              video = input(inputs && inputs.video, "video", true);
+              audio = input(inputs && inputs.audio, "audio", true);
+            }
+            if (video.stream && video.stream === audio.stream) throw new TypeError("video and audio must be distinct streams");
             for (const source of [video, audio]) {
               if (source.stream) readers.push(source.stream.getReader());
             }
-            id = create({ video: video.request, audio: audio.request, format, args });
+            start(id, { video: video.request, audio: audio.request, format, args });
             let readerIndex = 0;
             for (const [index, source] of [video, audio].entries()) {
               if (source.stream) void pump(readers[readerIndex++], index);
@@ -111,5 +135,5 @@
       cancel(reason) { stop(reason); }
     });
   }
-  globalThis.__gopeed_ffmpeg = Object.freeze({ merge });
+  globalThis.__gopeed_ffmpeg = Object.freeze({ merge, supportsInputFactory: true });
 })();

pkg/download/engine/inject/ffmpeg/module.go

@@ -37,11 +37,17 @@ type job struct {
 	cancel  context.CancelFunc
 	output  *io.PipeReader
 	streams [2]*media.StreamInput
+	mu      sync.Mutex
+	ready   chan struct{}
+	start   chan options
+	started bool
 }
 
 func (j *job) stop() {
 	j.cancel()
 	j.output.CloseWithError(context.Canceled)
+	j.mu.Lock()
+	defer j.mu.Unlock()
 	for _, s := range j.streams {
 		if s != nil {
 			s.Close()
@@ -99,6 +105,100 @@ func Enable(vm *goja.Runtime, loop *eventloop.EventLoop, cfg *Config) error {
 		if _, err := media.Arguments(opts.Format, opts.Args); err != nil {
 			panic(vm.NewGoError(err))
 		}
+		ctx, cancel := context.WithCancel(context.Background())
+		r, w := io.Pipe()
+		j := &job{ctx: ctx, cancel: cancel, output: r, ready: make(chan struct{}), start: make(chan options, 1)}
+		id := fmt.Sprintf("ffmpeg-%d", next.Add(1))
+		mu.Lock()
+		jobs[id] = j
+		mu.Unlock()
+		go func() {
+			var inputs [2]media.Input
+			var runErr error
+			defer func() {
+				if v := recover(); v != nil {
+					runErr = fmt.Errorf("ffmpeg panic: %v", v)
+				}
+				cancel()
+				for _, in := range inputs {
+					if in != nil {
+						in.Close()
+					}
+				}
+				w.CloseWithError(runErr)
+			}()
+			release, err := media.Acquire(ctx)
+			if err != nil {
+				runErr = err
+				return
+			}
+			defer release()
+			close(j.ready)
+			var opts options
+			select {
+			case opts = <-j.start:
+			case <-ctx.Done():
+				runErr = ctx.Err()
+				return
+			}
+			for i, source := range []*media.HTTPSource{opts.Video, opts.Audio} {
+				if source == nil {
+					inputs[i] = j.streams[i]
+				} else {
+					inputs[i], runErr = media.OpenHTTP(ctx, client, *source)
+					if runErr != nil {
+						return
+					}
+				}
+			}
+			runErr = media.RunAcquired(ctx, inputs[0], inputs[1], w, opts.Format, opts.Args)
+		}()
+		return vm.ToValue(id)
+	}); err != nil {
+		return err
+	}
+	if err := vm.Set("__gopeed_ffmpeg_acquire", func(id string) goja.Value {
+		promise, resolve, reject := vm.NewPromise()
+		j := get(id)
+		go func() {
+			var err error
+			if j == nil {
+				err = io.ErrClosedPipe
+			} else {
+				select {
+				case <-j.ready:
+				case <-j.ctx.Done():
+					err = j.ctx.Err()
+				}
+				if j.ctx.Err() != nil {
+					err = j.ctx.Err()
+				}
+			}
+			loop.RunOnLoop(func(vm *goja.Runtime) {
+				if err != nil {
+					reject(vm.NewGoError(err))
+				} else {
+					resolve(true)
+				}
+			})
+		}()
+		return vm.ToValue(promise)
+	}); err != nil {
+		return err
+	}
+	if err := vm.Set("__gopeed_ffmpeg_start", func(call goja.FunctionCall) goja.Value {
+		id := call.Argument(0).String()
+		j := get(id)
+		if j == nil {
+			panic(vm.NewGoError(io.ErrClosedPipe))
+		}
+		var opts options
+		if err := vm.ExportTo(call.Argument(1), &opts); err != nil {
+			panic(vm.NewGoError(err))
+		}
+		if _, err := media.Arguments(opts.Format, opts.Args); err != nil {
+			panic(vm.NewGoError(err))
+		}
 		for _, source := range []*media.HTTPSource{opts.Video, opts.Audio} {
 			if source == nil || cfg.DefaultUserAgent == nil {
 				continue
@@ -117,48 +217,20 @@ func Enable(vm *goja.Runtime, loop *eventloop.EventLoop, cfg *Config) error {
 				source.Headers["User-Agent"] = *cfg.DefaultUserAgent
 			}
 		}
-		ctx, cancel := context.WithCancel(context.Background())
-		r, w := io.Pipe()
-		j := &job{ctx: ctx, cancel: cancel, output: r}
+
+		j.mu.Lock()
+		defer j.mu.Unlock()
+		if j.started || j.ctx.Err() != nil {
+			panic(vm.NewGoError(io.ErrClosedPipe))
+		}
+		j.started = true
 		for i, source := range []*media.HTTPSource{opts.Video, opts.Audio} {
 			if source == nil {
-				j.streams[i] = media.NewStreamInput(ctx)
+				j.streams[i] = media.NewStreamInput(j.ctx)
 			}
 		}
-		id := fmt.Sprintf("ffmpeg-%d", next.Add(1))
-		mu.Lock()
-		jobs[id] = j
-		mu.Unlock()
-		go func() {
-			var inputs [2]media.Input
-			var runErr error
-			defer func() {
-				if v := recover(); v != nil {
-					runErr = fmt.Errorf("ffmpeg panic: %v", v)
-				}
-				cancel()
-				for _, in := range inputs {
-					if in != nil {
-						in.Close()
-					}
-				}
-				// Closing only after Run returns prevents partial output from
-				// being mistaken for a successful download on FFmpeg failure.
-				w.CloseWithError(runErr)
-			}()
-			for i, source := range []*media.HTTPSource{opts.Video, opts.Audio} {
-				if source == nil {
-					inputs[i] = j.streams[i]
-				} else {
-					inputs[i], runErr = media.OpenHTTP(ctx, client, *source)
-					if runErr != nil {
-						return
-					}
-				}
-			}
-			runErr = media.Run(ctx, inputs[0], inputs[1], w, opts.Format, opts.Args)
-		}()
-		return vm.ToValue(id)
+		j.start <- opts
+		return goja.Undefined()
 	}); err != nil {
 		return err
 	}