+## [Unreleased]

+

+### Changed

+- `--move-source` renamed to `--delete-source` (old name kept as alias)

+- `--continue-on-error` renamed to `--keep-going` (old name kept as alias)

+### Added

+- `--unattended` preset (`--delete-source` + `--keep-going`) for long unattended runs

+

+- `cleanup_garmin_varia_media_folder.sh` helper for media-folder hygiene (import + transcoded output):

+	removes AppleDouble artifacts (`._*`), removes zero-size MP4 files,

+	and normalizes single-suffix duplicate timestamp names

+

+### Behavior

+- Import cleanup returns exit code `1` when duplicate groups are blocked and need manual review

+

+./garmin_varia_transcode.sh -s SampleFootage -d Output --delete-source

+

+# Long unattended run preset (delete-source + keep-going)

+./garmin_varia_transcode.sh -s SampleFootage -d Output --unattended

+

+# Media cleanup helper (Apple artifacts, zero-byte MP4, duplicate suffix normalization)

+./cleanup_garmin_varia_media_folder.sh --dry-run ~/Autofs/xdev/autonas/ext01/@Camera/import

+  --delete-source                 Delete source after strict post-encode validation

+  --keep-going                    Continue after source-file failures (default: stop)

+  --unattended                    Preset for long runs: --delete-source + --keep-going

+  --no-apple-repack-fallback      Disable macOS avconvert fallback for unreadable MP4/MOV sources

+  --apple-repack-fallback         Enable macOS avconvert fallback (default)

+- `--delete-source` only deletes source after codec + duration validation passes

+- `Ctrl+C` behavior during long runs:

+  first press requests stop after current file; second press force-stops current encode

+- On macOS, unreadable MP4/MOV sources automatically try `avconvert --preset PresetPassthrough`

+  as fallback before being marked as unreadable

+

+Backward-compatible aliases:

+- `--move-source` maps to `--delete-source`

+- `--continue-on-error` maps to `--keep-going`

+

+## Media Cleanup Utility

+

+`cleanup_garmin_varia_media_folder.sh` is a companion utility for import and transcoded media folders.

+

+What it does:

+- Removes AppleDouble artifacts (`._*`) up to 4096 bytes

+- Removes zero-size `.mp4` files

+- Normalizes duplicate timestamp files:

+  if `YYYY-MM-DD_HH-MM-SS.mp4` is missing and exactly one

+  `YYYY-MM-DD_HH-MM-SS_<n>.mp4` exists, it renames it to base name

+- Reports blocked duplicate groups when base exists or multiple suffixed duplicates exist

+

+Usage:

+

+```bash

+# Preview only

+./cleanup_garmin_varia_media_folder.sh --dry-run ~/Autofs/xdev/autonas/ext01/@Camera/import

+

+# Apply changes

+./cleanup_garmin_varia_media_folder.sh ~/Autofs/xdev/autonas/ext01/@Camera/import

+

+# Example on transcoded output folder

+./cleanup_garmin_varia_media_folder.sh --dry-run ~/Autofs/xdev/is-baobab/nvme0n1/@backup/Garmin

+```

+

+Exit codes:

+- `0`: cleanup completed with no blocked duplicate groups

+- `1`: cleanup completed but blocked duplicate groups require manual review

+- `2`: invalid invocation or runtime error

+cleanup_garmin_varia_media_folder.sh   Media cleanup utility (import + transcoded folders)

+{

+	"folders": [

+		{

+			"path": "."

+		}

+	],

+	"settings": {}

+}

+#!/usr/bin/env bash

+set -euo pipefail

+

+TOOL_NAME="cleanup_garmin_varia_media_folder.sh"

+DEFAULT_MEDIA_ROOT="."

+MAX_APPLEDOUBLE_BYTES=4096

+

+DRY_RUN=false

+VERBOSE=false

+MEDIA_ROOT="$DEFAULT_MEDIA_ROOT"

+

+TMP_MP4_LIST=""

+TMP_ACTIONS=""

+TMP_NONSTANDARD=""

+TMP_ZERO=""

+TMP_BLOCKED=""

+TMP_APPLE=""

+

+APPLE_ARTIFACTS_REMOVED=0

+ZERO_SIZE_REMOVED=0

+NONSTANDARD_REMOVED=0

+RENAMES_DONE=0

+BLOCKED_GROUPS=0

+BLOCKED_FILES=0

+

