[BK-2020-03.git] / user / bk-copy-rand-music.sh

#!/usr/bin/env bash
# Desc: Copies random audio files
# Usage: bk-copy-rand-music.sh [dir SOURCE] [dir DEST] [int DURATION]
# Version: 0.0.3

declare -Ag appRollCall # Associative array for storing app status
declare -Ag fileRollCall # Associative array for storing file status
declare -Ag dirRollCall # Associative array for storing dir status
declare -a music_codecs # Array for storing valid codec names (e.g. "aac" "mp3")

# Adjustable parameters
music_codecs=("vorbis" "aac" "mp3" "flac" "opus"); # whitelist of valid codec_names ffprobe might return
max_loops="1000000"; # max number of files to test whether are audio or not
max_filename_length="255"; # max output filename length
min_file_duration="10"; # minimum duration per music file

yell() { echo "$0: $*" >&2; } # print script path and all args to stderr
die() { yell "$*"; exit 111; } # same as yell() but non-zero exit status
try() { "$@" || die "cannot $*"; } # runs args as command, reports args if command fails
checkapp() {
    # Desc: If arg is a command, save result in assoc array 'appRollCall'
    # Usage: checkapp arg1 arg2 arg3 ...
    # Version: 0.1.1
    # Input: global assoc. array 'appRollCall'
    # Output: adds/updates key(value) to global assoc array 'appRollCall'
    # Depends: bash 5.0.3
    local returnState    

    #===Process Args===
    for arg in "$@"; do
	if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
	    appRollCall[$arg]="true";
	    if ! [ "$returnState" = "false" ]; then returnState="true"; fi;
	else
	    appRollCall[$arg]="false"; returnState="false";
	fi;
    done;

    #===Determine function return code===
    if [ "$returnState" = "true" ]; then
	return 0;
    else
	return 1;
    fi;
} # Check that app exists
checkfile() {
    # Desc: If arg is a file path, save result in assoc array 'fileRollCall'
    # Usage: checkfile arg1 arg2 arg3 ...
    # Version: 0.1.1
    # Input: global assoc. array 'fileRollCall'
    # Output: adds/updates key(value) to global assoc array 'fileRollCall';
    # Output: returns 0 if app found, 1 otherwise
    # Depends: bash 5.0.3
    local returnState

    #===Process Args===
    for arg in "$@"; do
	if [ -f "$arg" ]; then
	    fileRollCall["$arg"]="true";
	    if ! [ "$returnState" = "false" ]; then returnState="true"; fi;
	else
	    fileRollCall["$arg"]="false"; returnState="false";
	fi;
    done;
    
    #===Determine function return code===
    if [ "$returnState" = "true" ]; then
	return 0;
    else
	return 1;
    fi;
} # Check that file exists
checkdir() {
    # Desc: If arg is a dir path, save result in assoc array 'dirRollCall'
    # Usage: checkdir arg1 arg2 arg3 ...
    # Version 0.1.2
    # Input: global assoc. array 'dirRollCall'
    # Output: adds/updates key(value) to global assoc array 'dirRollCall';
    # Output: returns 0 if all args are dirs; 1 otherwise
    # Depends: Bash 5.0.3
    local returnState

    #===Process Args===
    for arg in "$@"; do
	if [ -z "$arg" ]; then
	    dirRollCall["(Unspecified Dirname(s))"]="false"; returnState="false";
	elif [ -d "$arg" ]; then
	    dirRollCall["$arg"]="true";
	    if ! [ "$returnState" = "false" ]; then returnState="true"; fi
	else
	    dirRollCall["$arg"]="false"; returnState="false";
	fi
    done
    
    #===Determine function return code===
    if [ "$returnState" = "true" ]; then
	return 0;
    else
	return 1;
    fi
} # Check that dir exists
displayMissing() {
    # Desc: Displays missing apps, files, and dirs
    # Usage: displayMissing
    # Version 1.0.0
    # Input: associative arrays: appRollCall, fileRollCall, dirRollCall
    # Output: stderr: messages indicating missing apps, file, or dirs
    # Output: returns exit code 0 if nothing missing; 1 otherwise
    # Depends: bash 5, checkAppFileDir()
    local missingApps value appMissing missingFiles fileMissing
    local missingDirs dirMissing

    #==BEGIN Display errors==
    #===BEGIN Display Missing Apps===
    missingApps="Missing apps  :";
    #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
    for key in "${!appRollCall[@]}"; do
	value="${appRollCall[$key]}";
	if [ "$value" = "false" ]; then
	    #echo "DEBUG:Missing apps: $key => $value";
	    missingApps="$missingApps""$key ";
	    appMissing="true";
	fi;
    done;
    if [ "$appMissing" = "true" ]; then  # Only indicate if an app is missing.
	echo "$missingApps" 1>&2;
    fi;
    unset value;
    #===END Display Missing Apps===

    #===BEGIN Display Missing Files===
    missingFiles="Missing files:";
    #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
    for key in "${!fileRollCall[@]}"; do
	value="${fileRollCall[$key]}";
	if [ "$value" = "false" ]; then
	    #echo "DEBUG:Missing files: $key => $value";
	    missingFiles="$missingFiles""$key ";
	    fileMissing="true";
	fi;
    done;
    if [ "$fileMissing" = "true" ]; then  # Only indicate if an app is missing.
	echo "$missingFiles" 1>&2;
    fi;
    unset value;
    #===END Display Missing Files===

    #===BEGIN Display Missing Directories===
    missingDirs="Missing dirs:";
    #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
    for key in "${!dirRollCall[@]}"; do
	value="${dirRollCall[$key]}";
	if [ "$value" = "false" ]; then
	    #echo "DEBUG:Missing dirs: $key => $value";
	    missingDirs="$missingDirs""$key ";
	    dirMissing="true";
	fi;
    done;
    if [ "$dirMissing" = "true" ]; then  # Only indicate if an dir is missing.
	echo "$missingDirs" 1>&2;
    fi;
    unset value;
    #===END Display Missing Directories===

    #==END Display errors==
    #==BEGIN Determine function return code===
    if [ "$appMissing" == "true" ] || [ "$fileMissing" == "true" ] || [ "$dirMissing" == "true" ]; then
	return 1;
    else
	return 0;
    fi
    #==END Determine function return code===
} # Display missing apps, files, dirs
showUsage() {
    # Desc: Display script usage information
    # Usage: showUsage
    # Version 0.0.1
    # Input: none
    # Output: stdout
    # Depends: GNU-coreutils 8.30 (cat)
    cat <<'EOF'

    DESCRIPTION:
      This script may be used to copy a random selection of files containing
      audio tracks from SOURCE to DEST.

    USAGE:
      bk-copy-rand-music [dir SOURCE] [dir DEST] [int DURATION]

    EXAMPLE:
      bk-copy-rand-music ~/Music /tmp/music-sample 3600

    DEPENDENCIES:
      ffprobe
      GNU Coreutils 8.30
EOF
} # Display information on how to use this script.
check_parsable_audio_ffprobe() {
    # Desc: Checks if ffprobe returns valid audio codec name for file
    # Usage: check_parsable_audio_ffprobe [path FILE]
    # Version: 0.0.1
    # Input: arg1: file path
    # Output: exit code 0 if returns valid codec name; 1 otherwise
    # Depends: ffprobe, die()
    local file_in ffprobe_out

    if [[ $# -ne 1 ]]; then die "ERROR:Invalid number of args:$#"; fi;
    
    file_in="$1";
    
    # Check if ffprobe detects an audio stream
    if ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in" 1>/dev/null 2>&1; then
	return_state="true";
    else
	return_state="false";
    fi;

    # Fail if ffprobe returns no result
    ffprobe_out="$(ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in")";
    if [[ -z $ffprobe_out ]]; then
	return_state="false";
    fi;
    
    # Report exit code
    if [[ $return_state = "true" ]]; then
	return 0;
    else
	return 1;
    fi;
} # Checks if file has valid codec name using ffprobe
get_audio_format() {
    # Desc: Gets audio format of file as string
    # Usage: get_audio_format arg1
    # Depends: ffprobe
    # Version: 0.0.1
    # Input: arg1: input file path
    # Output: stdout (if valid audio format)
    #         exit code 0 if audio file; 1 otherwise
    # Example: get_audio_format myvideo.mp4
    #   Note: Would return "opus" if full ffprobe report had 'Audio: opus, 48000 Hz, stereo, fltp'
    # Note: Not tested with videos containing multiple video streams
    # Ref/Attrib: [1] https://stackoverflow.com/questions/5618363/is-there-a-way-to-use-ffmpeg-to-determine-the-encoding-of-a-file-before-transcod
    #             [2] https://stackoverflow.com/questions/44123532/how-to-find-out-the-file-extension-for-extracting-audio-tracks-with-ffmpeg-and-p#comment88464070_50723126
    local audio_format file_in;
    local return_state;
    file_in="$1";

    # Return error exit code if not audio file
    ## Return error if ffprobe itself exited on error
    if ! ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in" 1>/dev/null 2>&1; then
	return_state="false";
    fi;
    
    # Get audio format
    audio_format="$(ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in")"; # see [1]

    ## Return error if audio format is incorrectly formatted (e.g. reject if contains spaces)
    pattern="^[[:alnum:]]+$"; # alphanumeric string with no spaces
    if [[ $audio_format =~ $pattern ]]; then
	return_state="true";
	# Report audio format
	echo "$audio_format";
    else
	return_state="false";
    fi;
    
    # Report exit code
    if [[ $return_state = "true" ]]; then
	return 0;
    else
	return 1;
    fi;
} # Get audio format as stdout
get_media_length() {
    # Use ffprobe to get media container length in seconds (float)
    # Usage: get_media_length arg1
    # Input:  arg1: path to file
    # Output: stdout: seconds (float)
    # Depends: ffprobe 4.1.8
    # Ref/Attrib: [1] How to get video duration in seconds? https://superuser.com/a/945604
    local file_in
    file_in="$1";
    if [[ ! -f $file_in ]]; then
	die "ERROR:Not a file:$file_in";
    fi;
    ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$file_in";
} # Get media container length in seconds via stdout
checkInt() {
    # Desc: Checks if arg is integer
    # Usage: checkInt arg
    # Input: arg: integer
    # Output: - return code 0 (if arg is integer)
    #         - return code 1 (if arg is not integer)
    # Example: if ! checkInt $arg; then echo "not int"; fi;
    # Version: 0.0.1
    local returnState

    #===Process Arg===
    if [[ $# -ne 1 ]]; then
	die "ERROR:Invalid number of arguments:$#";
    fi;
    
    RETEST1='^[0-9]+$'; # Regular Expression to test
    if [[ ! $1 =~ $RETEST1 ]] ; then
	returnState="false";
    else
	returnState="true";
    fi;

    #===Determine function return code===
    if [ "$returnState" = "true" ]; then
	return 0;
    else
	return 1;
    fi;
} # Checks if arg is integer
checkIsInArray() {
    # Desc: Checks if input arg is element in array
    # Usage: checkIsInArray arg1 arg2
    # Version: 0.0.1
    # Input: arg1: test string
    #        arg2: array
    # Output: exit code 0 if test string is in array; 1 otherwise
    # Example: checkIsInArray "foo" "${myArray[@]}"
    # Ref/Attrib: [1] How do I check if variable is an array? https://stackoverflow.com/a/27254437
    #             [2] How to pass an array as function argument? https://askubuntu.com/a/674347
    local return_state input arg1 string_test
    declare -a arg2 array_test
    input=("$@") # See [2]
    arg1="${input[0]}";
    arg2=("${input[@]:1}");
    #yell "DEBUG:input:${input[@]}";
    #yell "DEBUG:arg1:${arg1[@]}";
    #yell "DEBUG:arg2:${arg2[@]}";

    string_test="$arg1";
    array_test=("${arg2[@]}");

    #yell "DEBUG:string_test:$string_test";
    #yell "DEBUG:$(declare -p array_test)";
    for element in "${array_test[@]}"; do
	#yell "DEBUG:element:$element";
	if [[ "$element" =~ ^"$string_test" ]]; then
	    return_state="true";
	    continue;
	fi;
    done;
    
    # Report exit code
    if [[ $return_state == "true" ]]; then
    	return 0;
    else
    	return 1;
    fi;
} # Check if string is element in array
main() {
    # Desc: Main program
    # Input: arg1: path to source tree
    #        arg2: path to destination tree
    #        arg3: cumulative duration (seconds) of audio files in destination tree
    #        assoc arrays: appRollCall, fileRollCall, dirRollCall
    # Output: [none]
    # Depends: yell(), checkdir() 0.1.2, displayMissing() 1.0.0, GNU Coreutils 8.30 (shuf)
    local arg1 arg2 arg3 dur_dest dir_source dir_dest list_all
    declare -a list_files # array for files to be considered
    declare -A list_copy # assoc array for files to be copied (key=path; value=duration)

    # Parse args
    arg1="$1";
    arg2="$2";
    arg3="$3";
    if [[ $# -ne 3 ]]; then showUsage; die "ERROR:Invalid number of args."; fi;

    ## Check duration
    if checkInt "$arg3"; then
	dur_dest="$arg3";
    else
	yell "ERROR:Duration (seconds) not an int:$arg3"
    fi;
    
    ## Check directories
    if checkdir "$arg1" "$arg2"; then
	dir_source="$arg1";
	dir_dest="$arg2";
    else
	yell "ERROR:Directory error";
    fi;

    ## Check apps
    checkapp ffprobe;

    if ! displayMissing; then
	showUsage;
	die "ERROR:Check missing resources.";
    fi;

    yell "STATUS:Working...";
    
    # Generate file path list
    list_all="$(find -L "$dir_source")";
    #yell "DEBUG:list_files_rel:$list_files_rel";

    # Prune list_all of non-files and save as array list_files
    while read -r line; do
	#yell "DEBUG:line:$line";
	if ! [[ -f $line ]]; then
	    #yell "DEBUG:Not a file:$line";
	    #yell ""; # debug
	    continue;
	fi;
	list_files+=("$line");
    done < <(echo "$list_all");

    # Randomly test and add elements of list_files array to list_copy
    dur=0; # Initialize duration
    n=0; # Initialize loop counter
    ## Get element count of list_files array
    list_files_count="${#list_files[@]}";
    while [[ $dur -le $dur_dest ]]; do
	#yell "DEBUG:list_copy building loop:$n";
	### Select random element of list_files array
	list_files_index="$(shuf -i 1-"$list_files_count" -n1)";
	list_files_index="$((list_files_index - 1))"; # bash arrays are zero-indexed
	path_candfile="${list_files[$list_files_index]}"; # path of candidate file

	### Check if has valid codec
	if ! check_parsable_audio_ffprobe "$path_candfile"; then continue; fi; # reject
	
	### Check if desired codec
	file_format="$(get_audio_format "$path_candfile")";
	if ! checkIsInArray "$file_format" "${music_codecs[@]}"; then continue; fi; # reject

	### Check and save duration
	dur_cand="$(get_media_length "$path_candfile")";
	dur_cand="${dur_cand%%.*}"; # convert float to int
	if ! checkInt "$dur_cand"; then continue; fi; # reject
	if [[ "$dur_cand" -lt "$min_file_duration" ]]; then continue; fi; # reject

	### Add/update candfile to list_copy assoc. array (key=path; value=duration)
	#yell "DEBUG:Adding $path_candfile";
	list_copy["$path_candfile"]="$dur_cand";

	### Update total duration $dur by summing all list_copy assoc. array values
	dur=0;
	for value in "${list_copy[@]}"; do
	    dur="$((dur + value))";
	done;
	#yell "DEBUG:dur:$dur";

	### Sanity check
	((n++));
	if [[ $n -gt $max_loops ]]; then die "ERROR:Too many loops:$n"; fi;
    done;

    n=0; # Initialize loop counter
    # Copy files in list_copy to dir_dest;
    for key in "${!list_copy[@]}"; do
	value="${list_copy[$key]}";
	## Get basename of path
	file_basename="$(basename "$key")";

	## Get 16-character b2sum fingerprint (for different files that share basename)
	fingerprint="$(b2sum -l64 "$key" | cut -d' ' -f1)";

	## Form output filename
	file_name="$fingerprint".."$file_basename";
	file_name="${file_name:0:$max_filename_length}"; # Limit filename length (e.g. Windows has max of 255 characters)

	## Form output path
	path_output="$dir_dest"/"$file_name";
	
	## Copy
	try cp "$key" "$path_output" && yell "NOTICE:Copied ($value seconds): $key ";
	#yell "DEBUG:Copied $file_basename to $dur_dest.";

	## Append log
	path_log_output="$dir_dest"/COPY.log;
	if [[ $n -le 0 ]]; then
            echo "fingerprint","duration","original_path" >> "$path_log_output";
	else
	    echo "$fingerprint","$value","$key" >> "$path_log_output";
	fi;

	((n++));
	unset file_basename path_output
    done;

    # Report total duration
    yell "NOTICE:Total duration (seconds):$dur";

} # Main program

main "$@";

# Author: Steven Baltakatei Sandoval
# License: GPLv3+
Commit	Line	Data
a9a36cc4	1	#!/usr/bin/env bash
40fcffff	2	# Desc: Copies random audio files
a9a36cc4	3	# Usage: bk-copy-rand-music.sh [dir SOURCE] [dir DEST] [int DURATION]
63170cb8	4	# Version: 0.0.3
a9a36cc4 SBS	5
	6	declare -Ag appRollCall # Associative array for storing app status
	7	declare -Ag fileRollCall # Associative array for storing file status
	8	declare -Ag dirRollCall # Associative array for storing dir status
	9	declare -a music_codecs # Array for storing valid codec names (e.g. "aac" "mp3")
	10
	11	# Adjustable parameters
	12	music_codecs=("vorbis" "aac" "mp3" "flac" "opus"); # whitelist of valid codec_names ffprobe might return
40fcffff SBS	13	max_loops="1000000"; # max number of files to test whether are audio or not
	14	max_filename_length="255"; # max output filename length
	15	min_file_duration="10"; # minimum duration per music file
a9a36cc4 SBS	16
	17	yell() { echo "$0: $*" >&2; } # print script path and all args to stderr
	18	die() { yell "$*"; exit 111; } # same as yell() but non-zero exit status
	19	try() { "$@" \|\| die "cannot $*"; } # runs args as command, reports args if command fails
	20	checkapp() {
	21	# Desc: If arg is a command, save result in assoc array 'appRollCall'
	22	# Usage: checkapp arg1 arg2 arg3 ...
	23	# Version: 0.1.1
	24	# Input: global assoc. array 'appRollCall'
	25	# Output: adds/updates key(value) to global assoc array 'appRollCall'
	26	# Depends: bash 5.0.3
	27	local returnState
	28
	29	#===Process Args===
	30	for arg in "$@"; do
	31	if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
	32	appRollCall[$arg]="true";
	33	if ! [ "$returnState" = "false" ]; then returnState="true"; fi;
	34	else
	35	appRollCall[$arg]="false"; returnState="false";
	36	fi;
	37	done;
	38
	39	#===Determine function return code===
	40	if [ "$returnState" = "true" ]; then
	41	return 0;
	42	else
	43	return 1;
	44	fi;
	45	} # Check that app exists
	46	checkfile() {
	47	# Desc: If arg is a file path, save result in assoc array 'fileRollCall'
	48	# Usage: checkfile arg1 arg2 arg3 ...
	49	# Version: 0.1.1
	50	# Input: global assoc. array 'fileRollCall'
	51	# Output: adds/updates key(value) to global assoc array 'fileRollCall';
	52	# Output: returns 0 if app found, 1 otherwise
	53	# Depends: bash 5.0.3
	54	local returnState
	55
	56	#===Process Args===
	57	for arg in "$@"; do
	58	if [ -f "$arg" ]; then
	59	fileRollCall["$arg"]="true";
	60	if ! [ "$returnState" = "false" ]; then returnState="true"; fi;
	61	else
	62	fileRollCall["$arg"]="false"; returnState="false";
	63	fi;
	64	done;
	65
	66	#===Determine function return code===
	67	if [ "$returnState" = "true" ]; then
	68	return 0;
	69	else
	70	return 1;
	71	fi;
	72	} # Check that file exists
	73	checkdir() {
	74	# Desc: If arg is a dir path, save result in assoc array 'dirRollCall'
	75	# Usage: checkdir arg1 arg2 arg3 ...
	76	# Version 0.1.2
	77	# Input: global assoc. array 'dirRollCall'
	78	# Output: adds/updates key(value) to global assoc array 'dirRollCall';
	79	# Output: returns 0 if all args are dirs; 1 otherwise
80	# Depends: Bash 5.0.3
81	local returnState
82
83	#===Process Args===
84	for arg in "$@"; do
85	if [ -z "$arg" ]; then
86	dirRollCall["(Unspecified Dirname(s))"]="false"; returnState="false";
87	elif [ -d "$arg" ]; then
88	dirRollCall["$arg"]="true";
89	if ! [ "$returnState" = "false" ]; then returnState="true"; fi
90	else
91	dirRollCall["$arg"]="false"; returnState="false";
92	fi
93	done
94
95	#===Determine function return code===
96	if [ "$returnState" = "true" ]; then
97	return 0;
98	else
99	return 1;
100	fi
101	} # Check that dir exists
102	displayMissing() {
103	# Desc: Displays missing apps, files, and dirs
104	# Usage: displayMissing
105	# Version 1.0.0
106	# Input: associative arrays: appRollCall, fileRollCall, dirRollCall
107	# Output: stderr: messages indicating missing apps, file, or dirs
108	# Output: returns exit code 0 if nothing missing; 1 otherwise
109	# Depends: bash 5, checkAppFileDir()
110	local missingApps value appMissing missingFiles fileMissing
111	local missingDirs dirMissing
112
113	#==BEGIN Display errors==
114	#===BEGIN Display Missing Apps===
115	missingApps="Missing apps :";
116	#for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
117	for key in "${!appRollCall[@]}"; do
118	value="${appRollCall[$key]}";
119	if [ "$value" = "false" ]; then
120	#echo "DEBUG:Missing apps: $key => $value";
121	missingApps="$missingApps""$key ";
122	appMissing="true";
123	fi;
124	done;
125	if [ "$appMissing" = "true" ]; then # Only indicate if an app is missing.
126	echo "$missingApps" 1>&2;
127	fi;
128	unset value;
129	#===END Display Missing Apps===
130
131	#===BEGIN Display Missing Files===
132	missingFiles="Missing files:";
133	#for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
134	for key in "${!fileRollCall[@]}"; do
135	value="${fileRollCall[$key]}";
136	if [ "$value" = "false" ]; then
137	#echo "DEBUG:Missing files: $key => $value";
138	missingFiles="$missingFiles""$key ";
139	fileMissing="true";
140	fi;
141	done;
142	if [ "$fileMissing" = "true" ]; then # Only indicate if an app is missing.
143	echo "$missingFiles" 1>&2;
144	fi;
145	unset value;
146	#===END Display Missing Files===
147
148	#===BEGIN Display Missing Directories===
149	missingDirs="Missing dirs:";
150	#for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
151	for key in "${!dirRollCall[@]}"; do
152	value="${dirRollCall[$key]}";
153	if [ "$value" = "false" ]; then
154	#echo "DEBUG:Missing dirs: $key => $value";
155	missingDirs="$missingDirs""$key ";
156	dirMissing="true";
157	fi;
158	done;
159	if [ "$dirMissing" = "true" ]; then # Only indicate if an dir is missing.
160	echo "$missingDirs" 1>&2;
161	fi;
162	unset value;
163	#===END Display Missing Directories===
164
165	#==END Display errors==
166	#==BEGIN Determine function return code===
167	if [ "$appMissing" == "true" ] \|\| [ "$fileMissing" == "true" ] \|\| [ "$dirMissing" == "true" ]; then
168	return 1;
169	else
170	return 0;
171	fi
172	#==END Determine function return code===
173	} # Display missing apps, files, dirs
174	showUsage() {
175	# Desc: Display script usage information
176	# Usage: showUsage
177	# Version 0.0.1
178	# Input: none
179	# Output: stdout
180	# Depends: GNU-coreutils 8.30 (cat)
181	cat <<'EOF'
182
183	DESCRIPTION:
40fcffff SBS	184	This script may be used to copy a random selection of files containing
40fcffff SBS	185	audio tracks from SOURCE to DEST.
a9a36cc4 SBS	186
	187	USAGE:
	188	bk-copy-rand-music [dir SOURCE] [dir DEST] [int DURATION]
	189
	190	EXAMPLE:
	191	bk-copy-rand-music ~/Music /tmp/music-sample 3600
	192
	193	DEPENDENCIES:
	194	ffprobe
	195	GNU Coreutils 8.30
	196	EOF
	197	} # Display information on how to use this script.
	198	check_parsable_audio_ffprobe() {
	199	# Desc: Checks if ffprobe returns valid audio codec name for file
	200	# Usage: check_parsable_audio_ffprobe [path FILE]
	201	# Version: 0.0.1
	202	# Input: arg1: file path
	203	# Output: exit code 0 if returns valid codec name; 1 otherwise
	204	# Depends: ffprobe, die()
	205	local file_in ffprobe_out
	206
	207	if [[ $# -ne 1 ]]; then die "ERROR:Invalid number of args:$#"; fi;
	208
	209	file_in="$1";
	210
	211	# Check if ffprobe detects an audio stream
	212	if ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in" 1>/dev/null 2>&1; then
	213	return_state="true";
	214	else
	215	return_state="false";
	216	fi;
	217
	218	# Fail if ffprobe returns no result
	219	ffprobe_out="$(ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in")";
	220	if [[ -z $ffprobe_out ]]; then
	221	return_state="false";
	222	fi;
	223
	224	# Report exit code
	225	if [[ $return_state = "true" ]]; then
	226	return 0;
	227	else
	228	return 1;
	229	fi;
	230	} # Checks if file has valid codec name using ffprobe
	231	get_audio_format() {
	232	# Desc: Gets audio format of file as string
	233	# Usage: get_audio_format arg1
	234	# Depends: ffprobe
	235	# Version: 0.0.1
	236	# Input: arg1: input file path
	237	# Output: stdout (if valid audio format)
	238	# exit code 0 if audio file; 1 otherwise
	239	# Example: get_audio_format myvideo.mp4
	240	# Note: Would return "opus" if full ffprobe report had 'Audio: opus, 48000 Hz, stereo, fltp'
	241	# Note: Not tested with videos containing multiple video streams
	242	# Ref/Attrib: [1] https://stackoverflow.com/questions/5618363/is-there-a-way-to-use-ffmpeg-to-determine-the-encoding-of-a-file-before-transcod
	243	# [2] https://stackoverflow.com/questions/44123532/how-to-find-out-the-file-extension-for-extracting-audio-tracks-with-ffmpeg-and-p#comment88464070_50723126
	244	local audio_format file_in;
	245	local return_state;
	246	file_in="$1";
	247
	248	# Return error exit code if not audio file
	249	## Return error if ffprobe itself exited on error
250	if ! ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in" 1>/dev/null 2>&1; then
251	return_state="false";
252	fi;
253
254	# Get audio format
255	audio_format="$(ffprobe -v error -select_streams a -show_entries stream=codec_name -of default=nokey=1:noprint_wrappers=1 "$file_in")"; # see [1]
256
257	## Return error if audio format is incorrectly formatted (e.g. reject if contains spaces)
258	pattern="^[[:alnum:]]+$"; # alphanumeric string with no spaces
259	if [[ $audio_format =~ $pattern ]]; then
260	return_state="true";
261	# Report audio format
262	echo "$audio_format";
263	else
264	return_state="false";
265	fi;
266
267	# Report exit code
268	if [[ $return_state = "true" ]]; then
269	return 0;
270	else
271	return 1;
272	fi;
273	} # Get audio format as stdout
274	get_media_length() {
275	# Use ffprobe to get media container length in seconds (float)
276	# Usage: get_media_length arg1
277	# Input: arg1: path to file
278	# Output: stdout: seconds (float)
279	# Depends: ffprobe 4.1.8
280	# Ref/Attrib: [1] How to get video duration in seconds? https://superuser.com/a/945604
281	local file_in
282	file_in="$1";
283	if [[ ! -f $file_in ]]; then
284	die "ERROR:Not a file:$file_in";
285	fi;
286	ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$file_in";
287	} # Get media container length in seconds via stdout
288	checkInt() {
289	# Desc: Checks if arg is integer
290	# Usage: checkInt arg
291	# Input: arg: integer
292	# Output: - return code 0 (if arg is integer)
293	# - return code 1 (if arg is not integer)
294	# Example: if ! checkInt $arg; then echo "not int"; fi;
295	# Version: 0.0.1
296	local returnState
297
298	#===Process Arg===
299	if [[ $# -ne 1 ]]; then
300	die "ERROR:Invalid number of arguments:$#";
301	fi;
302
303	RETEST1='^[0-9]+$'; # Regular Expression to test
304	if [[ ! $1 =~ $RETEST1 ]] ; then
305	returnState="false";
306	else
307	returnState="true";
308	fi;
309
310	#===Determine function return code===
311	if [ "$returnState" = "true" ]; then
312	return 0;
313	else
314	return 1;
315	fi;
316	} # Checks if arg is integer
317	checkIsInArray() {
318	# Desc: Checks if input arg is element in array
319	# Usage: checkIsInArray arg1 arg2
320	# Version: 0.0.1
321	# Input: arg1: test string
322	# arg2: array
323	# Output: exit code 0 if test string is in array; 1 otherwise
324	# Example: checkIsInArray "foo" "${myArray[@]}"
325	# Ref/Attrib: [1] How do I check if variable is an array? https://stackoverflow.com/a/27254437
326	# [2] How to pass an array as function argument? https://askubuntu.com/a/674347
327	local return_state input arg1 string_test
328	declare -a arg2 array_test
329	input=("$@") # See [2]
330	arg1="${input[0]}";
331	arg2=("${input[@]:1}");
332	#yell "DEBUG:input:${input[@]}";
333	#yell "DEBUG:arg1:${arg1[@]}";
334	#yell "DEBUG:arg2:${arg2[@]}";
335
336	string_test="$arg1";
337	array_test=("${arg2[@]}");
338
339	#yell "DEBUG:string_test:$string_test";
340	#yell "DEBUG:$(declare -p array_test)";
341	for element in "${array_test[@]}"; do
342	#yell "DEBUG:element:$element";
343	if [[ "$element" =~ ^"$string_test" ]]; then
344	return_state="true";
345	continue;
346	fi;
347	done;
348
349	# Report exit code
350	if [[ $return_state == "true" ]]; then
351	return 0;
352	else
353	return 1;
354	fi;
355	} # Check if string is element in array
356	main() {
357	# Desc: Main program
358	# Input: arg1: path to source tree
359	# arg2: path to destination tree
360	# arg3: cumulative duration (seconds) of audio files in destination tree
361	# assoc arrays: appRollCall, fileRollCall, dirRollCall
362	# Output: [none]
363	# Depends: yell(), checkdir() 0.1.2, displayMissing() 1.0.0, GNU Coreutils 8.30 (shuf)
364	local arg1 arg2 arg3 dur_dest dir_source dir_dest list_all
365	declare -a list_files # array for files to be considered
366	declare -A list_copy # assoc array for files to be copied (key=path; value=duration)
367
368	# Parse args
369	arg1="$1";
370	arg2="$2";
371	arg3="$3";
372	if [[ $# -ne 3 ]]; then showUsage; die "ERROR:Invalid number of args."; fi;
373
374	## Check duration
375	if checkInt "$arg3"; then
376	dur_dest="$arg3";
377	else
378	yell "ERROR:Duration (seconds) not an int:$arg3"
379	fi;
380
381	## Check directories
382	if checkdir "$arg1" "$arg2"; then
383	dir_source="$arg1";
384	dir_dest="$arg2";
385	else
386	yell "ERROR:Directory error";
387	fi;
388
389	## Check apps
390	checkapp ffprobe;
391
392	if ! displayMissing; then
393	showUsage;
394	die "ERROR:Check missing resources.";
395	fi;
396
397	yell "STATUS:Working...";
398
399	# Generate file path list
400	list_all="$(find -L "$dir_source")";
401	#yell "DEBUG:list_files_rel:$list_files_rel";
402
403	# Prune list_all of non-files and save as array list_files
404	while read -r line; do
405	#yell "DEBUG:line:$line";
406	if ! [[ -f $line ]]; then
407	#yell "DEBUG:Not a file:$line";
408	#yell ""; # debug
409	continue;
410	fi;
411	list_files+=("$line");
412	done < <(echo "$list_all");
413
414	# Randomly test and add elements of list_files array to list_copy
415	dur=0; # Initialize duration
416	n=0; # Initialize loop counter
417	## Get element count of list_files array
418	list_files_count="${#list_files[@]}";
419	while [[ $dur -le $dur_dest ]]; do
420	#yell "DEBUG:list_copy building loop:$n";
421	### Select random element of list_files array
422	list_files_index="$(shuf -i 1-"$list_files_count" -n1)";
423	list_files_index="$((list_files_index - 1))"; # bash arrays are zero-indexed
424	path_candfile="${list_files[$list_files_index]}"; # path of candidate file
425
426	### Check if has valid codec
427	if ! check_parsable_audio_ffprobe "$path_candfile"; then continue; fi; # reject
428
429	### Check if desired codec
430	file_format="$(get_audio_format "$path_candfile")";
431	if ! checkIsInArray "$file_format" "${music_codecs[@]}"; then continue; fi; # reject
432
433	### Check and save duration
434	dur_cand="$(get_media_length "$path_candfile")";
435	dur_cand="${dur_cand%%.*}"; # convert float to int
436	if ! checkInt "$dur_cand"; then continue; fi; # reject
40fcffff	437	if [[ "$dur_cand" -lt "$min_file_duration" ]]; then continue; fi; # reject
a9a36cc4 SBS	438
	439	### Add/update candfile to list_copy assoc. array (key=path; value=duration)
	440	#yell "DEBUG:Adding $path_candfile";
	441	list_copy["$path_candfile"]="$dur_cand";
	442
	443	### Update total duration $dur by summing all list_copy assoc. array values
	444	dur=0;
	445	for value in "${list_copy[@]}"; do
	446	dur="$((dur + value))";
	447	done;
	448	#yell "DEBUG:dur:$dur";
	449
	450	### Sanity check
	451	((n++));
	452	if [[ $n -gt $max_loops ]]; then die "ERROR:Too many loops:$n"; fi;
	453	done;
	454
63170cb8	455	n=0; # Initialize loop counter
a9a36cc4 SBS	456	# Copy files in list_copy to dir_dest;
	457	for key in "${!list_copy[@]}"; do
	458	value="${list_copy[$key]}";
	459	## Get basename of path
	460	file_basename="$(basename "$key")";
	461
	462	## Get 16-character b2sum fingerprint (for different files that share basename)
	463	fingerprint="$(b2sum -l64 "$key" \| cut -d' ' -f1)";
	464
40fcffff SBS	465	## Form output filename
	466	file_name="$fingerprint".."$file_basename";
	467	file_name="${file_name:0:$max_filename_length}"; # Limit filename length (e.g. Windows has max of 255 characters)
	468
a9a36cc4	469	## Form output path
40fcffff	470	path_output="$dir_dest"/"$file_name";
a9a36cc4 SBS	471
	472	## Copy
	473	try cp "$key" "$path_output" && yell "NOTICE:Copied ($value seconds): $key ";
	474	#yell "DEBUG:Copied $file_basename to $dur_dest.";
	475
63170cb8 SBS	476	## Append log
	477	path_log_output="$dir_dest"/COPY.log;
	478	if [[ $n -le 0 ]]; then
	479	echo "fingerprint","duration","original_path" >> "$path_log_output";
	480	else
	481	echo "$fingerprint","$value","$key" >> "$path_log_output";
	482	fi;
	483
	484	((n++));
a9a36cc4 SBS	485	unset file_basename path_output
	486	done;
	487
	488	# Report total duration
	489	yell "NOTICE:Total duration (seconds):$dur";
	490
	491	} # Main program
	492
	493	main "$@";
	494
	495	# Author: Steven Baltakatei Sandoval
	496	# License: GPLv3+