pwebm 0.0.1-alpha.0

package/src/ipc.ts

@@ -0,0 +1,182 @@
+import os from "os";
+import path from "path";
+
+import { queue } from "./queue";
+import { status } from "./status";
+import { logger } from "./logger";
+import { TEMP_PATH } from "./paths";
+import { unlinkSync } from "fs";
+import { assertNever } from "./utils";
+import { PIPE_NAME, SOCKET_NAME } from "./constants";
+import { IPCSchema, ResponseSchema } from "./schema/ipc";
+
+import type { StatusSchema } from "./schema/status";
+import type { UnixSocketListener } from "bun";
+
+// windows doesn't have unix sockets but named pipes
+const SOCKET_FILE =
+  os.platform() === "win32" ? PIPE_NAME : path.join(TEMP_PATH, SOCKET_NAME);
+
+let listener: UnixSocketListener<undefined> | undefined;
+
+const startListener = () => {
+  if (listener) {
+    logger.warn("Listener already started");
+    return;
+  }
+
+  logger.info("Listening for connections on " + SOCKET_FILE);
+
+  listener = Bun.listen({
+    unix: SOCKET_FILE,
+    socket: {
+      data: async (socket, rawData) => {
+        const parsedData = IPCSchema.safeParse(JSON.parse(rawData.toString()));
+
+        if (!parsedData.success) {
+          logger.warn("Invalid data received through the socket. Ignoring...");
+
+          socket.end();
+
+          return;
+        }
+
+        const { type, data } = parsedData.data;
+
+        switch (type) {
+          case "kill":
+            logger.info("Received kill signal, aborting the queue");
+
+            await queue.abortProcessing();
+
+            socket.end(
+              JSON.stringify({
+                type: "kill",
+                success: true,
+              } satisfies ResponseSchema),
+            );
+
+            break;
+          case "enqueue":
+            logger.info(
+              "Received new encoding parameters, adding to the queue",
+            );
+
+            queue.push(data);
+
+            socket.end(
+              JSON.stringify({
+                type: "enqueue",
+                success: true,
+              } satisfies ResponseSchema),
+            );
+            break;
+          case "status":
+            logger.info("Received status request, sending the current status");
+
+            socket.end(
+              JSON.stringify({
+                type: "status",
+                success: true,
+                data: status.getStatus(),
+              } satisfies ResponseSchema),
+            );
+            break;
+          default:
+            assertNever(type);
+        }
+
+        socket.end();
+      },
+    },
+  });
+};
+
+const stopListener = () => {
+  if (!listener) {
+    return;
+  }
+
+  listener.stop();
+  listener = undefined;
+
+  // cleanup socket file if not on windows
+  if (os.platform() !== "win32") {
+    try {
+      logger.info("Deleting the socket file: " + SOCKET_FILE);
+
+      unlinkSync(SOCKET_FILE);
+    } catch (error) {
+      logger.error("Error deleting socket file: " + SOCKET_FILE);
+
+      logger.error(
+        error instanceof Error ? error.message : JSON.stringify(error, null, 2),
+      );
+    }
+  }
+};
+
+// overloading
+type SendMessage = {
+  (message: Exclude<IPCSchema, { type: "status" }>): Promise<void>;
+  (message: Extract<IPCSchema, { type: "status" }>): Promise<StatusSchema>;
+};
+
+const sendMessage: SendMessage = async (message) =>
+  new Promise(async (resolve, reject) => {
+    try {
+      const socket = await Bun.connect({
+        unix: SOCKET_FILE,
+        socket: {
+          data: (socket, rawData) => {
+            socket.end();
+
+            const parsedData = ResponseSchema.safeParse(
+              JSON.parse(rawData.toString()),
+            );
+
+            if (!parsedData.success) {
+              // couldn't parse
+              logger.error("Invalid response received through the socket");
+
+              return reject();
+            }
+
+            if (!parsedData.data.success) {
+              // request did not succeed
+              return reject();
+            }
+
+            if (parsedData.data.type === "status") {
+              const { data } = parsedData.data;
+
+              return resolve(data);
+            }
+
+            return resolve(undefined as void & StatusSchema);
+          },
+        },
+      });
+
+      socket.write(JSON.stringify(message));
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT" &&
+        message.type !== "enqueue"
+      ) {
+        logger.info("No current main instance running", {
+          logToConsole: true,
+        });
+      }
+
+      reject(error);
+    }
+  });
+
+export const ipc = {
+  sendMessage,
+  stopListener,
+  startListener,
+};

