mediasnacks 0.19.1 → 0.20.1

package/.zsh/completions/_mediasnacks

@@ -6,6 +6,7 @@ _mediasnacks_commands=(
   
   'resize:Resizes videos or images'
   'edgespic:Extracts first and last frames'
+  'ssim:Computes similarity of two images'
   'gif:Video to GIF'
   
   'detectdups:Detects sequentially duplicate frames in a video'
@@ -39,7 +40,7 @@ fi
 
 local cmd="$words[2]"
 case "$cmd" in
-	avif|resize|sqcrop|moov2front|detectdups|dropdups|edgespic|seqcheck|hev1tohvc1|framediff|vdiff|vconcat|vsplit|vtrim|dlaudio|dlvideo|unemoji|rmcover|curltime|gif|flattendir|prores)
+	avif|resize|sqcrop|moov2front|detectdups|dropdups|edgespic|seqcheck|hev1tohvc1|framediff|vdiff|vconcat|vsplit|vtrim|dlaudio|dlvideo|unemoji|rmcover|curltime|gif|flattendir|prores|ssim)
 		_files
 		;;
 	qdir)

package/README.md

@@ -31,6 +31,7 @@ mediasnacks <command> <args>
 
 - `resize` Resizes videos or images
 - `edgespic` Extracts first and last frames
+- `ssim` Computes similarity of two images
 - `gif`: Video to GIF
 
 

package/package.json

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

package/src/avif.test.js

@@ -1,8 +1,8 @@
 import { join } from 'node:path'
 import { test } from 'node:test'
-import { deepEqual } from 'node:assert/strict'
+import { ok } from 'node:assert/strict'
 
-import { videoAttrs } from './utils/ffmpeg.js'
+import { ssim } from './ssim.js'
 import { mkTempDir, cli } from './utils/test-utils.js'
 
 const rel = f => join(import.meta.dirname, f)
@@ -11,9 +11,6 @@ test('PNG to AVIF', async () => {
 	const tmp = mkTempDir('avif')
 	cli('avif', '--output-dir', tmp, rel('fixtures/lenna.png'))
 
-	deepEqual(
-		await videoAttrs(join(tmp, 'lenna.avif')),
-		await videoAttrs(rel('fixtures/lenna.avif')))
-	// That's because we use non-deterministic avif.
-	// Claude says: avif is deterministic only when it's single-threaded: '-threads 1'
+	const similarityScore = await ssim(join(tmp, 'lenna.avif'), rel('fixtures/lenna.avif'))
+	ok(similarityScore > 0.99, `Similarity too low: ${similarityScore}`)
 })

package/src/cli.js

