Mes propres fonctions shell

# Mes propres fonctions shell

Posté par Yth (Mastodon) le 18 janvier 2024 à 09:40. En réponse à la dépêche Archiver ses vidéos : retour d’expérience. Évalué à 10.

Pour ce genre d'opérations, avec ffmpeg, j'ai un fichier avec des fonctions bash dedans, il suffit de le sourcer et on peut les utiliser :

On a d'abord une série de fonctions pour extraire quelques infos à partir de ffprobe. La première série extrait une info spécifique d'un fichier, la seconde liste ces infos pour chaque fichier dans la ligne de commande, avec des couleurs, et enfin la dernière fonction ffinfo regroupe un peu tout en une ligne.
Et il faudrait que je la réécrive, puisqu'à l'origine elle devait peu servir donc tant pis si on exécute 5 fois ffprobe, mais en pratique c'est la seule que j'utilise.
Avec des codes ANSI pour les couleurs aussi.

ANSICLEAR="033円[0;m"
ANSIBLACK="033円[30m"
ANSIRED="033円[31m"
ANSIGREEN="033円[32m"
ANSIORANGE="033円[33m"
ANSIBLUE="033円[34m"
ANSIMAGENTA="033円[35m"
ANSICYAN="033円[36m"
ANSIWHITE="033円[37m"
ANSILBLACK="033円[90m"
ANSILRED="033円[91m"
ANSILGREEN="033円[92m"
ANSILORANGE="033円[93m"
ANSILBLUE="033円[94m"
ANSILMAGENTA="033円[95m"
ANSILCYAN="033円[96m"
ANSILWHITE="033円[97m"
ff_size() {
 [ -f "1ドル" ] && echo $(ffprobe "1ドル" 2>&1 | grep -Ei "^.*video: .*[0-9]*x[0-9]*[, ].*$" | head -1 | sed 's/.* \([0-9]*x[0-9]*\)[, ].*/1円/')
}
ff_fps() {
 [ -f "1ドル" ] && echo $(ffprobe "1ドル" 2>&1 | grep -Ei "^.*video: .*[0-9]*x[0-9]*[, ].*$" | head -1 | sed 's/.* [0-9]*x[0-9]*[, ].* \([0-9.]*\) fps.*/1円/')
}
ff_len() {
 [ -f "1ドル" ] && echo $(ffprobe "1ドル" 2>&1 | grep -Ei "^.*Duration: .*[0-9]*:[0-9]*:[0-9]*\.[0-9]*[, ].*$" | head -1 | sed 's/.* \([0-9]*:[0-9]*:[0-9]*\.[0-9]*\)[, ].*/1円/')
}
ff_srt() {
 [ -f "1ドル" ] && echo $(ffprobe "1ドル" 2>&1 | grep -Ei "^.*Stream #[0-9]:[0-9](.*): Subtitle: .*$" | sed 's/.*Stream #[0-9]:[0-9][(]\([^)]*\)[)].*/1円/' | xargs | tr \  ,)
}
ff_audio() {
 [ -f "1ドル" ] && echo $(ffprobe "1ドル" 2>&1 | grep -Ei "^.*Stream #[0-9]:[0-9](.*): Audio: .*$" | sed 's/.*Stream #[0-9]:[0-9][(]\([^)]*\)[)].*/1円/' | xargs | tr \  ,)
}
ff_title() {
 [ -f "1ドル" ] && echo $(ffprobe "1ドル" 2>&1 | grep -Ei "^\s*title\s*: .*$") | sed 's/title : //'
}
ffsize() {
 while [ ! -z "1ドル" ]; do
 local FILE="1ドル" && shift
 if [ ! -f "$FILE" ]; then continue; fi
 local SIZE=$(ff_size "$FILE")
 echo -e "${ANSIRED}$SIZE\t: ${ANSIORANGE}${FILE}${ANSICLEAR}"
 done
}
fflen() {
 while [ ! -z "1ドル" ]; do
 local FILE="1ドル" && shift
 if [ ! -f "$FILE" ]; then continue; fi
 local LEN=$(ff_len "$FILE")
 echo -e "${ANSIRED}$LEN\t: ${ANSIORANGE}${FILE}${ANSICLEAR}"
 done
}
fffps() {
 while [ ! -z "1ドル" ]; do
 local FILE="1ドル" && shift
 if [ ! -f "$FILE" ]; then continue; fi
 local FPS=$(ff_fps "$FILE")
 echo -e "${ANSIRED}$FPS\t: ${ANSIORANGE}${FILE}${ANSICLEAR}"
 done
}
ffsrt() {
 while [ ! -z "1ドル" ]; do
 local FILE="1ドル" && shift
 if [ ! -f "$FILE" ]; then continue; fi
 local SRT=$(ff_srt "$FILE")
 echo -e "${ANSIRED}$SRT\t: ${ANSIORANGE}${FILE}${ANSICLEAR}"
 done
}
ffaudio() {
 while [ ! -z "1ドル" ]; do
 local FILE="1ドル" && shift
 if [ ! -f "$FILE" ]; then continue; fi
 local AUDIO=$(ff_audio "$FILE")
 echo -e "${ANSIRED}$AUDIO\t: ${ANSIORANGE}${FILE}${ANSICLEAR}"
 done
}
fftitle() {
 while [ ! -z "1ドル" ]; do
 local FILE="1ドル" && shift
 if [ ! -f "$FILE" ]; then continue; fi
 local TITLE=$(ff_title "$FILE")
 echo -e "${ANSIRED}$TITLE\t: ${ANSIORANGE}${FILE}${ANSICLEAR}"
 done
}
ffinfo() {
 while [ ! -z "1ドル" ]; do
 local FILE="1ドル" && shift
 if [ ! -f "$FILE" ]; then continue; fi
 local SIZE=$(ff_size "$FILE")
 local LEN=$(ff_len "$FILE")
 local FPS=$(ff_fps "$FILE")
 local SRT=$(ff_srt "$FILE")
 local AUDIO=$(ff_audio "$FILE")
 [ ! -z "$SRT" ] && SRT="[$SRT]\t"
 [ ! -z "$AUDIO" ] && AUDIO="{$AUDIO}\t"
 echo -e "${ANSIRED}$LEN\t$SIZE${ANSILRED}@$FPS\t$AUDIO$SRT: ${ANSIORANGE}${FILE}${ANSICLEAR}"
 done
}