package/src/logger.ts

@@ -0,0 +1,131 @@
+import os from "os";
+import path from "path";
+
+import { CONFIG_PATH } from "./paths";
+import { CLI_NAME, LOG_FILE_NAME } from "./constants";
+import { existsSync, mkdirSync, appendFileSync } from "fs";
+
+type Level = "INFO" | "ERROR" | "WARN" | "DEBUG";
+
+const LEVELS_FOR_CONSOLE: Level[] = ["ERROR"];
+
+const logFile = path.join(CONFIG_PATH, LOG_FILE_NAME);
+
+if (!existsSync(CONFIG_PATH)) {
+  mkdirSync(CONFIG_PATH, { recursive: true });
+}
+
+const writeToFile = (message: string, level: Level) => {
+  const now = new Date();
+  const day = String(now.getDate()).padStart(2, "0");
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const milliseconds = String(now.getMilliseconds()).padStart(3, "0");
+
+  const timestamp = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+  const logMessage = `${timestamp} ${os.hostname()} ${CLI_NAME}[${process.pid}]: ${level}: ${message}\n`;
+
+  appendFileSync(logFile, logMessage, "utf-8");
+};
+
+const COLORS = {
+  RED: "\u001b[1;91m",
+  BLUE: "\u001b[1;94m",
+  GREEN: "\u001b[1;92m",
+  YELLOW: "\u001b[1;93m",
+  ORANGE: "\u001b[1;38;5;208m",
+};
+
+const END_COLOR = "\u001b[0m";
+const CLEAR_LINE = "\r\u001b[K";
+
+type Options = {
+  onlyConsole?: boolean; // only logs to console regardless of the allowed level
+  logToConsole?: boolean; // logs to console regardless of the allowed level
+  fancyConsole?: {
+    colors?: boolean;
+    noNewLine?: boolean;
+    clearPreviousLine?: boolean;
+  };
+};
+
+type Message = Parameters<typeof print>[0];
+
+const log = (message: Message, level: Level, options?: Options) => {
+  let consoleLog: typeof console.log;
+
+  const skipNewLine = options?.fancyConsole?.noNewLine;
+
+  switch (level) {
+    case "INFO":
+      consoleLog = (message: string) => print(message, "stdout", skipNewLine);
+      break;
+    case "WARN":
+      message = `{ORANGE}${message}{/ORANGE}`;
+      consoleLog = (message: string) => print(message, "stderr", skipNewLine);
+      break;
+    case "ERROR":
+      message = `{RED}${message}{/RED}`;
+      consoleLog = (message: string) => print(message, "stderr", skipNewLine);
+      break;
+    case "DEBUG":
+      consoleLog = (message: string) => print(message, "stdout", skipNewLine);
+      break;
+  }
+
+  if (options?.fancyConsole?.colors || level === "ERROR" || level === "WARN") {
+    Object.keys(COLORS).forEach((color) => {
+      const endColorRegex = new RegExp(`\\{\/${color}\\}`, "g");
+      const startColorRegex = new RegExp(`\\{${color}\\}`, "g");
+
+      message = message.replace(
+        startColorRegex,
+        COLORS[color as keyof typeof COLORS],
+      );
+
+      message = message.replace(endColorRegex, END_COLOR);
+    });
+  }
+
+  // i don't want the following in the log file
+  let consoleMessage = message;
+
+  if (options?.fancyConsole?.clearPreviousLine) {
+    consoleMessage = CLEAR_LINE + message;
+  }
+
+  if (options?.onlyConsole) {
+    consoleLog(consoleMessage);
+    return;
+  }
+
+  if (LEVELS_FOR_CONSOLE.includes(level) || options?.logToConsole) {
+    consoleLog(consoleMessage);
+  }
+
+  writeToFile(message, level);
+};
+
+const print = (
+  message: string,
+  output: "stdout" | "stderr",
+  skipNewLine?: boolean,
+) => {
+  const newLine = skipNewLine ? "" : "\n";
+
+  process[output].write(message + newLine);
+};
+
+export const logger: {
+  [key in Lowercase<Level>]: (message: Message, options?: Options) => void;
+} = {
+  info: (message, options) => log(message, "INFO", options),
+  warn: (message, options) => log(message, "WARN", options),
+  error: (message, options) => log(message, "ERROR", options),
+  debug: (message, options) => log(message, "DEBUG", options),
+};
+
+logger.info("Started");

