m4k 0.1.2 → 0.2.1

package/README.md

@@ -3,27 +3,41 @@
 A media conversion toolkit based on [ffmpeg](https://ffmpeg.org/) and [sharp](https://sharp.pixelplumbing.com/)/[libvips](https://github.com/libvips/libvips).
 It provides queueing and progress reporting via async iterables.
 
+The API is unified for audio, images and videos.
+
 ## Usage
 
-Image optimization happens completely in memory.
+### Processing audio
+
+```ts
+import { processAudio, ProcessedFile } from "m4k";
+// input is a file path or an async iterable of Uint8Arrays or a Blob
+for await (const value of processAudio(input, opts)) {
+  if (value instanceof ProcessedFile) {
+    // do something with the file
+  }
+}
+```
+
+### Processing images
 
 ```ts
-import { optimizeImage, ConvertedFile } from "m4k";
-// input is a ReadableStream or Blob
-for await (const value of optimizeImage(input, opts)) {
-  if (value instanceof ConvertedFile) {
+import { processImage, ProcessedFile } from "m4k";
+// input is a file path or an async iterable of Uint8Arrays or a Blob
+for await (const value of processImage(input, opts)) {
+  if (value instanceof ProcessedFile) {
     // do something with the file
   }
 }
 ```
 
-For lower memory usage, video optimization happens with files.
+### Processing videos
 
 ```ts
-import { optimizeVideo, ConvertedFile } from "m4k";
-// input is a file path
-for await (const value of optimizeVideo(input, opts)) {
-  if (value instanceof ConvertedFile) {
+import { processVideo, ProcessedFile } from "m4k";
+// input is a file path or an async iterable of Uint8Arrays or a Blob
+for await (const value of processVideo(input, opts)) {
+  if (value instanceof ProcessedFile) {
     // do something with the file
   }
 }

package/lib/audio/audio-processor.d.ts

@@ -0,0 +1,20 @@
+import { type AudioOptions } from "@m4k/common";
+/**
+ * Process a video.
+ * @param input - The input video. Can be a file path, a stream or a blob.
+ * @param opts - The options for the video processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed videos.
+ */
+export declare function processAudio(input: string | AsyncIterable<Uint8Array> | Blob, opts: AudioOptions, { signal }?: {
+    signal?: AbortSignal;
+}): AsyncGenerator<import("@m4k/common").ProcessedFile | {
+    progress: number;
+} | {
+    position: number;
+}, void, unknown> | null;
+/**
+ * The queue for video processing.
+ */
+export declare const audioQueue: import("tasque").Tasque;
+//# sourceMappingURL=audio-processor.d.ts.map

package/lib/audio/audio-processor.js

@@ -0,0 +1,47 @@
+import {} from "@m4k/common";
+import { mkdir } from "node:fs/promises";
+import { createQueue } from "tasque";
+import { processFfmpeg } from "../util/ffmpeg-processor";
+/**
+ * Process a video.
+ * @param input - The input video. Can be a file path, a stream or a blob.
+ * @param opts - The options for the video processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed videos.
+ */
+export function processAudio(input, opts, { signal } = {}) {
+    return processFfmpeg(input, () => {
+        const inArgs = [];
+        if (opts.inputFormat)
+            inArgs.push("-f", opts.inputFormat);
+        if (opts.seek)
+            inArgs.push("-ss", opts.seek.toString());
+        if (opts.duration)
+            inArgs.push("-t", opts.duration.toString());
+        const outArgs = [];
+        if (opts.format)
+            outArgs.push("-f", opts.format);
+        if (opts.bitrate)
+            outArgs.push("-b:a", opts.bitrate.toString());
+        if (opts.filters)
+            outArgs.push("-af", opts.filters);
+        if (opts.complexFilters)
+            outArgs.push("-filter_complex", opts.complexFilters);
+        outArgs.push("-c:a", opts.codec ?? "copy");
+        return {
+            input: inArgs,
+            out: outArgs,
+            format: opts.format ?? "mp4",
+        };
+    }, { signal, queue: audioQueue, tmpDir });
+}
+/**
+ * The queue for video processing.
+ */
+export const audioQueue = createQueue({
+    parallelize: Number(process.env.AUDIO_PARALLELIZE ?? 1),
+    max: Number(process.env.AUDIO_QUEUE_SIZE ?? 5),
+});
+const tmpDir = `${process.env.M4K_TMP_DIR ?? "/tmp/m4k"}/audio`;
+await mkdir(tmpDir, { recursive: true });
+//# sourceMappingURL=audio-processor.js.map

package/lib/images/image-processor.d.ts

@@ -0,0 +1,22 @@
+import { type ImageOptions, ProcessedFile } from "@m4k/common";
+export type Format = Required<ImageOptions>["format"];
+export type Fit = Required<Required<ImageOptions>["resize"]>["fit"];
+/**
+ * Process an image.
+ * @param input - The input image. Can be a file path, a stream or a blob.
+ * @param opts - The options for the image processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed images.
+ */
+export declare function processImage(input: string | AsyncIterable<Uint8Array> | Blob, opts: ImageOptions | ImageOptions[], { signal }?: {
+    signal?: AbortSignal;
+}): AsyncGenerator<ProcessedFile | {
+    progress: number;
+} | {
+    position: number;
+}, void, unknown> | null;
+/**
+ * The queue for image processing.
+ */
+export declare const imageQueue: import("tasque").Tasque;
+//# sourceMappingURL=image-processor.d.ts.map

package/lib/images/{image-optimizer.js → image-processor.js}

@@ -1,13 +1,25 @@
-import { ConvertedFile } from "@m4k/common";
+import { ProcessedFile } from "@m4k/common";
+import { createReadStream } from "node:fs";
 import sharp from "sharp";
 import { createQueue } from "tasque";
-import { readableFromWeb, readableToWeb } from "../util/streams";
-export function optimizeImage(input, opts, signal) {
+import { exhaustAsyncIterableToWritable } from "../util/streams";
+/**
+ * Process an image.
+ * @param input - The input image. Can be a file path, a stream or a blob.
+ * @param opts - The options for the image processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed images.
+ */
+export function processImage(input, opts, { signal } = {}) {
     const sharpInstance = sharp();
     const iterable = imageQueue.iterate(async function* () {
         opts = Array.isArray(opts) ? opts : [opts];
-        readableFromWeb("stream" in input ? input.stream() : input).pipe(sharpInstance);
-        const files = await Promise.all(opts.map(async ({ colorspace, crop, format = "avif", keepExif, keepIcc, keepMetadata, quality, resize, rotate, }, idx) => {
+        void exhaustAsyncIterableToWritable(typeof input === "string"
+            ? createReadStream(input)
+            : "stream" in input
+                ? input.stream()
+                : input, sharpInstance);
+        const files = opts.map(async ({ colorspace, crop, format = "avif", keepExif, keepIcc, keepMetadata, quality, resize, rotate, }, idx) => {
             let s = sharpInstance.clone();
             s = s.rotate(rotate);
             if (resize)
@@ -31,12 +43,12 @@ export function optimizeImage(input, opts, signal) {
                 });
             }
             s = s.toFormat(format, { quality });
-            return new ConvertedFile(`file${idx + 1}.${format}`, `image/${format}`, readableToWeb(s));
-        }));
+            return new ProcessedFile(`file${idx + 1}.${format}`, `image/${format}`, s);
+        });
         let done = 0;
         yield { progress: 0 };
         for (const file of files) {
-            yield file;
+            yield await file;
             done++;
             yield { progress: Math.round((done / files.length) * 100) };
         }
@@ -52,8 +64,11 @@ export function optimizeImage(input, opts, signal) {
         }
     })();
 }
+/**
+ * The queue for image processing.
+ */
 export const imageQueue = createQueue({
     parallelize: Number(process.env.IMAGE_PARALLELIZE ?? 5),
     max: Number(process.env.IMAGE_QUEUE_SIZE ?? 100),
 });
-//# sourceMappingURL=image-optimizer.js.map
+//# sourceMappingURL=image-processor.js.map

package/lib/index.d.ts

@@ -1,4 +1,6 @@
 export * from "@m4k/common";
-export { imageQueue, optimizeImage } from "./images/image-optimizer";
-export { getExtension, optimizeVideo, tmpVideoDir, videoQueue } from "./videos/video-optimizer";
+export { audioQueue, processAudio } from "./audio/audio-processor";
+export { imageQueue, processImage } from "./images/image-processor";
+export { getExtension } from "./util/ffmpeg-processor";
+export { processVideo, videoQueue } from "./videos/video-processor";
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,4 +1,6 @@
 export * from "@m4k/common";
-export { imageQueue, optimizeImage } from "./images/image-optimizer";
-export { getExtension, optimizeVideo, tmpVideoDir, videoQueue } from "./videos/video-optimizer";
+export { audioQueue, processAudio } from "./audio/audio-processor";
+export { imageQueue, processImage } from "./images/image-processor";
+export { getExtension } from "./util/ffmpeg-processor";
+export { processVideo, videoQueue } from "./videos/video-processor";
 //# sourceMappingURL=index.js.map

package/lib/util/ffmpeg-processor.d.ts

@@ -0,0 +1,30 @@
+import { ProcessedFile } from "@m4k/common";
+import { type Tasque } from "tasque";
+/**
+ * Process a video.
+ * @param input - The input video. Can be a file path, a stream or a blob.
+ * @param opts - The options for the video processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed videos.
+ */
+export declare function processFfmpeg(input: string | AsyncIterable<Uint8Array> | Blob, buildArgs: () => {
+    input: string[];
+    out: string[];
+    format: string;
+}, { signal, queue, tmpDir, }: {
+    signal?: AbortSignal;
+    queue: Tasque;
+    tmpDir: string;
+}): AsyncGenerator<ProcessedFile | {
+    progress: number;
+} | {
+    position: number;
+}, void, unknown> | null;
+/**
+ * Get the extension for a given format.
+ * May not be complete yet. Most of the time, the format will be the same as the extension.
+ * @param format - The format to get the extension for.
+ * @returns The extension for the given format.
+ */
+export declare function getExtension(format: string): string;
+//# sourceMappingURL=ffmpeg-processor.d.ts.map

package/lib/{videos/video-optimizer.js → util/ffmpeg-processor.js}

@@ -1,45 +1,31 @@
-import { ConvertedFile } from "@m4k/common";
+import { ProcessedFile } from "@m4k/common";
 import { spawn } from "node:child_process";
 import { getRandomValues } from "node:crypto";
-import { mkdir, rm } from "node:fs/promises";
-import { createQueue } from "tasque";
+import { createWriteStream } from "node:fs";
+import { rm } from "node:fs/promises";
+import {} from "tasque";
 import { mimeTypes } from "../util/mime";
-export function optimizeVideo(inputPath, opts, signal) {
-    const iterable = videoQueue.iterate(async function* () {
-        await mkdir(tmpVideoDir, { recursive: true });
-        const outputPath = `${tmpVideoDir}/out-${Buffer.from(getRandomValues(new Uint8Array(16))).toString("base64url")}.${getExtension(opts.format ?? "mp4")}`;
-        const inArgs = [];
-        if (opts.inputFormat)
-            inArgs.push("-f", opts.inputFormat);
-        if (opts.seek)
-            inArgs.push("-ss", opts.seek.toString());
-        if (opts.duration)
-            inArgs.push("-t", opts.duration.toString());
-        const outArgs = [];
-        if (opts.format)
-            outArgs.push("-f", opts.format);
-        if (opts.audioBitrate)
-            outArgs.push("-b:a", opts.audioBitrate.toString());
-        if (opts.videoBitrate)
-            outArgs.push("-b:v", opts.videoBitrate.toString());
-        if (opts.audioFilters)
-            outArgs.push("-af", opts.audioFilters);
-        if (opts.videoFilters)
-            outArgs.push("-vf", opts.videoFilters);
-        if (opts.complexFilters)
-            outArgs.push("-filter_complex", opts.complexFilters);
-        if (opts.aspect)
-            outArgs.push("-aspect", opts.aspect.toString());
-        if (opts.pad)
-            outArgs.push("-pad", opts.pad);
-        if (opts.fps)
-            outArgs.push("-r", opts.fps.toString());
-        if (opts.size)
-            outArgs.push("-scale", opts.size);
-        outArgs.push("-c:v", opts.videoCodec ?? "copy");
-        outArgs.push("-c:a", opts.audioCodec ?? "copy");
+import { exhaustAsyncIterableToWritable } from "../util/streams";
+/**
+ * Process a video.
+ * @param input - The input video. Can be a file path, a stream or a blob.
+ * @param opts - The options for the video processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed videos.
+ */
+export function processFfmpeg(input, buildArgs, { signal, queue, tmpDir, }) {
+    const id = randomId();
+    const inputPath = typeof input === "string" ? input : createTmp(tmpDir, id, input);
+    const iterable = queue.iterate(async function* () {
+        const { input: inArgs, out: outArgs, format } = buildArgs();
+        const outputPath = `${tmpDir}/out-${id}.${getExtension(format)}`;
         try {
-            const child = spawn(ffmpeg, ["-y", ...inArgs, "-i", inputPath, ...outArgs, outputPath], { stdio: ["pipe", "pipe", "pipe"], signal });
+            signal?.throwIfAborted();
+            const p = await inputPath;
+            signal?.throwIfAborted();
+            const child = spawn(ffmpeg, ["-y", ...inArgs, "-i", p, ...outArgs, outputPath], { stdio: ["pipe", "pipe", "pipe"] });
+            // Use manual abort handling to avoid some uncatchable error, at least in bun.
+            signal?.addEventListener("abort", () => child.kill());
             const decoder = new TextDecoder();
             let metadataStr = "";
             let duration = null;
@@ -77,12 +63,19 @@ export function optimizeVideo(inputPath, opts, signal) {
             if (code !== 0) {
                 throw new Error(`ffmpeg exited with code ${code}: ${errStr}`);
             }
-            yield new ConvertedFile(outputPath, mimeTypes[opts.format ?? "mp4"]);
+            yield new ProcessedFile(outputPath, mimeTypes[format]);
+        }
+        catch (e) {
+            signal?.throwIfAborted();
+            throw e;
         }
         finally {
             await rm(outputPath, { force: true });
+            if (typeof inputPath !== "string") {
+                await rm(await inputPath, { force: true });
+            }
         }
-    }, signal);
+    });
     if (!iterable)
         return null;
     return (async function* () {
@@ -103,11 +96,15 @@ export function optimizeVideo(inputPath, opts, signal) {
 export function getExtension(format) {
     return extMap[format] ?? format;
 }
-export const videoQueue = createQueue({
-    parallelize: Number(process.env.VIDEO_PARALLELIZE ?? 1),
-    max: Number(process.env.VIDEO_QUEUE_SIZE ?? 5),
-});
-export const tmpVideoDir = `${process.env.TMP_DIR ?? "/tmp"}/videos`;
+async function createTmp(tmpDir, id, input) {
+    const filePath = `${tmpDir}/in-${id}`;
+    const writer = createWriteStream(filePath);
+    await exhaustAsyncIterableToWritable("stream" in input ? input.stream() : input, writer);
+    return filePath;
+}
+function randomId() {
+    return Buffer.from(getRandomValues(new Uint8Array(16))).toString("base64url");
+}
 function parseDuration(metadataStr) {
     const match = metadataStr.match(/Duration: (\d+:\d+:\d+\.\d+)/);
     if (!match)
@@ -122,4 +119,4 @@ const ffmpeg = process.env.FFMPEG_PATH ?? (await import("@ffmpeg-installer/ffmpe
 const extMap = {
     matroska: "mkv",
 };
-//# sourceMappingURL=video-optimizer.js.map
+//# sourceMappingURL=ffmpeg-processor.js.map

package/lib/util/streams.d.ts

@@ -1,4 +1,3 @@
-import { Readable } from "node:stream";
-export declare function readableFromWeb(stream: ReadableStream): Readable;
-export declare function readableToWeb(stream: Readable): ReadableStream & AsyncIterable<Uint8Array>;
+import type { Writable } from "stream";
+export declare function exhaustAsyncIterableToWritable(it: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
 //# sourceMappingURL=streams.d.ts.map

package/lib/util/streams.js

@@ -1,9 +1,9 @@
-import { Readable } from "node:stream";
-export function readableFromWeb(stream) {
-    // Currently node types don't match with TS lib types for ReadableStream, so we need to cast to any.
-    return Readable.fromWeb(stream);
-}
-export function readableToWeb(stream) {
-    return Readable.toWeb(stream);
+export async function exhaustAsyncIterableToWritable(it, writable) {
+    for await (const chunk of it) {
+        if (!writable.write(chunk))
+            await new Promise((resolve) => writable.once("drain", resolve));
+    }
+    writable.end();
+    await new Promise((resolve) => writable.on("finish", resolve));
 }
 //# sourceMappingURL=streams.js.map

package/lib/videos/video-processor.d.ts

@@ -0,0 +1,20 @@
+import { type VideoOptions } from "@m4k/common";
+/**
+ * Process a video.
+ * @param input - The input video. Can be a file path, a stream or a blob.
+ * @param opts - The options for the video processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed videos.
+ */
+export declare function processVideo(input: string | AsyncIterable<Uint8Array> | Blob, opts: VideoOptions, { signal }?: {
+    signal?: AbortSignal;
+}): AsyncGenerator<import("@m4k/common").ProcessedFile | {
+    progress: number;
+} | {
+    position: number;
+}, void, unknown> | null;
+/**
+ * The queue for video processing.
+ */
+export declare const videoQueue: import("tasque").Tasque;
+//# sourceMappingURL=video-processor.d.ts.map

package/lib/videos/video-processor.js

@@ -0,0 +1,60 @@
+import {} from "@m4k/common";
+import { mkdir } from "node:fs/promises";
+import { createQueue } from "tasque";
+import { processFfmpeg } from "../util/ffmpeg-processor";
+/**
+ * Process a video.
+ * @param input - The input video. Can be a file path, a stream or a blob.
+ * @param opts - The options for the video processing.
+ * @param signal - An optional abort signal.
+ * @returns An iterable of the processed videos.
+ */
+export function processVideo(input, opts, { signal } = {}) {
+    return processFfmpeg(input, () => {
+        const inArgs = [];
+        if (opts.inputFormat)
+            inArgs.push("-f", opts.inputFormat);
+        if (opts.seek)
+            inArgs.push("-ss", opts.seek.toString());
+        if (opts.duration)
+            inArgs.push("-t", opts.duration.toString());
+        const outArgs = [];
+        if (opts.format)
+            outArgs.push("-f", opts.format);
+        if (opts.audioBitrate)
+            outArgs.push("-b:a", opts.audioBitrate.toString());
+        if (opts.videoBitrate)
+            outArgs.push("-b:v", opts.videoBitrate.toString());
+        if (opts.audioFilters)
+            outArgs.push("-af", opts.audioFilters);
+        if (opts.videoFilters)
+            outArgs.push("-vf", opts.videoFilters);
+        if (opts.complexFilters)
+            outArgs.push("-filter_complex", opts.complexFilters);
+        if (opts.aspect)
+            outArgs.push("-aspect", opts.aspect.toString());
+        if (opts.pad)
+            outArgs.push("-pad", opts.pad);
+        if (opts.fps)
+            outArgs.push("-r", opts.fps.toString());
+        if (opts.size)
+            outArgs.push("-scale", opts.size);
+        outArgs.push("-c:v", opts.videoCodec ?? "copy");
+        outArgs.push("-c:a", opts.audioCodec ?? "copy");
+        return {
+            input: inArgs,
+            out: outArgs,
+            format: opts.format ?? "mp4",
+        };
+    }, { signal, queue: videoQueue, tmpDir });
+}
+/**
+ * The queue for video processing.
+ */
+export const videoQueue = createQueue({
+    parallelize: Number(process.env.VIDEO_PARALLELIZE ?? 1),
+    max: Number(process.env.VIDEO_QUEUE_SIZE ?? 5),
+});
+const tmpDir = `${process.env.M4K_TMP_DIR ?? "/tmp/m4k"}/video`;
+await mkdir(tmpDir, { recursive: true });
+//# sourceMappingURL=video-processor.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m4k",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/lib/images/image-optimizer.d.ts

@@ -1,10 +0,0 @@
-import { type ImageOptimizerOptions, ConvertedFile } from "@m4k/common";
-export type Format = Required<ImageOptimizerOptions>["format"];
-export type Fit = Required<Required<ImageOptimizerOptions>["resize"]>["fit"];
-export declare function optimizeImage(input: ReadableStream | Blob, opts: ImageOptimizerOptions | ImageOptimizerOptions[], signal?: AbortSignal): AsyncGenerator<ConvertedFile | {
-    progress: number;
-} | {
-    position: number;
-}, void, unknown> | null;
-export declare const imageQueue: import("tasque").Tasque;
-//# sourceMappingURL=image-optimizer.d.ts.map

package/lib/videos/video-optimizer.d.ts

@@ -1,16 +0,0 @@
-import { ConvertedFile, type VideoOptimizerOptions } from "@m4k/common";
-export declare function optimizeVideo(inputPath: string, opts: VideoOptimizerOptions, signal?: AbortSignal): AsyncGenerator<ConvertedFile | {
-    progress: number;
-} | {
-    position: number;
-}, void, unknown> | null;
-/**
- * Get the extension for a given format.
- * May not be complete yet. Most of the time, the format will be the same as the extension.
- * @param format - The format to get the extension for.
- * @returns The extension for the given format.
- */
-export declare function getExtension(format: string): string;
-export declare const videoQueue: import("tasque").Tasque;
-export declare const tmpVideoDir: string;
-//# sourceMappingURL=video-optimizer.d.ts.map