+usage() {

+  cat <<'EOF'

+Usage:

+  cleanup_garmin_varia_media_folder.sh [options] [MEDIA_ROOT]

+

+Purpose:

+  Clean common Apple artifacts and zero-size MP4 files, then normalize

+  duplicate MP4 names produced during copy/import retries.

+

+Rules:

+  - Delete AppleDouble sidecars matching ._* only when size <= 4096 bytes

+  - Delete zero-size .mp4 files

+  - For canonical timestamp names:

+      YYYY-MM-DD_HH-MM-SS.mp4

+      YYYY-MM-DD_HH-MM-SS_<n>.mp4

+    if exactly one suffixed duplicate exists and the base file is missing,

+    rename duplicate to base name

+  - If base exists, or multiple suffixed duplicates exist, keep files unchanged

+    and report them as blocked

+

+Options:

+  --dry-run         Print actions without changing files

+  --verbose         Print per-file operations

+  -h, --help        Show this help

+

+Examples:

+  ./cleanup_garmin_varia_media_folder.sh --dry-run ~/Autofs/xdev/autonas/ext01/@Camera/import

+  ./cleanup_garmin_varia_media_folder.sh ~/Autofs/xdev/is-baobab/nvme0n1/@backup/Garmin

+EOF

+}

+

+log_msg() {

+  local level="$1"

+  shift

+  printf '[%s] [%s] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$level" "$*"

+}

+

+vlog_msg() {

+  if [[ "$VERBOSE" == true ]]; then

+    log_msg "INFO" "$*"

+  fi

+}

+

+die() {

+  log_msg "ERROR" "$*"

+  exit 2

+}

+

+cleanup_tmp_files() {

+  rm -f -- "$TMP_MP4_LIST" "$TMP_ACTIONS" "$TMP_NONSTANDARD" "$TMP_ZERO" "$TMP_BLOCKED" "$TMP_APPLE" "$TMP_ACTIONS.tmp" 2>/dev/null || true

+}

+

+parse_args() {

+  while [[ $# -gt 0 ]]; do

+    case "$1" in

+      --dry-run)

+        DRY_RUN=true

+        shift

+        ;;

+      --verbose)

+        VERBOSE=true

+        shift

+        ;;

+      -h|--help)

+        usage

+        exit 0

+        ;;

+      -*)

+        die "Unknown option: $1"

+        ;;

+      *)

+        MEDIA_ROOT="$1"

+        shift

+        ;;

+    esac

+  done

+}

+

+init_tmp_files() {

+  TMP_MP4_LIST="$(mktemp)"

+  TMP_ACTIONS="$(mktemp)"

+  TMP_NONSTANDARD="$(mktemp)"

+  TMP_ZERO="$(mktemp)"

+  TMP_BLOCKED="$(mktemp)"

+  TMP_APPLE="$(mktemp)"

+  trap cleanup_tmp_files EXIT

+}

+

+validate_media_root() {

+  [[ -d "$MEDIA_ROOT" ]] || die "Media root not found: $MEDIA_ROOT"

+}

+

+rescan_mp4_files() {

+  find "$MEDIA_ROOT" -type f -name '*.mp4' | sort > "$TMP_MP4_LIST"

+}

+

+safe_remove_file() {

+  local path="$1"

+  if [[ "$DRY_RUN" == true ]]; then

+    return 0

+  fi

+  rm -f -- "$path"

+}

+

+remove_apple_artifacts() {

+  local file size

+  while IFS= read -r file; do

+    [[ -n "$file" ]] || continue

+    size="$(wc -c < "$file" | tr -d ' ')"

+

+    if [[ "$size" =~ ^[0-9]+$ ]] && [[ "$size" -le "$MAX_APPLEDOUBLE_BYTES" ]]; then

+      APPLE_ARTIFACTS_REMOVED=$((APPLE_ARTIFACTS_REMOVED + 1))

+      printf '%s\n' "$file" >> "$TMP_APPLE"

+      vlog_msg "Apple artifact: $file (${size} bytes)"

+      safe_remove_file "$file"

+    else

+      vlog_msg "Skipped ._* larger than threshold: $file (${size} bytes)"

+    fi

+  done < <(find "$MEDIA_ROOT" -type f -name '._*' | sort)

+

+  if [[ "$APPLE_ARTIFACTS_REMOVED" -gt 0 ]]; then

+    if [[ "$DRY_RUN" == true ]]; then

+      log_msg "INFO" "Would remove $APPLE_ARTIFACTS_REMOVED Apple artifact file(s)"

+    else

+      log_msg "INFO" "Removed $APPLE_ARTIFACTS_REMOVED Apple artifact file(s)"

+    fi

+    rescan_mp4_files

+  fi

+}

+

