mediasnacks 0.0.1 → 0.1.1

package/.zsh/completions/_mediasnacks

@@ -0,0 +1,42 @@
+#compdef mediasnacks
+
+_mediasnacks_commands=(
+  'avif:Converts images to AVIF'
+  'resize:Resizes videos or images'
+  'moov2front:Rearranges metadata for fast-start streaming'
+  'dropdups:Removes duplicate frames in a video'
+  'seqcheck:Finds missing sequence number'
+  'qdir:Sequentially runs all *.sh files in a folder'
+  'hev1tohvc1:Fixes video thumbnails not rendering in macOS Finder'
+  'framediff:ffplay with a filter for diffing adjacent frames'
+  'videodiff:Plays a video with the difference of two videos'
+)
+
+_mediasnacks() {
+  if (( CURRENT == 2 )); then
+    _describe -t commands 'mediasnacks commands' _mediasnacks_commands
+    return
+  fi
+
+  local cmd="$words[2]"
+  case "$cmd" in
+    avif|resize|moov2front|dropdups|seqcheck|hev1tohvc1|framediff|videodiff)
+      _files
+      ;;
+    qdir)
+      _files -/
+      ;;
+  esac
+}
+
+compdef _mediasnacks mediasnacks
+
+
+# INSTALL in: ~/.zshrc
+#fpath=(~/.zsh/completions $fpath)
+#zmodload zsh/complist
+#autoload -U compinit && compinit
+
+#function mediasnacks() {
+#  $HOME/work/mediasnacks/src/./cli.js "$@"
+#}

package/README.md

@@ -1,6 +1,6 @@
 # mediasnacks
 
-Utilities optimizing and preparing video and images for web.
+Utilities optimizing and preparing video and images for the web.
 
 
 ## Usage Overview
@@ -14,7 +14,13 @@ Commands:
 - `avif` Converts images to AVIF
 - `resize` Resizes videos or images
 - `moov2front` Rearranges .mov and .mp4 metadata for fast-start streaming
+- `dropdups` Removes duplicate frames in a video
+- `seqcheck` Finds missing sequence number
+- `qdir` Sequentially runs all *.sh files in a folder
+- `hev1tohvc1`: Fixes video thumbnails not rendering in macOS Finder 
 
+- `framediff`: Plays a video of adjacent frames diff
+- `videodiff`: Plays a video with the difference of two videos
 <br/>
 
 ### Converting Images to AVIF

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasnacks",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "description": "Utilities for preparing videos, images, and audio for the web",
   "license": "MIT",
   "author": "Eric Fortis",

package/src/{cli-avif.js → avif.js}

@@ -1,10 +1,8 @@
-#!/usr/bin/env node
-
 import { join } from 'node:path'
 import { parseArgs } from 'node:util'
 
-import { glob, replaceExt, lstat } from './fs-utils.js'
-import { ffmpeg, assertUserHasFFmpeg } from './ffmpeg.js'
+import { glob, replaceExt, lstat } from './utils/fs-utils.js'
+import { ffmpeg, assertUserHasFFmpeg } from './utils/ffmpeg.js'
 
 
 const USAGE = `
@@ -57,7 +55,6 @@ async function toAvif({ file, outFile, overwrite }) {
 		return
 	}
 
-	// TODO test on linux
 	console.log(file)
 	await ffmpeg([
 		'-y', // overwrites

package/src/cli.js

@@ -6,9 +6,17 @@ import pkgJSON from '../package.json' with { type: 'json' }
 
 
 const COMMANDS = {
-	avif: join(import.meta.dirname, 'cli-avif.js'),
-	resize: join(import.meta.dirname, 'cli-resize.js'),
-	moov2front: join(import.meta.dirname, 'cli-moov2front.js')
+	avif: join(import.meta.dirname, 'avif.js'),
+	resize: join(import.meta.dirname, 'resize.js'),
+	moov2front: join(import.meta.dirname, 'moov2front.js'),
+	
+	dropdups: join(import.meta.dirname, 'dropdups.js'),
+	seqcheck: join(import.meta.dirname, 'seqcheck.js'),
+	qdir: join(import.meta.dirname, 'qdir.js'),
+	hev1tohvc1: join(import.meta.dirname, 'hev1tohvc1.js'),
+	
+	framediff: join(import.meta.dirname, 'framediff.sh'),
+	videodiff: join(import.meta.dirname, 'videodiff.sh'),
 }
 
 const USAGE = `
