pwebm 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023-2025 4ndrs <andres.degozaru@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,15 @@
+# pwebm
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.0.0. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/TODO.md

@@ -0,0 +1,55 @@
+config, log ->  there has to be a way to retrieve the config dir with env variable or some api
+(socket)        similar to purewebm; have to be in ~/.config/pwebm/config, ~/.config/pwebm/log
+                the socket file (if there is any) goes to /tmp
+
+videos dir ->   use ~/Videos/pwebm for consistency as default, but make it changeable through
+                the config file ASAP, way to many webms in PureWebM to move to another dir
+
+filename   ->   use the unix timestamp with 16 digits (performance.now() + performance.timeOrigin)
+                the --name_type flag won't be ported
+
+flags      ->   -v/--version, -h/--help, --status, --kill, -i, -subs, -c:v, -ss, -to, -lavfi,
+                --size_limit/-sl, -crf, -cpu-used, -deadline, --extra_params/-ep
+
+
+some considerations:
+    - not being v1.0 permits for some leeway with breaking changes
+    - default size limit will be increased from 3 to 4
+    - if --status or --kill are used other flags will be ignored, consider maybe direct commands?
+    - current purewebm needs the start/end times in the metadata of the file to work no matter what
+      need to find a different way to get these, or at least not rely on them when they are set
+      manually
+    - it has to work with PureMPV (through pwebm-helper), tail log is nice but would be also nice
+      to have some kind of keybinding on the helper to show the status of the encoding on the mpv
+      window
+
+## Stuff
+
+- [x] argument parser
+- [x] expand tilde and $HOME in config video path
+- [x] check for ffmpeg and ffprobe in path
+- [x] convert webm, retry when limit reached
+- [x] convert any other encoder to mkv copied streams just like purewebm
+- [x] socket file for communication
+- [x] handle queue
+- [x] kill implementation
+- [x] ffmpeg progress
+- [x] status implementation
+- [x] handle signals
+- [x] name the process
+- [x] version implementation
+- [x] help implementation
+- [ ] add automatic releases with github actions (edge + tagged)
+- [ ] add bun bundled executable package releases to the automatic releases
+- [ ] update readme
+- [ ] add subs flag warning to the readme (how it works, output seeking needed, etc)
+- [ ] release tagged versions in npm
+- [ ] it's not part of this repo, but don't forget to improve the helper script for PureMPV (pwebm-helper), it has a missing readme
+
+### the following is just extra not implemented on purewebm but was its initial vision (can skip)
+- [ ] implement conversion logger view (save previous conversions to db with last bitrate info)
+- [ ] redo conversions in logger view
+- [ ] add limit for the amount of tries to redo a conversion
+- [ ] percentage bitrate offset when retrying a conversion with new calcs
+
+## 2025-03-03

package/bun.lock

@@ -0,0 +1,33 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "pwebm",
+      "dependencies": {
+        "smol-toml": "^1.3.1",
+        "zod": "^3.24.2",
+      },
+      "devDependencies": {
+        "@types/bun": "^1.2.3",
+        "typescript": "^5.7.3",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.2.3", "", { "dependencies": { "bun-types": "1.2.3" } }, "sha512-054h79ipETRfjtsCW9qJK8Ipof67Pw9bodFWmkfkaUaRiIQ1dIV2VTlheshlBx3mpKr0KeK8VqnMMCtgN9rQtw=="],
+
+    "@types/node": ["@types/node@22.13.5", "", { "dependencies": { "undici-types": "~6.20.0" } }, "sha512-+lTU0PxZXn0Dr1NBtC7Y8cR21AJr87dLLU953CWA6pMxxv/UDc7jYAY90upcrie1nRcD6XNG5HOYEDtgW5TxAg=="],
+
+    "@types/ws": ["@types/ws@8.5.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-bd/YFLW+URhBzMXurx7lWByOu+xzU9+kb3RboOteXYDfW+tr+JZa99OyNmPINEGB/ahzKrEuc8rcv4gnpJmxTw=="],
+
+    "bun-types": ["bun-types@1.2.3", "", { "dependencies": { "@types/node": "*", "@types/ws": "~8.5.10" } }, "sha512-P7AeyTseLKAvgaZqQrvp3RqFM3yN9PlcLuSTe7SoJOfZkER73mLdT2vEQi8U64S1YvM/ldcNiQjn0Sn7H9lGgg=="],
+
+    "smol-toml": ["smol-toml@1.3.1", "", {}, "sha512-tEYNll18pPKHroYSmLLrksq233j021G0giwW7P3D24jC54pQ5W5BXMsQ/Mvw1OJCmEYDgY+lrzT+3nNUtoNfXQ=="],
+
+    "typescript": ["typescript@5.7.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw=="],
+
+    "undici-types": ["undici-types@6.20.0", "", {}, "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg=="],
+
+    "zod": ["zod@3.24.2", "", {}, "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ=="],
+  }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "pwebm",
+  "version": "0.0.1-alpha.0",
+  "author": "4ndrs <andres.degozaru@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/4ndrs/pwebm.git"
+  },
+  "module": "index.ts",
+  "devDependencies": {
+    "@types/bun": "^1.2.3",
+    "typescript": "^5.7.3"
+  },
+  "$schema": "https://json.schemastore.org/package.json",
+  "bin": {
+    "pwebm": "pwebm"
+  },
+  "bugs": {
+    "url": "git+https://github.com/4ndrs/pwebm/issues"
+  },
+  "description": "Utility to encode size restricted webm files with ffmpeg",
+  "homepage": "https://github.com/4ndrs/pwebm",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "smol-toml": "^1.3.1",
+    "zod": "^3.24.2"
+  }
+}

