@editframe/assets 0.16.7-beta.0 → 0.17.6-beta.0

package/dist/Probe.js

@@ -1,313 +1,285 @@
+import debug from "debug";
 import { exec, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { createReadStream } from "node:fs";
-import * as z from "zod";
-import debug from "debug";
+import * as z$1 from "zod";
 const execPromise = promisify(exec);
 const log = debug("ef:assets:probe");
-const AudioStreamSchema = z.object({
-  index: z.number(),
-  codec_name: z.string(),
-  codec_long_name: z.string(),
-  codec_type: z.literal("audio"),
-  codec_tag_string: z.string(),
-  codec_tag: z.string(),
-  sample_fmt: z.string(),
-  sample_rate: z.string(),
-  channels: z.number(),
-  channel_layout: z.string().optional(),
-  bits_per_sample: z.number(),
-  initial_padding: z.number().optional(),
-  r_frame_rate: z.string(),
-  avg_frame_rate: z.string(),
-  time_base: z.string(),
-  start_pts: z.number().optional(),
-  start_time: z.coerce.number().optional(),
-  duration_ts: z.number(),
-  duration: z.coerce.number(),
-  bit_rate: z.string(),
-  disposition: z.record(z.unknown())
+const AudioStreamSchema = z$1.object({
+	index: z$1.number(),
+	codec_name: z$1.string(),
+	codec_long_name: z$1.string(),
+	codec_type: z$1.literal("audio"),
+	codec_tag_string: z$1.string(),
+	codec_tag: z$1.string(),
+	sample_fmt: z$1.string(),
+	sample_rate: z$1.string(),
+	channels: z$1.number(),
+	channel_layout: z$1.string().optional(),
+	bits_per_sample: z$1.number(),
+	initial_padding: z$1.number().optional(),
+	r_frame_rate: z$1.string(),
+	avg_frame_rate: z$1.string(),
+	time_base: z$1.string(),
+	start_pts: z$1.number().optional(),
+	start_time: z$1.coerce.number().optional(),
+	duration_ts: z$1.number(),
+	duration: z$1.coerce.number(),
+	bit_rate: z$1.string(),
+	disposition: z$1.record(z$1.unknown())
 });
-const VideoStreamSchema = z.object({
-  index: z.number(),
-  codec_name: z.string(),
-  codec_long_name: z.string(),
-  codec_type: z.literal("video"),
-  codec_tag_string: z.string(),
-  codec_tag: z.string(),
-  width: z.number(),
-  height: z.number(),
-  coded_width: z.number(),
-  coded_height: z.number(),
-  r_frame_rate: z.string(),
-  avg_frame_rate: z.string(),
-  time_base: z.string(),
-  start_pts: z.number().optional(),
-  start_time: z.coerce.number().optional(),
-  duration_ts: z.number().optional(),
-  duration: z.coerce.number().optional(),
-  bit_rate: z.string().optional(),
-  disposition: z.record(z.unknown())
+const VideoStreamSchema = z$1.object({
+	index: z$1.number(),
+	codec_name: z$1.string(),
+	codec_long_name: z$1.string(),
+	codec_type: z$1.literal("video"),
+	codec_tag_string: z$1.string(),
+	codec_tag: z$1.string(),
+	width: z$1.number(),
+	height: z$1.number(),
+	coded_width: z$1.number(),
+	coded_height: z$1.number(),
+	r_frame_rate: z$1.string(),
+	avg_frame_rate: z$1.string(),
+	time_base: z$1.string(),
+	start_pts: z$1.number().optional(),
+	start_time: z$1.coerce.number().optional(),
+	duration_ts: z$1.number().optional(),
+	duration: z$1.coerce.number().optional(),
+	bit_rate: z$1.string().optional(),
+	disposition: z$1.record(z$1.unknown())
 });
-const ProbeFormatSchema = z.object({
-  filename: z.string(),
-  nb_streams: z.number(),
-  nb_programs: z.number(),
-  format_name: z.string(),
-  format_long_name: z.string(),
-  start_time: z.string().optional(),
-  duration: z.string().optional(),
-  size: z.string().optional(),
-  bit_rate: z.string().optional(),
-  probe_score: z.number()
+const ProbeFormatSchema = z$1.object({
+	filename: z$1.string(),
+	nb_streams: z$1.number(),
+	nb_programs: z$1.number(),
+	format_name: z$1.string(),
+	format_long_name: z$1.string(),
+	start_time: z$1.string().optional(),
+	duration: z$1.string().optional(),
+	size: z$1.string().optional(),
+	bit_rate: z$1.string().optional(),
+	probe_score: z$1.number()
 });
-const DataStreamSchema = z.object({
-  index: z.number(),
-  codec_type: z.literal("data"),
-  duration: z.string().optional()
+const DataStreamSchema = z$1.object({
+	index: z$1.number(),
+	codec_type: z$1.literal("data"),
+	duration: z$1.string().optional()
 });
-const StreamSchema = z.discriminatedUnion("codec_type", [
-  AudioStreamSchema,
-  VideoStreamSchema,
-  DataStreamSchema
+const StreamSchema = z$1.discriminatedUnion("codec_type", [
+	AudioStreamSchema,
+	VideoStreamSchema,
+	DataStreamSchema
 ]);
-const ProbeSchema = z.object({
-  streams: z.array(StreamSchema),
-  format: ProbeFormatSchema
+const ProbeSchema = z$1.object({
+	streams: z$1.array(StreamSchema),
+	format: ProbeFormatSchema
 });
-class Probe {
-  constructor(absolutePath, rawData) {
-    this.absolutePath = absolutePath;
-    this.data = ProbeSchema.parse(rawData);
-  }
-  static async probePath(absolutePath) {
-    const probeCommand = `ffprobe -v error -show_format -show_streams -of json ${absolutePath}`;
-    log("Probing", probeCommand);
-    const probeResult = await execPromise(probeCommand);
-    log("Probe result", probeResult.stdout);
-    log("Probe stderr", probeResult.stderr);
-    const json = JSON.parse(probeResult.stdout);
-    return new Probe(absolutePath, json);
-  }
-  static async probeStream(stream) {
-    const probe = spawn(
-      "ffprobe",
-      [
-        "-i",
-        "-",
-        "-v",
-        "error",
-        "-show_format",
-        "-show_streams",
-        "-of",
-        "json"
-      ],
-      { stdio: ["pipe", "pipe", "pipe"] }
-    );
-    const chunks = [];
-    const processExit = new Promise((_, reject) => {
-      probe.on("exit", (code) => {
-        if (code !== 0) {
-          reject(new Error(`ffprobe exited with code ${code}`));
-        }
-      });
-      probe.on("error", (err) => reject(err));
-    });
-    probe.stderr.on("data", (data) => {
-      log(data.toString());
-    });
-    probe.stdout.on("data", (data) => {
-      chunks.push(data);
-    });
-    probe.stdin.on("error", (error) => {
-      if (error.code === "EPIPE") {
-        log("ffprobe closed input pipe");
-        return;
-      }
-      log("ffprobe stdin error", error);
-    });
-    stream.pipe(probe.stdin);
-    try {
-      const json = await Promise.race([
-        new Promise((resolve, reject) => {
-          probe.stdout.on("end", () => {
-            try {
-              const buffer = Buffer.concat(chunks).toString("utf8");
-              log("Got probe from stream", buffer);
-              resolve(JSON.parse(buffer));
-            } catch (error) {
-              reject(error);
-            }
-          });
-        }),
-        processExit
-      ]);
-      return new Probe("pipe:0", json);
-    } finally {
-      stream.unpipe(probe.stdin);
-      probe.stdin.end();
-      stream.destroy();
-    }
-  }
-  get audioStreams() {
-    return this.data.streams.filter(
-      (stream) => stream.codec_type === "audio"
-    );
-  }
-  get videoStreams() {
-    return this.data.streams.filter(
-      (stream) => stream.codec_type === "video"
-    );
-  }
-  get streams() {
-    return this.data.streams;
-  }
-  get format() {
-    return this.data.format;
-  }
-  get mustReencodeAudio() {
-    return this.audioStreams.some((stream) => stream.codec_name !== "aac");
-  }
-  get mustReencodeVideo() {
-    return false;
-  }
-  get mustRemux() {
-    return this.format.format_name !== "mp4" || this.data.streams.some((stream) => stream.codec_type !== "audio" && stream.codec_type !== "video");
-  }
-  get hasNonAudioOrVideoStreams() {
-    return this.data.streams.some(
-      (stream) => stream.codec_type !== "audio" && stream.codec_type !== "video"
-    );
-  }
-  get hasAudio() {
-    return this.audioStreams.length > 0;
-  }
-  get hasVideo() {
-    return this.videoStreams.length > 0;
-  }
-  get isAudioOnly() {
-    return this.audioStreams.length > 0 && this.videoStreams.length === 0;
-  }
-  get isMp3() {
-    return this.audioStreams.some(
-      (stream) => stream.codec_name === "mp3"
-    );
-  }
-  get isVideoOnly() {
-    return this.audioStreams.length === 0 && this.videoStreams.length > 0;
-  }
-  get mustProcess() {
-    return this.mustReencodeAudio || this.mustReencodeVideo || this.mustRemux;
-  }
-  get ffmpegAudioInputOptions() {
-    if (!this.hasAudio) {
-      return [];
-    }
-    if (this.isMp3) {
-      return ["-c:a", "mp3"];
-    }
-    return [];
-  }
-  get ffmpegVideoInputOptions() {
-    return [];
-  }
-  get ffmpegAudioOutputOptions() {
-    if (!this.hasAudio) {
-      return [];
-    }
-    if (this.mustReencodeAudio) {
-      return [
-        "-c:a",
-        "aac",
-        "-b:a",
-        "192k",
-        "-ar",
-        "48000"
-      ];
-    }
-    return ["-c:a", "copy"];
-  }
-  get ffmpegVideoOutputOptions() {
-    if (!this.hasVideo) {
-      return [];
-    }
-    if (this.mustReencodeVideo) {
-      return [
-        "-c:v",
-        "h264",
-        // Filter out SEI NAL units that aren't supported by the webcodecs decoder
-        "-bsf:v",
-        "filter_units=remove_types=6",
-        "-pix_fmt",
-        "yuv420p"
-      ];
-    }
-    return [
-      "-c:v",
-      "copy",
-      // Filter out SEI NAL units that aren't supported by the webcodecs decoder
-      "-bsf:v",
-      "filter_units=remove_types=6"
-    ];
-  }
-  createConformingReadstream() {
-    if (this.absolutePath === "pipe:0") {
-      throw new Error("Cannot create conforming readstream from pipe");
-    }
-    if (!this.mustProcess) {
-      return createReadStream(this.absolutePath);
-    }
-    const ffmpegConformanceArgs = [
-      ...this.ffmpegAudioInputOptions,
-      ...this.ffmpegVideoInputOptions,
-      "-i",
-      this.absolutePath,
-      ...this.ffmpegAudioOutputOptions,
-      ...this.ffmpegVideoOutputOptions,
-      "-f",
-      "mp4",
-      "-movflags",
-      "frag_keyframe",
-      "pipe:1"
-    ];
-    log("Running ffmpeg", ffmpegConformanceArgs);
-    const ffmpegConformer = spawn("ffmpeg", ffmpegConformanceArgs, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    ffmpegConformer.stderr.on("data", (data) => {
-      log("CONFORMER: ", data.toString());
-    });
-    const ffmpegFragmentArgs = [
-      "-i",
-      "-",
-      "-c",
-      "copy",
-      "-f",
-      "mp4",
-      "-movflags",
-      "frag_keyframe",
-      "pipe:1"
-    ];
-    log("Running ffmpeg", ffmpegFragmentArgs);
-    const ffmpegFragmenter = spawn("ffmpeg", ffmpegFragmentArgs, {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    ffmpegConformer.stdout.pipe(ffmpegFragmenter.stdin);
-    ffmpegFragmenter.stderr.on("data", (data) => {
-      log("FRAGMENTER: ", data.toString());
-    });
-    ffmpegConformer.on("error", (error) => {
-      ffmpegFragmenter.stdout.emit("error", error);
-    });
-    ffmpegFragmenter.on("error", (error) => {
-      ffmpegFragmenter.stdout.emit("error", error);
-    });
-    return ffmpegFragmenter.stdout;
-  }
-}
-export {
-  AudioStreamSchema,
-  DataStreamSchema,
-  Probe,
-  VideoStreamSchema
+var Probe = class Probe {
+	static async probePath(absolutePath) {
+		const probeCommand = `ffprobe -v error -show_format -show_streams -of json ${absolutePath}`;
+		log("Probing", probeCommand);
+		const probeResult = await execPromise(probeCommand);
+		log("Probe result", probeResult.stdout);
+		log("Probe stderr", probeResult.stderr);
+		const json = JSON.parse(probeResult.stdout);
+		return new Probe(absolutePath, json);
+	}
+	static async probeStream(stream) {
+		const probe = spawn("ffprobe", [
+			"-i",
+			"-",
+			"-v",
+			"error",
+			"-show_format",
+			"-show_streams",
+			"-of",
+			"json"
+		], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		const chunks = [];
+		const processExit = new Promise((_, reject) => {
+			probe.on("exit", (code) => {
+				if (code !== 0) reject(/* @__PURE__ */ new Error(`ffprobe exited with code ${code}`));
+			});
+			probe.on("error", (err) => reject(err));
+		});
+		probe.stderr.on("data", (data) => {
+			log(data.toString());
+		});
+		probe.stdout.on("data", (data) => {
+			chunks.push(data);
+		});
+		probe.stdin.on("error", (error) => {
+			if (error.code === "EPIPE") {
+				log("ffprobe closed input pipe");
+				return;
+			}
+			log("ffprobe stdin error", error);
+		});
+		stream.pipe(probe.stdin);
+		try {
+			const json = await Promise.race([new Promise((resolve, reject) => {
+				probe.stdout.on("end", () => {
+					try {
+						const buffer = Buffer.concat(chunks).toString("utf8");
+						log("Got probe from stream", buffer);
+						resolve(JSON.parse(buffer));
+					} catch (error) {
+						reject(error);
+					}
+				});
+			}), processExit]);
+			return new Probe("pipe:0", json);
+		} finally {
+			stream.unpipe(probe.stdin);
+			probe.stdin.end();
+			stream.destroy();
+		}
+	}
+	constructor(absolutePath, rawData) {
+		this.absolutePath = absolutePath;
+		this.data = ProbeSchema.parse(rawData);
+	}
+	get audioStreams() {
+		return this.data.streams.filter((stream) => stream.codec_type === "audio");
+	}
+	get videoStreams() {
+		return this.data.streams.filter((stream) => stream.codec_type === "video");
+	}
+	get streams() {
+		return this.data.streams;
+	}
+	get format() {
+		return this.data.format;
+	}
+	get mustReencodeAudio() {
+		return this.audioStreams.some((stream) => stream.codec_name !== "aac");
+	}
+	get mustReencodeVideo() {
+		return false;
+	}
+	get mustRemux() {
+		return this.format.format_name !== "mp4" || this.data.streams.some((stream) => stream.codec_type !== "audio" && stream.codec_type !== "video");
+	}
+	get hasNonAudioOrVideoStreams() {
+		return this.data.streams.some((stream) => stream.codec_type !== "audio" && stream.codec_type !== "video");
+	}
+	get hasAudio() {
+		return this.audioStreams.length > 0;
+	}
+	get hasVideo() {
+		return this.videoStreams.length > 0;
+	}
+	get isAudioOnly() {
+		return this.audioStreams.length > 0 && this.videoStreams.length === 0;
+	}
+	get isMp3() {
+		return this.audioStreams.some((stream) => stream.codec_name === "mp3");
+	}
+	get isVideoOnly() {
+		return this.audioStreams.length === 0 && this.videoStreams.length > 0;
+	}
+	get mustProcess() {
+		return this.mustReencodeAudio || this.mustReencodeVideo || this.mustRemux;
+	}
+	get ffmpegAudioInputOptions() {
+		if (!this.hasAudio) return [];
+		if (this.isMp3) return ["-c:a", "mp3"];
+		return [];
+	}
+	get ffmpegVideoInputOptions() {
+		return [];
+	}
+	get ffmpegAudioOutputOptions() {
+		if (!this.hasAudio) return [];
+		if (this.mustReencodeAudio) return [
+			"-c:a",
+			"aac",
+			"-b:a",
+			"192k",
+			"-ar",
+			"48000"
+		];
+		return ["-c:a", "copy"];
+	}
+	get ffmpegVideoOutputOptions() {
+		if (!this.hasVideo) return [];
+		if (this.mustReencodeVideo) return [
+			"-c:v",
+			"h264",
+			"-bsf:v",
+			"filter_units=remove_types=6",
+			"-pix_fmt",
+			"yuv420p"
+		];
+		return [
+			"-c:v",
+			"copy",
+			"-bsf:v",
+			"filter_units=remove_types=6"
+		];
+	}
+	createConformingReadstream() {
+		if (this.absolutePath === "pipe:0") throw new Error("Cannot create conforming readstream from pipe");
+		if (!this.mustProcess) return createReadStream(this.absolutePath);
+		const fragmenterArgs = this.isAudioOnly ? [
+			"-movflags",
+			"frag_keyframe",
+			"-frag_duration",
+			"4000000"
+		] : ["-movflags", "frag_keyframe"];
+		const ffmpegConformanceArgs = [
+			...this.ffmpegAudioInputOptions,
+			...this.ffmpegVideoInputOptions,
+			"-i",
+			this.absolutePath,
+			...this.ffmpegAudioOutputOptions,
+			...this.ffmpegVideoOutputOptions,
+			"-f",
+			"mp4",
+			...fragmenterArgs,
+			"pipe:1"
+		];
+		log("Running ffmpeg", ffmpegConformanceArgs);
+		const ffmpegConformer = spawn("ffmpeg", ffmpegConformanceArgs, { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		ffmpegConformer.stderr.on("data", (data) => {
+			log("CONFORMER: ", data.toString());
+		});
+		const ffmpegFragmentArgs = [
+			"-i",
+			"-",
+			"-c",
+			"copy",
+			"-f",
+			"mp4",
+			...fragmenterArgs,
+			"pipe:1"
+		];
+		log("Running ffmpeg", ffmpegFragmentArgs);
+		const ffmpegFragmenter = spawn("ffmpeg", ffmpegFragmentArgs, { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		ffmpegConformer.stdout.pipe(ffmpegFragmenter.stdin);
+		ffmpegFragmenter.stderr.on("data", (data) => {
+			log("FRAGMENTER: ", data.toString());
+		});
+		ffmpegConformer.on("error", (error) => {
+			ffmpegFragmenter.stdout.emit("error", error);
+		});
+		ffmpegFragmenter.on("error", (error) => {
+			ffmpegFragmenter.stdout.emit("error", error);
+		});
+		return ffmpegFragmenter.stdout;
+	}
 };
+export { Probe };