@@ -18,6 +26,14 @@ Commands:
     avif: Converts images to AVIF
     resize: Resizes videos or images
     moov2front: Rearranges .mov and .mp4 metadata for fast-start streaming
+    
+    dropdups: Removes duplicate frames in a video
+    seqcheck: Finds missing sequence number
+    qdir: Sequentially runs all *.sh files in a folder
+    hev1tohvc1: Fixes video thumbnails not rendering in macOS Finder 
+    
+    framediff: Plays a video of adjacent frames diff
+    videodiff: Plays a video with the difference of two videos
 `.trim()
 
 
@@ -43,5 +59,9 @@ if (!Object.hasOwn(COMMANDS, opt)) {
 	process.exit(1)
 }
 
-spawn(process.execPath, [COMMANDS[opt], ...args], { stdio: 'inherit' })
+const cmd = COMMANDS[opt]
+const executable = cmd.endsWith('.sh') 
+	? 'sh' 
+	: process.execPath
+spawn(executable, [cmd, ...args], { stdio: 'inherit' })
 	.on('exit', code => process.exit(code))

package/src/dropdups.js

@@ -0,0 +1,91 @@
+import { spawn } from 'node:child_process'
+import { parseArgs } from 'node:util'
+import { resolve, parse, format } from 'node:path'
+
+import { glob } from './utils/fs-utils.js'
+import { ffmpeg, assertUserHasFFmpeg, run } from './utils/ffmpeg.js'
+
+
+const PRORES_PROFILES = {
+	'proxy': 0,
+	'lt': 1,
+	'standard': 2,
+	'hq': 3,
+	'4444': 4,
+	'4444xq': 5,
+}
+const PROFILE = PRORES_PROFILES.hq
+
+
+const USAGE = `
+Usage: npx mediasnacks dropdups [-n <bad-frame-number>] <video>
+
+Removes duplicate frames and outputs ProRes 422 HQ.
+
+Options:
+  -n, --bad-frame-number <n>  Known frame interval to drop.
+		         (default: n=0) auto-detects repeated frames (slower)
+             Ex.A: Use n=2 when every other frame is repeated.
+		         Ex.B: Use n=6 if e.g., a 25 fps got upped to 30 fps without interpolation.
+  -h, --help
+`.trim()
+
+
+async function main() {
+	const { values, positionals } = parseArgs({
+		options: {
+			'bad-frame-number': { short: 'n', type: 'string', default: '' },
+			help: { short: 'h', type: 'boolean', default: false },
+		},
+		allowPositionals: true
+	})
+
+	if (values.help) {
+		console.log(USAGE)
+		process.exit(0)
+	}
+
+	if (!positionals.length)
+		throw new Error('No video specified. See npx mediasnacks dropdups --help')
+
+	let nBadFrame = values['bad-frame-number']
+	if (nBadFrame && /^\d+$/.test(nBadFrame))
+		throw new Error('Invalid --bad-frame-number. It must be a positive integer.')
+
+	await assertUserHasFFmpeg()
+
+	console.log('Dropping Duplicate Frames…')
+	for (const g of positionals)
+		for (const file of await glob(g))
+			await drop(resolve(file), nBadFrame)
+}
+
+async function drop(video, nBadFrame) {
+	await run('ffmpeg', [
+		'-v', 'error',
+		'-stats',
+		'-an',
+		'-i', video,
+		'-vf', nBadFrame
+			? `decimate=cycle=${nBadFrame}`
+			: 'mpdecimate,setpts=N/FRAME_RATE/TB',
+		'-fps_mode', 'cfr',
+		'-c:v', 'prores_ks',
+		'-profile:v', PROFILE,
+		'-pix_fmt', 'yuv422p10le',
+		makeOutputPath(video)
+	])
+}
+
+function makeOutputPath(video) {
+	const abs = resolve(video)
+	const { dir, name, ext } = parse(abs)
+	return ext.toLowerCase() === '.mov'
+		? format({ dir, name: `${name}.dedup`, ext: '.mov' })
+		: format({ dir, name, ext: '.mov' })
+}
+
+main().catch(err => {
+	console.error(err.message || err)
+	process.exit(1)
+})

package/src/framediff.sh

@@ -0,0 +1,11 @@
+# Plays a video with a filter for diffing adjacent frames.
+# I use this for finding repeated frames. For example, you’ll see 
+# a black frame if two consecutive frames are almost similar.
+
+# The frame number is rendered at the top-left.
+
+ffplay -hide_banner "$1" -vf "
+    tblend=all_mode=difference,
+    format=gray,
+    drawtext=text='%{n}':x=20:y=20:fontcolor=white:fontsize=48
+"

package/src/hev1tohvc1.js

@@ -0,0 +1,54 @@
+import { parseArgs } from 'node:util'
+import { unlink, rename } from 'node:fs/promises'
+
+import { glob, uniqueFilenameFor } from './utils/fs-utils.js'
+import { videoAttrs, ffmpeg, assertUserHasFFmpeg } from './utils/ffmpeg.js'
+
+
+const USAGE = `
+Usage: npx mediasnacks hev1tohvc1 <videos>
+
+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()
+
+
+async function main() {
+	const { positionals } = parseArgs({ allowPositionals: true })
+
+	if (!positionals.length)
+		throw new Error(USAGE)
+
+	await assertUserHasFFmpeg()
+
+	console.log('HEV1 to HVC1…')
+	for (const g of positionals)
+		for (const file of await glob(g))
+			await toHvc1(file)
+}
+
+async function toHvc1(file) {
+	const v = await videoAttrs(file, 'codec_tag_string')
+	if (v.codec_tag_string !== 'hev1') {
+		console.log('(skipped: non hev1)', file)
+		return
+	}
+
+	console.log(file)
+	const tmp = uniqueFilenameFor(file)
+	await ffmpeg([
+		'-i', file,
+		'-c', 'copy',
+		'-tag:v', 'hvc1',
+		tmp
+	])
+	await unlink(file)
+	await rename(tmp, file)
+}
+
+
+main().catch(err => {
+	console.error(err.message)
+	process.exit(1)
+})