+remove_zero_size_mp4() {

+  local file

+  while IFS= read -r file; do

+    [[ -n "$file" ]] || continue

+    if [[ ! -s "$file" ]]; then

+      ZERO_SIZE_REMOVED=$((ZERO_SIZE_REMOVED + 1))

+      printf '%s\n' "$file" >> "$TMP_ZERO"

+      vlog_msg "Zero-size MP4: $file"

+      safe_remove_file "$file"

+    fi

+  done < "$TMP_MP4_LIST"

+

+  if [[ "$ZERO_SIZE_REMOVED" -gt 0 ]]; then

+    if [[ "$DRY_RUN" == true ]]; then

+      log_msg "INFO" "Would remove $ZERO_SIZE_REMOVED zero-size MP4 file(s)"

+    else

+      log_msg "INFO" "Removed $ZERO_SIZE_REMOVED zero-size MP4 file(s)"

+    fi

+    rescan_mp4_files

+  fi

+}

+

+collect_duplicate_actions() {

+  local file base dir timestamp suffix

+

+  : > "$TMP_ACTIONS"

+  : > "$TMP_NONSTANDARD"

+

+  while IFS= read -r file; do

+    [[ -n "$file" ]] || continue

+    base="$(basename "$file")"

+

+    if [[ "$base" =~ ^([0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}-[0-9]{2})(_[0-9]+)?\.mp4$ ]]; then

+      dir="$(dirname "$file")"

+      timestamp="${BASH_REMATCH[1]}"

+      suffix="${BASH_REMATCH[2]:-}"

+      if [[ -n "$suffix" ]]; then

+        suffix="${suffix#_}"

+      else

+        suffix=0

+      fi

+      printf '%s\t%s\t%s\t%s\n' "$dir" "$timestamp" "$suffix" "$file" >> "$TMP_ACTIONS"

+    elif [[ "$base" =~ _[0-9]+\.mp4$ ]]; then

+      printf '%s\n' "$file" >> "$TMP_NONSTANDARD"

+      NONSTANDARD_REMOVED=$((NONSTANDARD_REMOVED + 1))

+      vlog_msg "Non-standard duplicate-like file: $file"

+      safe_remove_file "$file"

+    fi

+  done < "$TMP_MP4_LIST"

+}

+

+build_rename_plan() {

+  awk -F'\t' '

+function flush() {

+  if (dup_count == 1 && orig_seen == 0) {

+    print "RENAME\t" dup_files[1] "\t" dir "\t" timestamp

+  } else if (dup_count > 0) {

+    print "GROUP\t" dir "\t" timestamp "\t" dup_count

+    for (i = 1; i <= dup_count; i++) {

+      print "BLOCK\t" dup_files[i]

+    }

+  }

+}

+

+BEGIN {

+  OFS = "\t"

+  dir = ""

+  timestamp = ""

+  orig_seen = 0

+  dup_count = 0

+}

+

+{

+  if ($1 != dir || $2 != timestamp) {

+    if (NR > 1) {

+      flush()

+    }

+    dir = $1

+    timestamp = $2

+    orig_seen = 0

+    dup_count = 0

+    delete dup_files

+  }

+

+  if ($3 == 0) {

+    orig_seen = 1

+  } else {

+    dup_count++

+    dup_files[dup_count] = $4

+  }

+}

+

+END {

+  if (NR > 0) {

+    flush()

+  }

+}

+' "$TMP_ACTIONS" > "$TMP_ACTIONS.tmp"

+

+  mv "$TMP_ACTIONS.tmp" "$TMP_ACTIONS"

+}

+

+apply_rename_plan() {

+  local action src dir timestamp dup_count dst

+

+  while IFS=$'\t' read -r action src dir timestamp dup_count; do

+    [[ -n "$action" ]] || continue

+    case "$action" in

+      RENAME)

+        dst="$dir/$timestamp.mp4"

+        RENAMES_DONE=$((RENAMES_DONE + 1))

+        if [[ "$DRY_RUN" == true ]]; then

+          log_msg "INFO" "DRY-RUN rename: $src -> $dst"

+        else

+          mv -- "$src" "$dst"

+          vlog_msg "Renamed: $src -> $dst"

+        fi

+        ;;

+      GROUP)

+        BLOCKED_GROUPS=$((BLOCKED_GROUPS + 1))

+        ;;

+      BLOCK)

+        BLOCKED_FILES=$((BLOCKED_FILES + 1))

+        printf '%s\n' "$src" >> "$TMP_BLOCKED"

+        ;;

+    esac

+  done < "$TMP_ACTIONS"

+}

+

