mpvclip

#!/bin/bash

# MPVCLIP - run MPV with the start and end of playback set to a pattern.
# SPDX-License-Identifier: Unlicense
#
# This small work is dedicated to all those helping to protect endangered species.
# 2024 Looper Guará

# Regular expression to match a clip pattern
# lowercase letters only: a[0-9]+b[0-9]+
# uppercase letters only: A[0-9]+B[0-9]+
# case insensitive: [aA][0-9]+[bB][0-9]+
lpat="[aA][0-9]+[bB][0-9]+"

# Scale to convert clip pattern numbers
# deciseconds: 0.1
# seconds: 1
sc=0.1

# Time in seconds to press any key and exit the script
# half a second: 0.5
q=1

# Field delimiter in a playlist
d=,

scp="$(basename "$0")"

swreq() {
	type awk >/dev/null 2>&1 || { echo >&2 "${scp}: WARNING: AWK not found - aborting."; exit 1; }
	type file >/dev/null 2>&1 || { echo >&2 "${scp}: WARNING: FILE (command) not found - aborting."; exit 1; }
	type grep >/dev/null 2>&1 || { echo >&2 "${scp}: WARNING: GREP not found - aborting."; exit 1; }
	type mpv >/dev/null 2>&1 || { echo >&2 "${scp}: WARNING: MPV not found - aborting."; exit 1; }
}

lpat_tt() {
	h=$(awk "BEGIN { print $(cut -d ':' -f 1 <<< "$1") * 3600 }")
	m=$(awk "BEGIN { print $(cut -d ':' -f 2 <<< "$1") * 60 }")
	s=$(cut -d ':' -f 3 <<< "$1")
	awk 'BEGIN { printf ("%.0f", ( '"$h"' + '"$m"' + '"$s"' ) / '"$sc"' ) }'
}

lpat_aa() {
	tr -d '{a,A}' <<< "$ab" | tr '{b,B}' '-' | cut -d '-' -f 1
}

lpat_bb() {
	tr -d '{a,A}' <<< "$ab" | tr '{b,B}' '-' | cut -d '-' -f 2
}

lpat_a() {
	awk "BEGIN { print $aa * $sc }"
}

lpat_b() {
	awk "BEGIN { print $bb * $sc }"
}

uquit() {
	echo "${scp}: INFO: Press any key to exit the script or skip the file."
	if read -rst "$q" -N 1 ; then
		echo "${scp}: File: $f1"
		echo "${scp}: Please confirm:"
		select ans in "EXIT the script" "SKIP file" "Cancel" ; do
			case "$ans" in
				'EXIT the script' )
					echo "${scp}: $((iter - 1)) iterations completed - exiting..."
					exit;;
				'SKIP file' )
					return 1;;
				'Cancel' )
					break;;
			esac
		done 2>&1
	fi
	echo
}

core() {
	if [ "$aa" -eq 0 ] && [ "$bb" -eq 0 ] ; then
		echo "${scp}: Clip pattern: $(grep -oE "$lpat" <<< "$ab") (file)"
		echo "${scp}: Options:" "${@:-None}"
		echo "${scp}: Starting mpv..."
		mpv "$@" "$f1"
		return
	elif [ "$aa" -eq 0 ] ; then
		b=$(lpat_b)
		echo "${scp}: Clip pattern and duration: $(grep -oE "$lpat" <<< "$ab") (${b}s)"
		echo "${scp}: Options: --end=$b" "$@"
		echo "${scp}: Starting mpv..."
		mpv --end="$b" "$@" "$f1"
		return
	elif [ "$bb" -eq 0 ] ; then
		a=$(lpat_a)
		echo "${scp}: Clip pattern: $(grep -oE "$lpat" <<< "$ab")"
		echo "${scp}: Options: --start=$a" "$@"
		echo "${scp}: Starting mpv..."
		mpv --start="$a" "$@" "$f1"
		return
	fi
	a=$(lpat_a)
	b=$(lpat_b)
	echo "${scp}: Clip pattern and duration: $(grep -oE "$lpat" <<< "$ab") ($(awk "BEGIN { print ( $bb * $sc ) - ( $aa * $sc ) }")s)"
	echo "${scp}: Options: --start=$a --end=$b" "$@"
	echo "${scp}: Starting mpv..."
	mpv --start="$a" --end="$b" "$@" "$f1"
}

