web: simplify CobaltFileReference type

web/src/components/queue/ProcessingQueueItem.svelte

@@ -90,7 +90,7 @@
             return $t("queue.state.starting");
 
         case "done":
-            return formatFileSize(info.resultFile?.file?.size);
+            return formatFileSize(info.resultFile?.size);
 
         case "error":
             return !retrying ? info.errorCode : $t("queue.state.retrying");
@@ -162,7 +162,7 @@
         {#if info.state === "done" && info.resultFile}
             <button
                 class="button action-button"
-                on:click={() => download(info.resultFile.file)}
+                on:click={() => download(info.resultFile)}
             >
                 <IconDownload />
             </button>

web/src/lib/libav.ts

@@ -86,7 +86,7 @@ export default class LibAVWrapper {
 
         try {
             for (let i = 0; i < files.length; i++) {
-                const file = files[i].file;
+                const file = files[i];
 
                 await libav.mkreadaheadfile(`input${i}`, file);
                 ffInputs.push('-i', `input${i}`);
@@ -95,7 +95,7 @@ export default class LibAVWrapper {
             await libav.mkwriterdev(outputName);
             await libav.mkwriterdev('progress.txt');
 
-            const totalInputSize = files.reduce((a, b) => a + b.file.size, 0);
+            const totalInputSize = files.reduce((a, b) => a + b.size, 0);
             const storage = await Storage.init(totalInputSize);
 
             libav.onwrite = async (name, pos, data) => {
@@ -120,14 +120,15 @@ export default class LibAVWrapper {
                 outputName
             ]);
 
-            const file = await storage.res();
+            const file = new File(
+                [ await storage.res() ],
+                outputName,
+                { type: output.type }
+            );
 
             if (file.size === 0) return;
 
-            return {
+            return file;
-                file,
-                type: output.type,
-            }
         } finally {
             try {
                 await libav.unlink(outputName);

web/src/lib/state/task-manager/queue.ts

@@ -4,17 +4,16 @@ import { schedule } from "$lib/task-manager/scheduler";
 import { clearFileStorage, removeFromFileStorage } from "$lib/storage/opfs";
 import { clearCurrentTasks, removeWorkerFromQueue } from "$lib/state/task-manager/current-tasks";
 
-import type { CobaltFileReference } from "$lib/types/storage";
 import type { CobaltQueue, CobaltQueueItem, CobaltQueueItemRunning } from "$lib/types/queue";
 
 const clearPipelineCache = (queueItem: CobaltQueueItem) => {
     if (queueItem.state === "running") {
-        let item: CobaltFileReference | undefined;
+        let item: File | undefined;
         while ((item = queueItem.pipelineResults.pop())) {
-            removeFromFileStorage(item.file.name);
+            removeFromFileStorage(item.name);
         }
     } else if (queueItem.state === "done") {
-        removeFromFileStorage(queueItem.resultFile.file.name);
+        removeFromFileStorage(queueItem.resultFile.name);
     }
 
     return queueItem;
@@ -54,7 +53,7 @@ export function itemError(id: string, workerId: string, error: string) {
     schedule();
 }
 
-export function itemDone(id: string, file: CobaltFileReference) {
+export function itemDone(id: string, file: File) {
     update(queueData => {
         if (queueData[id]) {
             queueData[id] = clearPipelineCache(queueData[id]);
@@ -71,7 +70,7 @@ export function itemDone(id: string, file: CobaltFileReference) {
     schedule();
 }
 
-export function pipelineTaskDone(id: string, workerId: string, file: CobaltFileReference) {
+export function pipelineTaskDone(id: string, workerId: string, file: File) {
     update(queueData => {
         const item = queueData[id];
 

web/src/lib/task-manager/queue.ts

@@ -24,10 +24,7 @@ export const createRemuxPipeline = (file: File) => {
         workerId: crypto.randomUUID(),
         parentId,
         workerArgs: {
-            files: [{
+            files: [file],
-                file,
-                type: file.type,
-            }],
             ffargs: [
                 "-c", "copy",
                 "-map", "0"

web/src/lib/task-manager/run-worker.ts

@@ -5,7 +5,6 @@ import { runFFmpegWorker } from "$lib/task-manager/runners/ffmpeg";
 import { runFetchWorker } from "$lib/task-manager/runners/fetch";
 
 import type { CobaltPipelineItem } from "$lib/types/workers";
-import type { CobaltFileReference } from "$lib/types/storage";
 
 export const killWorker = (worker: Worker, unsubscribe: () => void, interval?: NodeJS.Timeout) => {
     unsubscribe();
@@ -14,7 +13,7 @@ export const killWorker = (worker: Worker, unsubscribe: () => void, interval?: N
 }
 
 export const startWorker = async ({ worker, workerId, parentId, workerArgs }: CobaltPipelineItem) => {
-    let files: CobaltFileReference[] = [];
+    let files: File[] = [];
 
     switch (worker) {
         case "remux":

web/src/lib/task-manager/runners/ffmpeg.ts

@@ -6,14 +6,13 @@ import { pipelineTaskDone, itemError, queue } from "$lib/state/task-manager/queu
 
 import type { FileInfo } from "$lib/types/libav";
 import type { CobaltQueue } from "$lib/types/queue";
-import type { CobaltFileReference } from "$lib/types/storage";
 
 let startAttempts = 0;
 
 export const runFFmpegWorker = async (
     workerId: string,
     parentId: string,
-    files: CobaltFileReference[],
+    files: File[],
     args: string[],
     output: FileInfo,
     variant: 'remux' | 'encode',

web/src/lib/task-manager/workers/fetch.ts

@@ -76,7 +76,9 @@ const fetchFile = async (url: string) => {
             return error("tunnel is broken");
         }
 
-        const file = await storage.res();
+        const file = new File(
+            [ await storage.res() ], '', { type: contentType }
+        );
 
         if (contentLength && Number(contentLength) !== file.size) {
             return error("file was not downloaded fully");
@@ -84,10 +86,7 @@ const fetchFile = async (url: string) => {
 
         self.postMessage({
             cobaltFetchWorker: {
-                result: {
+                result: file
-                    file,
-                    type: contentType,
-                }
             }
         });
     } catch (e) {

web/src/lib/task-manager/workers/ffmpeg.ts

@@ -1,7 +1,6 @@
 import LibAVWrapper from "$lib/libav";
 
 import type { FileInfo } from "$lib/types/libav";
-import type { CobaltFileReference } from "$lib/types/storage";
 
 const error = (code: string) => {
     self.postMessage({
@@ -11,7 +10,7 @@ const error = (code: string) => {
     })
 }
 
-const ffmpeg = async (variant: string, files: CobaltFileReference[], args: string[], output: FileInfo) => {
+const ffmpeg = async (variant: string, files: File[], args: string[], output: FileInfo) => {
     if (!(files && output && args)) return;
 
     const ff = new LibAVWrapper((progress) => {
@@ -32,7 +31,7 @@ const ffmpeg = async (variant: string, files: CobaltFileReference[], args: strin
 
     try {
         // probing just the first file in files array (usually audio) for duration progress
-        const probeFile = files[0]?.file;
+        const probeFile = files[0];
         if (!probeFile) return error("couldn't probe one of files");
 
         const file_info = await ff.probe(probeFile).catch((e) => {

web/src/lib/types/libav.ts

@@ -1,12 +1,10 @@
-import type { CobaltFileReference } from "$lib/types/storage";
-
 export type FileInfo = {
     type?: string,
     format?: string,
 }
 
 export type RenderParams = {
-    files: CobaltFileReference[],
+    files: File[],
     output: FileInfo,
     args: string[],
 }

web/src/lib/types/queue.ts

@@ -1,5 +1,4 @@
 import type { CobaltSaveRequestBody } from "$lib/types/api";
-import type { CobaltFileReference } from "$lib/types/storage";
 import type { CobaltPipelineItem, CobaltPipelineResultFileType } from "$lib/types/workers";
 
 export type CobaltQueueItemState = "waiting" | "running" | "done" | "error";
@@ -24,12 +23,12 @@ export type CobaltQueueItemRunning = CobaltQueueBaseItem & {
     state: "running",
     runningWorker: string,
     completedWorkers: Set<string>,
-    pipelineResults: CobaltFileReference[],
+    pipelineResults: File[],
 };
 
 export type CobaltQueueItemDone = CobaltQueueBaseItem & {
     state: "done",
-    resultFile: CobaltFileReference,
+    resultFile: File,
 };
 
 export type CobaltQueueItemError = CobaltQueueBaseItem & {

web/src/lib/types/storage.ts

@@ -1,4 +0,0 @@
-export type CobaltFileReference = {
-    file: File,
-    type: string,
-}

web/src/lib/types/workers.ts

@@ -1,5 +1,4 @@
 import type { FileInfo } from "$lib/types/libav";
-import type { CobaltFileReference } from "$lib/types/storage";
 
 export const resultFileTypes = ["video", "audio", "image"] as const;
 
@@ -12,7 +11,7 @@ export type CobaltWorkerProgress = {
 }
 
 type CobaltFFmpegWorkerArgs = {
-    files: CobaltFileReference[],
+    files: File[],
     ffargs: string[],
     output: FileInfo,
 }