Par exemple :

$ ffinfo vidéo.mkv vidéautre.mkv
00:58:53.97 960x480@23.98 {eng} [eng] : vidéo.mkv
02:04:33.65 1280x692@23.98 {fre,jpn} [fre,eng] : vidéautre.mkv

Ensuite une multifonction (au moins suisse) de conversion.
Elle est assez imbitable, mais elle fait ce qu'elle prétend faire dans le Usage : Usage ff [unmap] [format:mkv|mk4|mp4|ogm|mp3|ogg|opus|audio] [scale width] [destination directory] file [files|non existant destination file]
Il y a une variable d'environnement CRF=22, qu'on peut bien sûr modifier en ligne de commande.

En gros, elle prend un fichier source, le balance à la destination, et converti.
L'option unmap permet de virer des infos inconvertibles, comme parfois des chapitrages qui ne passent pas d'un avi vers un mkv, ou un truc du genre. Par défaut on copie tous les flux, en transformant l'audio et la vidéo, avec unmap on converti l'audio et la vidéo, on copie les sous-titres, et on oublie le reste. Quand ça plante j'essaie avec unmap, voilà.

Ensuite le format de sortie, ça fait des choix en fonction de mes besoins ponctuels, pas du tout en fonction des besoins du monde entier :
* mkv : par défaut, conversion x265 vers fichier .mkv
* mk4 : conversion x264 vers fichier .mkv, pour compatibilité avec un matériel plus ancien.
* mp4 : conversion x264 vers .mp4, pour compatibilité windows sans VlC.
* ogm : pour faire de l'ogg/vorbis en .ogm, en pratique je n'utilise jamais.
Et les formats d'extraction audio mp3, ogg, opus qui convertissent le flux audio dans le format mentionné, et enfin audio pour extraire le format audio sans y toucher.