package/pwebm

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "./src/main";

package/src/args.ts

@@ -0,0 +1,445 @@
+import {
+  AUTHOR,
+  LICENSE,
+  VERSION,
+  HOMEPAGE,
+  CLI_NAME,
+  DESCRIPTION,
+  COPYRIGHT_YEAR,
+} from "./constants";
+
+import { ipc } from "./ipc";
+import { config } from "./config";
+import { logger } from "./logger";
+import { ArgsSchema } from "./schema/args";
+
+const RECOGNIZED_ARGS = [
+  "-h",
+  "--help",
+  "-v",
+  "--version",
+  "-kill",
+  "-status",
+  "-i",
+  "-ss",
+  "-to",
+  "-lavfi",
+  "-c:v",
+  "-deadline",
+  "-crf",
+  "-cpu-used",
+  "-subs",
+  "-sl",
+  "--size-limit",
+  "-ep",
+  "--extra-params",
+  "--video-path",
+];
+
+export const parseArgs = async (args: string[]): Promise<ArgsSchema> => {
+  if (args.length === 0) {
+    printUsage();
+
+    // if the user isn't using any of the quick actions we require the -i flag
+    logger.error("Input file is required");
+
+    process.exit(1);
+  }
+
+  const rawArgs: Partial<ArgsSchema> = {};
+
+  let skip = false;
+  let isExtraParam = false;
+  let seeking: { startTime?: string; stopTime?: string } | undefined;
+
+  const skipNext = () => (skip = true);
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+
+    if (skip) {
+      skip = false;
+      continue;
+    }
+
+    if (isExtraParam) {
+      rawArgs.extraParams?.push(arg);
+      continue;
+    }
+
+    if (arg.startsWith("-") && !RECOGNIZED_ARGS.includes(arg)) {
+      printUsage();
+
+      logger.error(`Unrecognized argument: ${arg}`);
+
+      process.exit(1);
+    }
+
+    if (["-h", "--help"].includes(arg)) {
+      printUsage();
+
+      process.exit();
+    }
+
+    if (["-v", "--version"].includes(arg)) {
+      logger.info(
+        `${CLI_NAME} version ${VERSION}\nCopyright (c) ${COPYRIGHT_YEAR} ${AUTHOR}\nLicensed under the ${LICENSE} License\n${HOMEPAGE}`,
+        { onlyConsole: true },
+      );
+      process.exit();
+    }
+
+    if (arg === "-kill") {
+      try {
+        await ipc.sendMessage({ type: "kill" });
+
+        logger.info("Main instance successfully killed", {
+          logToConsole: true,
+        });
+      } catch (error) {
+        if (
+          error instanceof Error &&
+          "code" in error &&
+          error.code !== "ENOENT"
+        ) {
+          logger.error("Couldn't kill the main instance");
+        }
+
+        process.exit(1);
+      }
+
+      process.exit();
+    }
+
+    if (arg === "-status") {
+      try {
+        const status = await ipc.sendMessage({ type: "status" });
+
+        logger.info(JSON.stringify(status, null, 2), { onlyConsole: true });
+
+        logger.info("Status printed to the screen");
+      } catch (error) {
+        if (
+          error instanceof Error &&
+          "code" in error &&
+          error.code !== "ENOENT"
+        ) {
+          logger.error("Couldn't get the status of the main instance");
+        }
+
+        process.exit(1);
+      }
+
+      process.exit();
+    }
+
+    if (!arg.startsWith("-") && !arg.startsWith("--")) {
+      if (rawArgs.output?.file) {
+        logger.error("Only one output file is allowed");
+
+        logger.debug(
+          `Current output file: ${rawArgs.output.file}, new file: ${arg}`,
+        );
+
+        process.exit(1);
+      }
+
+      if (!rawArgs.output) {
+        rawArgs.output = {};
+      }
+
+      rawArgs.output.file = arg;
+
+      continue;
+    }
+
+    if (arg === "-ss") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      if (!seeking) {
+        seeking = {};
+      }
+
+      seeking.startTime = args[index + 1];
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-to") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      if (!seeking) {
+        seeking = {};
+      }
+
+      seeking.stopTime = args[index + 1];
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-i") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      if (!rawArgs.inputs) {
+        rawArgs.inputs = [];
+      }
+
+      rawArgs.inputs.push({
+        file: args[index + 1],
+        ...seeking,
+      });
+
+      seeking = undefined;
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-subs") {
+      rawArgs.subs = true;
+
+      continue;
+    }
+
+    if (arg === "-sl" || arg === "--size-limit") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      const sizeLimit = Number(args[index + 1]);
+
+      if (isNaN(sizeLimit)) {
+        logInvalidNumber(arg, sizeLimit);
+
+        process.exit(1);
+      }
+
+      rawArgs.sizeLimit = sizeLimit;
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-ep" || arg === "--extra-params") {
+      if (args[index + 1] === undefined) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      isExtraParam = true;
+
+      rawArgs.extraParams = [];
+
+      continue;
+    }
+
+    if (arg === "--video-path") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      rawArgs.videoPath = args[index + 1];
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-crf") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      const crf = Number(args[index + 1]);
+
+      if (isNaN(crf)) {
+        logInvalidNumber(arg, crf);
+
+        process.exit(1);
+      }
+
+      rawArgs.crf = crf;
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-cpu-used") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      const cpuUsed = Number(args[index + 1]);
+
+      if (isNaN(cpuUsed)) {
+        logInvalidNumber(arg, cpuUsed);
+
+        process.exit(1);
+      }
+
+      if (ArgsSchema.shape.cpuUsed.safeParse(cpuUsed).success === false) {
+        logger.error(
+          `The ${arg} flag requires a number between 0 and 5 inclusive. "${cpuUsed}" is out of that range`,
+        );
+
+        process.exit(1);
+      }
+
+      rawArgs.cpuUsed = cpuUsed as 0 | 1 | 2 | 3 | 4 | 5;
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-deadline") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      if (!["good", "best"].includes(args[index + 1])) {
+        logger.error(
+          `The ${arg} flag requires either "good" or "best". "${args[index + 1]}" is not a valid value`,
+        );
+
+        process.exit(1);
+      }
+
+      rawArgs.deadline = args[index + 1] as "good" | "best";
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-c:v") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      rawArgs.encoder = args[index + 1];
+
+      skipNext();
+
+      continue;
+    }
+
+    if (arg === "-lavfi") {
+      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
+        logMissingArg(arg);
+
+        process.exit(1);
+      }
+
+      rawArgs.lavfi = args[index + 1];
+
+      skipNext();
+
+      continue;
+    }
+  }
+
+  if (seeking) {
+    rawArgs.output = { ...rawArgs.output, ...seeking };
+
+    seeking = undefined;
+  }
+
+  const parsedArgs = ArgsSchema.safeParse(rawArgs);
+
+  if (!parsedArgs.success) {
+    logger.error("Error parsing the arguments");
+
+    logger.error(
+      JSON.stringify(parsedArgs.error.flatten().fieldErrors, null, 2),
+    );
+
+    process.exit(1);
+  }
+
+  return parsedArgs.data;
+};
+
+const logMissingArg = (arg: string) =>
+  logger.error(`The ${arg} flag requires an argument`);
+
+const logInvalidNumber = (arg: string, value: number) =>
+  logger.error(
+    `The ${arg} flag requires a number. "${value}" is not a valid number`,
+  );
+
+const printUsage = () => {
+  const usage = `Usage: ${CLI_NAME} [options] [[infile options] -i infile]... [outfile options] [outfile] [extra params]
+
+${DESCRIPTION}
+
+Positional arguments:
+  [outfile]                 The output file. If not specified, a generated unix timestamp as filename will be used
+                            and saved to the directory set in the --video-path option
+
+Options:
+  -h, --help                 Show this help message
+  -v, --version              Show version information
+  -kill                      Terminate the running ${CLI_NAME} instance, if there is any
+  -status                    Show the current status
+  -i <input>                 The input file to encode
+  -ss <start_time>           The start time (same as ffmpeg's -ss)
+  -to <stop_time>            The stop time (same as ffmpeg's -to)
+  -lavfi <filters>           The set of filters to pass to ffmpeg
+  -c:v <encoder>             The video encoder to use (default is ${config.encoder})
+  -deadline {good,best}      The deadline for libvpx-vp9; good is the recommended one, best has the best
+                             compression efficiency but takes the most time (default is ${config.deadline})
+  -crf <value>               The crf to use (default is 24)
+  -cpu-used {0,1,2,3,4,5}    The cpu-used for libvpx-vp9; a number between 0 and 5 inclusive, the higher
+                             the number the faster the encoding will be with a quality trade-off (default is ${config.cpuUsed})
+  -subs                      Burn the subtitles onto the output file; this flag will automatically use
+                             the subtitles found in the first input file, to use a different file use
+                             the -lavfi flag with the subtitles filter directly
+  -sl, --size-limit <limit>  The size limit of the output file in MiB, use 0 for no limit (default is ${config.sizeLimit})
+  --video-path <path>        The video path where the video files are stored (default is ${config.videoPath})
+                             this is overridden if the output file is specified
+  -ep, --extra-params <params>
+                             The extra parameters to pass to ffmpeg, these will be appended making it
+                             possible to override some defaults. This option has to be the last one, everything
+                             will be passed as is to ffmpeg
+
+Examples:
+  ${CLI_NAME} -i "/tmp/Videos/nijinosaki.mkv" -ss 00:00:02.268 -to 00:00:10.310 
+  ${CLI_NAME} -i "/tmp/Videos/nijinosaki.mkv" --size-limit 6 -subs --extra-params -map 0:a -c:a libopus -b:a 128k`;
+
+  logger.info(usage, {
+    onlyConsole: true,
+  });
+};