core_ll() {
	if [ -v shuffle ] ; then
		readarray -t iall1 < <(shuf "$loopfile")
	else
		readarray -t iall1 < <(cat "$loopfile")
	fi
	for line in "${iall1[@]}" ; do
		f1="$(cut -d "$d" -f 1 <<< "$line")"
		if [ ! -f "$f1" ] || grep -qv "$d" <<< "$line" ; then
			if [ ${#line} -gt 90 ] ; then
				echo >&2 "${scp}: WARNING: No field separator or file - skipping: ${line:0:45}...${line: -45}"
				continue
			else
				echo >&2 "${scp}: WARNING: No field separator or file - skipping: $line"
				continue
			fi
		fi
		for ab in $(cut -s -d "$d" -f 1 --complement <<< "$line" | tr "$d" '\t') ; do
			if grep -qE ^"${lpat}" <<< "$ab" ; then
				aa=$(lpat_aa)
				bb=$(lpat_bb | grep -oE "[0-9]+")
				iter=$((iter + 1))
				if ((iter > 1)) ; then
					uquit
					if [ "$?" -eq 1 ] ; then
						iter=$((iter - 1))
						break
					fi
				fi
				core "$@"
			else
				echo >&2 "${scp}: WARNING: Invalid clip pattern - skipping: $ab"
				continue
			fi
		done
	done
}

if [ -e "$1" ] ; then
	swreq
	for f2 in "$@" ; do
		if [ -d "$f2" ] ; then
			shopt -qs globstar
			f1a="$(realpath -q "$f2")"
			for f1b in "${f1a}"/** ; do
				if [ -f "$f1b" ] ; then
					iall1+=("$f1b")
				else
					continue
				fi
			done
		elif [ -f "$f2" ] ; then
			iall1+=("$f2")
		else
			echo >&2 "${scp}: WARNING: No such file or directory - skipping: $f2"
		fi
	done
	for f1 in "${iall1[@]}" ; do
		if basename "$f1" | grep -oqE "${lpat}" ; then
			for ab in $(basename "$f1" | grep -oE "${lpat}") ; do
				aa=$(lpat_aa)
				bb=$(lpat_bb)
				iter=$((iter + 1))
				if ((iter > 1)) ; then
					uquit
					if [ "$?" -eq 1 ] ; then
						iter=$((iter - 1))
						break
					fi
				fi
				core
			done
		else
			echo >&2 "${scp}: WARNING: No clip pattern - skipping: $(basename "$f1")"
		fi
	done
	echo "${scp}: ${iter:-0} iterations completed - exiting..."
elif [ '--help' = "$1" ] ; then
	cat << '_EOF_'
MPVCLIP - run MPV with the start and end of playback set to a pattern.

	SYNOPSIS
mpvclip {[<mpv profile,...>] [<clip pattern>... | -l] [-s] [path/]filename |
	--lpat <timestamp range>... | --help | --version}

	DESCRIPTION
MPVCLIP is a bash script that executes MPV with playback options for start and
end times set according to a pattern in file names, a playlist or the command
line.

MPV is run with any combination or none of the options: --start, --end.
MPV profile names are parsed and MPV is run according to: --profile.
MPV is only invoked to play a file with a clip pattern and is executed once for
each clip pattern; otherwise the files are skipped. Input directories are
expanded recursively. The line is read from left to right. If a key is pressed
within one second before MPV runs again, the script may exit or continue after
confirmation. Status messages report clip patterns and MPV options used, clip
duration, invalid inputs such as a file name without a pattern, and the number
of successful iterations.

	CLIP PATTERN
Recognized patterns are formed with an initial letter A followed by numbers next
to an intermediate letter B followed by numbers. Letters are matched regardless
of the case. Numbers are positive integers or zero and represent time in
deciseconds, that is, tenths of a second. Zero disables each time point.
Patterns are converted to seconds with one decimal place and translated into
time settings for playback start and end points A and B.

	Examples:
a1b2	(from 00:00:00.1 to 00:00:00.2)	(from 0.1 seconds to 0.2 seconds)
a10b20	(from 00:00:01 to 00:00:02)	(from 1 second to 2 seconds)
a0b123	(from 00:00:00 to 00:00:12.3)	(from start of file to 12.3 seconds)
a123b0	(from 00:00:12.3)		(from 12.3 seconds to end of file)
a0b0	(from 00:00:00)			(from start to end of file)

	For command line:
mpvclip foo-a1b2-a10b20.mp4
	How MPV is run:
mpv --start=0.1 --end=0.2 foo-a1b2-a10b20.mp4 ; \
mpv --start=1 --end=2 foo-a1b2-a10b20.mp4

	OPTIONS
MPV profile names and any number of clip patterns without flags can be entered
on the command line. Usage is printed if no arguments are given.

	<mpv profile,...>
Name of the MPV profile to use.

	For command line:
mpvclip gpu-hq foo-a1b2.mp4
	How MPV is run:
mpv --start=0.1 --end=0.2 --profile=gpu-hq foo-a1b2.mp4

	<clip pattern>...
Play files according to this optional pattern. Other patterns in filenames, if
any, are ignored.

	For command line:
mpvclip a10b20 foo-a1b2.mp4
	How MPV is run:
mpv --start=1 --end=2 foo-a1b2.mp4

	-l file
Plaintext playlist with commas to separate a single file followed by any number
of associated patterns on each line. Patterns in filenames, if any, are ignored.
A line which does not satisfy all of the conditions below is also ignored:
- There is comma.
- There is clip pattern.
- The first field is a regular file.

	For playlist file foo.txt which contains the following two lines:
path/to/foo1.mp4,a1b2,a123b0
foo2.mp4,a0b123

	How MPV is run:
mpv --start=0.1 --end=0.2 path/to/foo1.mp4 ; \
mpv --start=12.3 path/to/foo1.mp4 ; mpv --end=12.3 foo2.mp4

	-s
Shuffle the file list. With -l, options must be combined in any order, for
example: -ls.

	--lpat <timestamp range>...
Print clip patterns equivalent to the timestamp ranges entered in any of the
following three formats. Decisecond place is optional. A single missing
timestamp translates to zero in the clip pattern:
1. HH:MM:SS[.n]-HH:MM:SS[.n]
2. HH:MM:SS[.n]-
3. -HH:MM:SS[.n]

	Example:
mpvclip --lpat '00:02:03.4-00:09:27.8' '-00:00:12.3' '00:00:12.3-'
a1234b5678	(00:02:03.4-00:09:27.8)
a0b123		(-00:00:12.3)
a123b0		(00:00:12.3-)

	--version
Display version information.

	--help
Print this help summary.

	DEPENDENCIES
Awk
file (command)
GNU Bourne-Again SHell (Bash)
GNU Coreutils
GNU Grep
mpv

	COPYRIGHT
Unlicense <http://unlicense.org/>
This is free and unencumbered software released into the public domain and
provided without warranty of any kind.

	SEE ALSO
	input.conf (MPV)
The last line will configure MPV to print the current playing time in seconds to
the terminal screen (stdout) in addition to setting or clearing loop points as
in the default configuration when the L key is pressed. If "{time-pos}" instead
of "{=time-pos}" is used, the playing time will be printed as a timestamp
instead of seconds.
l ab-loop ; print-text "ab-loop=${=time-pos}"
_EOF_
elif [ '--version' = "$1" ] ; then
	echo "mpvclip 1.1"
elif [ '--lpat' = "$1" ] ; then
	swreq
	if [ -n "$2" ] ; then
		shift
		for tt in "$@" ; do
			if grep -qP '^[0-9][0-9]:[0-5][0-9]:[0-5][0-9](?:\.[0-9])?-[0-9][0-9]:[0-5][0-9]:[0-5][0-9](?:\.[0-9])?$' <<< "$tt" ; then
				ta=$(cut -d '-' -f 1 <<< "$tt")
				tb=$(cut -d '-' -f 2 <<< "$tt")
				lpat_ab="a$(lpat_tt "$ta")b$(lpat_tt "$tb")"
				if [ ${#lpat_ab} -lt 8 ] ; then
					printf "%s\\t\\t%s\\n" "$lpat_ab" "(${tt})"
				else
					printf "%s\\t%s\\n" "$lpat_ab" "(${tt})"
				fi
			elif grep -qP '^[0-9][0-9]:[0-5][0-9]:[0-5][0-9](?:\.[0-9])?-$' <<< "$tt" ; then
				ta=$(cut -d '-' -f 1 <<< "$tt")
				lpat_ab="a$(lpat_tt "$ta")b0"
				if [ ${#lpat_ab} -lt 8 ] ; then
					printf "%s\\t\\t%s\\n" "$lpat_ab" "(${tt})"
				else
					printf "%s\\t%s\\n" "$lpat_ab" "(${tt})"
				fi
			elif grep -qP '^-[0-9][0-9]:[0-5][0-9]:[0-5][0-9](?:\.[0-9])?$' <<< "$tt" ; then
				tb=$(cut -d '-' -f 2 <<< "$tt")
				lpat_ab="a0b$(lpat_tt "$tb")"
				if [ ${#lpat_ab} -lt 8 ] ; then
					printf "%s\\t\\t%s\\n" "$lpat_ab" "(${tt})"
				else
					printf "%s\\t%s\\n" "$lpat_ab" "(${tt})"
				fi
			else
				echo >&2 "${scp}: WARNING: Invalid timestamp format - skipping: $tt"
			fi
		done
	else
		echo "${scp}: Usage: ${scp} --lpat <HH:MM:SS[.n]-HH:MM:SS[.n] | HH:MM:SS[.n]- | -HH:MM:SS[.n]>..."
		echo "${scp}: Help summary: ${scp} --help"

	fi
elif [ '-l' = "$1" ] || [ '-ls' = "$1" ] || [ '-sl' = "$1" ] ; then
	swreq
	if [ "$#" -eq 2 ] && [ -r "$2" ] ; then
		if file -b --mime-type "$2" | grep -q 'text/plain' ; then
			if grep -q '[^[:space:]]' < "$2" ; then
				if [ '-ls' = "$1" ] || [ '-sl' = "$1" ] ; then
					shuffle=y
				fi
				loopfile="$2"
				core_ll
			else
				echo >&2 "${scp}: WARNING: Empty file: $2"
				echo "${scp}: Help summary: ${scp} --help"
			fi
		else
			echo >&2 "${scp}: WARNING: A single plaintext file is expected for playlist: $2"
			echo "${scp}: Help summary: ${scp} --help"
		fi
	else
		shift
		echo >&2 "${scp}: WARNING: A single plaintext file is expected for playlist:" "$@"
		echo "${scp}: Help summary: ${scp} --help"
	fi
	echo "${scp}: ${iter:-0} iterations completed - exiting..."
elif [ '-l' = "$2" ] || [ '-ls' = "$2" ] || [ '-sl' = "$2" ] ; then
	swreq
	if [ "$#" -eq 3 ] && [ -r "$3" ] ; then
		if file -b --mime-type "$3" | grep -q 'text/plain' ; then
			if grep -q '[^[:space:]]' < "$3" ; then
				if [ '-ls' = "$2" ] || [ '-sl' = "$2" ] ; then
					shuffle=y
				fi
				loopfile="$3"
				core_ll --profile="$1"
			else
				echo >&2 "${scp}: WARNING: Empty file: $3"
				echo "${scp}: Help summary: ${scp} --help"
			fi
		else
			echo >&2 "${scp}: WARNING: A single plaintext file is expected for playlist: $3"
			echo "${scp}: Help summary: ${scp} --help"
		fi
	else
		shift 2
		echo >&2 "${scp}: WARNING: A single plaintext file is expected for playlist:" "$@"
		echo "${scp}: Help summary: ${scp} --help"
	fi
	echo "${scp}: ${iter:-0} iterations completed - exiting..."
elif [ "$#" -eq 0 ] ; then
	echo "${scp}: Usage: ${scp} {[<mpv profile,...>] [<clip pattern>... | -l] [-s] [path/]filename | --lpat <timestamp range>... | --help | --version}"
else
	swreq
	for arg in "$@" ; do
		iterin=$((iterin + 1))
		if grep -oqE ^"${lpat}"\$ <<< "$arg" ; then
			aball+=("$arg")
		elif [ -e "$arg" ] ; then
			shift $((iterin - 1))
			iall3+=("$@")
			break
		elif [ '-s' = "$arg" ] ; then
			shuffle=y
		else
			if [ ! -v prf ] ; then
				prf="$arg"
			else
				echo >&2 "${scp}: WARNING: MPV profile already set to ${prf@Q} - skipping: $arg"
			fi
		fi
	done
	unset iterin
	if [ -v iall3 ] ; then
		for f2 in "${iall3[@]}" ; do
			if [ -d "$f2" ] ; then
				shopt -qs globstar
				f1a="$(realpath -q "$f2")"
				for f1b in "${f1a}"/** ; do
					if [ -f "$f1b" ] ; then
						iall2+=("$f1b")
					else
						continue
					fi
				done
			elif [ -f "$f2" ] ; then
				iall2+=("$f2")
			else
				echo >&2 "${scp}: WARNING: No such file or directory - skipping: $f2"
			fi
		done
		if [ -v shuffle ] ; then
			readarray -t iall1 < <(shuf -e "${iall2[@]}")
		else
			iall1+=("${iall2[@]}")
		fi
		for f1 in "${iall1[@]}" ; do
			if [ -v aball ] ; then
				for ab in "${aball[@]}" ; do
					aa=$(lpat_aa)
					bb=$(lpat_bb)
					iter=$((iter + 1))
					if ((iter > 1)) ; then
						uquit
						if [ "$?" -eq 1 ] ; then
							iter=$((iter - 1))
							break
						fi
					fi
					if [ -v prf ] ; then
						core --profile="$prf"
					else
						core
					fi
				done
			else
				if basename "$f1" | grep -oqE "${lpat}" ; then
					for ab in $(basename "$f1" | grep -oE "${lpat}") ; do
						aa=$(lpat_aa)
						bb=$(lpat_bb)
						iter=$((iter + 1))
						if ((iter > 1)) ; then
							uquit
							if [ "$?" -eq 1 ] ; then
								iter=$((iter - 1))
								break
							fi
						fi
						if [ -v prf ] ; then
							core --profile="$prf"
						else
							core
						fi
					done
				else
					echo >&2 "${scp}: WARNING: No clip pattern - skipping: $(basename "$f1")"
				fi
			fi
		done
	else
		echo >&2 "${scp}: WARNING: Invalid options - aborting."
		echo "${scp}: Help summary: ${scp} --help"
	fi
	echo "${scp}: ${iter:-0} iterations completed - exiting..."
fi