L'option suivante est intéressante : elle permet de redimensionner à la largeur souhaitée, en conservant le ratio. Donc pour passer de 4k à fullHD on va mettre 1920, si on veut faire tourner la vidéo sur la vieille machine qui gère pas le fullHD on va mettre 720 par exemple, on aura en 16/9è une vidéo en 720x405.

Après, soit on met [fichier source] [fichier destination], le fichier de destination est facultatif, il sera construit à partir du nom du fichier source - soit on met [répertoire de destination] [plein de fichiers source...], et là aussi les noms de fichiers de destination sont construits à partir de noms des fichiers sources.

On pourra noter si on arrive à déchiffrer les hiéroglyphe bashiques de la 4ème dynastie et demi de l'empire sed, que le nom de fichier est nettoyé : les espaces deviennent des _, on vire ce qui est après le premier ., des trucs du genre. Ça peut être très pourri si la vidéo s'appelle ma.video.de.vacances.avi on va avoir ma.mkv avec le nommage automatique. Bien fait.

Attention aussi, c'est codé avec des moufles, donc l'ordre des options est impératif, c'est comme ça, et c'est tout. Autant dire que je lance toujours ff sans rien d'abord pour me rappeler de l'ordre, sinon je fais n'importe quoi.

export CRF=22
ff() {
 local EXT="mkv"; local SCALE=""; local WIDTH=""; local MAP="-map 0 -c copy"; local DESTDIR=""; local VCODEC=""; local NN=""; local ACODEC=""; local VCODEC=""
 [ -z "1ドル" ] && echo "Usage ${FUNCNAME[0]} [unmap] [format:mkv|mk4|mp4|ogm|mp3|ogg|opus|audio] [scale width] [destination directory] file [files|non existant destination file]" && return
 [ "1ドル" == "unmap" ] && MAP="-scodec copy" && shift
 [[ "1ドル" =~ ^mkv$|^mk4$|^mp4$|^ogm$|^mp3$|^ogg$|^opus$|^audio$ ]] && EXT=1ドル && shift
 [[ "1ドル" =~ ^[0-9]+$ ]] && WIDTH=1ドル && shift
 [ -d "1ドル" ] && DESTDIR="$(realpath "1ドル")" && shift && NN="-n"
 while [ ! -z "1ドル" ]; do
 ACODEC="-c:a aac -b:a 128k"
 [ $EXT == "mp3" ] && MAP="-map a" && SCALE="" && ACODEC="-c:a libmp3lame -q:a 2"
 [ $EXT == "ogg" ] && MAP="-map a" && SCALE="" && ACODEC="-c:a libvorbis -q:a 5"
 [ $EXT == "opus" ] && MAP="-map a" && SCALE="" && ACODEC="-c:a libopus -b:a 96k -vbr on -compression_level 10"
 [ $EXT == "audio" ] && MAP="-map a" && SCALE="" && ACODEC="-q:a 0"
 [ $EXT == "mkv" ] && VCODEC="-c:v libx265 -preset medium -crf $CRF"
 [ $EXT == "mk4" ] && VCODEC="-c:v libx264 -preset medium -crf $CRF" && EXT="mkv"
 [ $EXT == "mp4" ] && VCODEC="-c:v libx264 -preset medium -crf $CRF"
 [ $EXT == "ogm" ] && VCODEC="-c:v libtheora -q:v 7" && ACODEC="-c:a libvorbis -q:a 5" && EXT='ogg'
 local SRC="1ドル"; local DEST="1ドル"
 shift
 #echo "#=$#"
 [ "$#" -eq 1 ] && [ ! -f "1ドル" -o $(sed 's/.*\.//' <<< "1ドル") = "srt" ] && DEST="1ドル" && shift
 DEST="$(sed 's/ /_/g;s/__/-/g;s/_-_/-/g;s/-0/-/;s/\([^-]*-[0-9]*\)x/1円/;s/\(.*\)\.[^.].*/1円/;s/-Epi.*//;s/'"'"'/’/g' <<< "$DEST").$EXT"
 [ ! -z "$DESTDIR" ] && DEST="$DESTDIR/$(basename "$DEST")"
 echo "$SRC -> $DEST"
 if [ ! -z "$WIDTH" ]; then
 local SIZE=$(ff_size "$SRC")
 local W=$(cut -dx -f1 <<< $SIZE)
 local H=$(cut -dx -f2 <<< $SIZE)
 local HEIGHT=$((($H*$WIDTH/$W+2)/4*4))
 local SCALE="-vf scale=${WIDTH}x${HEIGHT}"
 fi
 local CMD="ffmpeg $NN -i '$SRC' $SCALE$MAP$VCODEC$ACODEC '$DEST'"
 echo $CMD
 [ -z "$DEBUG" ] && ffmpeg -n $NN -i "$SRC" $SCALE $MAP $VCODEC $ACODEC "$DEST"
 done
}

