web/workers/remux: accept several files, custom args and output

web/src/lib/queen-bee/queue.ts

@@ -22,6 +22,15 @@ export const createRemuxPipeline = (file: File) => {
         parentId,
         workerArgs: {
             files: [file],
+            ffargs: [
+                "-c", "copy",
+                "-map", "0"
+            ],
+            output: {
+                type: file.type,
+                extension: file.name.split(".").pop(),
+            },
+            filename: file.name,
         },
     }];
 

web/src/lib/queen-bee/run-worker.ts

@@ -4,6 +4,7 @@ import FetchWorker from "$lib/workers/fetch?worker";
 import { updateWorkerProgress } from "$lib/state/queen-bee/current-tasks";
 import { pipelineTaskDone, itemError, queue } from "$lib/state/queen-bee/queue";
 
+import type { FileInfo } from "$lib/types/libav";
 import type { CobaltQueue } from "$lib/types/queue";
 import type { CobaltPipelineItem } from "$lib/types/workers";
 
@@ -13,7 +14,7 @@ const killWorker = (worker: Worker, unsubscribe: () => void, interval?: NodeJS.T
     if (interval) clearInterval(interval);
 }
 
-export const runRemuxWorker = async (workerId: string, parentId: string, file: File) => {
+export const runRemuxWorker = async (workerId: string, parentId: string, files: File[], args: string[], output: FileInfo, filename: string) => {
     const worker = new RemuxWorker();
 
     // sometimes chrome refuses to start libav wasm,
@@ -42,7 +43,10 @@ export const runRemuxWorker = async (workerId: string, parentId: string, file: F
 
     worker.postMessage({
         cobaltRemuxWorker: {
-            file
+            files,
+            args,
+            output,
+            filename,
         }
     });
 
@@ -139,12 +143,26 @@ export const runFetchWorker = async (workerId: string, parentId: string, url: st
 }
 
 export const startWorker = async ({ worker, workerId, parentId, workerArgs }: CobaltPipelineItem) => {
+    let files: File[] = [];
+
     switch (worker) {
         case "remux":
             if (workerArgs?.files) {
-                await runRemuxWorker(workerId, parentId, workerArgs.files[0]);
+                files = workerArgs.files;
+            }
+
+            if (files.length > 0 && workerArgs.ffargs && workerArgs.output && workerArgs.filename) {
+                await runRemuxWorker(
+                    workerId,
+                    parentId,
+                    files,
+                    workerArgs.ffargs,
+                    workerArgs.output,
+                    workerArgs.filename
+                );
             }
             break;
+
         case "fetch":
             if (workerArgs?.url) {
                 await runFetchWorker(workerId, parentId, workerArgs.url)

web/src/lib/types/workers.ts

@@ -1,3 +1,5 @@
+import type { FileInfo } from "$lib/types/libav";
+
 export const resultFileTypes = ["video", "audio", "image"] as const;
 
 export type CobaltWorkerType = "remux" | "fetch";
@@ -12,7 +14,9 @@ export type CobaltWorkerProgress = {
 export type CobaltWorkerArgs = {
     files?: File[],
     url?: string,
-    //TODO: args for libav & etc with unique types
+    ffargs?: string[],
+    output?: FileInfo,
+    filename?: string,
 }
 
 export type CobaltPipelineItem = {

web/src/lib/workers/remux.ts

@@ -1,4 +1,5 @@
 import LibAVWrapper from "$lib/libav";
+import type { FileInfo } from "$lib/types/libav";
 
 const error = (code: string) => {
     self.postMessage({
@@ -24,13 +25,13 @@ const ff = new LibAVWrapper((progress) => {
 
 ff.init();
 
-const remux = async (file: File) => {
+const remux = async (files: File[], args: string[], output: FileInfo, filename: string) => {
-    if (!file) return;
+    if (!(files && output && args)) return;
 
     await ff.init();
 
     try {
-        const file_info = await ff.probe(file).catch((e) => {
+        const file_info = await ff.probe(files[0]).catch((e) => {
             if (e?.message?.toLowerCase().includes("out of memory")) {
                 console.error("uh oh! out of memory");
                 console.error(e);
@@ -41,8 +42,7 @@ const remux = async (file: File) => {
         });
 
         if (!file_info?.format) {
-            error("remux.corrupted");
+            return error("remux.corrupted");
-            return;
         }
 
         self.postMessage({
@@ -53,36 +53,31 @@ const remux = async (file: File) => {
             }
         });
 
-        if (!file.type) {
+        for (const file of files) {
-            // TODO: better & more appropriate error code
+            if (!file.type) {
-            error("remux.corrupted");
+                // TODO: better & more appropriate error code
+                return error("remux.corrupted");
+            }
         }
 
         const render = await ff
             .render({
-                files: [file],
+                files,
-                output: {
+                output,
-                    type: file.type,
+                args,
-                    extension: file.name.split(".").pop(),
-                },
-                args: ["-c", "copy", "-map", "0"],
             })
             .catch((e) => {
                 console.error("uh-oh! render error");
                 console.error(e);
-
+                // TODO: better error codes, there are more reasons for a crash
                 error("remux.out_of_resources");
             });
 
         if (!render) {
-            return console.log("not a valid file");
+            console.log("not a valid file");
+            return error("incorrect input or output");
         }
 
-        const filenameParts = file.name.split(".");
-        const filenameExt = filenameParts.pop();
-
-        const filename = `${filenameParts.join(".")} (remux).${filenameExt}`;
-
         self.postMessage({
             cobaltRemuxWorker: {
                 render,
@@ -95,9 +90,10 @@ const remux = async (file: File) => {
 }
 
 self.onmessage = async (event: MessageEvent) => {
-    console.log(event.data);
+    const ed = event.data.cobaltRemuxWorker;
-
+    if (ed) {
-    if (event.data.cobaltRemuxWorker.file) {
+        if (ed.files && ed.args && ed.output && ed.filename) {
-        await remux(event.data.cobaltRemuxWorker.file);
+            await remux(ed.files, ed.args, ed.output, ed.filename);
+        }
     }
 }