mediasnacks 0.26.0 → 0.28.0

package/index.js

@@ -1,11 +1,14 @@
 export { avif } from './src/avif.js'
 export { countframes } from './src/countframes.js'
 export { detectdups } from './src/detectdups.js'
+export { dlaudio } from './src/dlaudio.js'
+export { dlvideo } from './src/dlvideo.js'
 export { dropdups } from './src/dropdups.js'
 export { edgespic } from './src/edgespic.js'
 export { frameseq } from './src/frameseq.js'
 export { hev1tohvc1 } from './src/hev1tohvc1.js'
 export { moov2front } from './src/moov2front.js'
+export { png } from './src/png.js'
 export { play } from './src/play.js'
 export { prores } from './src/prores.js'
 export { qdir } from './src/qdir.js'
@@ -14,5 +17,6 @@ export { resize } from './src/resize.js'
 export { seqcheck } from './src/seqcheck.js'
 export { sqcrop } from './src/sqcrop.js'
 export { ssim } from './src/ssim.js'
+export { unemoji } from './src/unemoji.js'
 export { vsplit } from './src/vsplit.js'
 export { vtrim } from './src/vtrim.js'

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasnacks",
-	"version": "0.26.0",
+	"version": "0.28.0",
 	"description": "Utilities for optimizing and preparing videos and images",
 	"license": "MIT",
 	"author": "Eric Fortis",

package/src/avif.js

@@ -1,7 +1,7 @@
 import { join, basename, dirname } from 'node:path'
 import { parseOptions } from './utils/parseOptions.js'
 import { replaceExt, lstat } from './utils/fs-utils.js'