Donc typiquement on va faire pour un lot avec une qualité plus basse : $ CRF=28; ff 720 ~/tmp/ ~/vidéos_à_traiter/* où on notera bien le mix de paramètres et de variable d'environnement, pour l'incohérence.

Et enfin la dernière fonction pratique, qui attends qu'un fichier existe, par exemple si on le télécharge et qu'il est en .part, et qu'il a son nom définitif, sans le .part, à la fin du téléchargement, ou si on le construit par ailleurs, et qu'il est déplacé dans le répertoire de traitement. Puis qui attends qu'il n'y ait pas d'autre processus ffmpeg qui tourne. Et enfin qui appelle ff. La syntaxe est incohérente avec celle de ff c'est pour mieux embrouiller les gens :

ffifo() { # Wait for {file} to be available, then wait for no ffmpeg process to run, then call ff()
 # ffifo file.part file.srt
 local DIR=$(dirname "1ドル")
 local FILE=$(basename "1ドル" .part)
 shift
 local DEST=1ドル
 shift
 echo "ff $@ \"$DIR/$FILE\" \"$DEST\""
 while [ ! -f "$DIR/$FILE" ]; do echo -n .; sleep 10; done
 while [ $(pidof ffmpeg > /dev/null && echo 1) ]; do echo -n °; sleep 10; done
 echo
 echo "# $DIR/$FILE"
 ff $@ "$DIR/$FILE" "$DEST"
}

Ça ne fonctionne qu'en mode source->destination pas en lots, et toutes les options de ff sont mises à la fin plutôt qu'au début.
Donc on va faire :

ffifo ~/Téléchargements/ma_vidéo_de_chat.touyube.[TROLOL].4K.x437.aac.dolby.camrip.webm.part ~/Mes_Vidéos/Chats/une_autre_vidéo_de_chats.mp4 720
# Qui appellera plus tard :
# ff 720 [src...].webm [dest...].mp4

Et aller se préparer un thé.
Dès que le téléchargement en cours est terminé, la conversion va commencer, et si on en fait deux en parallèle, le premier va convertir et le second attendre que le premier ait terminé avant de démarrer.
Pas de surcharge bourrine de la machine, merci !
Et même pas besoin d'attendre le nez devant l'écran que le téléchargement se termine.
Après on peut envoyer ça à sa cousine qui pourra montrer sa super vidéo de chats en classe à tous ses élèves de terminale sur son PC de l'éducation nationale, avec un format et une qualité que la poussive machine saura probablement appréhender.

Yth.