Archiver ses vidéos : retour d’expérience.

Par : mobuturoiduzaire Julien Jorge orfenor Ysabeau gUI Tequila_Yuen

18 janvier 2024 à 02:22

Préambule : ma vie (et peut-être aussi la vôtre)

Comme probablement beaucoup d’entre vous, j’ai des milliers de photos et vidéos accumulées au cours des 20 dernières années. C’est très pratique de pouvoir stocker cela sur un seul disque dur. Mais cela pose trois problèmes majeurs :

la pérennité du support ;
le classement des fichiers pour pouvoir en retrouver un en particulier dans… très longtemps.
la possibilité de lire des fichiers dans plusieurs années (je pense à des fichiers Publisher 2.0 que je ne suis plus parvenu à lire par la suite – et non : les versions ultérieures à Publisher 2.0 ne lisent pas ces fichiers.

Ce texte s’adresse à toute personne qui se pose trois questions :

Pourrai-je visionner mes fichiers vidéos dans 30 ans pour les montrer à mes petits-enfants ?
Comment organiser/classer mes fichiers vidéos pour les retrouver rapidement ?
Comment réencoder mes fichiers vidéos pour limiter la place occupée (ou, dit autrement : quel format utiliser) ?

Après avoir lu cette dépêche, je vous recommande très fortement de vous reporter aux commentaires qui suivent car vous y trouverez probablement des précisions, liens, corrections ou suggestions qui l’enrichissent.

Pour le point 1., aucun support n’étant inaltérable/incassable, la règle tient en une phrase : « sauvegarder sur plusieurs supports (pour parer une éventuelle défaillance), dans différents endroits (en cas d’incendie, de vol, d’inondation…) et si possible en chiffrant ses disques (pour protéger votre vie privée en cas de vol : c’est incroyablement simple sous linux)
Pour le point 2., j’avais rédigé un document il y a fort fort longtemps où j’expliquais que le seul classement pérenne était le classement chronologique (je vous laisse vous reporter au document pour comprendre pourquoi l’utilisation de logiciels propriétaires est à proscrire). Pour résumer, je crée un dossier par année (2023) dans lequel il y a douze sous-dossiers (2023_01, 2023_02 etc.) et dans chacun d’eux, je crée un dossier par jour avec la date et le lieu (par exemple, 2023_06_25_saint_denis_la_reunion indique immédiatement où et quand ont été prises les photos et les vidéos à l’intérieur de ce dossier). Les photos sont renommées (et retournées si nécessaire) automatiquement avec l’instruction jhead -autorot -nf%Y_%m_%d__%H_%M_%S_ *.jpg. Les vidéos sont renommées manuellement sous la forme 2023_06_25__video_02_christophe_et_philippe_en_velo.mov ¹
Pour le point 3., le format JPG étant ouvert, la lisibilité des photos est garantie dans le temps. Pour les vidéos, c’est un peu plus compliqué puisqu’en général, trois formats interviennent :
- le codec vidéo pour l’image (comme h264, h265, av1, mjpeg…) ;
- le codec audio pour le son (comme mp3)
- le format de conteneur (comme avi, mp4, mts…)

C’est là où on en revient à l’histoire de ma vie.

note : je n’ai jamais trouvé comment récupérer les métadonnées des vidéos pour les utiliser dans le nom du fichier, comme je le fais avec jhead. ↩

Sommaire

I Il était une fois MA vie !

Après plus de 20 ans de stockage, mon disque dur de 1 To frisait les 90 % de remplissage. Alors, oui, 1 To, c’est très commun aujourd’hui : il me suffisait d’acheter un disque de 4 To et le problème était réglé.

Oui… mais non. Je n’aime pas occuper de la place. Je pense que c’est une mauvaise habitude que d’avoir des téraoctets disponibles ou des gigaoctets sur une carte SD pour son smartphone que l’on utilise sans se poser de questions en ayant l’impression d’un stockage illimité. Car un jour, cela nous revient dans les dents (carte SD/disque dur qui plante sans sauvegarde, réinstallation de tout le système, sauvegarde de ses milliers de photos que l’on se décide - un jour - de ranger dans un dossier A_RANGER1 puis A_RANGER2 puis A_RANGER3, etc. puis on abandonne).

En ayant un espace de stockage limité, on doit apprendre à le gérer.

Les plus anciens se souviennent peut-être des magnétoscopes : on achète des cassettes, on enregistre des films en se disant « je le regarderai un jour » et on se retrouve avec des centaines de cassettes qui prennent la poussière. Ben c’est pareil avec les disques durs : on a des téraoctets en pagaille et on se dit : « je garde, on ne sait jamais. Et un jour (qui n’arrivera jamais), je ferai le tri ! »
J’en reviens donc à mon disque dur quasi plein. Je fais une recherche sur mes fichiers vidéos et regarde le débit binaire (bitrate par la suite) : 40 000 kb/s soit environ 5 Mo/s pour des vidéos FullHD et jusqu’à 100 Mb/s (12 Mo/s) pour des vidéos 4k (évidemment, cela dépend de l’appareil à l’origine de la vidéo). Voici les différents bitrate que j’ai pu rencontrer :
• fichier mp4 4K drone : 100 Mb/s ;
• fichier mp4 4K go pro : 60 Mb/s
• fichier mov FullHD : environ 16Mb/s
• ficher avi 640*480 : environ 15 MB/ (mjpeg et format son araw)
• fichier avi 320*240 : entre 1 et 2,5 Mb/s

Loin d’être un expert dans la compression vidéo, le poids des fichiers m’interpelle quand même. En effet, un site de téléchargement de films - que je n’ai jamais fréquenté car c’est illégal - a pour objectif d’optimiser le ratio qualité/poids et donc d’offrir une bonne qualité visuelle pour un poids réduit. Ainsi, un film en FullHD de 90 min a un poids de 1400 Mo soit un bitrate d’environ 2 Mb/s (250 ko/s avec le codec H264). Un film en 4K de 90 min a un poids de 4 Go soit un bitrate d’environ 4Mb (500 ko/s avec le codec H265). Et il paraît – je ne le sais pas directement car je n’ai jamais fréquenté ce site dont je ne connais même pas l’existence – que la qualité des films sur le site en question est bonne, visuellement parlant s’entend.

Il était donc temps de se mettre au travail et de réencoder mes vidéos personnelles.

L’objectif de ce document est donc triple (et permettra de répondre aux questions 1. et 3. que s’est posé le lecteur ou la lectrice dans le préambule :

ré encoder ses vidéos automatiquement via un script bash (en utilisant le logiciel libre ffmpeg ) sans perte de qualité visible ;
réduire le poids des fichiers de façon notable (par notable, j’entends ici une réduction d’au moins 20 %, ce qui est totalement subjectif, mais j’assume) ;
s’assurer de la pérennité de ses vidéos (i.e. être capable de les visionner dans 20 ans) ;

II Mon environnement

Le matériel : Lenovo V45 (payé 300 € environ avec un AMD A4-9125 radeon R3, 8Go de mémoire vive et un SSD Samsung de 1To, le tout sous kubuntu 22,04).
Les logiciels : ffmpeg version 4.4.2, vlc, krename (pour renommer ses fichiers par lot), kfind pour retrouver des fichiers avec des extensions précises (je ne maîtrise pas du tout l’outil en ligne de commande find), avidemux pour faire du montage vidéo basique (couper quelques minutes d’une vidéo par exemple), dolphin pour naviguer dans les fichiers et, surtout, indicator-cpufreq (qui permet de réduire la fréquence du processeur et éviter que le ventilateur ne tourne en permanence).

III Les choix techniques

Je ne devais utiliser que des logiciels libres et des formats ouverts. Pour les logiciels : mon choix s’est porté sur ffmpeg pour l’encodage car c’est LA référence pour la conversion de vidéos, même si l’usage de la ligne de commande peut rebuter cetains (mais vous verrez par la suite que les scripts simplifient grandement la vie). Pour les formats :

MP3 pour l’audio : il n’est plus protégé par un brevet depuis 2017 et me convenait parfaitement, en choisissant un débit de 250kb/s (ce qui est sûrement excessif mais la place occupée par le son dans une vidéo est faible par rapport à la vidéo). Je sais qu’il y a vorbis mais le mp3 me semble plus « universel », notamment si l’on regarde la vidéo sur un téléviseur
MKV pour le conteneur : c’est un format ouvert et qui est lu sur tous les téléviseurs sur lesquels j’ai pu le tester.
H265 pour le format vidéo : c’est un format sorti en 2013 soumis à brevet mais il est possible d’utiliser une bibliothèque libre (x265) pour effectuer l’encodage (c’est cette bibliothèque qu’utilise ffmpeg). Là encore, lorsque j’ai testé des vidéos encodées en h265 sur différents téléviseurs pas trop vieux, je n’ai jamais eu de problème. Sachez qu’il existe le format AV1, plus récent, plus efficace en termes de compression, libre et qui répond à mes besoins. Mais deux éléments m’ont fait renoncer à l’utiliser :
- l’encodage (avec ma machine) est extrêmement lent (j’ai abandonné l’encodage de 30 secondes de vidéo quand, après une heure, il en était toujours à la première seconde !) ;
- il n’est pas encore généralisé : peu de téléviseurs peuvent lire ce format (si vous en connaissez, je suis preneur). Il est fort probable que dans une dizaine d’années, je réencoderai mes vidéos en AV1, mais laissons cela pour plus tard.

J’ai également choisi d’encoder mes vidéos en deux passes car cela me permet de décider du débit binaire (et donc de la taille du fichier finale) tout en ayant une meilleure qualité qu’en une passe.
J’ai utilisé le programme indicator-cpufreq qui me permet de réduire au minimum la fréquence de mon processeur (ici 1,2 Gh) afin d’éviter que le ventilateur ne tourne sans arrêt (à noter qu’une mise en veille repasse la fréquence au maximum et il n’est plus possible de la réduire, sauf à redémarrer l’ordinateur). Avec une fréquence réduite au minimum, le ventilateur ne se déclenche que quelques secondes toutes les minutes et le processeur ne dépasse pas les 50°C (c’est hardinfo qui me le dit).

IV Les problèmes rencontrés et les contraintes (spoiler : il faut du temps !)

L’encodage en deux passes permet d’obtenir une meilleure qualité visuelle (de ce que j’ai compris) mais au prix d’un temps de calcul doublé. Ainsi, une vidéo d’une minute (en FullHD) a nécessité environ 100 minutes d’encodage pour obtenir le fichier final. Autant vous dire que mon ordinateur a tourné pendant environ 5 mois près de 20 heures par jour en moyenne. En revanche, j’ai découvert comment arrêter un processus (kill - STOP numero_pid_util) lorsque j’avais besoin de retrouver toute la puissance du processeur et comment le reprendre plus tard (kill - CONT numero_pid_util). Par ailleurs, je n’ai pas trouvé comment utiliser la carte graphique pour le réencodage, car il paraît que c’est plus rapide…
Je ne connais pas l’instruction ou l’option (si elle existe) de ffmpeg qui permet de conserver les métadonnées des vidéos. Ainsi, la conversion effectuée avec les scripts ci-dessous supprime toutes les métadonnées (pourtant, cela semble possible)
Je n’ai pas trouvé, malgré mes recherches, comment reprendre la première passe d’un encodage après une coupure ou un bug (ffmpeg génère un fichier log durant la première passe, fichier qu’il devrait être possible de réutiliser afin de reprendre là où il s’est arrêté). Il m’a donc fallu, parfois, reprendre l’encodage d’une vidéo à zéro.
La procédure avant encodage demande de l’organisation :
- Rechercher toutes ses vidéos est relativement aisé et rapide : kfind permet d’effectuer une recherche sur de multiples formats. Ensuite, un copier-coller sur un autre disque dur permet de les isoler.
- Il est nécessaire de connaître le bitrate de chacune d’elle. Une recherche Internet et hop, le script qui va bien (voir la partie sur les scripts) génère un fichier CSV pour nous faciliter le travail.
- Il faut ensuite regrouper les vidéos par débit et définition : ainsi, une vidéo 640*480 de 10 Mb/s ne pouvait pas être dans le même répertoire qu’une vidéo en 320*240 de 5 Mb/s également puisque le bitrate final n’était pas le même. Là, pas de secret, il faut le faire manuellement. Mais rassurez-vous, bien souvent, les vidéos d’une même période ont toute le même bitrate.
- L’étape suivante a consisté à choisir le débit final des vidéos suivant leur définition de façon à ce que la vidéo finale subisse une compression pas ou peu visible à l’œil par rapport à l’original (ce qui est très subjectif). J’ai donc choisi (en partant des débits de YiFY et un peu au doigt mouillé) :
  - 10 Mb/s pour de la 4K (porté très rarement à 12 Mb/s si la vidéo comportait beaucoup de mouvements) ;
  - 4 Mb/s pour de la FullHD ;
  - environ 2 Mb/s pour de la 640*480
  - 1 Mb/s pour de la 320*240
Un bug est apparu lors de la conversion des fichiers MJPEG directement en H265 : les couleurs finales étaient complètement différentes des originales. Je ne suis pas le seul à avoir subi ce qui semble être un bug. Au final, j’ai contourné ce désagrément en convertissant d’abord ces fichiers en xvid avec un gros bitrate pour limiter la perte de qualité (opération très rapide) puis les xvid en H265, ce qui a réglé le problème.
J’imagine que, comme beaucoup d’entre nous, je souhaite limiter mon impact environnemental. N’ayant pas de panneaux photovoltaïques, mon empreinte carbone est probablement élevée car j’ai été contraint de laisser tourner mon ordinateur jour et nuit en consommant de l’électricité pas toujours verte. En contrepartie, j’économise l’achat d’un nouveau disque dur. Cela me permet de me donner bonne conscience.

V Les scripts utilisés

Ces scripts (qui fonctionnent sous Linux. Pour Windows, il faudra adapter…) ont été écrits à partir de ce que j’ai trouvé sur Internet car ma maîtrise de ce genre d’outils est très fragile voire inexistante (j’ai donc pas mal bidouillé et ils peuvent sûrement être optimisés). Je vous dirais volontiers qu’ils sont sous licence libre ou dans le domaine public mais n’ayant pas noté mes sources, je les livre ci-dessous sans aucune garantie de quoi que ce soit (la seule chose que je peux garantir, c’est que j’ai fait pas mal de modifications par rapport aux scripts originaux).
Je vous rappelle que pour utiliser ces scripts, vous devez faire un copier-coller du script dans un fichier texte (en utilisant kate par exemple), l’enregistrer puis le rendre exécutable. Ensuite, vous placez ce script dans le répertoire de vos vidéos, et, dans une console, vous tapez ./nom_du_script
Je pense avoir mis suffisamment de commentaires pour comprendre ce que fait chaque script. Si cela n’était pas le cas, signalez les erreurs ou les suggestions dans les commentaires.
Voici un résumé pour chacun d’eux :

convertion_par_lot_videos_en_265 : c’est le script que j’ai le plus utilisé pour convertir des vidéos en H265 en choisissant une ou deux passes et le bitrate.
convertion_par_lot_videos_en_265_une_passe_crf : convertir en une seule passe en choisissant la qualité voulue
convertion_par_lot_videos_en_xvid : convertir des vidéos au format XVID, lorsque la conversion des MJPEG vers H265 pose problème
convertion_vers_mkv_par_lot : convertir tous les formats de conteneur en MKV (j’ai eu parfois des problèmes avec certaines extensions, le passage en MKV réglait le problème) ;
convertion_videos_en_son_par_lot : ne garder que le son (pour des vidéos youtube que l’on souhaite uniquement écouter par exemple) ;
convertir_son_en_mp3_garder_video : réeconde uniquement le son en MP3, ne touche pas la vidéo
extraire_image_precise_d_une_video : permet d’extraire une image précise (par exemple la 123) d’une ou plusieurs vidéos. Ce script m’a permis de comparer l’image d’origine et l’image réencodée. J’utilisais ensuite Gimp pour visualiser les différences entre les deux images.
recuperer_bitrate_video_par_lot : récupère tous les bitrates des vidéos d’un même répertoire et l’exporte dans un fichier CSV (données séparées par une espace) ;
recuperer_toutes_infos_video_par_lot : exporte dans un fichier csv les dimensions de l’image, le fps etc. mais pas le bitrate (je n’ai pas trouvé comment fusionner ce script avec le précédent)
stabiliser_video_par_lot_en_testant_les_10_qualites : script pour stabiliser une vidéo avec une image « secouée » en testant les 10 qualités possibles automatiquement. Vous pouvez faire des tests, chez moi, ce n’était pas probant. Le script est à revoir probablement.
stabiliser_video_par_lot_version : idem que ci-dessus mais vous choisissez le paramètre de la stabilisation.
creer_video_cote_a_cote_par_lot : pour comparer deux vidéos en en créant une nouvelle avec les deux côte à côte (je l’utilise pour comparer la vidéo d’origine et la vidéo stabilisée).
supprimer_bande_son_video : ne conserve que la vidéo, supprime le son (pour des vidéos où le son ne présente aucun intérêt). Et c’est parti !

convertion_par_lot_videos_en_265

#/bin/bash
# conversion par lot de fichier video au format H265 avec audio en mp3 qualité 256k
# nice -19 signifie que le programme aura la priorité la plus faible, ce qui ne devrait pas beaucoup ralentir l'exécution des autres programmes (en théorie tout au moins...)
# si vous souhaitez interrompre le programme pour avoir accès à tout le processeur, tapez l'instruction top puis identifiez le PID UTIL des processeurs ffmpeg concernés puis tapez kill - STOP numero_pid_util. Pour relancer le processus, tapez kill - CONT numero_pid_util
echo "Ce script va réencoder vos vidéos (MKV MP4 MTS AVI MOV WEBM FLV MPG MPEG WMV 3GP RM ASX VOB F4V MKS M4V OGV M2V MPV TS M2TS AVC HEVC M1V M2V MPV) en H265, le son en MP3 256k et au format de conteneur MKV en 1 ou 2 passes. Vous allez pouvoir choisir le bitrate d'encodage pour la vidéo, le codec et le nombre de passe. Les extensions des vidéos peuvent être en minuscules ou majuscules mais pas un mélange des deux. Les fichiers originaux seront déplacés dans le dossier originaux et les fichiers convertis dans le dossier convertis_x265"
echo -n "Entrez le bitrate -sans espace - que vous souhaitez utiliser : (4000 recommandé pour de la video FullHD, 10000 pour de la 4K) "
read bitrate
# les lignes (rm x265_2pass.log / rm x265_2pass.log.cutree / rm x265_2pass.log.cutree.temp / rm x265_2pass.log.temp) suppriment les fichiers générés lors des deux passes
# pour conserver l'audio, remplacer -c:a libmp3lame -b:a 256k par -c:a copy
# pour réduire la qualité audio, remplacer le 256k dans "-c:a libmp3lame -b:a 256k" par un nombre plus petit (par exemple 128k ou 92k)
echo -n "Souhaitez-vous une passe ou deux passes ? Taper 1 pour une passe (plus rapide mais de moins bonne qualité) ou 2 pour deux passes (plus lent mais la vidéo finale est de meilleure qualité) :  "
read passe
if [ "$passe" = "1" ] ; then
mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir convertis_x265
#crée un répertoire où seront déplacés les fichiers convertis
    for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do
    nice -19 ffmpeg -i "$i" -c:v "libx265" -b:v "${bitrate}k" -"x265"-params pass=1 -c:a libmp3lame -b:a 256k "$i.mkv"
    mv "$i.mkv" ./convertis_x265
    #déplace les fichiers convertis
    mv "$i" ./originaux
    #déplace les fichiers originaux
    done
elif [ "$passe" = "2" ]; then
mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir convertis_x265
#crée un répertoire où seront déplacés les fichiers convertis
    for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do
    nice -19 ffmpeg -y -i "$i" -c:v "libx265" -b:v "${bitrate}k" -"x265"-params pass=1 -an -f null /dev/null && \
    #première passe
    nice -19 ffmpeg -i "$i" -c:v "libx265" -b:v "${bitrate}k" -"x265"-params pass=2 -c:a libmp3lame -b:a 256k "$i.mkv"
    mv "$i.mkv" ./convertis_x265
    #déplace les fichiers convertis
    mv "$i" ./originaux
    #déplace les fichiers originaux
#les lignes suivantes suivantes suppriment les fichiers temporaires de la première passe en cas d'interruption.
    rm x265_2pass.log
    rm x265_2pass.log.cutree
    rm x265_2pass.log.cutree.temp
    rm x265_2pass.log.temp
    rm x264_2pass.log
    rm x264_2pass.log.cutree
    rm x264_2pass.log.cutree.temp
    rm x264_2pass.log.temp
    done
else
    echo "Il faut taper 1 ou 2, rien d'autre. Relancez le script !"
fi
    rm x265_2pass.log
    rm x265_2pass.log.cutree
    rm x265_2pass.log.cutree.temp
    rm x265_2pass.log.temp
    rm x264_2pass.log
    rm x264_2pass.log.cutree
    rm x264_2pass.log.cutree.temp
    rm x264_2pass.log.temp

convertion_par_lot_videos_en_265_une_passe_crf

#!/bin/bash
# conversion par lot de fichier video au format H265 avec audio en mp3 qualité 320k
# nice -19 signifie que le programme aura la priorité la plus faible, ce qui ne devrait pas beaucoup ralentir l'exécution des autres programmes.
# si vous souhaitez interrompre le programme pour avoir accès à tout le processeur, tapez l'instruction top puis identifiez le PID UTIL des processeurs ffmpeg concernés puis tapez kill - STOP numero_pid_util. Pour relancer le processus, tapez kill - CONT numero_pid_util

echo "Ce script va réencoder vos vidéos (MKV, MP4, MTS, AVI, MOV, WEBM FLV) en H265, le son en MP3 256k et au format de conteneur MKV en 1 passe. Vous allez pouvoir choisir CRF (constant rate factor) pour la vidéo. Les extensions des vidéos peuvent être en minuscules ou majuscules mais pas un mélange des deux."
echo -n "Entrez le CRF que vous souhaitez utiliser : (entre 1 et 51 - 1 pour la meilleure qualité, 51 pour la plus mauvaise) - 28 est recommandé : "
read crf

echo -n "Entrez la vitesse que vous souhaitez utiliser : (ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow) - votre choix joue sur la vitesse de traitement et la qualité. Superfast sera très rapide mais de moins bonne qualité. medium est le choix recommandé. Votre choix : "
read speed

# on peut modifier le fichier de sortie en ajoutant un répertoire : "$i.mkv" devient "/home/perso/mon_repertoire/$i.mkv"
# les lignes (rm x265_2pass.log / rm x265_2pass.log.cutree / rm x265_2pass.log.cutree.temp / rm x265_2pass.log.temp) suppriment les fichiers générés lors des deux passes
# pour conserver l'audio, remplacer -c:a libmp3lame -b:a 256k par -c:a copy
# pour réduire la qualité audio, remplacer le 256k dans "-c:a libmp3lame -b:a 256k" par un nombre plus petit (par exemple 128k ou 92k)
mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir convertis_x265
#crée un répertoire où seront déplacés les fichiers convertis

    for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ;
    do
    nice -19 ffmpeg -i "$i" -c:v libx265 -crf "$crf" -preset "$speed" -c:a libmp3lame -b:a 256k "$i.mkv"

    mv "$i.mkv" ./convertis_x265
    #déplace les fichiers convertis

    mv "$i" ./originaux
    #déplace les fichiers originaux
    done

#les lignes suivantes suivantes suppriment les fichiers temporaires de la première passe en cas d'interruption.
    rm x265_2pass.log
    rm x265_2pass.log.cutree
    rm x265_2pass.log.cutree.temp
    rm x265_2pass.log.temp
    rm x264_2pass.log
    rm x264_2pass.log.cutree
    rm x264_2pass.log.cutree.temp
    rm x264_2pass.log.temp

convertion_par_lot_videos_en_xvid

#!/bin/bash
# ce script balaie tous les fichiers d'un même répertoire et va convertir les AVI en XVID et conserver le son d'origine
# nice -19 signifie que le programme aura la priorité la plus faible, ce qui ne devrait pas beaucoup ralentir l'exécution des autres programmes.
# si vous souhaitez interrompre le programme pour avoir accès à tout le processeur, tapez l'instruction top puis identifiez le PID UTIL des processeurs ffmpeg concernés puis tapez kill - STOP numero_pid_util. Pour relancer le processus, tapez kill - CONT numero_pid_util

echo "Ce script va réencoder vos vidéos AVI en XVID, conserver le son d'origine et au format de conteneur MKV en 2 passes. Les extensions des vidéos (AVI ou avi) peuvent être en minuscules ou majuscules mais pas un mélange des deux. La convertion directe de MJPEG vers 265 pose des problèmes de couleurs. Il faut donc passer par XVID d'abord (voir https://stackoverflow.com/questions/71397605/ffmpeg-mjpeg-h-265-smeared-color-on-output-video-file )"
# on peut modifier le fichier de sortie en ajoutant un répertoire : "$i.mkv" devient "/home/perso/mon_repertoire/$i.mkv"
# pour conserver l'audio, remplacer -c:a libmp3lame -b:a 256k par -c:a copy
# pour réduire la qualité audio, remplacer le 256k dans "-c:a libmp3lame -b:a 256k" par un nombre plus petit (par exemple 128k ou 92k)

mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion

mkdir convertis_xvid
#crée un répertoire où seront déplacés les fichiers convertis

    for i in *.avi *.AVI ; do
    nice -19 ffmpeg -y -i "$i" -c:v mpeg4 -vtag xvid -b:v 16000k -pass 1 -an -f avi /dev/null
    ffmpeg -i "$i" -c:v mpeg4 -vtag xvid -b:v 16000k -pass 2 -c:a copy "$i.mkv"

    mv "$i.mkv" ./convertis_xvid
    #déplace les fichiers convertis

    mv "$i" ./originaux
    #déplace les fichiers originaux

    done

convertion_vers_mkv_par_lot

#!/bin/bash
# conversion par lot de fichiers vers mkv - mofifier l'extension si nécessaire - supprimer les extensions d'origine avec krename ensuite. Attention, s'il y a déjà des fichiers MKV, ils seront reconvertis en MKV

mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir convertis_mkv
#crée un répertoire où seront déplacés les fichiers convertis

    for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do


#    autre chose trouvé sur internet avec bug : ffmpeg -flags +genpts -i "$i" -c copy -sn "$i.mkv"

nice -19 ffmpeg -y -i "$i" -c:v copy -c:a copy "$i.mkv"
  mv "$i.mkv" ./convertis_mkv
    #déplace les fichiers convertis
    mv "$i" ./originaux
    #déplace les fichiers originaux

done

convertion_videos_en_son_par_lot

#!/bin/bash
# conversion par lot de fichiers vers mkv - mofifier l'extension si nécessaire - supprimer les extensions d'origine avec krename ensuite. Attention, s'il y a déjà des fichiers MKV, ils seront reconvertis en MKV

mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir convertis_mkv
#crée un répertoire où seront déplacés les fichiers convertis

    for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do


#    autre chose trouvé sur internet avec bug : ffmpeg -flags +genpts -i "$i" -c copy -sn "$i.mkv"

nice -19 ffmpeg -y -i "$i" -c:v copy -c:a copy "$i.mkv"
  mv "$i.mkv" ./convertis_mkv
    #déplace les fichiers convertis
    mv "$i" ./originaux
    #déplace les fichiers originaux

done

convertir_son_en_mp3_garder_video

#!/bin/bash
echo -n "Ce script va convertir le son des videos en mp3 sans toucher la video et ajouter l'extension .MKV à la fin du fichier. Choisissez la qualité mp3 (256 recommandé) : "
read bitratemp3

mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir convertis_mp3
#crée un répertoire où seront déplacés les fichiers convertis


for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do

    nice -19 ffmpeg -i "$i" -c:v copy -c:a libmp3lame -b:a "${bitratemp3}k" "$i.mkv"

    mv "$i.mkv" ./convertis_mp3
    #déplace les fichiers convertis
    mv "$i" ./originaux
    #déplace les fichiers originaux
done

extraire_image_precise_d_une_video

#!/bin/bash


echo -n "Entrez le numéro de l'image que vous souhaitez extraire (attention, la numérotation commence à 0 donc si vous souhaitez la frame 536, il faut saisir 535) "
read num_frame


for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do



nice -19 ffmpeg -i "$i" -vf "select=eq(n\,$num_frame)" -vframes 1 screenshot_frame_"$num_frame"_"$i".png

done

recuperer_bitrate_video_par_lot

#!/bin/bash

#recherche le bitrate des videos de façon récursive
find . \( -iname "*.mkv" -or -iname "*.mov" -or -iname "*.mts" -or -iname "*.mp4" -or -iname "*.mpg" -or -iname "*.mpeg" -or -iname "*.flv" -or -iname "*.avi" -or -iname "*.webm" -or -iname "*.wmv" -or -iname "*.3gp" -or -iname "*.rm" -or -iname "*.asx" -or -iname "*.vob" -or -iname "*.f4v" -or -iname "*.mks" -or -iname "*.m4v" -or -iname "*.ogv" -or -iname "*.m2v"  -or -iname "*.mpv" -or -iname "*.ts" -or -iname "*.m2ts" -or -iname "*.avc" -or -iname "*.hevc" -or -iname "*.m1v" -or -iname "*.m2v" -or -iname "*.mpv" \) -print0 | xargs -0 -i{} sh -c " echo -n '{} ' && ffmpeg -i '{}' 2>&1 | sed -n -e 's/^.*bitrate: //p' " > result_bitrate.csv
#ecrit le bitrate de toutes les videos d'un dossier dans le fichier result_mts.csv.
# Ouvrir avec tableur et choisir séparateur ESPACE pour mieux visualiser les bitrate

recuperer_toutes_infos_video_par_lot

#!/bin/bash

#recherche les informations des videos
find . \( -iname "*.mkv" -or -iname "*.mov" -or -iname "*.mts" -or -iname "*.mp4" -or -iname "*.mpg" -or -iname "*.mpeg" -or -iname "*.flv" -or -iname "*.avi" -or -iname "*.webm" -or -iname "*.wmv" -or -iname "*.3gp" -or -iname "*.rm" -or -iname "*.asx" -or -iname "*.vob" -or -iname "*.f4v" -or -iname "*.mks" -or -iname "*.m4v" -or -iname "*.ogv" -or -iname "*.m2v"  -or -iname "*.mpv" -or -iname "*.ts" -or -iname "*.m2ts" -or -iname "*.avc" -or -iname "*.hevc" -or -iname "*.m1v" -or -iname "*.m2v" -or -iname "*.mpv" \) -print0 | xargs -0 -i{} sh -c " echo -n '{} ' && ffmpeg -i '{}' 2>&1 | sed -n -e 's/^.*Video: //p' " > result_toutes_les_infos.csv


#ecrit les informations toutes les videos d'un dossier dans le fichier result_toutes_les_infos.csv.
#Ouvrir avec tableur et choisir séparateur ESPACE pour mieux visualiser les bitrate

stabiliser_video_par_lot_version

#!/bin/bash
# stabiliser des videos par lot

echo -n "Sélectionnez la stabilité de la vidéo que vous souhaitez : 1 (très stable) jusqu'à 10 (très instable)  "
read stabilite

mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir stabilisee
#crée un répertoire où seront déplacés les fichiers convertis

for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do

    nice -19 ffmpeg -i "$i" -vf vidstabdetect=shakiness=$stabilite:accuracy=15 -f null - && \

#shakiness=10 peut etre modifié en mettant shakiness = nombre_entre_1_et_10 : 1 video stable, 10 video très instable

    nice -19 ffmpeg -i "$i" -vf vidstabdetect=shakiness=$stabilite:accuracy=15 -f null -&& nice -19 ffmpeg -i "$i" -vf vidstabtransform=smoothing=30:input="transforms.trf" "stabilisee_$i"

rm transforms.trf

mv "stabilisee_$i" ./stabilisee
    #déplace les fichiers convertis
    mv "$i" ./originaux
    #déplace les fichiers originaux
done

creer_video_cote_a_cote_par_lot

#!/bin/bash
#ce script va créer une vidéo à partir de deux vidéos, l'une que l'on peut nommer ma_video.mkv et l'autre qui doit alors se nommer stabilisee_ma_video.mkv
#les deux vidéos seront côte à côte, ce qui permet de les comparer
for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB ; do


# la video d'origine correspond à $i et l'autre video doit commencer par "stabilisee" mais il suffit de changer le prefixe si necessaire

    ffmpeg -i "$i" -i "stabilisee_$i" -filter_complex "[0:v]setpts=PTS-STARTPTS, pad=iw*2:ih[bg]; [1:v]setpts=PTS-STARTPTS[fg]; [bg][fg]overlay=w" "cote_a_cote_$i"


done

supprimer_bande_son_video

#!/bin/bash
#supprimer la bande son de toutes les videos (au format voir ci-dessous) d'un même répertoire et crée un fichier MKV sans bande son. Ne réencode pas la vidéo.

mkdir originaux
# crée un répertoire où seront déplacés les fichiers originaux après conversion
mkdir sans_son
#crée un répertoire où seront déplacés les fichiers convertis


    for i in *.mkv *.MKV *.mp4 *.MP4 *.mts *.MTS *.avi *.AVI *.mov *.MOV *.webm *.WEBM *.flv *.FLV *.mpg *.MPG *.mpeg *.MPEG *.wmv *.WMV *.3gp *.3GP *.rm *.RM *.asx *.ASX *.vob *.VOB *.f4v *.F4V *.mks *.MKS *.m4v *.M4V *.ogv *.OGV *.m2v *.M2V *.mpv *.MPV *.ts *.TS *.m2ts *.M2TS *.avc *.AVC *.hevc *.HEVC *.m1v *.M1V *.m2v *.M2V *.mpv *.MPV ; do
    nice -19 ffmpeg -i "$i" -c copy -an "$i.mkv"

    mv "$i.mkv" ./sans_son
    #déplace les fichiers convertis
    mv "$i" ./originaux
    #déplace les fichiers originaux


    done

stabiliser_video_par_lot_en_testant_les_10_qualites

#!/bin/bash
# test toutes les qualités de stabilisation pour un même fichier

# test les 10 qualités de stabilité

        for qualite in 1 2 3 4 5 6 7 8 9 10 ; do
            for i in *.mkv ; do

            # nice -19 ffmpeg -i "$i" -vf vidstabdetect=shakiness=$qualite:accuracy=15 -f null - && \

            #shakiness=10 peut etre modifié en mettant shakiness = nombre_entre_1_et_10 : 1 video stable, 10 video très instable

            nice -19 ffmpeg -i "$i" -vf vidstabdetect=shakiness=$qualite:accuracy=15 -f null -&& nice -19 ffmpeg -i "$i" -vf vidstabtransform=smoothing=30:input="transforms.trf" "stabilisee_$i_$qualite.mp4"

            rm transforms.trf

            done


        done

En conclusion

Il faut du temps et de l’envie pour se lancer dans cette aventure, même si le CPU fait 80 % du travail. Mais les 20 % restant ne sont pas à négliger. Entre les copier-coller qu’il ne faut pas rater, le classement des vidéos par bitrate ou dimension, les vidéos réencondées qu’il faut visionner (en accéléré) pour s’assurer qu’elles sont correctes, etc. il faut vraiment rester concentré pour éviter d’oublier une vidéo ou, pire, de l’effacer alors qu’elle n’a pas été réencondée.

Les avantages

Mais je ne regrette pas tout ce temps, surtout pour avoir revisionné quasiment toutes mes vidéos, celle de mes enfants bébé (le coup de vieux en pleine figure), les moments en famille, les grands-parents disparus… Cela a été des moments vraiment agréables.

Cela m’a également permis de ranger des vidéos qui n’étaient pas dans le bon répertoire ou de renommer celles qui comportaient une erreur dans leur nom.

J’ai maintenant toutes mes vidéos avec le même format de conteneur (MKV), et les mêmes codec vidéo et audio, ce qui facilitera grandement un réencodage ultérieur.

Et puis – c’était l’un des objectifs – le gain de place est très important puisque mon disque dur est passé de 90 % à 48 % d’occupation (j’ai fait aussi un peu de ménage donc ce gain ne provient pas que du réencodage des vidéos).

Les inconvénients

Est-ce une bonne idée de mettre tous ses œufs dans le même panier (un seul format de conteneur, un seul codec video, un seul codec audio) , même si ces formats sont libres et, pour H265, lisible avec des logiciels libres, ce qui est tout de même une bonne assurance pour l’avenir ?

Du temps, du temps, et encore du temps : il faut en avoir pour ce projet (mais j’espère que les scripts vous permettront d’en gagner)

Cela consomme de l’énergie et, si beaucoup de gens veulent réencoder leurs vidéos, l’impact environnemental ne sera pas négligeable.

L’opération monopolise un ordinateur (nice -19 ne m’a pas paru très efficace quand je lançais trois encodages simultanément!). Mais cela peut être l’occasion d’en utiliser un qui dort dans un placard et qui pourrait ainsi resservir.

Si c’était à refaire…

Je le referai, sans aucun doute !
J’essaierai de conserver les métadonnées (date, heure, coordonnées GPS) de mes vidéos (même si les informations les plus importantes sont dans leur nom) ;
Je tenterai d’utiliser le GPU pour le réencodage, ce qui réduirait le temps de calcul.

Note pour le prochain confinement :

convertir les vidéos en AV1 ;
convertir les photos en AVIF ;
créer des fichiers PAR2 pour sécuriser mes sauvegardes

[1] : je n'ai pas réussi à trouver l'équivalent de la commande jhead -autorot -nf%Y_%m_%d_%H%M_%S_ *.jpg pour les videos

Télécharger ce contenu au format EPUB

Commentaires : voir le flux Atom ouvrir dans le navigateur

Vue normale