package/src/config.ts

@@ -0,0 +1,49 @@
+import path from "path";
+
+import { parse } from "smol-toml";
+import { logger } from "./logger";
+import { CONFIG_PATH } from "./paths";
+import { ConfigSchema } from "./schema/config";
+import { CONFIG_FILE_NAME } from "./constants";
+import { existsSync, readFileSync } from "fs";
+
+const configPath = path.join(CONFIG_PATH, CONFIG_FILE_NAME);
+
+let rawConfig: unknown = {};
+
+if (existsSync(configPath)) {
+  logger.info("Loading config file " + configPath);
+
+  try {
+    rawConfig = parse(readFileSync(configPath, "utf-8"));
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(
+        "Error parsing the config file " + configPath + ":\n\n" + error.message,
+      );
+
+      process.exit(1);
+    }
+
+    throw error;
+  }
+}
+
+const parsedConfig = ConfigSchema.safeParse(rawConfig);
+
+if (!parsedConfig.success) {
+  logger.error("Error parsing the config file " + configPath);
+
+  const errors = parsedConfig.error.flatten().fieldErrors;
+
+  for (const key in errors) {
+    logger.error(
+      `Error in option "${key}": ` +
+        errors[key as keyof typeof errors]?.join("; "),
+    );
+  }
+
+  process.exit(1);
+}
+
+export const config = parsedConfig.data;

package/src/constants.ts

@@ -0,0 +1,15 @@
+import packageJson from "../package.json";
+
+export const CLI_NAME = packageJson.bin.pwebm;
+export const LOG_FILE_NAME = CLI_NAME + ".log";
+export const CONFIG_FILE_NAME = "config.toml";
+
+export const PIPE_NAME = "\\\\.\\pipe\\" + CLI_NAME; // Named pipe for Windows
+export const SOCKET_NAME = CLI_NAME + ".sock";
+
+export const AUTHOR = packageJson.author;
+export const VERSION = packageJson.version;
+export const LICENSE = packageJson.license;
+export const HOMEPAGE = packageJson.homepage;
+export const DESCRIPTION = packageJson.description;
+export const COPYRIGHT_YEAR = "2023-2025";