package/src/main.ts

@@ -0,0 +1,86 @@
+import { ipc } from "./ipc";
+import { queue } from "./queue";
+import { logger } from "./logger";
+import { CLI_NAME } from "./constants";
+import { parseArgs } from "./args";
+
+process.title = CLI_NAME;
+
+process.on("SIGINT", () => {
+  logger.warn("Received SIGINT, aborting processing");
+  queue.abortProcessing();
+});
+
+process.on("SIGTERM", () => {
+  logger.warn("Received SIGTERM, aborting processing");
+  queue.abortProcessing();
+});
+
+process.on("SIGHUP", () => {
+  logger.warn("Received SIGHUP, aborting processing");
+  queue.abortProcessing();
+});
+
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught exception: " + error.message);
+  queue.abortProcessing();
+});
+
+const args = Bun.argv.slice(2);
+
+logger.info("argv: " + args.join(" "));
+
+const parsedArgs = await parseArgs(args);
+
+// let's check if ffmpeg and ffprobe are available before encoding anything
+try {
+  const ffmpegProcess = Bun.spawnSync(["ffmpeg", "-hide_banner", "-version"]);
+
+  if (!ffmpegProcess.success) {
+    throw new Error(ffmpegProcess.stderr.toString());
+  }
+} catch (error) {
+  logger.error(
+    "Error checking ffmpeg executable" +
+      (error instanceof Error ? `: ${error.message}` : ""),
+  );
+
+  process.exit(1);
+}
+
+try {
+  const ffprobeProcess = Bun.spawnSync(["ffprobe", "-hide_banner", "-version"]);
+
+  if (!ffprobeProcess.success) {
+    throw new Error(ffprobeProcess.stderr.toString());
+  }
+} catch (error) {
+  logger.error(
+    "Error checking ffprobe executable" +
+      (error instanceof Error ? `: ${error.message}` : ""),
+  );
+
+  process.exit(1);
+}
+
+try {
+  // try sending the args to the running process if there is one
+  await ipc.sendMessage({
+    type: "enqueue",
+    data: parsedArgs,
+  });
+
+  logger.info("Sent the encoding parameters to the already running instance", {
+    logToConsole: true,
+  });
+} catch (error) {
+  logger.warn("No running instance found, starting a new queue");
+
+  queue.push(parsedArgs);
+
+  ipc.startListener();
+
+  await queue.processQueue();
+
+  ipc.stopListener();
+}

package/src/paths.ts

@@ -0,0 +1,44 @@
+import os from "os";
+import path from "path";
+
+import { CLI_NAME } from "./constants";
+
+const home = os.homedir();
+
+const tempPath = path.join(os.tmpdir());
+const configPath = path.join(home, ".config", CLI_NAME);
+
+let videoPath: string;
+let nullDevicePath: string;
+
+switch (os.platform()) {
+  case "darwin":
+    nullDevicePath = "/dev/null";
+    videoPath = path.join(home, "Movies", CLI_NAME);
+    break;
+  case "win32":
+    nullDevicePath = "NUL";
+    videoPath = path.join(home, "Videos", CLI_NAME);
+    break;
+  case "linux":
+  default:
+    nullDevicePath = "/dev/null";
+    videoPath = path.join(home, "Videos", CLI_NAME);
+}
+
+export const expandHome = <T extends string | undefined>(value: T) => {
+  if (value?.startsWith("~")) {
+    return value.replace("~", home);
+  }
+
+  if (value?.startsWith("$HOME")) {
+    return value.replace("$HOME", home);
+  }
+
+  return value;
+};
+
+export const TEMP_PATH = tempPath;
+export const CONFIG_PATH = configPath;
+export const DEFAULT_VIDEO_PATH = videoPath;
+export const NULL_DEVICE_PATH = nullDevicePath;