-import { ffmpeg, assertUserHasFFmpeg } from './utils/subprocess.js'
+import { ffmpeg } from './utils/subprocess.js'
 
 
 const HELP = `
@@ -14,45 +14,33 @@ DESCRIPTION
 EXAMPLES
   mediasnacks avif -y '*.png'
   mediasnacks avif --outdir=foo/ 'a/**/*.png'
-`.trim()
-
+`
 
 export default async function main() {
-	await assertUserHasFFmpeg()
-
-	const { values, files } = await parseOptions({
+	const { values, files } = await parseOptions(HELP, {
 		outdir: { type: 'string', default: '' },
 		overwrite: { short: 'y', type: 'boolean' },
-		help: { short: 'h', type: 'boolean' },
 	})
 
-	if (values.help) {
-		console.log(HELP)
-		return
-	}
-
 	if (!files.length)
-		throw new Error('No images specified. See mediasnacks avif --help')
-
-	console.log('AVIF…')
-	for (const file of files)
-		try {
-			await avif({
-				file,
-				outFile: join(values.outdir || dirname(file), replaceExt(basename(file), 'avif')),
-				overwrite: values.overwrite
-			})
-			console.log(file)
-		}
-		catch (err) {
-			console.error(err?.message || err)
-		}
+		throw 'Invalid input image'
+
+	for (const file of files) {
+		await avif({
+			file,
+			outFile: join(values.outdir || dirname(file), replaceExt(basename(file), 'avif')),
+			overwrite: values.overwrite
+		})
+		console.log(file)
+	}
 }
 
 export async function avif({ file, outFile, overwrite = false }) {
 	const stAvif = lstat(outFile)
-	if (!overwrite && stAvif?.isFile()) throw new Error(`output file exists but --overwrite=false. ${file}`)
-	if (stAvif?.mtimeMs > lstat(file)?.mtimeMs) throw new Error(`avif is newer. ${file}`)
+	if (!overwrite) {
+		if (stAvif?.isFile()) throw `output file exists: ${file}`
+		if (stAvif?.mtimeMs > lstat(file)?.mtimeMs) throw `avif is newer: ${file}`
+	}
 
 	await ffmpeg([
 		'-y',

package/src/cli.js

@@ -8,7 +8,7 @@ import pkgJSON from '../package.json' with { type: 'json' }
 
 const COMMANDS = {
 	avif: ['./avif.js', 'Converts images to AVIF'],
-	png: ['./png.sh', 'Optimizes PNG images with oxipng'],
+	png: ['./png.js', 'Optimizes PNG images with oxipng'],
 	sqcrop: ['./sqcrop.js', 'Square crops images\n'],
 
 	resize: ['./resize.js', 'Resizes videos or images'],
@@ -16,7 +16,7 @@ const COMMANDS = {
 	frameseq: ['./frameseq.js', 'Converts video to sequence of PNGs'],
 	countframes: ['./countframes.js', 'Counts frames in a video'],
 	ssim: ['./ssim.js', 'Computes SSIM between two images'],
-	gif: ['./gif.sh', 'Video to GIF\n'],
+	gif: ['./gif.js', 'Video to GIF\n'],
 
 	detectdups: ['./detectdups.js', 'Detects duplicate frames in a video'],
 	dropdups: ['./dropdups.js', 'Removes duplicate frames in a video'],
@@ -35,10 +35,10 @@ const COMMANDS = {
 	openrand: ['./openrand.js', 'Opens a random file (macOS only)'],
 	play: ['./play.js', 'Plays filtered playlist with mpv\n'],
 
-	dlaudio: ['./dlaudio.sh', 'yt-dlp best audio'],
-	dlvideo: ['./dlvideo.sh', 'yt-dlp best video\n'],
+	dlaudio: ['./dlaudio.js', 'yt-dlp best audio'],
+	dlvideo: ['./dlvideo.js', 'yt-dlp best video\n'],
 
-	unemoji: ['./unemoji.sh', 'Removes emojis from filenames'],
+	unemoji: ['./unemoji.js', 'Removes emojis from filenames'],
 	rmcover: ['./rmcover.sh', 'Removes cover art'],
 }
 
@@ -60,27 +60,24 @@ ${commandsSummary().map(([cmd, desc]) =>
 async function main() {
 	const [, , opt, ...args] = process.argv
 
-	if (opt === '-v' || opt === '--version') {
-		console.log(pkgJSON.version)
-		return
-	}
-	if (opt === '-h' || opt === '--help') {
-		console.log(HELP)
-		return
-	}
+	switch (opt) {
+		case '-v':
+		case '--version':
+			console.log(pkgJSON.version)
+			return
 
-	if (!opt) {
-		console.log(HELP)
-		process.exit(1)
-	}
-	if (!Object.hasOwn(COMMANDS, opt)) {
-		console.error(`'${opt}' is not a command. See mediasnacks --help\n`)
-		process.exit(1)
+		case '-h':
+		case '--help':
+			console.log(HELP)
+			return
 	}
 
+	if (!opt) throw HELP
+	if (!Object.hasOwn(COMMANDS, opt)) throw `'${opt}' is not a command. See mediasnacks --help\n`
+
 	const cmd = COMMANDS[opt][0]
 	if (cmd.endsWith('.js'))
-		(await import(cmd)).default()
+		await (await import(cmd)).default()
 	else
 		spawn(join(import.meta.dirname, cmd), args, { stdio: 'inherit' })
 			.on('exit', process.exit)

package/src/countframes.js

@@ -1,5 +1,4 @@
 import { parseOptions } from './utils/parseOptions.js'
-import { assertUserHasFFmpeg } from './utils/subprocess.js'
 import { videoAttrs } from './utils/videoAttrs.js'
 import { parseTimecode } from './utils/parseTimecode.js'
 
@@ -19,27 +18,20 @@ OPTIONS
 EXAMPLES
   mediasnacks countframes --start=1:30.16 --end=60 video.mov
   mediasnacks countframes --fps=12 video.mov
-`.trim()
+`
 
 
 export default async function main() {
-	await assertUserHasFFmpeg()
-
-	const { values, files } = await parseOptions({
-		fps: { type: 'string', default: '' },
-		start: { short: 's', type: 'string', default: '' },
-		end: { short: 'e', type: 'string', default: '' },
-		help: { short: 'h', type: 'boolean' }
+	const { values, files } = await parseOptions(HELP, {
+		fps: { type: 'string' },
+		start: { short: 's', type: 'string' },
+		end: { short: 'e', type: 'string' },
 	})
 
-	if (values.help) {
-		console.log(HELP)
-		return
-	}
-
 	const { fps, start, end } = values
 	const video = files[0]
-	if (!video) throw new Error('No video file specified')
+	if (!video)
+		throw 'No video file specified'
 
 	const n = await countframes({ video, fps, start, end })
 	console.log(String(n))
@@ -48,10 +40,9 @@ export default async function main() {
 
 export async function countframes({ video, fps, start, end }) {
 	const v = await videoAttrs(video)
-	const videoDuration = parseFloat(v.duration || 0)
+	const duration = parseFloat(v.duration || 0)
 	const startSecs = start ? parseTimecode(start) : 0
-	const endSecs = end ? parseTimecode(end) : videoDuration
-	const durationLimit = Math.max(0, endSecs - startSecs)
+	const endSecs = end ? parseTimecode(end) : duration
 	const actualFps = fps ? Number(fps) : eval(v.r_frame_rate)
-	return Math.ceil(durationLimit * actualFps)
+	return Math.ceil(Math.max(0, endSecs - startSecs) * actualFps)
 }

package/src/detectdups.js

@@ -1,5 +1,5 @@
 import { parseOptions } from './utils/parseOptions.js'
-import { ffmpeg, assertUserHasFFmpeg } from './utils/subprocess.js'
+import { ffmpeg } from './utils/subprocess.js'
 import { videoAttrs } from './utils/videoAttrs.js'
 
 const STDEV_THRESHOLD = 0.2
@@ -22,32 +22,25 @@ OPTIONS
   -s, --seek <sec>      Video start time for detection
   -d, --duration <sec>  Analyze this many seconds of video
   -v, --verbose
-  -h, --help
   
 SEE ALSO
   mediasnacks framediff
-`.trim()
+`
 
 
 export default async function main() {
-	await assertUserHasFFmpeg()
-
-	const { values, files } = await parseOptions({
+	const { values, files } = await parseOptions(HELP, {
 		seek: { short: 's', type: 'string', },
 		duration: { short: 'd', type: 'string' },
-		help: { short: 'h', type: 'boolean' }
 	})
 
-	if (values.help) {
-		console.log(HELP)
-		return
-	}
-
-	if (files.length !== 1) throw new Error('Invalid input file. One video file must be specified. See mediasnacks detectdups --help')
+	if (files.length !== 1)
+		throw 'Invalid input file. One video file must be specified.'
 
 	const video = files[0]
 	const v = await videoAttrs(video)
-	if (v.codec_type !== 'video') throw new Error('Invalid input file. Must be a video.')
+	if (v.codec_type !== 'video')
+		throw 'Invalid input file. Must be a video.'
 
 	const vDur = Number(v.duration)
 
@@ -59,9 +52,9 @@ export default async function main() {
 		? Number(values.duration)
 		: vDur > 60 ? 20 : vDur
 
-	if (isNaN(seek) || seek < 0) throw new Error(`Invalid --seek value: ${values.seek}`)
-	if (isNaN(duration) || duration < 1) throw new Error(`Invalid --duration value: ${values.duration}`)
-	if ((seek + duration) > vDur) throw new Error(`Invalid analysis range. Exceeds video duration: ${vDur}`)
+	if (isNaN(seek) || seek < 0) throw `Invalid --seek value: ${values.seek}`
+	if (isNaN(duration) || duration < 1) throw `Invalid --duration value: ${values.duration}`
+	if ((seek + duration) > vDur) throw `Invalid analysis range. Exceeds video duration: ${vDur}`
 
 	const dups = await detectdups({ video: files[0], seek, duration })
 	const h = deltaHistogram(dups)

package/src/dlaudio.js

@@ -0,0 +1,34 @@
+import { parseOptions } from './utils/parseOptions.js'
+import { runSilently } from './utils/subprocess.js'
+import { unemoji } from './unemoji.js'
+
+
+const HELP = `
+SYNOPSIS
+  mediasnacks dlaudio <url>
+
+DESCRIPTION
+  yt-dlp best m4a
+`
+
+export default async function main() {
+	const { values, positionals } = await parseOptions(HELP)
+
+	if (!positionals[0])
+		throw 'Missing URL'
+
+	const f = await dlaudio(positionals[0])
+	console.log(f)
+}
+
+export async function dlaudio(url) {
+	const f = (await runSilently('yt-dlp', [
+		'--print', 'filename',
+		'--no-simulate',
+		'-o', '%(title)s.%(ext)s',
+		'-f', 'bestaudio[ext=m4a]/bestaudio',
+		url
+	])).stdout.trim()
+
+	return await unemoji(f) || f
+}

package/src/dlvideo.js

@@ -0,0 +1,28 @@
+import { parseOptions } from './utils/parseOptions.js'
+import { run } from './utils/subprocess.js'
+
+
+const HELP = `
+SYNOPSIS
+  mediasnacks dlvideo <url>
+
+DESCRIPTION
+  yt-dlp best mp4
+`
+
+export default async function main() {
+	const { values, positionals } = await parseOptions(HELP)
+
+	if (!positionals[0])
+		throw 'Missing URL'
+
+	await dlvideo(positionals[0])
+}
+
+export async function dlvideo(url) {
+	await run('yt-dlp', [
+		'-o', '%(title)s.%(ext)s',
+		'-f', 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/mp4',
+		url
+	])
+}

package/src/dropdups.js

@@ -1,6 +1,6 @@
 import { resolve, parse, format } from 'node:path'
 import { parseOptions } from './utils/parseOptions.js'
-import { ffmpeg, assertUserHasFFmpeg, run } from './utils/subprocess.js'
+import { ffmpeg, run } from './utils/subprocess.js'
 import { ProresProfiles } from './prores.js'
 
 
@@ -16,7 +16,6 @@ DESCRIPTION
 OPTIONS
   -n, --dup-frame-num <n>  Known frame interval to drop.
 		                       Default: n=0, which auto-detects repeated frames (slower)
-  -h, --help
 
 EXAMPLES
   Use n=2 when every other frame is repeated:
@@ -24,30 +23,21 @@ EXAMPLES
   
 	Use n=6 if e.g., a 25 fps got upped to 30 fps without interpolation.
   mediasnacks dropdups -n6 vid.mov
-`.trim()
+`
 
 
 export default async function main() {
-	await assertUserHasFFmpeg()
-
-	const { values, files } = await parseOptions({
-		'dup-frame-num': { short: 'n', type: 'string', default: '' },
-		help: { short: 'h', type: 'boolean' },
+	const { values, files } = await parseOptions(HELP, {
+		'dup-frame-num': { short: 'n', type: 'string' },
 	})
 
-	if (values.help) {
-		console.log(HELP)
-		return
-	}
-
 	if (!files.length)
-		throw new Error('No video specified. See mediasnacks dropdups --help')
+		throw 'No video specified.'
 
 	let dupFrameNum = values['dup-frame-num']
 	if (dupFrameNum && !Number.isInteger(+dupFrameNum))
-		throw new Error('Invalid -n. It must be a positive integer.')
+		throw 'Invalid -n. It must be a positive integer.'
 
-	console.log('Dropping Duplicate Frames…')
 	for (const file of files)
 		await dropdups(resolve(file), dupFrameNum)
 }

package/src/edgespic.js

@@ -3,46 +3,38 @@ import { basename, extname, join, parse } from 'node:path'
 import { mkDir } from './utils/fs-utils.js'
 import { videoAttrs } from './utils/videoAttrs.js'
 import { parseOptions } from './utils/parseOptions.js'
-import { ffmpeg, assertUserHasFFmpeg } from './utils/subprocess.js'
+import { ffmpeg } from './utils/subprocess.js'
 
 
+const WIDTH = 640
+
 const HELP = `
 SYNOPSIS
