292 lines
26 KiB
JavaScript
292 lines
26 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
|
|
// src/index.ts
|
|
var src_exports = {};
|
|
__export(src_exports, {
|
|
FFmpeg: () => FFmpeg,
|
|
changeFFmpegFlags: () => changeFFmpegFlags,
|
|
createFFmpegArgs: () => createFFmpegArgs,
|
|
version: () => version
|
|
});
|
|
module.exports = __toCommonJS(src_exports);
|
|
|
|
// src/FFmpeg.ts
|
|
var import_node_child_process = require("child_process");
|
|
var import_node_stream = require("stream");
|
|
var VERSION_REGEX = /version (.+) Copyright/im;
|
|
var validatePathParam = /* @__PURE__ */ __name((path, displayName) => {
|
|
if (!path) throw new Error(`Failed to resolve ${displayName}`);
|
|
return path;
|
|
}, "validatePathParam");
|
|
var _FFmpeg = class _FFmpeg extends import_node_stream.Duplex {
|
|
/**
|
|
* Create FFmpeg duplex stream
|
|
* @param options Options to initialize ffmpeg
|
|
* @example ```typescript
|
|
* const ffmpeg = new FFmpeg({
|
|
* args: [
|
|
* '-analyzeduration', '0',
|
|
* '-loglevel', '0',
|
|
* '-f', 's16le',
|
|
* '-ar', '48000',
|
|
* '-ac', '2',
|
|
* '-af', 'bass=g=10,acompressor'
|
|
* ]
|
|
* });
|
|
*
|
|
* const pcm = input.pipe(ffmpeg);
|
|
*
|
|
* pcm.pipe(fs.createWriteStream('./audio.pcm'));
|
|
* ```
|
|
*/
|
|
constructor(options = {}) {
|
|
super(options);
|
|
/**
|
|
* Current FFmpeg process
|
|
*/
|
|
__publicField(this, "process");
|
|
this.process = _FFmpeg.spawn(options);
|
|
const EVENTS = {
|
|
readable: this._reader,
|
|
data: this._reader,
|
|
end: this._reader,
|
|
unpipe: this._reader,
|
|
finish: this._writer,
|
|
drain: this._writer
|
|
};
|
|
this._readableState = this._reader._readableState;
|
|
this._writableState = this._writer._writableState;
|
|
this._copy(["write", "end"], this._writer);
|
|
this._copy(["read", "setEncoding", "pipe", "unpipe"], this._reader);
|
|
for (const method of [
|
|
"on",
|
|
"once",
|
|
"removeListener",
|
|
"removeAllListeners",
|
|
"listeners"
|
|
]) {
|
|
this[method] = (ev, fn) => (
|
|
// @ts-expect-error
|
|
EVENTS[ev] ? (
|
|
// @ts-expect-error
|
|
EVENTS[ev][method](ev, fn)
|
|
) : (
|
|
// @ts-expect-error
|
|
import_node_stream.Duplex.prototype[method].call(this, ev, fn)
|
|
)
|
|
);
|
|
}
|
|
const processError = /* @__PURE__ */ __name((error) => this.emit("error", error), "processError");
|
|
this._reader.on("error", processError);
|
|
this._writer.on("error", processError);
|
|
}
|
|
/**
|
|
* Checks if FFmpeg is loaded.
|
|
*/
|
|
static isLoaded() {
|
|
return _FFmpeg.cached != null;
|
|
}
|
|
/**
|
|
* Adds a new FFmpeg source.
|
|
* @param source FFmpeg source
|
|
*/
|
|
static addSource(source) {
|
|
if (_FFmpeg.sources.some((s) => s.name === source.name)) return false;
|
|
_FFmpeg.sources.push(source);
|
|
return true;
|
|
}
|
|
/**
|
|
* Removes a FFmpeg source.
|
|
* @param source FFmpeg source
|
|
*/
|
|
static removeSource(source) {
|
|
const index = _FFmpeg.sources.findIndex((s) => s.name === source.name);
|
|
if (index === -1) return false;
|
|
_FFmpeg.sources.splice(index, 1);
|
|
return true;
|
|
}
|
|
/**
|
|
* Resolves FFmpeg path. Throws an error if it fails to resolve.
|
|
* @param force if it should relocate the command
|
|
*/
|
|
static resolve(force = false) {
|
|
if (!force && _FFmpeg.cached) return _FFmpeg.cached;
|
|
const errors = [];
|
|
for (const source of _FFmpeg.sources) {
|
|
try {
|
|
let path;
|
|
if (source.module) {
|
|
const mod = require(source.name);
|
|
path = validatePathParam(
|
|
mod.default?.path || mod.path || mod,
|
|
source.name
|
|
);
|
|
} else {
|
|
path = source.name;
|
|
}
|
|
const result = (0, import_node_child_process.spawnSync)(path, ["-v"], { windowsHide: true });
|
|
const resolved = {
|
|
result: result.stdout.toString(),
|
|
command: path,
|
|
module: source.module,
|
|
name: source.name,
|
|
path,
|
|
version: VERSION_REGEX.exec(result.stderr.toString())?.[1] ?? "unknown"
|
|
};
|
|
_FFmpeg.cached = resolved;
|
|
errors.length = 0;
|
|
return resolved;
|
|
} catch (e) {
|
|
const err = e && e instanceof Error ? e.message : `${e}`;
|
|
const msg = `Failed to load ffmpeg using ${source.module ? `require('${source.name}')` : `spawn('${source.name}')`}. Error: ${err}`;
|
|
errors.push(msg);
|
|
}
|
|
}
|
|
throw new Error(`Could not load ffmpeg. Errors:
|
|
${errors.join("\n")}`);
|
|
}
|
|
/**
|
|
* Resolves FFmpeg path safely. Returns null if it fails to resolve.
|
|
* @param force if it should relocate the command
|
|
*/
|
|
static resolveSafe(force = false) {
|
|
try {
|
|
return _FFmpeg.resolve(force);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
/**
|
|
* Spawns ffmpeg process
|
|
* @param options Spawn options
|
|
*/
|
|
static spawn({ args = [], shell = false } = {}) {
|
|
if (!args.includes("-i")) args.unshift("-i", "-");
|
|
return (0, import_node_child_process.spawn)(_FFmpeg.resolve().command, args.concat(["pipe:1"]), {
|
|
windowsHide: true,
|
|
shell
|
|
});
|
|
}
|
|
get _reader() {
|
|
return this.process.stdout;
|
|
}
|
|
get _writer() {
|
|
return this.process.stdin;
|
|
}
|
|
_copy(methods, target) {
|
|
for (const method of methods) {
|
|
this[method] = target[method].bind(target);
|
|
}
|
|
}
|
|
_destroy(err, cb) {
|
|
this._cleanup();
|
|
if (cb) return cb(err);
|
|
}
|
|
_final(cb) {
|
|
this._cleanup();
|
|
cb();
|
|
}
|
|
_cleanup() {
|
|
if (this.process) {
|
|
this.once("error", () => {
|
|
});
|
|
this.process.kill("SIGKILL");
|
|
this.process = null;
|
|
}
|
|
}
|
|
};
|
|
__name(_FFmpeg, "FFmpeg");
|
|
/**
|
|
* Cached FFmpeg source.
|
|
*/
|
|
__publicField(_FFmpeg, "cached", null);
|
|
/**
|
|
* Supported FFmpeg sources.
|
|
*/
|
|
__publicField(_FFmpeg, "sources", [
|
|
// paths
|
|
{ name: "ffmpeg", module: false },
|
|
{ name: "./ffmpeg", module: false },
|
|
{ name: "avconv", module: false },
|
|
{ name: "./avconv", module: false },
|
|
// modules
|
|
{ name: "ffmpeg-static", module: true },
|
|
{ name: "@ffmpeg-installer/ffmpeg", module: true },
|
|
{ name: "@node-ffmpeg/node-ffmpeg-installer", module: true },
|
|
{ name: "ffmpeg-binaries", module: true }
|
|
]);
|
|
var FFmpeg = _FFmpeg;
|
|
|
|
// src/common.ts
|
|
function changeFFmpegFlags(oldFlags, newFlags) {
|
|
const updatedFlags = [...oldFlags];
|
|
for (let i = 0; i < newFlags.length; i++) {
|
|
const key = newFlags[i];
|
|
const value = newFlags[i + 1];
|
|
const oldIndex = updatedFlags.indexOf(key);
|
|
if (oldIndex !== -1) {
|
|
if (value && !value.startsWith("-")) {
|
|
updatedFlags[oldIndex + 1] = value;
|
|
i++;
|
|
} else {
|
|
updatedFlags.splice(oldIndex, 1);
|
|
}
|
|
} else {
|
|
if (value && !value.startsWith("-")) {
|
|
updatedFlags.push(key, value);
|
|
i++;
|
|
} else {
|
|
updatedFlags.push(key);
|
|
}
|
|
}
|
|
}
|
|
return updatedFlags;
|
|
}
|
|
__name(changeFFmpegFlags, "changeFFmpegFlags");
|
|
|
|
// src/version.ts
|
|
var version = (
|
|
/* @__MACRO__ getVersion */
|
|
"7.2.0"
|
|
);
|
|
|
|
// src/index.ts
|
|
var createFFmpegArgs = /* @__PURE__ */ __name((input, post) => {
|
|
const args = [];
|
|
for (const [key, value] of Object.entries(input)) {
|
|
if (value == null) continue;
|
|
args.push(`-${key}`, String(value));
|
|
}
|
|
if (post) {
|
|
Array.isArray(post) ? args.push(...post) : args.push(post);
|
|
}
|
|
return args;
|
|
}, "createFFmpegArgs");
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
FFmpeg,
|
|
changeFFmpegFlags,
|
|
createFFmpegArgs,
|
|
version
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/FFmpeg.ts", "../src/common.ts", "../src/version.ts"],
  "sourcesContent": ["export * from './FFmpeg';\n\nexport type ArgPrimitive = string | number | null;\n\n/**\n * Create FFmpeg arguments from an object.\n * @param input The input object.\n * @param post Additional arguments to append.\n * @returns The FFmpeg arguments.\n * @example createFFmpegArgs({ i: 'input.mp3', af: ['bass=g=10','acompressor'] }, './out.mp3');\n * // => ['-i', 'input.mp3', '-af', 'bass=g=10,acompressor', './out.mp3']\n */\nexport const createFFmpegArgs = (\ninput: Record<string, ArgPrimitive | ArgPrimitive[]>,\npost?: string | string[])\n: string[] => {\n  const args = [];\n\n  for (const [key, value] of Object.entries(input)) {\n    if (value == null) continue;\n    args.push(`-${key}`, String(value));\n  }\n\n  if (post) {\n    Array.isArray(post) ? args.push(...post) : args.push(post);\n  }\n\n  return args;\n};\n\nexport * from './common';\nexport { version } from './version';", "import {\n  ChildProcessWithoutNullStreams,\n  spawn,\n  spawnSync } from\n'node:child_process';\nimport { Duplex, DuplexOptions } from 'node:stream';\nimport { FFmpegCallback, FFmpegSource, ResolvedFFmpegSource } from './common';\n\nexport interface FFmpegOptions extends DuplexOptions {\n  args?: string[];\n  shell?: boolean;\n}\n\nconst VERSION_REGEX = /version (.+) Copyright/im;\n\nconst validatePathParam = (path: string, displayName: string) => {\n  if (!path) throw new Error(`Failed to resolve ${displayName}`);\n  return path;\n};\n\nexport class FFmpeg extends Duplex {\n  /**\n   * Cached FFmpeg source.\n   */\n  private static cached: ResolvedFFmpegSource | null = null;\n  /**\n   * Supported FFmpeg sources.\n   */\n  public static sources: FFmpegSource[] = [\n  // paths\n  { name: 'ffmpeg', module: false },\n  { name: './ffmpeg', module: false },\n  { name: 'avconv', module: false },\n  { name: './avconv', module: false },\n  // modules\n  { name: 'ffmpeg-static', module: true },\n  { name: '@ffmpeg-installer/ffmpeg', module: true },\n  { name: '@node-ffmpeg/node-ffmpeg-installer', module: true },\n  { name: 'ffmpeg-binaries', module: true }];\n\n\n  /**\n   * Checks if FFmpeg is loaded.\n   */\n  public static isLoaded() {\n    return FFmpeg.cached != null;\n  }\n\n  /**\n   * Adds a new FFmpeg source.\n   * @param source FFmpeg source\n   */\n  public static addSource(source: FFmpegSource) {\n    if (FFmpeg.sources.some((s) => s.name === source.name)) return false;\n    FFmpeg.sources.push(source);\n    return true;\n  }\n\n  /**\n   * Removes a FFmpeg source.\n   * @param source FFmpeg source\n   */\n  public static removeSource(source: FFmpegSource) {\n    const index = FFmpeg.sources.findIndex((s) => s.name === source.name);\n    if (index === -1) return false;\n    FFmpeg.sources.splice(index, 1);\n    return true;\n  }\n\n  /**\n   * Resolves FFmpeg path. Throws an error if it fails to resolve.\n   * @param force if it should relocate the command\n   */\n  public static resolve(force = false) {\n    if (!force && FFmpeg.cached) return FFmpeg.cached;\n\n    const errors: string[] = [];\n\n    for (const source of FFmpeg.sources) {\n      try {\n        let path: string;\n\n        if (source.module) {\n          // eslint-disable-next-line @typescript-eslint/no-var-requires\n          const mod = require(source.name);\n          path = validatePathParam(\n            mod.default?.path || mod.path || mod,\n            source.name\n          );\n        } else {\n          path = source.name;\n        }\n\n        const result = spawnSync(path, ['-v'], { windowsHide: true });\n\n        const resolved: ResolvedFFmpegSource = {\n          result: result.stdout.toString(),\n          command: path,\n          module: source.module,\n          name: source.name,\n          path,\n          version:\n          VERSION_REGEX.exec(result.stderr.toString())?.[1] ?? 'unknown'\n        };\n\n        FFmpeg.cached = resolved;\n\n        errors.length = 0;\n\n        return resolved;\n      } catch (e) {\n        const err = e && e instanceof Error ? e.message : `${e}`;\n        const msg = `Failed to load ffmpeg using ${\n        source.module ?\n        `require('${source.name}')` :\n        `spawn('${source.name}')`}. Error: ${\n        err}`;\n\n        errors.push(msg);\n      }\n    }\n\n    throw new Error(`Could not load ffmpeg. Errors:\\n${errors.join('\\n')}`);\n  }\n\n  /**\n   * Resolves FFmpeg path safely. Returns null if it fails to resolve.\n   * @param force if it should relocate the command\n   */\n  public static resolveSafe(force = false) {\n    try {\n      return FFmpeg.resolve(force);\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Spawns ffmpeg process\n   * @param options Spawn options\n   */\n  public static spawn({ args = [] as string[], shell = false } = {}) {\n    if (!args.includes('-i')) args.unshift('-i', '-');\n    return spawn(FFmpeg.resolve().command, args.concat(['pipe:1']), {\n      windowsHide: true,\n      shell\n    });\n  }\n\n  /**\n   * Current FFmpeg process\n   */\n  public process: ChildProcessWithoutNullStreams;\n\n  /**\n   * Create FFmpeg duplex stream\n   * @param options Options to initialize ffmpeg\n   * @example ```typescript\n   * const ffmpeg = new FFmpeg({\n   *   args: [\n   *     '-analyzeduration', '0',\n   *     '-loglevel', '0',\n   *     '-f', 's16le',\n   *     '-ar', '48000',\n   *     '-ac', '2',\n   *     '-af', 'bass=g=10,acompressor'\n   *   ]\n   * });\n   *\n   * const pcm = input.pipe(ffmpeg);\n   *\n   * pcm.pipe(fs.createWriteStream('./audio.pcm'));\n   * ```\n   */\n  public constructor(options: FFmpegOptions = {}) {\n    super(options);\n\n    this.process = FFmpeg.spawn(options);\n\n    const EVENTS = {\n      readable: this._reader,\n      data: this._reader,\n      end: this._reader,\n      unpipe: this._reader,\n      finish: this._writer,\n      drain: this._writer\n    } as const;\n\n    // @ts-expect-error\n    this._readableState = this._reader._readableState;\n    // @ts-expect-error\n    this._writableState = this._writer._writableState;\n\n    this._copy(['write', 'end'], this._writer);\n    this._copy(['read', 'setEncoding', 'pipe', 'unpipe'], this._reader);\n\n    for (const method of [\n    'on',\n    'once',\n    'removeListener',\n    'removeAllListeners',\n    'listeners'] as\n    const) {\n      // @ts-expect-error\n      this[method] = (ev, fn) =>\n      // @ts-expect-error\n      EVENTS[ev] ?\n      // @ts-expect-error\n      EVENTS[ev][method](ev, fn) :\n      // @ts-expect-error\n      Duplex.prototype[method].call(this, ev, fn);\n    }\n\n    const processError = (error: Error) => this.emit('error', error);\n\n    this._reader.on('error', processError);\n    this._writer.on('error', processError);\n  }\n\n  get _reader() {\n    return this.process!.stdout;\n  }\n  get _writer() {\n    return this.process!.stdin;\n  }\n\n  private _copy(methods: string[], target: unknown) {\n    for (const method of methods) {\n      // @ts-expect-error\n      this[method] = target[method].bind(target);\n    }\n  }\n\n  public _destroy(err: Error | null, cb: FFmpegCallback<[Error | null]>) {\n    this._cleanup();\n    if (cb) return cb(err);\n  }\n\n  public _final(cb: FFmpegCallback<[]>) {\n    this._cleanup();\n    cb();\n  }\n\n  private _cleanup() {\n    if (this.process) {\n      this.once('error', () => {\n\n        //\n      });this.process.kill('SIGKILL');\n      this.process = null as unknown as ChildProcessWithoutNullStreams;\n    }\n  }\n}", "export type FFmpegLib =\n'ffmpeg' |\n'./ffmpeg' |\n'avconv' |\n'./avconv' |\n'ffmpeg-static' |\n'@ffmpeg-installer/ffmpeg' |\n'@node-ffmpeg/node-ffmpeg-installer' |\n'ffmpeg-binaries';\n\nexport type FFmpegCallback<Args extends Array<unknown>> = (\n...args: Args)\n=> unknown;\n\n/**\n * FFmpeg source configuration\n */\nexport interface FFmpegSource {\n  /** Name or path of the FFmpeg executable */\n  name: FFmpegLib;\n  /** Whether this source is a Node.js module */\n  module: boolean;\n}\n\nexport interface ResolvedFFmpegSource extends FFmpegSource {\n  path: string;\n  version: string;\n  command: string;\n  result: string;\n}\n\n/**\n * Compares and updates FFmpeg flags as needed\n * @param oldFlags The old flags\n * @param newFlags The new flags\n * @returns The updated flags\n */\nexport function changeFFmpegFlags(oldFlags: string[], newFlags: string[]) {\n  const updatedFlags = [...oldFlags];\n\n  for (let i = 0; i < newFlags.length; i++) {\n    const key = newFlags[i];\n    const value = newFlags[i + 1];\n\n    const oldIndex = updatedFlags.indexOf(key);\n\n    if (oldIndex !== -1) {\n      if (value && !value.startsWith('-')) {\n        updatedFlags[oldIndex + 1] = value;\n        i++;\n      } else {\n        updatedFlags.splice(oldIndex, 1);\n      }\n    } else {\n      if (value && !value.startsWith('-')) {\n        updatedFlags.push(key, value);\n        i++;\n      } else {\n        updatedFlags.push(key);\n      }\n    }\n  }\n\n  return updatedFlags;\n}", "\n\n\n\n\n\nexport const version = /* @__MACRO__ getVersion */\"7.2.0\";"],
  "mappings": "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",
  "names": []
}

|