package/src/queue.ts

@@ -0,0 +1,68 @@
+import { ffmpeg } from "./ffmpeg";
+import { ArgsSchema } from "./schema/args";
+import { setTimeout } from "timers/promises";
+
+const store: {
+  total: number;
+  abort: boolean;
+  queue: ArgsSchema[];
+  processing: boolean;
+} = {
+  total: 0,
+  queue: [],
+  abort: false,
+  processing: false,
+};
+
+const push = (args: ArgsSchema) => {
+  store.queue.push(args);
+  store.total++;
+};
+
+const abortProcessing = async () => {
+  store.abort = true;
+
+  ffmpeg.kill();
+
+  while (store.processing) {
+    await setTimeout(100);
+  }
+};
+
+const processQueue = async () => {
+  if (store.processing) {
+    return;
+  }
+
+  store.processing = true;
+
+  while (getProcessedCount() < store.total) {
+    const current = store.queue.shift();
+
+    if (!current) {
+      continue;
+    }
+
+    await ffmpeg.encode(current);
+
+    if (store.abort) {
+      break;
+    }
+  }
+
+  store.abort = false;
+  store.processing = false;
+};
+
+const getTotalCount = () => store.total;
+const getProcessedCount = () => store.total - store.queue.length;
+const getStatus = () => `Encoding ${getProcessedCount()} of ${store.total}`;
+
+export const queue = {
+  push,
+  getStatus,
+  processQueue,
+  getTotalCount,
+  abortProcessing,
+  getProcessedCount,
+};

package/src/schema/args.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { config } from "../config";
+import { expandHome } from "../paths";
+import { ConfigSchema } from "./config";
+
+export const ArgsSchema = ConfigSchema.merge(
+  z.object({
+    inputs: z.array(
+      z.object({
+        file: z.string().transform(expandHome),
+        stopTime: z.string().optional(),
+        startTime: z.string().optional(),
+      }),
+    ),
+    output: z
+      .object({
+        file: z.string().optional().transform(expandHome),
+        stopTime: z.string().optional(),
+        startTime: z.string().optional(),
+      })
+      .optional(),
+    lavfi: z.string().optional(),
+    extraParams: z.array(z.string()).optional(),
+    // the next ones come from the config schema
+    // we are just replacing the defaults with the values loaded from the config file
+    crf: ConfigSchema.shape.crf.default(config.crf),
+    subs: ConfigSchema.shape.subs.default(config.subs),
+    encoder: ConfigSchema.shape.encoder.default(config.encoder),
+    cpuUsed: ConfigSchema.shape.cpuUsed.default(config.cpuUsed),
+    deadline: ConfigSchema.shape.deadline.default(config.deadline),
+    sizeLimit: ConfigSchema.shape.sizeLimit.default(config.sizeLimit),
+    videoPath: ConfigSchema.shape.videoPath.default(config.videoPath),
+  }),
+);
+
+export type ArgsSchema = z.infer<typeof ArgsSchema>;