-  mediasnacks edgespic [--width=<num>] <files>
+  mediasnacks edgespic [-w | --width=<num>] <files>
 
 DESCRIPTION
   Extracts the first and last frames from each video and saves them to the 'edgepics/' subfolder.
   
 OPTIONS
-  -w, --width    Default:640 The aspect ratio is preserved.
+  -w, --width    Default: ${WIDTH} The aspect ratio is preserved.
 
 EXAMPLES
   mediasnacks edgespic -w 800 *.mov
   mediasnacks edgespic -w 600 'videos/**/*.mp4'
-`.trim()
-
+`
 
 export default async function main() {
-	await assertUserHasFFmpeg()
-
-	const { values, files } = await parseOptions({
-		'width': { short: 'w', type: 'string', default: '640' },
-		help: { short: 'h', type: 'boolean' },
+	const { values, files } = await parseOptions(HELP, {
+		width: { short: 'w', type: 'string', default: String(WIDTH) }
 	})
 
-	if (values.help) {
-		console.log(HELP)
-		return
-	}
-
-	const width = Number(values['width'])
-	if (width <= 0 || !Number.isInteger(width)) throw new Error('--width must be a positive number')
-	if (!files.length) throw new Error('No video files specified')
+	const width = Number(values.width)
+	if (width <= 0 || !Number.isInteger(width)) throw '--width must be a positive number'
+	if (!files.length) throw 'No video files specified'
 
 	const outDir = join(parse(files[0]).dir, 'edgespic')
 	await mkDir(outDir)
 
-	console.log('Extracting edge frames…')
 	for (const file of files)
 		await edgespic(file, width, outDir)
 }

package/src/frameseq.js

@@ -2,7 +2,7 @@ import { basename, extname, join, parse } from 'node:path'
 
 import { mkDir } from './utils/fs-utils.js'
 import { parseOptions } from './utils/parseOptions.js'
-import { ffmpeg, assertUserHasFFmpeg } from './utils/subprocess.js'
+import { ffmpeg } from './utils/subprocess.js'
 import { countframes } from './countframes.js'
 
 
@@ -24,31 +24,23 @@ EXAMPLES
   
   Custom framerate, all video duration
   mediasnacks frameseq --fps=12 video.mov
-`.trim()
+`
 
 
 export default async function main() {
-	await assertUserHasFFmpeg()
-
-	const { values, files } = await parseOptions({
-		fps: { short: 'f', type: 'string', default: '' },
-		start: { short: 's', type: 'string', default: '' },
-		end: { short: 'e', type: 'string', default: '' },
+	const { values, files } = await parseOptions(HELP, {
+		fps: { short: 'f', type: 'string' },
+		start: { short: 's', type: 'string' },
+		end: { short: 'e', type: 'string' },
 		outdir: { type: 'string', default: '' },
-		help: { short: 'h', type: 'boolean' }
 	})
 
-	if (values.help) {
-		console.log(HELP)
-		return
-	}
-
 	const { fps, start, end, outdir } = values
 	const video = files[0]
-	if (!video) throw new Error('No video files specified')
-	if (fps && isNaN(parseFloat(fps))) throw new Error('Invalid --fps')
-	if (start && isNaN(parseFloat(start))) throw new Error('Invalid --start')
-	if (end && isNaN(parseFloat(end))) throw new Error('Invalid --end')
+	if (!video) throw 'No video files specified'
+	if (fps && isNaN(parseFloat(fps))) throw 'Invalid --fps'
+	if (start && isNaN(parseFloat(start))) throw 'Invalid --start'
+	if (end && isNaN(parseFloat(end))) throw 'Invalid --end'
 
 	const nFrames = await countframes({ video, fps, start, end })
 	const pad = String(nFrames).length
@@ -57,13 +49,13 @@ export default async function main() {
 
 export async function frameseq({ video, fps, start, end, pad, outdir }) {
 	const name = basename(video, extname(video))
-	const outDir = outdir || join(parse(video).dir, name)
-	await mkDir(outDir)
+	const dir = outdir || join(parse(video).dir, name)
+	await mkDir(dir)
 	await ffmpeg([
 		start ? ['-ss', start] : [],
 		end ? ['-to', end] : [],
 		'-i', video,
 		fps ? ['-vf', `fps=${fps}`] : [],
-		join(outDir, `${name}_%0${pad}d.png`)
+		join(dir, `${name}_%0${pad}d.png`)
 	].flat())
 }

package/src/gif.js

@@ -0,0 +1,43 @@
+import { parse, format } from 'node:path'
+import { parseOptions } from './utils/parseOptions.js'
+import { run } from './utils/subprocess.js'
+
+
+const FPS = 12
+const WIDTH = 600
+
+const HELP = `
+SYNOPSIS
+  mediasnacks gif [-f | --fps <number>] [-w | --width <pixels>] <file>
+
+DESCRIPTION
+  Converts video to GIF
+
+OPTIONS
+  -f, --fps    Default: ${FPS}
+  -w, --width  Default: ${WIDTH}
+`
+
+export default async function main() {
+	const { values, files } = await parseOptions(HELP, {
+		fps: { short: 'f', type: 'string', default: String(FPS) },
+		width: { short: 'w', type: 'string', default: String(WIDTH) },
+	})
+
+	if (!files.length)
+		throw 'Missing input file'
+
+	await gif(files[0], values.fps, values.width)
+}
+
+export async function gif(file, fps, width) {
+	const { dir, name } = parse(file)
+	const outName = format({ dir, name, ext: '.gif' })
+
+	await run('ffmpeg', [
+		'-v', 'error',
+		'-i', file,
+		'-vf', `fps=${fps},scale=${width}:-1`,
+		outName,
+	])
+}

package/src/hev1tohvc1.js

@@ -1,6 +1,6 @@
 import { parseOptions } from './utils/parseOptions.js'
 import { uniqueFilenameFor, overwrite } from './utils/fs-utils.js'
-import { ffmpeg, assertUserHasFFmpeg } from './utils/subprocess.js'
+import { ffmpeg } from './utils/subprocess.js'
 import { videoAttrs } from './utils/videoAttrs.js'
 
 
@@ -12,36 +12,25 @@ DESCRIPTION
   This program fixes video thumbnails not rendering in macOS
   Finder, and fixes video not importable in Final Cut Pro. That’s done 
   by changing the container’s sample entry code from HEV1 to HVC1.
-`.trim()
+`
 
 
 export default async function main() {
-	await assertUserHasFFmpeg()
+	const { values, files } = await parseOptions(HELP)
 
-	const { values, files } = await parseOptions({
-		help: { short: 'h', type: 'boolean' }
-	})
+	if (!files.length)
+		throw 'Missing input file(s)'
 
-	if (values.help) {
-		console.log(HELP)
-		return
+	for (const file of files) {
+		await hev1tohvc1(file)
+		console.log(file)
 	}
-
-	if (!files.length) throw new Error('Missing input file(s)')
-
-	for (const file of files)
-		try {
-			await hev1tohvc1(file)
-			console.log(file)
-		}
-		catch (err) {
-			console.error(err?.message || err)
-		}
 }
 
 export async function hev1tohvc1(file) {
 	const v = await videoAttrs(file)
-	if (v.codec_tag_string !== 'hev1') throw new Error(`non hev1 ${file}`)
+	if (v.codec_tag_string !== 'hev1')
+		throw `non hev1 ${file}`
 
 	const tmp = uniqueFilenameFor(file)
 	await ffmpeg([