m4k 0.3.2 → 0.3.4

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to `m4k` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.4]
+
+### Changed
+
+- Updated the Sharp peer dependency to `0.35.3`.
+- Updated the TypeScript development dependency.

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

@@ -1,4 +1,6 @@
 import { type ImageOptions, ProcessedFile } from "@m4k/common";
+import { ffmpeg } from "../util/ffmpeg-processor.js";
+export { ffmpeg };
 export type Format = Required<ImageOptions>["format"];
 export type Fit = Required<Required<ImageOptions>["resize"]>["fit"];
 /**

package/lib/images/image-processor.js

@@ -1,8 +1,13 @@
-import { ProcessedFile } from "@m4k/common";
+import { ProcessedFile, isImageNoOp } from "@m4k/common";
+import { spawn } from "node:child_process";
 import { createReadStream } from "node:fs";
+import { readFile, rm } from "node:fs/promises";
 import sharp from "sharp";
 import { createQueue } from "tasque";
+import { ffmpeg, createTmp, randomId } from "../util/ffmpeg-processor.js";
 import { exhaustAsyncIterableToWritable } from "../util/streams.js";
+export { ffmpeg };
+const imageTmpDir = `${process.env.M4K_TMP_DIR ?? "/tmp/m4k"}/image`;
 /**
  * Process an image.
  * @param input - The input image. Can be a file path, a stream or a blob.
@@ -11,46 +16,32 @@ import { exhaustAsyncIterableToWritable } from "../util/streams.js";
  * @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];
-        void exhaustAsyncIterableToWritable(typeof input === "string"
-            ? createReadStream(input)
-            : "stream" in input
-                ? input.stream()
-                : input, sharpInstance);
-        const files = opts.map(async ({ colorspace, crop, format = "avif", ext = format, keepExif, keepIcc, keepMetadata, quality, resize, rotate, }, idx) => {
-            let s = sharpInstance.clone();
-            s = s.rotate(rotate);
-            if (resize)
-                s = s.resize({
-                    ...resize,
-                    fit: resize.fit ?? "inside",
-                });
-            if (keepMetadata)
-                s = s.keepMetadata();
-            if (keepExif)
-                s = s.keepExif();
-            if (keepIcc)
-                s = s.keepIccProfile();
-            if (colorspace)
-                s = s.toColorspace(colorspace);
-            if (crop) {
-                s = s.extract({
-                    ...crop,
-                    left: crop.left ?? 0,
-                    top: crop.top ?? 0,
-                });
+        const optsArr = Array.isArray(opts) ? opts : [opts];
+        const resolvedInput = await resolveInput(input);
+        const inputExt = detectExt(resolvedInput);
+        if (inputExt != null && optsArr.every((o) => isImageNoOp(o, inputExt))) {
+            yield { progress: 0 };
+            const bytes = await toBytes(resolvedInput);
+            for (let i = 0; i < optsArr.length; i++) {
+                const ext = optsArr[i].ext ?? optsArr[i].format ?? inputExt;
+                yield new ProcessedFile(`file${i + 1}.${ext}`, `image/${ext}`, toAsyncIterable(bytes));
+                yield { progress: Math.round(((i + 1) / optsArr.length) * 100) };
             }
-            s = s.toFormat(ext, { quality });
-            return new ProcessedFile(`file${idx + 1}.${ext}`, `image/${ext}`, s);
-        });
-        let done = 0;
+            return;
+        }
+        let files;
+        try {
+            files = await runSharp(resolvedInput, optsArr);
+        }
+        catch {
+            const png = await ffmpegDecodeToPng(resolvedInput);
+            files = await runSharp(png, optsArr);
+        }
         yield { progress: 0 };
-        for (const file of files) {
-            yield await file;
-            done++;
-            yield { progress: Math.round((done / files.length) * 100) };
+        for (let i = 0; i < files.length; i++) {
+            yield files[i];
+            yield { progress: Math.round(((i + 1) / files.length) * 100) };
         }
     }, signal);
     if (!iterable)
@@ -71,4 +62,125 @@ export const imageQueue = createQueue({
     parallelize: Number(process.env.IMAGE_PARALLELIZE ?? 5),
     max: Number(process.env.IMAGE_QUEUE_SIZE ?? 100),
 });
+async function runSharp(input, opts) {
+    const sharpInstance = sharp();
+    void exhaustAsyncIterableToWritable(toSharpInput(input), sharpInstance);
+    return Promise.all(opts.map(async ({ colorspace, crop, format = "avif", ext = format, keepExif, keepIcc, keepMetadata, quality, resize, rotate, }, idx) => {
+        let s = sharpInstance.clone();
+        s = s.rotate(rotate);
+        if (resize)
+            s = s.resize({
+                ...resize,
+                fit: resize.fit ?? "inside",
+            });
+        if (keepMetadata)
+            s = s.keepMetadata();
+        if (keepExif)
+            s = s.keepExif();
+        if (keepIcc)
+            s = s.keepIccProfile();
+        if (colorspace)
+            s = s.toColorspace(colorspace);
+        if (crop) {
+            s = s.extract({
+                ...crop,
+                left: crop.left ?? 0,
+                top: crop.top ?? 0,
+            });
+        }
+        s = s.toFormat(ext, { quality });
+        const buf = await s.toBuffer();
+        return new ProcessedFile(`file${idx + 1}.${ext}`, `image/${ext}`, toAsyncIterable(buf));
+    }));
+}
+async function ffmpegDecodeToPng(input) {
+    const { mkdir } = await import("node:fs/promises");
+    await mkdir(imageTmpDir, { recursive: true });
+    const id = randomId();
+    const outPath = `${imageTmpDir}/out-${id}.png`;
+    const inputPath = typeof input === "string"
+        ? input
+        : await createTmp(imageTmpDir, id, input instanceof Buffer ? toAsyncIterable(input) : input);
+    try {
+        await new Promise((resolve, reject) => {
+            const child = spawn(ffmpeg, ["-y", "-i", inputPath, "-update", "1", "-frames:v", "1", outPath], {
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            let errStr = "";
+            child.stderr.on("data", (chunk) => { errStr += chunk.toString(); });
+            child.on("close", (code) => {
+                if (code !== 0)
+                    reject(new Error(`ffmpeg exited with code ${code}: ${errStr}`));
+                else
+                    resolve();
+            });
+        });
+        return await readFile(outPath);
+    }
+    finally {
+        await rm(outPath, { force: true });
+        if (typeof input !== "string")
+            await rm(inputPath, { force: true });
+    }
+}
+async function resolveInput(input) {
+    if (typeof input === "string" || "stream" in input)
+        return input;
+    const chunks = [];
+    for await (const chunk of input)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
+async function toBytes(input) {
+    if (input instanceof Buffer)
+        return input;
+    if (typeof input === "string")
+        return readFile(input);
+    const blob = input;
+    return Buffer.from(await blob.arrayBuffer());
+}
+function toSharpInput(input) {
+    if (typeof input === "string")
+        return createReadStream(input);
+    if ("stream" in input)
+        return input.stream();
+    return toAsyncIterable(input);
+}
+// eslint-disable-next-line typescript/require-await
+async function* toAsyncIterable(buf) {
+    yield new Uint8Array(buf instanceof Buffer ? buf : buf);
+}
+function detectExt(input) {
+    if (typeof input === "string") {
+        const dot = input.lastIndexOf(".");
+        return dot !== -1 ? input.slice(dot + 1).toLowerCase() : null;
+    }
+    if ("type" in input && input.type) {
+        const mime = input.type;
+        if (mime === "image/avif" || mime === "image/heif")
+            return "avif";
+        const slash = mime.lastIndexOf("/");
+        return slash !== -1 ? mime.slice(slash + 1).toLowerCase() : null;
+    }
+    if (input instanceof Buffer && input.byteLength >= 12) {
+        if (input[0] === 0xff && input[1] === 0xd8)
+            return "jpeg";
+        if (input[0] === 0x89 && input[1] === 0x50 && input[2] === 0x4e && input[3] === 0x47)
+            return "png";
+        if (input[0] === 0x47 && input[1] === 0x49 && input[2] === 0x46)
+            return "gif";
+        if (input[0] === 0x52 && input[1] === 0x49 && input[2] === 0x46 && input[3] === 0x46 &&
+            input[8] === 0x57 && input[9] === 0x45 && input[10] === 0x42 && input[11] === 0x50)
+            return "webp";
+        // AVIF/HEIF: ftyp box at offset 4, brand at offset 8
+        if (input[4] === 0x66 && input[5] === 0x74 && input[6] === 0x79 && input[7] === 0x70) {
+            const brand = input.slice(8, 12).toString("ascii");
+            if (brand.startsWith("avif") || brand.startsWith("avis"))
+                return "avif";
+            if (brand.startsWith("heic") || brand.startsWith("heix") || brand.startsWith("mif1"))
+                return "heif";
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=image-processor.js.map

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

@@ -26,4 +26,8 @@ export declare function processFfmpeg(input: string | AsyncIterable<Uint8Array>
  * @returns The extension for the given format.
  */
 export declare function getExtension(format: string): string;