+print_summary_lists() {

+  if [[ -s "$TMP_APPLE" ]]; then

+    if [[ "$DRY_RUN" == true ]]; then

+      log_msg "INFO" "Apple artifacts that would be removed:"

+    else

+      log_msg "INFO" "Apple artifacts removed:"

+    fi

+    cat "$TMP_APPLE"

+  fi

+

+  if [[ -s "$TMP_ZERO" ]]; then

+    if [[ "$DRY_RUN" == true ]]; then

+      log_msg "INFO" "Zero-size MP4 files that would be removed:"

+    else

+      log_msg "INFO" "Zero-size MP4 files removed:"

+    fi

+    cat "$TMP_ZERO"

+  fi

+

+  if [[ -s "$TMP_NONSTANDARD" ]]; then

+    if [[ "$DRY_RUN" == true ]]; then

+      log_msg "INFO" "Non-standard duplicate-like MP4 files that would be removed:"

+    else

+      log_msg "INFO" "Non-standard duplicate-like MP4 files removed:"

+    fi

+    cat "$TMP_NONSTANDARD"

+  fi

+

+  if [[ -s "$TMP_BLOCKED" ]]; then

+    log_msg "WARN" "Blocked duplicate files (manual review needed):"

+    cat "$TMP_BLOCKED"

+  fi

+}

+

+print_summary() {

+  local mode_text

+  mode_text="apply"

+  if [[ "$DRY_RUN" == true ]]; then

+    mode_text="dry-run"

+  fi

+

+  log_msg "INFO" "Summary ($mode_text): apple_removed=$APPLE_ARTIFACTS_REMOVED zero_removed=$ZERO_SIZE_REMOVED nonstandard_removed=$NONSTANDARD_REMOVED renamed=$RENAMES_DONE blocked_groups=$BLOCKED_GROUPS blocked_files=$BLOCKED_FILES"

+}

+

+main() {

+  parse_args "$@"

+  init_tmp_files

+  validate_media_root

+

+  log_msg "INFO" "Starting cleanup for media root: $MEDIA_ROOT"

+  if [[ "$DRY_RUN" == true ]]; then

+    log_msg "INFO" "Dry-run enabled; no files will be changed"

+  fi

+

+  rescan_mp4_files

+  remove_apple_artifacts

+  remove_zero_size_mp4

+  collect_duplicate_actions

+  build_rename_plan

+  apply_rename_plan

+  print_summary_lists

+  print_summary

+

+  if [[ "$BLOCKED_GROUPS" -gt 0 ]]; then

+    log_msg "WARN" "Cleanup completed with blocked duplicate groups"

+    exit 1

+  fi

+

+  log_msg "INFO" "Cleanup completed successfully"

+}

+

+main "$@"

+FAIL_FAST=true

+SOURCE_READABLE_MODE="normal"

+APPLE_REPACK_FALLBACK=true

+REPACKED_SOURCE_PATH=""

+HAS_AVCONVERT=false

+EXT_LIST=()

+VIDEO_FILES=()

+INVALID_SOURCES_SKIPPED=0

+DESTINATION_FAILURES=0

+STOP_AFTER_CURRENT=false

+INTERRUPT_COUNT=0

+CURRENT_FFMPEG_PID=""

+PROGRESS_LINE_OPEN=false

+  --delete-source                 Delete source file only after strict post-encode validation

+  --keep-going                    Continue after source-file failures (default: stop)

+  --unattended                    Preset for long runs: --delete-source + --keep-going

+  --no-apple-repack-fallback      Disable macOS avconvert fallback for unreadable MP4/MOV sources

+  --apple-repack-fallback         Enable macOS avconvert fallback (default)

+  ./garmin_varia_transcode.sh -s SampleFootage -d encoded --delete-source

+  ./garmin_varia_transcode.sh -s SampleFootage -d encoded --unattended

+# Quiet-mode per-file progress lines

+log_progress_start() {

+  local ts

+  ts="$(date '+%Y-%m-%d %H:%M:%S')"

+  printf '%s : Transcoding %s ...' "$ts" "$input_file"

+  PROGRESS_LINE_OPEN=true

+}

+

