Automatiser la numérisation de vos coffrets DVD de séries TV

#!/bin/bash

# --- Formatage & Couleurs ---
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # Pas de couleur

log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_err()  { echo -e "${RED}[ERROR]${NC} $1"; }
log_prompt() { echo -ne "${YELLOW}[PROMPT]${NC} $1"; }

show_help() {
    cat << EOF
Usage: $(basename "$0") [options] [dossier_cible]

Encode automatiquement en boucle les titres des DVD insérés vers le format MKV (sans upscaling).

Arguments :
  dossier_cible   Le chemin du dossier de destination pour les fichiers MKV.
                  Si non spécifié, le script vous demandera de le saisir.

Options :
  -h, --help      Affiche cette aide et quitte.
  -a, --anime     Optimise l'encodage pour les dessins animés (tune=animation).
  -x, --hevc      Utilise le codec H.265 (HEVC) pour un meilleur ratio qualité/taille.
  -q, --quality   Force la qualité de la source : low (faible), medium (moyenne), high (bonne).
EOF
    exit 0
}

# --- Gestion des signaux ---
cleanup_and_exit() {
    echo ""
    log_info "Interruption détectée (Ctrl+C). Arrêt propre en cours..."
    exit 1
}

trap cleanup_and_exit SIGINT SIGTERM

# --- Fonctions de vérification et détection ---