@@ -12,6 +12,7 @@ const COMMANDS = {
 
 	resize: ['resize.js', 'Resizes videos or images'],
 	edgespic: ['edgespic.js', 'Extracts first and last frames'],
+	ssim: ['ssim.js', 'Computes SSIM between two images'],
 	gif: ['gif.sh', 'Video to GIF\n'],
 
 	detectdups: ['detectdups.js', 'Detects duplicate frames in a video'],

package/src/detectdups.js

@@ -3,6 +3,7 @@
 import { parseOptions } from './utils/parseOptions.js'
 import { ffmpeg, assertUserHasFFmpeg, videoAttrs } from './utils/ffmpeg.js'
 
+const STDEV_THRESHOLD = 0.2
 
 const MAN = `
 Usage: mediasnacks detectdups [options] <video>
@@ -73,7 +74,7 @@ async function main() {
 	analyze(dups, seek, duration)
 }
 
-async function detectDuplicateFramesNums(video, seek, duration) {
+export async function detectDuplicateFramesNums(video, seek, duration) {
 	const { stderr } = await ffmpeg([
 		'-v', 'info',
 		'-stats',
@@ -81,7 +82,6 @@ async function detectDuplicateFramesNums(video, seek, duration) {
 		'-t', duration,
 		'-i', video,
 		'-vf', [
-			'scale=320:-1',
 			'tblend=all_mode=difference',
 			'format=gray',
 			'showinfo',
@@ -89,16 +89,23 @@ async function detectDuplicateFramesNums(video, seek, duration) {
 		'-f', 'null', '-',
 	])
 
-	const reBlackFramesNum = /n:\s*(\d+).*?mean:\[0]/
+	const reNearBlackFrames = /n:\s*(\d+).*?mean:\[0].*?stdev:\[([0-9.]+)]/
 	const dupFrames = []
 	for (const line of stderr.split('\n')) {
-		const match = line.match(reBlackFramesNum)
-		if (match)
-			dupFrames.push(Number(match[1]))
+		const match = line.match(reNearBlackFrames)
+		if (match) {
+			const stdev = parseFloat(match[2])
+			if (stdev <= STDEV_THRESHOLD) {
+				const frameNum = parseInt(match[1], 10)
+				dupFrames.push(frameNum)
+			}
+		}
 	}
 	return dupFrames
 }
 
+// This is only good for when there's one repeated frame in a cycle.
+// i.e. it's the wrong approach for e.g. 25 to 60, in which N=2 and N=3
 function analyze(dup_frames, seek, duration) {
 	const histogram = {}
 	for (let i = 1; i < dup_frames.length; i++) {
@@ -110,11 +117,28 @@ function analyze(dup_frames, seek, duration) {
 			start_sec: seek,
 			end_sec: seek + duration
 		},
-		histogram
+		histogram,
+		n: maxFreqKey(histogram)
 	}, null, 2))
 }
 
-main().catch(err => {
-	console.error(err.message || err)
-	process.exit(1)
-})
+function maxFreqKey(hist) {
+	let maxKey = null
+	let maxVal = -1
+	for (const [key, val] of Object.entries(hist))
+		if (val > maxVal) {
+			maxVal = val
+			maxKey = key
+		}
+	return maxKey !== null
+		? Number(maxKey)
+		: null
+}
+
+
+
+if (import.meta.main)
+	main().catch(err => {
+		console.error(err.message || err)
+		process.exit(1)
+	})

package/src/detectdups.test.js

@@ -0,0 +1,36 @@
+import { test } from 'node:test'
+import { join } from 'node:path'
+import { equal } from 'node:assert/strict'
+import { cli } from './utils/test-utils.js'
+
+const rel = f => join(import.meta.dirname, f)
+
+function detect(video) {
+	const { stdout } = cli('detectdups', rel(video), 0, 7)
+	return JSON.parse(stdout).n
+}
+
+
+test('no dups', () =>
+	equal(detect('fixtures/big-buck-bunny/bbb_24fps_no_dups.mp4'), null))
+
+
+// These fixtures are badly retimed (non-interpolated, just duplicating a frame)
+
+test('24 to 48 (has dup at n=2)', () =>
+	equal(detect('fixtures/big-buck-bunny/bbb_24_to_48fps_dup.mp4'), 2))
+
+test('25 to 50 (has dup at n=2)', () =>
+	equal(detect('fixtures/big-buck-bunny/bbb_25_to_50fps_dup.mp4'), 2))
+
+
+test('24 to 30 (has dup at n=5)', () =>
+	equal(detect('fixtures/big-buck-bunny/bbb_24_to_30fps_dup.mp4'), 5))
+
+test('25 to 30 (has dup at n=6)', () =>
+	equal(detect('fixtures/big-buck-bunny/bbb_25_to_30fps_dup.mp4'), 6))
+
+
+test('24 to 25 (has dup at n=25)', () =>
+	equal(detect('fixtures/big-buck-bunny/bbb_24_to_25fps_dup.mp4'), 25))
+

package/src/edgespic.test.js

@@ -1,9 +1,10 @@
+import { ok } from 'node:assert/strict'
 import { join } from 'node:path'
-import { ok, equal } from 'node:assert/strict'
 import { describe, test } from 'node:test'
 import { cpSync, readdirSync, } from 'node:fs'
 
-import { cli, mkTempDir, sha1 } from './utils/test-utils.js'
+import { ssim } from './ssim.js'
+import { cli, mkTempDir } from './utils/test-utils.js'
 
 const rel = f => join(import.meta.dirname, f)
 
@@ -18,15 +19,18 @@ describe('edgespic', () => {
 		ok(files.length === 2, `Expected 2 PNG files, got ${files.length}`)
 	})
 
-	test('extracts first frame', () => {
+	test('extracts first frame', async () => {
+		const out = join(tmp, 'edgespic', '60fps_first.png')
 		const fixture = rel('fixtures/edgespic/60fps_first.png')
-		const generated = join(tmp, 'edgespic', '60fps_first.png')
-		equal(sha1(generated), sha1(fixture))
+		const similarityScore = await ssim(out, fixture)
+		ok(similarityScore > 0.99, `Similarity too low: ${similarityScore}`)
 	})
 
-	test('extracts last frame', () => {
+	test('extracts last frame', async () => {
+		const out = join(tmp, 'edgespic', '60fps_last.png')
 		const fixture = rel('fixtures/edgespic/60fps_last.png')
-		const generated = join(tmp, 'edgespic', '60fps_last.png')
-		equal(sha1(generated), sha1(fixture))
+		const similarityScore = await ssim(out, fixture)
+		ok(similarityScore > 0.99, `Similarity too low: ${similarityScore}`)
 	})
 })
+

package/src/fixtures/big-buck-bunny/generate.md

@@ -0,0 +1,71 @@
+# Generating Fixtures
+
+
+## 1. Download a video (Big Buck Bunny)
+
+```sh
+curl https://download.blender.org/peach/bigbuckbunny_movies/big_buck_bunny_1080p_h264.mov -o bbb_full_24fps.mov
+```
+
+## 2. Extract a scene
+Using the third scene because it's complex enough to cover many edge cases.
+It has a bird flapping its wings with motion blur. Also, animated text titles, 
+and fairly static frames after the title ends.
+
+The scene is 1080p, 24fps, 7.28sec, h.264.
+```sh
+brew tap ericfortis/fcpscene
+brew install fcpscene
+fcpscene -m files bbb_full_24fps.mov 
+
+cp bbb/bbb_full_24fps_003.mov ./bbb_24fps_no_dups.mov
+rm -rf bbb
+rm bbb_full_24fps.mov  
+```
+
+## 3. Re-encode the scene 24fps
+This way all videos will share the same encoding, and no audio.
+
+```sh
+ffmpeg -i bbb_24fps_no_dups.mov \
+  -c:v libx264 -crf 18 -preset slow \
+  -an \
+  bbb_24fps_no_dups.mp4
+```
+
+## 4. Retime (no dups) speed stretch to 25fps
+For a good (no dups) 25fps, retiming by speeding it up.
+```sh
+ffmpeg -i bbb_24fps_no_dups.mp4 \
+  -vf "setpts=24/25*PTS" \
+  -r 25 \
+  bbb_25fps_no_dups.mp4
+```
+
+
+## 5. Retime by inserting duplicates (no interpolation)
+```sh
+for TARGET_FPS in 48 30 25; do
+  ffmpeg -i bbb_24fps_no_dups.mp4 \
+    -vf fps=$TARGET_FPS \
+    -c:v libx264 -crf 18 -preset slow \
+    -an \
+    "bbb_24_to_${TARGET_FPS}fps_dup.mp4"
+done
+
+for TARGET_FPS in 60 50 30; do
+  ffmpeg -i bbb_25fps_no_dups.mp4 \
+    -vf fps=$TARGET_FPS \
+    -c:v libx264 -crf 18 -preset slow \
+    -an \
+    "bbb_25_to_${TARGET_FPS}fps_dup.mp4"
+done
+```
+Counting the cycle from 1 (not from 0):
+
+- 24 to 48 (inserts dup at n=2) 0101
+- 25 to 50 (inserts dup at n=2) 0101
+- 24 to 30 (inserts dup at n=5) 0000100001
+- 25 to 30 (inserts dup at n=6) 000001000001
+- 24 to 25 (inserts dup at n=25) (0*24)1
+- 25 to 60 (inserts dup at n=2 and n=3) 01011

package/src/ssim.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+import { ffmpeg } from './utils/ffmpeg.js'
+
+
+const MAN = `
+SYNOPSIS
+  mediasnacks ssim <img1> <img2>
+
+DESCRIPTION
+  Computes the Structural Similarity Index (SSIM) between two images using ffmpeg.
+`.trim()
+
+
+async function main() {
+	const [img1, img2] = process.argv.slice(2)
+	if (!img1 || !img2) {
+		console.log(MAN)
+		process.exit(1)
+	}
+
+	const score = await ssim(img1, img2)
+	console.log(score)
+}
+
+export async function ssim(img1, img2) {
+	const result = await ffmpeg([
+		'-i', img1,
+		'-i', img2,
+		'-filter_complex', 'ssim',
+		'-f', 'null', '-'
+	])
+	const match = result.stderr.match(/All:([\d.]+)/)
+	if (!match)
+		throw new Error(`Could not parse SSIM output:\n${result.stderr}`)
+	return parseFloat(match[1])
+}
+
+
+if (import.meta.main)
+	main().catch(err => {
+		console.error(err.message)
+		process.exit(1)
+	})

package/src/utils/ffmpeg.js

@@ -1,10 +1,6 @@
 import { spawn } from 'node:child_process'
 
 
-export async function ffmpeg(args) {
-	return runSilently('ffmpeg', args)
-}
-
 export async function assertUserHasFFmpeg() {
 	try {
 		await runSilently('ffmpeg', ['-version'])
@@ -15,6 +11,9 @@ export async function assertUserHasFFmpeg() {
 	}
 }
 
+export async function ffmpeg(args) {
+	return runSilently('ffmpeg', args)
+}
 
 async function runSilently(program, args) {
 	return new Promise((resolve, reject) => {

package/src/utils/test-utils.js

@@ -1,8 +1,7 @@
-import { join }                               from 'node:path'
-import { tmpdir }                              from 'node:os'
-import { spawnSync }                           from 'node:child_process'
-import { createHash }                           from 'node:crypto'
-import { mkdtempSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs'
 
 const rel = f => join(import.meta.dirname, f)
 
@@ -11,13 +10,7 @@ export function mkTempDir(prefix = 'test-') {
 }
 
 export function cli(...args) {
-	spawnSync(rel('../cli.js'), args)
-}
-
-export function sha1(filePath) {
-	return createHash('sha1')
-		.update(readFileSync(filePath))
-		.digest('base64')
+	return spawnSync(rel('../cli.js'), args)
 }
 
 export function dir(...args) {