+log_progress_done() {

+  if [[ "$PROGRESS_LINE_OPEN" == true ]]; then

+    printf ' done in %ss (encode %ss)\n' "$real_elapsed_sec" "$encode_elapsed_sec"

+    PROGRESS_LINE_OPEN=false

+    return

+  fi

+

+  local input_file="$1"

+log_progress_failed() {

+  local input_file="$1"

+  local real_elapsed_sec="$2"

+  local encode_elapsed_sec="$3"

+  local ffmpeg_rc="$4"

+  local ffmpeg_log="$5"

+

+  if [[ "$PROGRESS_LINE_OPEN" == true ]]; then

+    printf ' FAILED after %ss (encode %ss, rc=%s, log=%s)\n' "$real_elapsed_sec" "$encode_elapsed_sec" "$ffmpeg_rc" "${ffmpeg_log:-n/a}"

+    PROGRESS_LINE_OPEN=false

+    return

+  fi

+

+  local ts

+  ts="$(date '+%Y-%m-%d %H:%M:%S')"

+  echo "$ts : Transcoding $input_file ... FAILED after ${real_elapsed_sec}s (encode ${encode_elapsed_sec}s, rc=$ffmpeg_rc, log=${ffmpeg_log:-n/a})"

+}

+

+log_progress_skipped_unreadable() {

+  local input_file="$1"

+

+  if [[ "$PROGRESS_LINE_OPEN" == true ]]; then

+    printf ' SKIPPED (unreadable/corrupted source)\n'

+    PROGRESS_LINE_OPEN=false

+    return

+  fi

+

+  local ts

+  ts="$(date '+%Y-%m-%d %H:%M:%S')"

+  echo "$ts : Transcoding $input_file ... SKIPPED (unreadable/corrupted source)"

+}

+

+handle_interrupt() {

+  INTERRUPT_COUNT=$((INTERRUPT_COUNT + 1))

+  STOP_AFTER_CURRENT=true

+

+  if [[ "$INTERRUPT_COUNT" -eq 1 ]]; then

+    if [[ -n "$CURRENT_FFMPEG_PID" ]]; then

+      log_msg "WARN" "Stop requested. Will stop after current file. Press Ctrl+C again to abort current encode immediately."

+    else

+      log_msg "WARN" "Stop requested. Exiting before next file."

+    fi

+    return

+  fi

+

+  if [[ -n "$CURRENT_FFMPEG_PID" ]]; then

+    log_msg "WARN" "Force-stopping current encode (pid=$CURRENT_FFMPEG_PID)."

+    kill -INT "$CURRENT_FFMPEG_PID" 2>/dev/null || true

+  fi

+}

+

+run_ffmpeg_with_signal_guard() {

+  (

+    trap '' INT TERM

+    exec "$@"

+  ) &

+

+  CURRENT_FFMPEG_PID=$!

+  if wait "$CURRENT_FFMPEG_PID"; then

+    CURRENT_FFMPEG_PID=""

+    return 0

+  fi

+

+  local rc=$?

+  CURRENT_FFMPEG_PID=""

+  return "$rc"

+}

+

+make_temp_output_file() {

+  local target_file="$1"

+  local target_dir target_base target_noext temp_path seed_path

+

+  target_dir="$(dirname "$target_file")"

+  target_base="$(basename "$target_file")"

+  target_noext="${target_base%.*}"

+

+  seed_path="$(mktemp "$target_dir/.varia_tmp.${target_noext}.XXXXXX" 2>/dev/null || true)"

+  if [[ -n "$seed_path" ]]; then

+    rm -f -- "$seed_path" 2>/dev/null || true

+    temp_path="${seed_path}.mp4"

+  else

+    temp_path="$target_dir/.varia_tmp.${target_noext}.$$.$RANDOM.mp4"

+    if ! touch "$temp_path" >/dev/null 2>&1; then

+      temp_path=""

+    else

+      rm -f -- "$temp_path" 2>/dev/null || true

+    fi

+  fi

+

+  printf '%s\n' "$temp_path"

+}

+

+cleanup_transcode_artifacts() {

+  local temp_output="$1"

+  local final_output="$2"

+

+  rm -f -- "$temp_output" 2>/dev/null || true

+

+  # Defensive cleanup for previously failed non-atomic runs.

+  if [[ -f "$final_output" && ! -s "$final_output" ]]; then

+    rm -f -- "$final_output" 2>/dev/null || true

+  fi

+}

+

+is_apple_noise_file() {

+  local file_path="$1"

+  local base

+  base="$(basename "$file_path")"

+

+  case "$base" in

+    ._*|.DS_Store|.AppleDouble|._.DS_Store)

+      return 0

+      ;;

+  esac

+

+  return 1

+}

+

+      --delete-source)

+        MOVE_SOURCE=true

+        shift

+        ;;

+      --keep-going)

+        FAIL_FAST=false

+        shift

+        ;;

+      --unattended)

+        MOVE_SOURCE=true

+        FAIL_FAST=false

+        shift

+        ;;

+      --no-apple-repack-fallback)

+        APPLE_REPACK_FALLBACK=false

+        shift

+        ;;

+      --apple-repack-fallback)