check_dependencies() {
    local deps=("ffmpeg" "ffprobe" "lsdvd" "eject" "awk" "mediainfo")
    local missing=()

    for dep in "${deps[@]}"; do
        if ! command -v "$dep" &> /dev/null; then
            missing+=("$dep")
        fi
    done

    # Vérification de la bibliothèque libdvdcss
    local libcss_found=false
    for libdir in /usr/lib /usr/lib64 /usr/local/lib /lib; do
        if [[ -f "${libdir}/libdvdcss.so" || -f "${libdir}/libdvdcss.so.2" ]]; then
            libcss_found=true
            break
        fi
    done
    [[ "$libcss_found" == "false" ]] && missing+=("libdvdcss")

    if (( ${#missing[@]} > 0 )); then
        log_err "Les dépendances requises suivantes sont manquantes : ${missing[*]}"
        echo "Veuillez les installer avec votre gestionnaire de paquets :"
        echo "  - apt/deb : sudo apt install -y lsdvd eject ffmpeg gawk libdvd-pkg && sudo dpkg-reconfigure libdvd-pkg"
        echo "  - pacman  : sudo pacman -S lsdvd util-linux ffmpeg gawk libdvdcss"
        exit 1
    fi
}

detect_dvd_device() {
    local device_name=$(awk '/drive name:/ {print $3}' /proc/sys/dev/cdrom/info 2>/dev/null | head -n 1)
    if [[ -z "$device_name" ]]; then
        log_err "Aucun lecteur DVD trouvé dans /proc/sys/dev/cdrom/info."
        exit 1
    fi
    echo "/dev/${device_name}"
}

# --- Fonctions d'analyse et de configuration ---

get_quality_settings() {
    local bitrate=$1
    local force_q=$2

    # Valeurs par défaut pour HQDN3D et UNSHARP
    local hqdn3d=""
    local unsharp=""
    local msg=""

    if [[ "$force_q" == "low" ]]; then
        hqdn3d="3:3:6:6"; unsharp="3:3:0.8:3:3:0.8"; msg="forcée (faible/low)"
    elif [[ "$force_q" == "medium" ]]; then
        hqdn3d="2:2:4:4"; unsharp="3:3:0.6:3:3:0.6"; msg="forcée (moyenne/medium)"
    elif [[ "$force_q" == "high" ]]; then
        hqdn3d="1.5:1.5:3:3"; unsharp="3:3:0.5:3:3:0.5"; msg="forcée (bonne/high)"
    else
        # Sélection automatique selon le bitrate source
        if [[ -n "$bitrate" && "$bitrate" -lt 2000000 ]]; then
            hqdn3d="3:3:6:6"; unsharp="3:3:0.8:3:3:0.8"; msg="auto (low, bitrate < 2M)"
        elif [[ -n "$bitrate" && "$bitrate" -lt 5000000 ]]; then
            hqdn3d="2:2:4:4"; unsharp="3:3:0.6:3:3:0.6"; msg="auto (medium, bitrate < 5M)"
        else
            hqdn3d="1.5:1.5:3:3"; unsharp="3:3:0.5:3:3:0.5"; msg="auto (high, par défaut)"
        fi
    fi
    echo "$hqdn3d|$unsharp|$msg"
}

# Tableaux globaux pour stocker les arguments de métadonnées et de mapping sans risque de splitting
GLOBAL_METADATA_ARGS=()
GLOBAL_MAP_ARGS=()

get_metadata_args() {
    local device=$1
    local title_id=$2

    # Réinitialisation des tableaux globaux
    GLOBAL_METADATA_ARGS=()
    GLOBAL_MAP_ARGS=("-map" "0:v:0")

    local probe_out=$(ffprobe -f dvdvideo -title "${title_id}" -i "${device}" -show_entries stream=index,codec_type:stream_tags=language -of csv=p=0 2>/dev/null || echo "")
    if [[ -z "$probe_out" ]]; then
        GLOBAL_MAP_ARGS=("-map" "0:v:0" "-map" "0:a?" "-map" "0:s?")
        return
    fi

    local a_idx=0
    local s_idx=0
    local has_fre_audio=false

    # Premier passage pour détecter l'audio français
    while IFS=',' read -r idx codec_type lang; do
        if [[ "$codec_type" == "audio" ]]; then
            local lang_lower=$(echo "$lang" | tr '[:upper:]' '[:lower:]' | xargs)
            [[ "$lang_lower" =~ ^(fre|fra|fr)$ ]] && has_fre_audio=true
        fi
    done <<< "$probe_out"

    # Deuxième passage pour construire les arguments
    while IFS=',' read -r idx codec_type lang; do
        [[ -z "$codec_type" ]] && continue
        local lang_lower=$(echo "$lang" | tr '[:upper:]' '[:lower:]' | xargs)

        if [[ "$codec_type" == "audio" ]]; then
            if [[ "$lang_lower" =~ ^(eng|en)$ ]]; then
                GLOBAL_METADATA_ARGS+=("-metadata:s:a:${a_idx}" "title=anglais [VO]" "-metadata:s:a:${a_idx}" "language=eng")
                [[ "$has_fre_audio" == "false" && $a_idx -eq 0 ]] && GLOBAL_METADATA_ARGS+=("-disposition:a:${a_idx}" "default") || GLOBAL_METADATA_ARGS+=("-disposition:a:${a_idx}" "0")
                GLOBAL_MAP_ARGS+=("-map" "0:${idx}")
                (( a_idx++ ))
            elif [[ "$lang_lower" =~ ^(fre|fra|fr)$ ]]; then
                GLOBAL_METADATA_ARGS+=("-metadata:s:a:${a_idx}" "title=français" "-metadata:s:a:${a_idx}" "language=fre")
                GLOBAL_METADATA_ARGS+=("-disposition:a:${a_idx}" "default")
                GLOBAL_MAP_ARGS+=("-map" "0:${idx}")
                (( a_idx++ ))
            fi
        elif [[ "$codec_type" == "subtitle" ]]; then
            if [[ "$lang_lower" =~ ^(fre|fra|fr)$ ]]; then
                GLOBAL_METADATA_ARGS+=("-metadata:s:s:${s_idx}" "title=français" "-metadata:s:s:${s_idx}" "language=fre")
            elif [[ "$lang_lower" =~ ^(eng|en)$ ]]; then
                GLOBAL_METADATA_ARGS+=("-metadata:s:s:${s_idx}" "title=anglais (CC)" "-metadata:s:s:${s_idx}" "language=eng")
            else
                local label="${lang_lower:-sub_${s_idx}}"
                GLOBAL_METADATA_ARGS+=("-metadata:s:s:${s_idx}" "title=${label}" "-metadata:s:s:${s_idx}" "language=${lang_lower:-${label}}")
            fi
            GLOBAL_MAP_ARGS+=("-map" "0:${idx}")
            (( s_idx++ ))
        fi
    done <<< "$probe_out"

    # Si aucune piste audio française ou anglaise n'a été trouvée, on conserve toutes les pistes audio disponibles par précaution
    if [[ $a_idx -eq 0 ]]; then
        log_warn "Aucune piste audio anglaise ou française détectée. Conservation de toutes les pistes audio par précaution."
        a_idx=0
        while IFS=',' read -r idx codec_type lang; do
            [[ -z "$codec_type" ]] && continue
            local lang_lower=$(echo "$lang" | tr '[:upper:]' '[:lower:]' | xargs)
            if [[ "$codec_type" == "audio" ]]; then
                local label="${lang_lower:-audio_${a_idx}}"
                GLOBAL_METADATA_ARGS+=("-metadata:s:a:${a_idx}" "title=${label}" "-metadata:s:a:${a_idx}" "language=${lang_lower:-${label}}")
                [[ $a_idx -eq 0 ]] && GLOBAL_METADATA_ARGS+=("-disposition:a:${a_idx}" "default") || GLOBAL_METADATA_ARGS+=("-disposition:a:${a_idx}" "0")
                GLOBAL_MAP_ARGS+=("-map" "0:${idx}")
                (( a_idx++ ))
            fi
        done <<< "$probe_out"
    fi
}

# --- Logique d'encodage ---

process_title() {
    local device=$1
    local title_id=$2
    local out_file=$3
    local err_file=$4
    local vcodec=$5
    local vcrf=$6
    local vpreset=$7
    local vprofile=$8
    local vpixfmt=$9

    # On place tous les arguments dans un tableau pour un accès facile par index
    local args=("$@")
    local total_args=${#args[@]}

    # Les 3 derniers arguments sont : target_fps, vf_chain, metadata_args (ce dernier est maintenant ignoré car on utilise le tableau global)
    local metadata_args_ignored="${args[$((total_args - 1))]}"
    local vf_chain="${args[$((total_args - 2))]}"
    local target_fps="${args[$((total_args - 3))]}"
    local tune_option="${args[$((total_args - 4))]}"

    # Tout ce qui se trouve entre l'argument 10 (index 9) et le 4ème dernier est une option de codec
    local vcodec_opts=()
    for (( i=9; i < total_args - 4; i++ )); do
        vcodec_opts+=("${args[$i]}")
    done

    local tune_args=()
    [[ -n "$tune_option" ]] && tune_args=("-tune" "$tune_option")

    ffmpeg -f dvdvideo -title "${title_id}" -i "${device}" \
        "${GLOBAL_MAP_ARGS[@]}" \
        -c:v "${vcodec}" -crf "${vcrf}" -preset "${vpreset}" -profile:v "${vprofile}" \
        -pix_fmt "${vpixfmt}" "${vcodec_opts[@]}" "${tune_args[@]}" \
        -r "${target_fps}" -vsync cfr \
        -vf "${vf_chain}" \
        -c:a aac -ar 44100 -b:a 128k "${GLOBAL_METADATA_ARGS[@]}" -c:s copy \
        -y "${out_file}" 2> "${err_file}"

    return $?
}

# --- Initialisation et Arguments ---

TUNE_OPTION="film"
WORKDIR=""
USE_HEVC=false
FORCE_QUALITY=""

while [[ $# -gt 0 ]]; do
    case "$1" in
        -h|--help) show_help ;;
        -a|--anime) TUNE_OPTION="animation"; shift ;;
        -x|--hevc|--h265) USE_HEVC=true; shift ;;
        -q|--quality)
            if [[ "$2" =~ ^(low|medium|high)$ ]]; then
                FORCE_QUALITY="$2"; shift 2
            else
                log_err "Qualité invalide : '${2:-vide}'. Utilisez low, medium ou high."; exit 1
            fi
            ;;
        *) [[ -z "$WORKDIR" ]] && WORKDIR="$1"; shift ;;
    esac
done

# Configuration du codec
if $USE_HEVC; then
    VCODEC="libx265"; VCRF="22"; VPRESET="slow"; VPROFILE="main10"; VPIXFMT="yuv420p10le"
    VCODEC_OPTS=("-x265-params" "no-sao=1"); VCODEC_SUFFIX="x265"
    [[ "$TUNE_OPTION" == "film" ]] && TUNE_OPTION=""
else
    VCODEC="libx264"; VCRF="18"; VPRESET="veryslow"; VPROFILE="high"; VPIXFMT="yuv420p"
    VCODEC_OPTS=(); VCODEC_SUFFIX="x264"
fi

# Gestion du dossier de travail
if [[ -z "$WORKDIR" ]]; then
    log_prompt "Chemin du dossier cible (Entrée pour le dossier courant) : "
    read -r WORKDIR
fi
[[ -n "$WORKDIR" && "${WORKDIR}" != */ ]] && WORKDIR="${WORKDIR}/"
[[ -n "$WORKDIR" && ! -d "$WORKDIR" ]] && { log_info "Création du dossier : $WORKDIR"; mkdir -p "$WORKDIR"; }

check_dependencies
DVD_DEVICE=$(detect_dvd_device)
log_info "Lecteur utilisé : ${DVD_DEVICE}"

# --- Boucle principale ---
while true; do
    if ! dd if="${DVD_DEVICE}" of=/dev/null bs=2048 count=1 status=none 2>/dev/null; then
        if [[ $(dd if="${DVD_DEVICE}" of=/dev/null bs=2048 count=1 2>&1) == *"No medium found"* ]]; then
            sleep 2; continue
        else
            log_err "Erreur lecture disque. Attente..."; sleep 5; continue
        fi
    fi

    log_info "Disque détecté. Analyse..."
    DVD_INFOS=$(lsdvd "${DVD_DEVICE}" 2>/dev/null | grep -v '00:00' || true)
    [[ -z "$DVD_INFOS" ]] && { log_warn "Impossible de lire le DVD. Attente..."; sleep 5; continue; }

    MEDIA_NAME=$(awk -F': ' '/^Disc Title/ {print $2}' <<< "$DVD_INFOS" | xargs)
    MEDIA_TITLE_ID=$(awk -F'[:,]' '/^Title:/ {print $2}' <<< "$DVD_INFOS" | tr -d ' ')

    if [[ -z "$MEDIA_NAME" || -z "$MEDIA_TITLE_ID" ]]; then
        log_warn "Infos incomplètes. Éjection..."; eject "${DVD_DEVICE}"; continue
    fi

    log_info "Média : ${MEDIA_NAME}"

    # Extraction de la saison
    SEASON_STR=""
    if [[ "$MEDIA_NAME" =~ S([0-9]+) ]]; then
        SEASON_STR=$(printf "S%02d" "${BASH_REMATCH[1]}")
        log_info "Saison détectée : ${SEASON_STR}"
    else
        log_prompt "Saison pour ce DVD (ex: 1 ou S01) : "
        read -r USER_SEASON
        if [[ "$USER_SEASON" =~ ([0-9]+) ]]; then
            SEASON_STR=$(printf "S%02d" "${BASH_REMATCH[1]}")
        else
            SEASON_STR="S01"
            log_warn "Saison invalide ou non spécifiée. Utilisation de S01 par défaut."
        fi
        log_info "Saison utilisée : ${SEASON_STR}"
    fi

    # Calcul de l'épisode de départ
    EPISODE_ID=$(find "${WORKDIR:-.}" -maxdepth 1 -type f -name "${MEDIA_NAME} - ${SEASON_STR}E*.mkv" 2>/dev/null | wc -l)

    for i in ${MEDIA_TITLE_ID}; do
        (( EPISODE_ID++ ))
        EP_STR=$(printf "E%02d" "${EPISODE_ID}")
        OUT_FILE="${WORKDIR}${MEDIA_NAME} - ${SEASON_STR}${EP_STR} [MULTi DVD][AAC 2.0][${VCODEC_SUFFIX}].mkv"
        ERR_FILE="${WORKDIR}${MEDIA_NAME} - ${SEASON_STR}${EP_STR} [MULTi DVD][AAC 2.0][${VCODEC_SUFFIX}].err"

        log_info "Traitement du Titre ${i} -> ${OUT_FILE}"

        # Analyse vidéo
        SRC_VIDEO_PROPS=$(ffprobe -v error -f dvdvideo -title "${i}" -i "${DVD_DEVICE}" -select_streams v:0 -show_entries stream=field_order,r_frame_rate,bit_rate -of default=nw=1 2>/dev/null || echo "")
        SRC_FIELD_ORDER=$(echo "$SRC_VIDEO_PROPS" | awk -F'=' '/field_order/ {print $2}')
        SRC_FPS_RAW=$(echo "$SRC_VIDEO_PROPS" | awk -F'=' '/r_frame_rate/ {print $2}')

        # Bitrate
        SRC_BITRATE=$(echo "$SRC_VIDEO_PROPS" | awk -F'=' '/bit_rate/ {v=$2} END {if (v~/^[0-9]+$/) print v}')
        if [[ -z "$SRC_BITRATE" ]]; then
            # Estimation rapide du bitrate via ffmpeg (demuxing de 2s, gère correctement le CSS)
            SRC_BITRATE_KBPS=$(ffmpeg -f dvdvideo -title "${i}" -i "${DVD_DEVICE}" -t 2 -c copy -map 0:v:0 -f mpegts -y /dev/null 2>&1 | grep -o 'bitrate=[0-9.]\+' | tail -n 1 | cut -d'=' -f2)
            if [[ -n "$SRC_BITRATE_KBPS" ]]; then
                KBPS_INT=$(echo "$SRC_BITRATE_KBPS" | cut -d'.' -f1)
                [[ "$KBPS_INT" =~ ^[0-9]+$ ]] && SRC_BITRATE=$(( KBPS_INT * 1000 ))
            fi
        fi

        if [[ -z "$SRC_BITRATE" ]]; then
            # Tentative avec ffprobe (fallback stderr standard)
            SRC_BITRATE_KBPS=$(ffprobe -f dvdvideo -title "${i}" -i "${DVD_DEVICE}" 2>&1 | awk '/bitrate: [0-9]+ kb\/s/ {for(j=1;j<=NF;j++) if ($j=="bitrate:") {print $(j+1); exit}}')
            [[ "$SRC_BITRATE_KBPS" =~ ^[0-9]+$ ]] && SRC_BITRATE=$(( SRC_BITRATE_KBPS * 1000 ))
        fi

        # Si toujours vide, on tente d'utiliser mediainfo sur le premier VOB trouvé (en montant le DVD si nécessaire)
        if [[ -z "$SRC_BITRATE" ]]; then
            MOUNT_POINT=$(lsblk -no MOUNTPOINT "${DVD_DEVICE}" 2>/dev/null | head -n 1)
            WAS_MOUNTED=true
            if [[ -z "$MOUNT_POINT" ]]; then
                WAS_MOUNTED=false
                log_info "Montage du DVD pour analyse des fichiers VOB..."
                udisksctl mount -b "${DVD_DEVICE}" &>/dev/null
                MOUNT_POINT=$(lsblk -no MOUNTPOINT "${DVD_DEVICE}" 2>/dev/null | head -n 1)
            fi

            if [[ -n "$MOUNT_POINT" ]]; then
                # Chercher le premier fichier .VOB (>500MB) dans VIDEO_TS pour éviter les menus
                FIRST_VOB=$(find "${MOUNT_POINT}/VIDEO_TS" -name "*.VOB" -size +500M 2>/dev/null | head -n 1)
                if [[ -n "$FIRST_VOB" ]]; then
                    MI_BITRATE=$(mediainfo --Inform="General;%OverallBitRate%" "${FIRST_VOB}" 2>/dev/null)
                    # Si mediainfo retourne une valeur déraisonnable (> 10 Mbps) due à l'encryption CSS, on l'ignore
                    if [[ "$MI_BITRATE" =~ ^[0-9]+$ && "$MI_BITRATE" -lt 10000000 ]]; then
                        SRC_BITRATE="$MI_BITRATE"
                    fi
                fi

                # Démontage si c'est ce script qui l'a monté pour l'analyse
                if [[ "$WAS_MOUNTED" == "false" ]]; then
                    udisksctl unmount -b "${DVD_DEVICE}" &>/dev/null
                fi
            fi
        fi

        # Framerate cible
        TARGET_FPS=25
        if [[ -n "$SRC_FPS_RAW" && "$SRC_FPS_RAW" =~ ^[0-9]+/[0-9]+$ ]]; then
            S_NUM=$(echo "$SRC_FPS_RAW" | cut -d'/' -f1); S_DEN=$(echo "$SRC_FPS_RAW" | cut -d'/' -f2)
            [[ $S_DEN -gt 0 ]] && { S_INT=$(( S_NUM / S_DEN )); [[ $S_INT -le 25 && $S_INT -gt 0 ]] && TARGET_FPS="$S_INT"; }
        fi

        # Qualité et Filtres
        QUALITY_DATA=$(get_quality_settings "$SRC_BITRATE" "$FORCE_QUALITY")
        HQDN3D=$(echo "$QUALITY_DATA" | cut -d'|' -f1)
        UNSHARP=$(echo "$QUALITY_DATA" | cut -d'|' -f2)
        QUALITY_MSG=$(echo "$QUALITY_DATA" | cut -d'|' -f3)

        IS_INTERLACED=false
        [[ "$SRC_FIELD_ORDER" =~ ^(tt|bb|tb|bt)$ ]] && IS_INTERLACED=true

        if $IS_INTERLACED; then
            VF_CHAIN="yadif=mode=0:parity=-1:deint=0,hqdn3d=${HQDN3D},unsharp=${UNSHARP}"
        else
            VF_CHAIN="hqdn3d=${HQDN3D},unsharp=${UNSHARP}"
        fi

        # Métadonnées
        get_metadata_args "${DVD_DEVICE}" "${i}"

        log_info "Sorce: ${SRC_FIELD_ORDER:-?}, fps: ${SRC_FPS_RAW:-?}, bitrate: ${SRC_BITRATE:-?} b/s"
        log_info "Paramètres: entrelacé=${IS_INTERLACED}, fps=${TARGET_FPS}, qualité=${QUALITY_MSG}, vf='${VF_CHAIN}'"

        # Exécution de l'encodage
        # On passe le tableau VCODEC_OPTS complet pour ne pas perdre d'arguments
        process_title "${DVD_DEVICE}" "${i}" "${OUT_FILE}" "${ERR_FILE}" \
                      "${VCODEC}" "${VCRF}" "${VPRESET}" "${VPROFILE}" "${VPIXFMT}" \
                      "${VCODEC_OPTS[@]}" "${TUNE_OPTION}" "${TARGET_FPS}" "${VF_CHAIN}" "placeholder_metadata"

        if [[ $? -eq 0 ]]; then
            log_info "Succès : ${OUT_FILE}"; rm -f "${ERR_FILE}"
        else
            log_err "Échec du Titre ${i}. Voir ${ERR_FILE}"
        fi
    done

    log_info "Terminé pour ${MEDIA_NAME}. Éjection..."
    eject "${DVD_DEVICE}"
    sleep 5
done