package/src/schema/config.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { DEFAULT_VIDEO_PATH, expandHome } from "../paths";
+
+export const ConfigSchema = z.object({
+  subs: z.boolean().default(false),
+  encoder: z.string().default("libvpx-vp9"),
+  sizeLimit: z.number().default(4),
+  crf: z.number().default(24),
+  cpuUsed: z
+    .union([
+      z.literal(0),
+      z.literal(1),
+      z.literal(2),
+      z.literal(3),
+      z.literal(4),
+      z.literal(5),
+    ])
+    .default(0),
+  deadline: z.enum(["good", "best"]).default("good"),
+  videoPath: z.string().default(DEFAULT_VIDEO_PATH).transform(expandHome),
+});
+
+export type ConfigSchema = z.infer<typeof ConfigSchema>;

package/src/schema/ffmpeg.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const ProgressSchema = z
+  .object({
+    progress: z.union([z.literal("continue"), z.literal("end")]),
+    total_size: z
+      .string()
+      .transform(Number)
+      .refine((value) => !isNaN(value), { message: "Invalid number" }),
+    out_time_us: z
+      .string()
+      .transform(Number)
+      .refine((value) => !isNaN(value), { message: "Invalid number" }),
+  })
+  .transform((data) => ({
+    outTime: data.out_time_us / 1_000_000, // seconds
+    progress: data.progress,
+    totalSize: data.total_size, // bytes
+  }));
+
+export type ProgressSchema = z.infer<typeof ProgressSchema>;

package/src/schema/ffprobe.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+
+const Format = z.object({
+  format_name: z.string(),
+  format_long_name: z.string(),
+  size: z.string().transform(Number),
+  duration: z.string().transform(Number),
+  start_time: z.string(),
+});
+
+const Stream = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+});
+
+const Video = Stream.extend({
+  codec_type: z.literal("video"),
+  width: z.number(),
+  height: z.number(),
+  pix_fmt: z.string(),
+  start_time: z.string().optional(),
+  duration: z.string().transform(Number).optional(),
+});
+
+const Audio = Stream.extend({
+  codec_type: z.literal("audio"),
+  start_time: z.string().optional(),
+  duration: z.string().transform(Number).optional(),
+});
+
+const Subtitle = Stream.extend({
+  codec_type: z.literal("subtitle"),
+});
+
+const Attachment = Stream.merge(
+  z.object({
+    codec_type: z.literal("attachment"),
+    codec_name: Stream.shape.codec_name.optional(),
+    codec_long_name: Stream.shape.codec_long_name.optional(),
+  }),
+);
+
+const Data = Stream.merge(
+  z.object({
+    codec_type: z.literal("data"),
+    codec_name: Stream.shape.codec_name.optional(),
+    codec_long_name: Stream.shape.codec_long_name.optional(),
+  }),
+);
+
+export const FFProbeSchema = z.object({
+  format: Format,
+  streams: z.array(z.union([Video, Audio, Subtitle, Attachment, Data])),
+});
+
+export type FFProbeSchema = z.infer<typeof FFProbeSchema>;

package/src/schema/ipc.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { ArgsSchema } from "./args";
+import { StatusSchema } from "./status";
+
+const KillRequest = z.object({
+  type: z.literal("kill"),
+  data: z.undefined(),
+});
+
+const StatusRequest = z.object({
+  type: z.literal("status"),
+  data: z.undefined(),
+});
+
+const EnqueueRequest = z.object({
+  type: z.literal("enqueue"),
+  data: ArgsSchema,
+});
+
+const SimpleResponse = z.object({
+  type: z.union([z.literal("enqueue"), z.literal("kill")]),
+  success: z.boolean(),
+});
+
+const StatusOKResponse = z.object({
+  type: z.literal("status"),
+  data: StatusSchema,
+  success: z.literal(true),
+});
+
+const StatusFAILResponse = z.object({
+  type: z.literal("status"),
+  data: z.undefined(),
+  success: z.literal(false),
+});
+
+const StatusResponse = z.union([StatusOKResponse, StatusFAILResponse]);
+
+export const IPCSchema = z.union([KillRequest, StatusRequest, EnqueueRequest]);
+export const ResponseSchema = z.union([SimpleResponse, StatusResponse]);
+
+export type IPCSchema = z.infer<typeof IPCSchema>;
+export type ResponseSchema = z.infer<typeof ResponseSchema>;