package/src/{cli-moov2front.js → moov2front.js}

@@ -1,11 +1,8 @@
-#!/usr/bin/env node
-
-import { join } from 'node:path'
 import { parseArgs } from 'node:util'
 import { unlink, rename } from 'node:fs/promises'
 
-import { glob, makeTempDir, makeDirFor } from './fs-utils.js'
-import { ffmpeg, assertUserHasFFmpeg } from './ffmpeg.js'
+import { glob, uniqueFilenameFor } from './utils/fs-utils.js'
+import { ffmpeg, assertUserHasFFmpeg } from './utils/ffmpeg.js'
 
 
 const USAGE = `
@@ -42,9 +39,7 @@ async function moov2front(file) {
 	}
 
 	console.log(file)
-	const tmp = join(await makeTempDir(), file) // FFmpeg can’t edit in-place
-	await makeDirFor(tmp)
-
+	const tmp = uniqueFilenameFor(file)
 	await ffmpeg([
 		'-hide_banner',
 		'-i', file,

package/src/qdir.js

@@ -0,0 +1,99 @@
+import { spawn } from 'node:child_process'
+import { parseArgs } from 'node:util'
+import { resolve, join } from 'node:path'
+import { readdir, writeFile, unlink, rename } from 'node:fs/promises'
+import { isFile } from './utils/fs-utils.js'
+import { fileURLToPath } from 'node:url'
+
+
+const USAGE = `
+Usage: npx mediasnacks qdir [folder]
+
+Sequentially runs all *.sh files in a folder. 
+It uses the current working directory by default.
+
+-h, --help
+`.trim()
+
+
+async function main() {
+	const { values, positionals } = parseArgs({
+		options: {
+			help: { short: 'h', type: 'boolean', default: false },
+		},
+		allowPositionals: true,
+	})
+
+	if (values.help) {
+		console.log(USAGE)
+		process.exit(0)
+	}
+
+	const dir = positionals[0] || process.cwd()
+	const err = await qdir(dir)
+	if (err)
+		throw new Error(err)
+}
+
+
+export async function qdir(dir, pollIntervalMs = 10_000) {
+	const lock = join(dir, '.lock')
+
+	if (isFile(lock))
+		return 'Found lockfile'
+
+	while (true) {
+		if (isFile(lock)) {
+			await sleep(pollIntervalMs)
+			continue
+		}
+
+		const job = await getNextJob(dir)
+		if (!job)
+			return null
+
+		const jobName = job.split('/').pop()
+		await writeFile(lock, jobName, 'utf8')
+
+		try {
+			const exitCode = await runShell(job)
+			await rename(job, job + (exitCode === 0
+				? '.done'
+				: `.failed.${exitCode}`))
+		}
+		finally {
+			await unlink(lock).catch(() => {})
+		}
+	}
+}
+
+async function getNextJob(dir) {
+	const entries = await readdir(dir, { withFileTypes: true })
+	const scripts = entries
+		.filter(d => d.isFile() && d.name.endsWith('.sh'))
+		.map(d => d.name)
+		.sort()
+	return scripts.length
+		? join(dir, scripts[0])
+		: null
+}
+
+
+async function runShell(scriptPath) {
+	return new Promise((resolve, reject) => {
+		const p = spawn('/bin/sh', [scriptPath], { stdio: 'inherit' })
+		p.on('error', reject)
+		p.on('exit', code => resolve(code))
+	})
+}
+
+function sleep(ms) {
+	return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+
+if (fileURLToPath(import.meta.url) === process.argv[1])
+	main().catch(err => {
+		console.error(err.message || err)
+		process.exit(1)
+	})

package/src/{cli-resize.js → resize.js}

@@ -1,11 +1,9 @@
-#!/usr/bin/env node
-
 import { join } from 'node:path'
 import { rename } from 'node:fs/promises'
 import { parseArgs } from 'node:util'
 
-import { glob, isFile, makeTempDir, makeDirFor } from './fs-utils.js'
-import { ffmpeg, videoAttrs, assertUserHasFFmpeg } from './ffmpeg.js'
+import { glob, isFile, uniqueFilenameFor } from './utils/fs-utils.js'
+import { ffmpeg, videoAttrs, assertUserHasFFmpeg } from './utils/ffmpeg.js'
 
 
 
@@ -83,10 +81,7 @@ async function resize({ file, outFile, overwrite, width, height }) {
 	}
 
 	console.log(file)
-	const tmp = join(await makeTempDir(), file) // FFmpeg can’t edit in-place
-	await makeDirFor(tmp)
-	await makeDirFor(outFile)
-
+	const tmp = uniqueFilenameFor(file)
 	await ffmpeg([
 		'-i', file,
 		'-vf', `scale=${width}:${height}`,

package/src/seqcheck.js

@@ -0,0 +1,71 @@
+import { resolve } from 'node:path'
+import { parseArgs } from 'node:util'
+import { readdirSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+
+const USAGE = `
+Usage: npx mediasnacks seqcheck [options] [folder]
+
+Find missing numbered files in a sequence.
+
+Options:
+  -ld, --left-delimiter <str>   Delimiter before the number (default: "_")
+  -rd, --right-delimiter <str>  Delimiter after the number (default: ".")
+  -h,  --help
+`.trim()
+
+
+function main() {
+	const { values, positionals } = parseArgs({
+		options: {
+			'left-delimiter': { type: 'string', default: '_' },
+			'right-delimiter': { type: 'string', default: '.' },
+			help: { short: 'h', type: 'boolean', default: false },
+		},
+		allowPositionals: true,
+	})
+
+	if (values.help) {
+		console.log(USAGE)
+		process.exit(0)
+	}
+
+	const seq = extractSeqNums(
+		readdirSync(positionals[0] || process.cwd()),
+		values['left-delimiter'],
+		values['right-delimiter'])
+
+	const missing = findMissingNumbers(seq)
+	if (missing.length)
+		console.log('Missing:', missing)
+}
+
+export function extractSeqNums(names, leftDelimiter, rightDelimiter) {
+	const pattern = new RegExp(escapeRegex(leftDelimiter) + '(\\d+)' + escapeRegex(rightDelimiter))
+	const seq = []
+	for (const name of names) {
+		const match = name.match(pattern)
+		if (match)
+			seq.push(Number(match[1]))
+	}
+	return seq.sort()
+}
+
+export function findMissingNumbers(seq) {
+	if (seq.length < 2)
+		return []
+	const missing = []
+	for (let i = seq[0]; i <= seq[seq.length - 1]; i++)
+		if (!seq.includes(i))
+			missing.push(i)
+	return missing
+}
+
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+
+if (fileURLToPath(import.meta.url) === process.argv[1])
+	main()

package/src/{ffmpeg.js → utils/ffmpeg.js}

@@ -2,13 +2,13 @@ import { spawn } from 'node:child_process'
 
 
 export async function ffmpeg(args) {
-	return run('ffmpeg', args)
+	return runSilently('ffmpeg', args)
 }
 
 export async function assertUserHasFFmpeg() {
 	try {
-		await run('ffmpeg', ['-version'])
-		await run('ffprobe', ['-version'])
+		await runSilently('ffmpeg', ['-version'])
+		await runSilently('ffprobe', ['-version'])
 	}
 	catch {
 		throw new Error('ffmpeg not found. Please install ffmpeg.')
@@ -16,7 +16,7 @@ export async function assertUserHasFFmpeg() {
 }
 
 export async function videoAttrs(v, ...props) {
-	const { stdout } = await run('ffprobe', [
+	const { stdout } = await runSilently('ffprobe', [
 		'-v', 'error',
 		'-select_streams', 'v:0',
 		'-show_entries', `stream=${props.join(',')}`,
@@ -27,7 +27,7 @@ export async function videoAttrs(v, ...props) {
 }
 
 
-async function run(program, args) {
+async function runSilently(program, args) {
 	return new Promise((resolve, reject) => {
 		const stdout = []
 		const stderr = []
@@ -49,3 +49,20 @@ async function run(program, args) {
 	})
 }
 
+export async function run(program, args) {
+	return new Promise((resolve, reject) => {
+		const p = spawn(program, args)
+		p.stdout.on('data', data => process.stdout.write(data))
+		p.stderr.on('data', chunk => process.stderr.write(chunk))
+
+		p.on('error', reject)
+		p.on('close', code => {
+			if (code === 0)
+				resolve()
+			else
+				reject(new Error(`${program} failed with code ${code}`))
+		})
+	})
+}
+
+

package/src/{fs-utils.js → utils/fs-utils.js}

@@ -1,7 +1,6 @@
-import { tmpdir } from 'node:os'
 import { promisify } from 'node:util'
-import { join, dirname } from 'node:path'
-import { mkdtemp, mkdir } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import { dirname, extname, join } from 'node:path'
 import { lstatSync, glob as _glob } from 'node:fs'
 
 
@@ -10,9 +9,6 @@ export const glob = promisify(_glob)
 export const lstat = f => lstatSync(f, { throwIfNoEntry: false })
 export const isFile = path => lstat(path)?.isFile()
 
-export const makeDirFor = async file => mkdir(dirname(file), { recursive: true })
-export const makeTempDir = async () => mkdtemp(join(tmpdir(), 'mediasnacks-'))
-
 export const replaceExt = (f, ext) => {
 	const parts = f.split('.')
 	if (parts.length > 1 && parts[0])
@@ -20,3 +16,6 @@ export const replaceExt = (f, ext) => {
 	parts.push(ext)
 	return parts.join('.')
 }
+
+export const uniqueFilenameFor = file => 
+	join(dirname(file), randomUUID() + extname(file))

package/src/videodiff.sh

@@ -0,0 +1,10 @@
+# Diffs two video files
+# The videos must have the same resolution and ideally the same framerate.
+video1="$1"
+video2="$2"
+
+ffplay -f lavfi "movie=$video1 [a]; movie=$video2 [b]; [a][b] blend=all_mode=difference128"
+
+#all_mode=difference: absolute diff (ideal for detecting visual changes)
+#all_mode=subtract: raw subtraction (can go <0, may appear darker)
+#all_mode=difference128: shows neutral gray if identical, differences as dark/light shifts

package/tests/qdir/jobs/job1_good.sh

@@ -0,0 +1 @@
+exit 0

package/tests/qdir/jobs/job2_bad.sh

@@ -0,0 +1 @@
+exit 1

package/tests/qdir/jobs/job3_good.sh

@@ -0,0 +1,2 @@
+sleep 0.5
+exit 0

package/tests/qdir/jobs/job4_bad.sh

@@ -0,0 +1 @@
+exit 1

package/tests/qdir/qdir.test.js

@@ -0,0 +1,26 @@
+import test from 'node:test'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { equal, deepEqual } from 'node:assert/strict'
+import { mkdtempSync, cpSync, readdirSync } from 'node:fs'
+
+import { qdir } from '../../src/qdir.js'
+
+
+test('jobs get renamed and failed have their exit status code', async () => {
+	const fixtures = join(import.meta.dirname, 'jobs')
+	const tmp = join(mkdtempSync(join(tmpdir(), 'qdir-')))
+
+	cpSync(fixtures, tmp, { recursive: true })
+
+	const err = await qdir(tmp, 0.2)
+	equal(err, null)
+
+	const files = readdirSync(tmp).sort()
+	deepEqual(files, [
+		'job1_good.sh.done',
+		'job2_bad.sh.failed.1',
+		'job3_good.sh.done',
+		'job4_bad.sh.failed.1'
+	])
+})

package/tests/seqcheck.test.js

@@ -0,0 +1,27 @@
+import { test } from 'node:test'
+import { deepEqual } from 'node:assert/strict'
+import { extractSeqNums, findMissingNumbers } from '../src/seqcheck.js'
+
+
+test('extractSeqNums extracts sequence numbers from filenames', () => {
+	const filenames = [
+		'video-111_001.mov',
+		'video-111_002.mov',
+		'video-111_004.mov',
+		'bad.mov',
+		'bad_too_a39.mov',
+	]
+	deepEqual(extractSeqNums(filenames, '_', '.'), [1, 2, 4])
+})
+
+
+test('findMissingNumbers ', () => {
+	test('finds gaps in a sequence', () =>
+		deepEqual(findMissingNumbers([1, 2, 4, 5, 8]), [3, 6, 7]))
+
+	test('returns empty array for empty input', () =>
+		deepEqual(findMissingNumbers([]), []))
+
+	test('returns empty array when there are no gaps', () =>
+		deepEqual(findMissingNumbers([10, 11, 12]), []))
+})