+        APPLE_REPACK_FALLBACK=true

+        shift

+        ;;

+      --continue-on-error)

+        FAIL_FAST=false

+        shift

+        ;;

+

+  HAS_AVCONVERT=false

+  if [[ "$(uname -s)" == "Darwin" ]] && command -v avconvert >/dev/null 2>&1; then

+    HAS_AVCONVERT=true

+  fi

+}

+

+make_temp_repack_file() {

+  local base_tmp="${TMPDIR:-/tmp}"

+  local seed_path temp_path

+

+  base_tmp="${base_tmp%/}"

+  seed_path="$(mktemp "$base_tmp/varia_repack.XXXXXX" 2>/dev/null || true)"

+  if [[ -n "$seed_path" ]]; then

+    rm -f -- "$seed_path" 2>/dev/null || true

+    temp_path="${seed_path}.mp4"

+    printf '%s\n' "$temp_path"

+    return

+  fi

+

+  temp_path="$base_tmp/varia_repack.$$.$RANDOM.mp4"

+  printf '%s\n' "$temp_path"

+}

+

+cleanup_repacked_input() {

+  local repacked_file="$1"

+  if [[ -n "$repacked_file" ]]; then

+    rm -f -- "$repacked_file" 2>/dev/null || true

+  fi

+}

+

