**EDIT** - I had a typo in the title that may have set the wrong impression, fixed (along with a copying pasting error earlier, thank the devs we have edits here) **EDIT 2** - I don't think it's a ```bash``` vs ```dash``` thing after all, changing the shebang to bash didn't help I am not a coder. I have been staring at a screen the past two weeks trying to "vibe code" for the first time with unpaid chat bots, for a seemingly simple project. But I still haven't even gotten a single version to the real-world testing stage, keep getting failures on more basic self-tests. The project is supposed to convert files to QR code videos and back. Right now, it can complete a round-trip self test (which please bewarned is meaningless to real world results) in the Debian environment I developed it in. However, every chat bot I've consulted tells me this script should be so "portable" it would run on everything from Linux to BSD to termux, and instead it's failed on the first additional Linux distro I tried it on: devuan. I spent most of this morning figuring out where the issue probably is: in the ```extract_bin_folder``` logic, devuan seems to lose the final payload chunk every time. As a result, the file hits EOF exactly one chunk early when reassembled. Oddly, the ```extract_bin_folder``` does get the "footer" QR code (which comes after the missing payload chunk) from the encoder's default looped videos. If the user calls ```-l 0``` in the encoder to disable the loop, then ```extract_bin_folder``` will miss both the footer and the final payload chunk. (I don't think the footer chunk is being used for anything regardless, just noting the odd behavior). I've spent the rest of the day trying to fix it, but I simply lack the knowledge/skills to understand or fix the behavior difference between my Debian environment and my Devuan environment. I guess something to do with ```bash``` vs ```dash```, but my chat bots and I just aren't making progress. Any human help would be appreciated. **Let me reiterate this is not ready for release at all, it isn't even passing these basic tests, hence the version number 0.0.0**. I'll also mention a lot of the comments and echo statements from the chat bot are stupidly inaccurate, I can't clean up the phrasing as fast as it generates slop. I would consider the comments and echo statements just as important to fix as the actual functionality before calling this "ready to use." ``` #!/bin/sh # SPDX-License-Identifier: CC0-1.0 # Public Domain # SnowyQR 0.0.0 by Digital Assistant # 56 years after UNIX epoch # Instruction to the shell to exit if any command fails. set -e # Default configuration for cleanup and temporary workspace. DO_CLEANUP=true USER_WORK_DIR="" # Help menu explaining the various operational modes and flags. usage() { echo "Usage:" echo " Encode input file to video" echo " $0 -f " echo "" echo " Decode file(s) from video" echo " $0 -v " echo "" echo " Encode file to QR code directory (for test/debug)" echo " $0 -f " echo "" echo " Compile QR code dir to video (for test/debug)" echo " $0 -d " echo "" echo " Extract .bin folder from video (for test/debug)" echo " $0 -b " echo "" echo " Reassemble .bin folder to file(s) (for test/debug)" echo " $0 -b " echo "" echo "Options:" echo " -l N Video mode: loop N times (default: 1, plays twice). Set 0 to disable." echo " -c FG BG Set custom Hex colors for Foreground and Background" echo " Defaults: 000000 6B6B6B" echo " Use 000000 FFFFFF for standard black and white." echo " -w DIR Specify a permanent work directory. Skips cleanup and uses" echo " numbered subfolders inside DIR." echo " (For debugging and systems without mktemp)" exit 1 } # --- Shared Utility Functions --- # Verifies the presence of 'zint', required for barcode/QR generation. check_zint() { if ! command -v zint >/dev/null 2>&1; then echo "Error: can't find tool 'zint'" >&2 exit 1 fi } # Verifies 'ffmpeg' is installed for video encoding and frame extraction tasks. check_ffmpeg() { if ! command -v ffmpeg >/dev/null 2>&1; then echo "Error: 'ffmpeg' not found for video processing." >&2 exit 1 fi } # Verifies 'zbarimg' is installed for reading data from QR and barcodes. check_zbarimg() { if ! command -v zbarimg >/dev/null 2>&1; then echo "Error: 'zbarimg' (zbar-tools) not found for QR scanning." >&2 exit 1 fi } # Ensures a temporary directory creator is available if no custom path is provided. check_mktemp() { if [ -z "$USER_WORK_DIR" ] && ! command -v mktemp >/dev/null 2>&1; then echo "Error: 'mktemp' not found. This system cannot create temporary directories automatically." >&2 echo "Please install 'mktemp' or use the '-w ' option to specify a work directory." >&2 exit 1 fi } # Creates or identifies a working directory, respecting user-defined paths or using mktemp. get_work_dir() { if [ -n "$USER_WORK_DIR" ]; then _i=1 while [ -d "$USER_WORK_DIR/$_i" ]; do _i=$((_i + 1)); done _dir="$USER_WORK_DIR/$_i" mkdir -p "$_dir" echo "$_dir" else mktemp -d || { echo "Error: Failed to create a temporary directory." >&2; exit 1; } fi } # --- Core Logic Sections --- # Logic from encoder script # encode_qr: Splits a file into binary chunks and generates a sequenced folder of QR code PNGs. # Includes a metadata header (index 0) and a footer. encode_qr() { infile="$1" outdir="$2" fg_color="$3" bg_color="$4" if [ ! -f "$infile" ]; then echo "Error: '$infile' does not exist?" >&2 exit 1 fi # Prepare the output folder and convert paths to absolute for reliability. echo "Checking output directory permissions..." mkdir -p "$outdir" outdir_abs="$(cd "$outdir" && pwd)" # Capture file information. filename=$(basename "$infile") input_dir_path=$(dirname "$infile") input_abs_path="$(cd "$input_dir_path" && pwd)/$(basename "$infile")" echo "Creating temporary work folder for QR generation..." work_dir=$(get_work_dir) # Trap to ensure temporary files are removed if the process is interrupted. cleanup_enc() { if [ "$DO_CLEANUP" = true ] && [ -d "$work_dir" ]; then echo "Cleaning up temporary files..." rm -rf "$work_dir" fi } trap cleanup_enc EXIT INT TERM orig_pwd=$(pwd) cd "$work_dir" # Divide the source file into 362-byte segments (max capacity for this QR configuration). echo "Splitting '$filename' into 362-byte chunks..." mkdir -p 1 split -b 362 "$input_abs_path" 1/_ # Iterate through segments and generate high-density binary QR codes. echo "Generating data QR codes..." mkdir -p 1o # Filename format: [index].[original_filename].qr.png i=1 for f in 1/_*; do [ -f "$f" ] || continue out=$(printf "1o/%08d.%s.qr.png" "$i" "$filename") zint -b 58 --binary --secure=2 --scale=2.5 --whitesp=4 --vwhitesp=4 --fg="$fg_color" --bg="$bg_color" -o "$out" -i "$f" i=$((i + 1)) done # Generate metadata frames: 00000000 as header and final index as footer. echo "Generating header/footer QR code..." header_filename=$(printf "00000000.%s.qr.png" "$filename") footer_filename=$(printf "%08d.%s.qr.png" "$i" "$filename") filesize=$(wc -c < "$input_abs_path" | tr -d ' ') printf "%s\n%s\n%s bytes\n%s\n%s" "0" "$filename" "$filesize" "snowyQR 0.0.0 by Digital Assistant" "this is a metadata header/footer, payload data should be before or after this (may loop)" > header.tmp zint -b 58 --secure=2 --scale=2.5 --whitesp=4 --vwhitesp=4 --fg="$fg_color" --bg="$bg_color" -i header.tmp -o "1o/$header_filename" printf "%s\n%s\n%s bytes\n%s\n%s" "1" "$filename" "$filesize" "snowyQR 0.0.0 by Digital Assistant" "this is a metadata header/footer, payload data should be before or after this (may loop)" > footer.tmp zint -b 58 --secure=2 --scale=2.5 --whitesp=4 --vwhitesp=4 --fg="$fg_color" --bg="$bg_color" -i footer.tmp -o "1o/$footer_filename" # Transfer processed frames to the final destination. echo "Moving generated QR codes to '$outdir'..." cd "$orig_pwd" mv "$work_dir"/1o/* "$outdir_abs"/ # Disarm trap and perform manual cleanup. trap - EXIT INT TERM if [ "$DO_CLEANUP" = true ] && [ -d "$work_dir" ]; then rm -rf "$work_dir"; fi } # Logic from encoder script # create_video: Stacks QR codes and linear barcodes side-by-side into a lossless video stream. create_video() { indir="$1" outfile="$2" fg_color="$3" bg_color="$4" loop_count="$5" if [ ! -d "$indir" ]; then echo "Error: Input directory '$indir' does not exist." >&2 exit 1 fi # Workspace for intermediate barcodes. tmp_process_dir=$(get_work_dir) barcode_dir="$tmp_process_dir/barcodes" mkdir -p "$barcode_dir" # Generate a matching Code-128 barcode for every QR frame to assist frame sequencing during decode. echo "Generating linear barcodes for frames..." for f in "$indir"/[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9].*.png; do [ -f "$f" ] || continue base_name=$(basename "$f") seq_num=$(echo "$base_name" | cut -c1-8) zint -b 20 --scale=2 --whitesp=4 --vwhitesp=4 --fg="$fg_color" --bg="$bg_color" -o "$barcode_dir/$base_name" -d "$seq_num" done # Add padding to the end of the barcode sequence to prevent video truncation. highest_barcode="" for f in "$barcode_dir"/[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9].*.png; do [ -f "$f" ] && highest_barcode="$f" done if [ -n "$highest_barcode" ]; then base_bar=$(basename "$highest_barcode") bar_num=$(echo "$base_bar" | cut -c1-8) bar_num_clean=$(echo "$bar_num" | sed 's/^0*//'); : "${bar_num_clean:=0}" bar_suffix=$(echo "$base_bar" | cut -c9-) for j in 1 2 3 4 5; do next_bar_num=$((bar_num_clean + j)) next_bar_padded=$(printf "%08d" "$next_bar_num") cp "$highest_barcode" "$barcode_dir/$next_bar_padded$bar_suffix" done # Add 4 copies of barcode #00000000 to complete 9 total padding frames. zero_barcode="$barcode_dir/00000000$bar_suffix" if [ -f "$zero_barcode" ]; then for j in 6 7 8 9; do next_bar_num=$((bar_num_clean + j)) next_bar_padded=$(printf "%08d" "$next_bar_num") cp "$zero_barcode" "$barcode_dir/$next_bar_padded$bar_suffix" done fi fi # Add padding to the end of the QR sequence to prevent video truncation. highest_file="" for f in "$indir"/[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9].*.png; do [ -f "$f" ] && highest_file="$f" done if [ -n "$highest_file" ]; then base_file=$(basename "$highest_file") highest_num=$(echo "$base_file" | cut -c1-8) highest_num_clean=$(echo "$highest_num" | sed 's/^0*//'); : "${highest_num_clean:=0}" file_suffix=$(echo "$base_file" | cut -c9-) for j in 1 2 3 4 5 6 7 8 9; do next_num=$((highest_num_clean + j)) next_num_padded=$(printf "%08d" "$next_num") target_qr="$indir/$next_num_padded$file_suffix" cp "$highest_file" "$target_qr" # Log the created path cleanly to a tracking text file echo "$target_qr" >> "$tmp_process_dir/qr_to_clean.txt" done fi # Set ffmpeg loop arguments if specified. LOOP_ARGS="" if [ "$loop_count" -ne 0 ]; then LOOP_ARGS="-stream_loop $loop_count" fi # FFmpeg assembly: stacks QR on the left and Barcode on the right. echo "Combining QR codes and Barcodes into video (Loop: $loop_count)..." # Use hstack and pad to create a combined canvas, encoded to lossless VP9. if ffmpeg \ $LOOP_ARGS -f image2 -pattern_type glob -i "$indir/*.png" \ $LOOP_ARGS -f image2 -pattern_type glob -i "$barcode_dir/*.png" \ -filter_complex "[0:v]pad=420:420:0:420-ih:color=black@0[qr]; \ [1:v]pad=420:420:420-iw:420-ih:color=black@0[bar]; \ [qr][bar]hstack=inputs=2,format=yuva420p[out]" \ -map "[out]" \ -c:v libvpx-vp9 -lossless 1 \ "$outfile"; then echo "Video output: $outfile" fi # Remove the temporary padding files created in the input directory. if [ "$DO_CLEANUP" = true ] && [ -f "$tmp_process_dir/qr_to_clean.txt" ]; then echo "Cleaning up temporary QR codes from input directory..." while IFS= read -r file_to_remove; do rm -f "$file_to_remove" done < "$tmp_process_dir/qr_to_clean.txt" fi [ "$DO_CLEANUP" = true ] && rm -rf "$tmp_process_dir" } # Logic from extractor script # extract_bin_folder: Extracts frames from video and scans them back into raw binary chunks. # Detects sequence loops to organize data from repeated transmissions. extract_bin_folder() { input_source="$1" output_dir="$2" video_input="" input_dir="" # Determine if the input is a file or a folder of existing images. if [ -f "$input_source" ]; then video_input="$input_source" elif [ -d "$input_source" ]; then input_dir="$input_source" else echo "Error: Extraction input source '$input_source' not found." >&2 exit 1 fi # Create an internal work directory for the extraction process # This respects -w and skips mktemp if requested. _internal_work=$(get_work_dir) cleanup_ext() { if [ "$DO_CLEANUP" = true ] && [ -d "$_internal_work" ]; then rm -rf "$_internal_work"; fi; } trap cleanup_ext EXIT INT TERM # Unpack video frames into images. if [ -n "$video_input" ]; then input_dir="$_internal_work/video_frames" mkdir -p "$input_dir" ffmpeg -i "$video_input" "$input_dir/snowyqr_%08d.png" || { echo "Error: ffmpeg failed." >&2; exit 1; } fi [ -d "$input_dir" ] || { echo "Error: Input directory does not exist." >&2; exit 1; } # Setup output folder for extracted .bin files. [ -z "$output_dir" ] && output_dir="snowyQR_$(date +%H%M%S)_$$" mkdir -p "$output_dir" # Initialize set folders for handling looped playback. folder_index=1 current_temp_dir="$_internal_work/chunk_set_${folder_index}" mkdir -p "$current_temp_dir" echo "Extracting binary chunks. Please wait, may take hours. (Do not run without zbarimg and ffmpeg)" # Scanning is intensive. prev_barcode="" for img in "$input_dir"/*; do [ -f "$img" ] || continue tmp_bin="$current_temp_dir/tmp.qr.bin" # Scan frame for QR data. if zbarimg -q --raw -S*.disable -Sqr.enable -Sbinary "$img" 2>/dev/null > "$tmp_bin" && [ -s "$tmp_bin" ]; then dd if="$tmp_bin" of="$_internal_work/dd.tmp" bs=1 count=362 2>/dev/null mv "$_internal_work/dd.tmp" "$tmp_bin" else rm -f "$tmp_bin"; continue fi # Scan frame for sequence index barcode. barcode=$(zbarimg -q --raw -S*.disable -Scode128.enable "$img" 2>/dev/null | tr -d '\n\r') # Skip if sequencing data is missing. if [ -z "$barcode" ]; then rm -f "$tmp_bin" else target_name="$current_temp_dir/${barcode}.qr.bin" if [ "$barcode" = "$prev_barcode" ]; then rm -f "$tmp_bin" continue fi # Start a new folder if we detect a repeat index (indicating a loop start). if [ -f "$target_name" ]; then folder_index=$((folder_index + 1)) current_temp_dir="$_internal_work/chunk_set_${folder_index}" mkdir -p "$current_temp_dir" target_name="$current_temp_dir/${barcode}.qr.bin" prev_barcode="" else prev_barcode="$barcode" fi mv "$tmp_bin" "$target_name" fi done [ -n "$video_input" ] && [ "$DO_CLEANUP" = true ] && rm -rf "$input_dir" # Final renaming: parse the header chunk (index 0) to recover the original filename. i=1 while [ $i -le "$folder_index" ]; do dir="$_internal_work/chunk_set_${i}" if [ -d "$dir" ]; then zero_file="$dir/00000000.qr.bin" file_prefix="" # Peek at metadata chunk for filename recovery. if [ -f "$zero_file" ]; then insert_name=$(sed -n '2p' "$zero_file" | tr -d '\n\r/') [ -n "$insert_name" ] && file_prefix="${insert_name}." fi for bin_file in "$dir"/*; do [ -f "$bin_file" ] || continue base_name=${bin_file##*/} [ "$base_name" = "tmp.qr.bin" ] && continue barcode_part="${base_name%%.*}" mv "$bin_file" "$output_dir/${barcode_part}.${file_prefix}qr.bin" done [ "$DO_CLEANUP" = true ] && rm -rf "$dir" fi i=$((i + 1)) done echo "Extraction complete. Output folder available at: $output_dir" trap - EXIT INT TERM cleanup_ext } # Logic from reassembler script # reassemble_bin_folder: Concatenates binary chunks back into their original file format. reassemble_bin_folder() { input_dir="$1" output_dir="$2" if [ ! -d "$input_dir" ]; then echo "Error: Input directory '$input_dir' does not exist." >&2 exit 1 fi mkdir -p "$output_dir" _internal_work=$(get_work_dir) processed_targets="$_internal_work/targets.$$" cleanup_re() { [ "$DO_CLEANUP" = true ] && rm -f "$processed_targets"; } trap cleanup_re EXIT INT TERM # Catalog all unique target files based on chunk naming patterns. for filepath in "$input_dir"/*.bin; do [ -f "$filepath" ] || continue filename=${filepath##*/} length=$(printf "%s" "$filename" | wc -c) # Convention check. if [ "$length" -lt 16 ]; then continue fi rest=$(printf "%s" "$filename" | cut -c 10-) target_name=$(printf "%s" "$rest" | cut -c 1-$((length - 15))) echo "$target_name" >> "$processed_targets" done # Deduplicate the list of targets to process. if [ -s "$processed_targets" ]; then unique_targets=$(sort -u "$processed_targets") else echo "No .bin files matching the requirements were found." exit 0 fi # Process each unique target by stitching its chunks together in order. echo "$unique_targets" | while read -r target; do [ -z "$target" ] && continue echo "Processing $target..." # Collate chunks for this specific target. set -- for chunk in "$input_dir"/????????."$target"??????; do [ -f "$chunk" ] && set -- "$@" "$chunk" done total_chunks=$# # A valid sequence must contain at least Header, Footer, and one data chunk. if [ "$total_chunks" -le 2 ]; then echo "Skipping $target: Has $total_chunks chunk(s). Ignoring the boundaries leaves no data." continue fi output_target=${target%.} output_file="$output_dir/$output_target" # Skip the metadata header chunk. : > "$output_file" shift 1 count=1 limit=$((total_chunks - 2)) # Iterate through the data chunks only. while [ "$count" -le "$limit" ]; do current_chunk="$1" dd if="$current_chunk" bs=1 count=362 2>/dev/null >> "$output_file" shift 1 count=$((count + 1)) done echo "Reassembled file: $output_target (skipped boundaries, 362 bytes per chunk)." done echo "Reassembly complete. Output directory: '$output_dir'." trap - EXIT INT TERM cleanup_re } # --- CLI Routing Arguments Parsing --- MODE="" INPUT_ARG="" OUTPUT_ARG="" FG_COLOR="000000" BG_COLOR="6B6B6B" LOOP_COUNT=1 # Argument parsing loop. while [ $# -gt 0 ]; do case "$1" in -l) if [ -z "$2" ] || [ "${2#-}" != "$2" ]; then echo "Error: -l requires a numeric argument." >&2 usage fi LOOP_COUNT="$2" shift 2 ;; -c) if [ -z "$2" ] || [ "${2#-}" != "$2" ] || [ -z "$3" ] || [ "${3#-}" != "$3" ]; then echo "Error: -c requires two color hex arguments (FG and BG)." >&2 usage fi if ! echo "$2" | grep -Eq '^[0-9a-fA-F]{6}$' || ! echo "$3" | grep -Eq '^[0-9a-fA-F]{6}$'; then echo "Error: Colors must be valid 6-digit hex values (e.g., 000000)." >&2 usage fi FG_COLOR="$2" BG_COLOR="$3" shift 3 ;; -w) if [ -z "$2" ] || [ "${2#-}" != "$2" ]; then echo "Error: -w requires a directory argument." >&2 usage fi USER_WORK_DIR="$2" DO_CLEANUP=false mkdir -p "$USER_WORK_DIR" shift 2 ;; -f|-v|-d|-b) if [ -n "$MODE" ]; then echo "Error: Multiple operation mode flags specified." >&2 usage fi MODE="$1" if [ -z "$2" ] || [ "${2#-}" != "$2" ]; then echo "Error: Mode option $1 requires a parameter path." >&2 usage fi INPUT_ARG="$2" shift 2 ;; -*) echo "Unknown option: $1" >&2 usage ;; *) if [ -n "$OUTPUT_ARG" ]; then echo "Error: Too many trailing arguments arguments." >&2 usage fi OUTPUT_ARG="$1" shift ;; esac done if [ -z "$MODE" ] || [ -z "$INPUT_ARG" ] || [ -z "$OUTPUT_ARG" ]; then echo "Error: Missing required mode flags, input path, or output destination targets." >&2 usage fi # --- Dependency Validation --- # Validate required binaries are installed for the chosen operation mode. check_mktemp case "$MODE" in -f) check_zint case "$OUTPUT_ARG" in *.mkv|*.webm|*.mp4|*.avi|*.mov|*.flv) check_ffmpeg ;; esac ;; -v) check_ffmpeg check_zbarimg ;; -d) check_zint check_ffmpeg ;; -b) if [ -f "$INPUT_ARG" ]; then check_ffmpeg check_zbarimg fi ;; esac # --- Flow Execution Management --- case "$MODE" in -f) # Check if output specifies a common video format extension IS_VIDEO=false case "$OUTPUT_ARG" in *.mkv|*.webm|*.mp4|*.avi|*.mov|*.flv) IS_VIDEO=true ;; esac if [ "$IS_VIDEO" = true ]; then # Workflow 1: Encode input file directly to video # Automated extension fix-ups and validation for video encoding. case "$OUTPUT_ARG" in *.mkv|*.webm) ;; *) echo "Warning: Only .webm and .mkv video formats are officially supported." >&2 # Check if stdin is NOT connected to an interactive terminal if [ ! -t 0 ]; then echo "Error: Non-interactive shell detected. Cannot prompt for input. Aborting." >&2 exit 1 fi echo "Please choose an action:" >&2 echo " [1] Swap output extension to .mkv (Recommended)" >&2 echo " [2] Cancel render" >&2 echo " [3] Ignore and attempt video rendering anyway" >&2 printf "Choice (1/2/3): " >&2 read -r choice if [ "$choice" = "1" ]; then case "$OUTPUT_ARG" in */*) _dir="${OUTPUT_ARG%/*}" _file="${OUTPUT_ARG##*/}" case "$_file" in *.*) _file="${_file%.*}.mkv" ;; *) _file="$_file.mkv" ;; esac OUTPUT_ARG="$_dir/$_file" ;; *.*) OUTPUT_ARG="${OUTPUT_ARG%.*}.mkv" ;; *) OUTPUT_ARG="$OUTPUT_ARG.mkv" ;; esac echo "Updated output format target name to: $OUTPUT_ARG" >&2 elif [ "$choice" = "2" ]; then echo "Aborting operation."; exit 1 fi ;; esac # Create a sandboxed QR directory for the two-step video build. TEMP_QR_DIR=$(get_work_dir) cleanup_workflow() { if [ "$DO_CLEANUP" = true ] && [ -d "$TEMP_QR_DIR" ]; then rm -rf "$TEMP_QR_DIR"; fi; } trap cleanup_workflow EXIT INT TERM echo "Phase 1: Splitting and encoding data files to temporary raw QR configurations..." encode_qr "$INPUT_ARG" "$TEMP_QR_DIR" "$FG_COLOR" "$BG_COLOR" echo "Phase 2: Translating temporary raw frames into final targeted sequence compilation..." create_video "$TEMP_QR_DIR" "$OUTPUT_ARG" "$FG_COLOR" "$BG_COLOR" "$LOOP_COUNT" [ "$DO_CLEANUP" = true ] && rm -rf "$TEMP_QR_DIR" trap - EXIT INT TERM else # Workflow 3: Encode file directly to standard folder directory (Debug mode) encode_qr "$INPUT_ARG" "$OUTPUT_ARG" "$FG_COLOR" "$BG_COLOR" echo "Raw storage configuration generated inside output directory: '$OUTPUT_ARG'." fi ;; -v) # Workflow 2: Complete direct sequential Decode file(s) right out of video package container TEMP_EXTRACT_DIR=$(get_work_dir) cleanup_dec() { if [ "$DO_CLEANUP" = true ] && [ -d "$TEMP_EXTRACT_DIR" ]; then rm -rf "$TEMP_EXTRACT_DIR"; fi; } trap cleanup_dec EXIT INT TERM # Execute the two-phase recovery process: extract frames then reassemble binary data. echo "Phase 1: Running deep visual scanner to unpack assets into structural chunks..." extract_bin_folder "$INPUT_ARG" "$TEMP_EXTRACT_DIR" echo "Phase 2: Executing assembly rules to recover targeted file data boundaries..." reassemble_bin_folder "$TEMP_EXTRACT_DIR" "$OUTPUT_ARG" [ "$DO_CLEANUP" = true ] && rm -rf "$TEMP_EXTRACT_DIR" trap - EXIT INT TERM ;; -d) # Workflow 4: Compile existing raw directories into complete matrix video frame structures create_video "$INPUT_ARG" "$OUTPUT_ARG" "$FG_COLOR" "$BG_COLOR" "$LOOP_COUNT" ;; -b) # Handle overlap parsing based on filesystem layout configurations if [ -f "$INPUT_ARG" ]; then # Workflow 5: Extract .bin metadata directories right from underlying video container tracks extract_bin_folder "$INPUT_ARG" "$OUTPUT_ARG" else # Workflow 6: Stitch pre-existing standalone binary component directory elements reassemble_bin_folder "$INPUT_ARG" "$OUTPUT_ARG" fi ;; esac exit 0 ```

bamfingle