+declare function createTmp(tmpDir: string, id: string, input: AsyncIterable<Uint8Array<ArrayBufferLike>> | Blob): Promise<string>;
+declare function randomId(): string;
+export declare const ffmpeg: string;
+export { createTmp, randomId };
 //# sourceMappingURL=ffmpeg-processor.d.ts.map

package/lib/util/ffmpeg-processor.js

@@ -128,7 +128,8 @@ function durationToMs(duration) {
     const [, hours, minutes, seconds, centiseconds] = duration.match(/(\d+):(\d+):(\d+)\.(\d+)/)?.map(Number) ?? [];
     return (((hours * 60 + minutes) * 60 + seconds) * 100 + centiseconds) * 10;
 }
-const ffmpeg = process.env.FFMPEG_PATH ?? (await import("@ffmpeg-installer/ffmpeg")).path;
+export const ffmpeg = process.env.FFMPEG_PATH ?? (await import("@ffmpeg-installer/ffmpeg")).path;
+export { createTmp, randomId };
 const extMap = {
     matroska: "mkv",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m4k",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Media toolkit for node, bun, and deno",
   "keywords": [
     "audio",
@@ -33,14 +33,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@m4k/common": "^0.2.6"
+    "@m4k/common": "^0.2.8"
   },
   "devDependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "tasque": "^0.1.2",
-    "typescript": "^6.0.2"
+    "typescript": "^7.0.2"
   },
   "peerDependencies": {
-    "sharp": "^0.34.5"
+    "sharp": "^0.35.3"
   }
 }