+try_apple_repack_for_unreadable() {

+  local source_file="$1"

+  local repacked_file=""

+

+  REPACKED_SOURCE_PATH=""

+

+  if [[ "$APPLE_REPACK_FALLBACK" != true || "$HAS_AVCONVERT" != true || "$(uname -s)" != "Darwin" ]]; then

+    return 1

+  fi

+

+  repacked_file="$(make_temp_repack_file)"

+  if [[ -z "$repacked_file" ]]; then

+    return 1

+  fi

+

+  if [[ "$VERBOSE" == true ]]; then

+    log_msg "WARN" "Trying avconvert passthrough repack fallback: $source_file"

+    if ! avconvert --source "$source_file" --preset PresetPassthrough --output "$repacked_file" --replace; then

+      cleanup_repacked_input "$repacked_file"

+      return 1

+    fi

+  else

+    if ! avconvert --source "$source_file" --preset PresetPassthrough --output "$repacked_file" --replace >/dev/null 2>&1; then

+      cleanup_repacked_input "$repacked_file"

+      return 1

+    fi

+  fi

+

+  if ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$repacked_file" >/dev/null 2>&1; then

+    REPACKED_SOURCE_PATH="$repacked_file"

+    return 0

+  fi

+

+  cleanup_repacked_input "$repacked_file"

+  return 1

+source_video_is_readable() {

+  local file_path="$1"

+  REPACKED_SOURCE_PATH=""

+

+  if ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$file_path" >/dev/null 2>&1; then

+    SOURCE_READABLE_MODE="normal"

+    return 0

+  fi

+

+  if [[ "$VERBOSE" == true ]]; then

+    log_msg "WARN" "Source probe failed, trying tolerant mode: $file_path"

+  fi

+

+  if ffprobe -v error -fflags +genpts -err_detect ignore_err -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$file_path" >/dev/null 2>&1; then

+    SOURCE_READABLE_MODE="tolerant"

+    vlog_msg "INFO" "Source readable in tolerant mode: $file_path"

+    return 0

+  fi

+

+  if try_apple_repack_for_unreadable "$file_path"; then

+    SOURCE_READABLE_MODE="repacked"

+    log_msg "WARN" "Using avconvert repack fallback for unreadable source: $file_path"

+    return 0

+  fi

+

+  SOURCE_READABLE_MODE="normal"

+  return 1

+}

+

+source_error_from_ffmpeg_log() {

+  local ffmpeg_log="$1"

+  [[ -n "$ffmpeg_log" && -f "$ffmpeg_log" ]] || return 1

+  grep -Eiq 'invalid data found when processing input|error reading header|moov atom not found|corrupt|truncated|end of file|contradictionary STSC and STCO' "$ffmpeg_log"

+}

+

+destination_cannot_accept_file() {

+  local input_file="$1"

+  local out_dir="$2"

+  local ffmpeg_log="$3"

+  local probe_path=""

+  local avail_kb=""

+  local avail_bytes=0

+

+  if [[ -n "$ffmpeg_log" && -f "$ffmpeg_log" ]]; then

+    if grep -Eiq 'no space left on device|disk quota exceeded|read-only file system|permission denied|file too large|input/output error|stale file handle' "$ffmpeg_log"; then

+      return 0

+    fi

+  fi

+

+  probe_path="$(mktemp "$out_dir/.varia_write_probe.XXXXXX" 2>/dev/null || true)"

+  if [[ -z "$probe_path" ]]; then

+    return 0

+  fi

+  rm -f -- "$probe_path" 2>/dev/null || true

+

+  avail_kb="$(df -Pk "$out_dir" 2>/dev/null | awk 'NR==2 {print $4}' || true)"

+  if [[ "$avail_kb" =~ ^[0-9]+$ ]]; then

+    avail_bytes=$((avail_kb * 1024))

+    if [[ "$avail_bytes" -lt 67108864 ]]; then

+      return 0

+    fi

+  fi

+

+  return 1

+}

+

+    if is_apple_noise_file "$file"; then

+      vlog_msg "SKIP" "Ignoring Apple artifact: $file"

+      continue

+    fi

+  local rel_path output_file temp_output_file out_dir

+  local display_path

+  local encode_input_file

+  local repacked_input_file=""

+  display_path="${input_file#$PWD/}"

+  encode_input_file="$input_file"

+  if ! source_video_is_readable "$input_file"; then

+    ERRORS=$((ERRORS + 1))

+    INVALID_SOURCES_SKIPPED=$((INVALID_SOURCES_SKIPPED + 1))

+    if [[ "$VERBOSE" == true ]]; then

+      log_msg "ERROR" "Skipping unreadable/corrupted source video: $input_file"

+    else

+      log_progress_start "$display_path"

+      log_progress_skipped_unreadable "$display_path"

+    fi

+    return 2

+  fi

+

+  if [[ "$SOURCE_READABLE_MODE" == "repacked" && -n "$REPACKED_SOURCE_PATH" ]]; then

+    repacked_input_file="$REPACKED_SOURCE_PATH"

+    encode_input_file="$REPACKED_SOURCE_PATH"

+    vlog_msg "INFO" "Encoding from avconvert repacked source: $repacked_input_file"

+  fi

+

+    cleanup_repacked_input "$repacked_input_file"

+  if probe_has_audio "$encode_input_file"; then

+  temp_output_file="$(make_temp_output_file "$output_file")"

+  if [[ -z "$temp_output_file" ]]; then

+    ERRORS=$((ERRORS + 1))

+    DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+    log_msg "ERROR" "Could not create temporary output file: $output_file"

+    return 3

+  fi

+

+  if [[ "$SOURCE_READABLE_MODE" == "tolerant" ]]; then

+    cmd+=( -fflags +genpts -err_detect ignore_err )

+  fi

+  cmd+=( -i "$encode_input_file" -map 0:v:0 )

+  cmd+=( "${VIDEO_ARGS[@]}" -map_metadata 0 -movflags +faststart "$temp_output_file" )

+  if [[ "$VERBOSE" != true ]]; then

+    log_progress_start "$display_path"

+  fi

+

+  vlog_msg "INFO" "Encoding: $input_file -> $output_file (temp: $temp_output_file)"

+  local ffmpeg_log=""

+    if run_ffmpeg_with_signal_guard "${cmd[@]}"; then

+      DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+      return 3

+    if run_ffmpeg_with_signal_guard "${cmd[@]}" >"$ffmpeg_log" 2>&1; then

+    local failure_rc=1

+    if destination_cannot_accept_file "$input_file" "$out_dir" "$ffmpeg_log"; then

+      failure_rc=3

+    elif source_error_from_ffmpeg_log "$ffmpeg_log"; then

+      failure_rc=2

+    fi

+

+    cleanup_transcode_artifacts "$temp_output_file" "$output_file"

+    if [[ "$failure_rc" -eq 2 ]]; then

+      INVALID_SOURCES_SKIPPED=$((INVALID_SOURCES_SKIPPED + 1))

+    elif [[ "$failure_rc" -eq 3 ]]; then

+      DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+    fi

+      log_progress_failed "$display_path" "$file_real_elapsed_sec" "$encode_elapsed_sec" "$ffmpeg_rc" "$ffmpeg_log"

+    if [[ "$failure_rc" -eq 3 ]]; then

+      log_msg "ERROR" "Destination cannot accept more output data: $out_dir"

+    fi

+    cleanup_repacked_input "$repacked_input_file"

+    return "$failure_rc"

+  if ! restore_metadata_with_exiftool "$input_file" "$temp_output_file"; then

+    cleanup_transcode_artifacts "$temp_output_file" "$output_file"

+    if [[ "$STOP_AFTER_CURRENT" == true && "$INTERRUPT_COUNT" -gt 0 ]]; then

+      cleanup_repacked_input "$repacked_input_file"

+      return 4

+    fi

+    DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+    cleanup_repacked_input "$repacked_input_file"

+    return 3

+  if ! map_garmin_model_to_standard_tags "$input_file" "$temp_output_file"; then

+    cleanup_transcode_artifacts "$temp_output_file" "$output_file"

+    if [[ "$STOP_AFTER_CURRENT" == true && "$INTERRUPT_COUNT" -gt 0 ]]; then

+      cleanup_repacked_input "$repacked_input_file"

+      return 4

+    fi

+    DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+    cleanup_repacked_input "$repacked_input_file"

+    return 3

+  if ! write_transcode_encoder_metadata "$temp_output_file"; then

+    cleanup_transcode_artifacts "$temp_output_file" "$output_file"

+    if [[ "$STOP_AFTER_CURRENT" == true && "$INTERRUPT_COUNT" -gt 0 ]]; then

+      cleanup_repacked_input "$repacked_input_file"

+      return 4

+    fi

+    DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+    cleanup_repacked_input "$repacked_input_file"

+    return 3

+    if ! validate_transcoded_output "$encode_input_file" "$temp_output_file"; then

+      cleanup_transcode_artifacts "$temp_output_file" "$output_file"

+      if [[ "$STOP_AFTER_CURRENT" == true && "$INTERRUPT_COUNT" -gt 0 ]]; then

+        cleanup_repacked_input "$repacked_input_file"

+        return 4

+      fi

+      DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+      cleanup_repacked_input "$repacked_input_file"

+      return 3

+  touch -r "$input_file" "$temp_output_file" || true

+

+  if [[ "$OVERWRITE" == true ]]; then

+    if ! mv -f "$temp_output_file" "$output_file"; then

+      cleanup_transcode_artifacts "$temp_output_file" "$output_file"

+      ERRORS=$((ERRORS + 1))

+      DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+      log_msg "ERROR" "Failed to move completed output into place: $output_file"

+      cleanup_repacked_input "$repacked_input_file"

+      return 3

+    fi

+  else

+    if ! mv -n "$temp_output_file" "$output_file"; then

+      cleanup_transcode_artifacts "$temp_output_file" "$output_file"

+      ERRORS=$((ERRORS + 1))

+      DESTINATION_FAILURES=$((DESTINATION_FAILURES + 1))

+      log_msg "ERROR" "Failed to move completed output into place: $output_file"

+      cleanup_repacked_input "$repacked_input_file"

+      return 3

+    fi

+  fi

+      cleanup_repacked_input "$repacked_input_file"

+    log_progress_done "$display_path" "$file_real_elapsed_sec" "$encode_elapsed_sec"

+  cleanup_repacked_input "$repacked_input_file"

+

+    if is_apple_noise_file "$jf"; then

+      vlog_msg "SKIP" "Ignoring Apple artifact JSON: $jf"

+      continue

+    fi

+  trap 'handle_interrupt' INT TERM

+

+  if [[ -z "${VIDEO_FILES[*]-}" ]]; then

+  for f in ${VIDEO_FILES+"${VIDEO_FILES[@]}"}; do

+    if [[ "$STOP_AFTER_CURRENT" == true ]]; then

+      log_msg "INFO" "Stop requested; ending before next file"

+

+    local process_rc=0

+    if process_video_file "$f"; then

+      continue

+    else

+      process_rc=$?

+    fi

+

+    case "$process_rc" in

+      2)

+        log_msg "INFO" "Continuing after unreadable/corrupted source file"

+        continue

+        ;;

+      3)

+        log_msg "ERROR" "Stopping encoding chain because destination is not writable or is out of space"

+        break

+        ;;

+      4)

+        log_msg "INFO" "Stopped by user after current file"

+        break

+        ;;

+      *)

+        if [[ "$FAIL_FAST" == true ]]; then

+          log_msg "ERROR" "Stopping encoding chain due to ffmpeg failure/interruption"

+          break

+        fi

+        log_msg "ERROR" "Continuing after ffmpeg failure because --keep-going is enabled"

+        continue

+        ;;

+    esac

+  if [[ "$STOP_AFTER_CURRENT" == true ]]; then

+    log_msg "INFO" "Skipping sidecar copy and manifest because run was stopped by user"

+  elif [[ "$ERRORS" -eq 0 ]]; then

+  log_msg "INFO" "Summary: videos_processed=$VIDEOS_PROCESSED videos_skipped=$VIDEOS_SKIPPED invalid_sources_skipped=$INVALID_SOURCES_SKIPPED destination_failures=$DESTINATION_FAILURES json_copied=$JSON_COPIED json_skipped=$JSON_SKIPPED errors=$ERRORS"