mediasnacks 0.20.0 → 0.21.0

package/.zsh/completions/_mediasnacks

@@ -29,8 +29,6 @@ _mediasnacks_commands=(
   
   'unemoji:Removes emojis from filenames'
   'rmcover:Removes cover art'
-  
-  'curltime:Measures request response timings'
 )
 
 if (( CURRENT == 2 )); then

package/README.md

@@ -60,8 +60,6 @@ mediasnacks <command> <args>
 - `rmcover`: Removes cover art
 
 
-- `curltime`: Measures request response timings
-
 ### Globs
 Glob patterns are expanded by Node.js.
 

package/package.json

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

package/src/cli.js

@@ -34,9 +34,7 @@ const COMMANDS = {
 	dlvideo: ['dlvideo.sh', 'yt-dlp best video\n'],
 
 	unemoji: ['unemoji.sh', 'Removes emojis from filenames'],
-	rmcover: ['rmcover.sh', 'Removes cover art\n'],
-
-	curltime: ['curltime.sh', 'Measures request response timings'],
+	rmcover: ['rmcover.sh', 'Removes cover art'],
 }
 
 const MAN = `

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>
@@ -70,10 +71,19 @@ async function main() {
 
 
 	const dups = await detectDuplicateFramesNums(files[0], seek, duration)
-	analyze(dups, seek, duration)
+	const h = deltaHistogram(dups)
+	const report = {
+		n: maxFreqKey(h),
+		histogram: h,
+		analyzed_region: {
+			start_sec: seek,
+			end_sec: seek + duration
+		},
+	}
+	console.log(JSON.stringify(report, null, 2))
 }
 
-async function detectDuplicateFramesNums(video, seek, duration) {
+export async function detectDuplicateFramesNums(video, seek, duration) {
 	const { stderr } = await ffmpeg([
 		'-v', 'info',
 		'-stats',
@@ -81,7 +91,6 @@ async function detectDuplicateFramesNums(video, seek, duration) {
 		'-t', duration,
 		'-i', video,
 		'-vf', [
-			'scale=320:-1',
 			'tblend=all_mode=difference',
 			'format=gray',
 			'showinfo',
@@ -89,32 +98,48 @@ 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
 }
 
-function analyze(dup_frames, seek, duration) {
+// 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 deltaHistogram(dups) {
 	const histogram = {}
-	for (let i = 1; i < dup_frames.length; i++) {
-		const diff = dup_frames[i] - dup_frames[i - 1]
+	for (let i = 1; i < dups.length; i++) {
+		const diff = dups[i] - dups[i - 1]
 		histogram[diff] = (histogram[diff] || 0) + 1
 	}
-	console.log(JSON.stringify({
-		analyzed_region: {
-			start_sec: seek,
-			end_sec: seek + duration
-		},
-		histogram
-	}, null, 2))
+	return histogram
+}
+
+function maxFreqKey(histogram) {
+	let maxKey = null
+	let maxVal = -1
+	for (const [k, v] of Object.entries(histogram))
+		if (v > maxVal) {
+			maxVal = v
+			maxKey = k
+		}
+	return maxKey !== null
+		? Number(maxKey)
+		: null
 }
 
-main().catch(err => {
-	console.error(err.message || err)
-	process.exit(1)
-})
+
+if (import.meta.main)
+	main().catch(err => {
+		console.error(err.message || err)
+		process.exit(1)
+	})

package/src/detectdups.test.js

@@ -0,0 +1,24 @@
+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))
+	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/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/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 { 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) {

package/src/curltime.sh

@@ -1,14 +0,0 @@
-#!/bin/sh
-
-# https://stackoverflow.com/a/47944496
-
-curl -so /dev/null -w "\
-   DNS Lookup  %{time_namelookup}
-TCP Handshake  %{time_connect}
-TLS Handshake  %{time_appconnect}
-         Wait  %{time_pretransfer}
-     Redirect  %{time_redirect}
-   First Byte  %{time_starttransfer}
-───────────────────────   
-        TOTAL  %{time_total}
-" "$@"