FFMPEG - Incruster des sous-titres dans un vidéo

• Que la vidéo possède du flux vidéo (votre essai sans son est correct, mais la piste vidéo doit être active).
• D'un fichier de sous-titres externe (au format .srt ou .ass). Si le fichier .srt configuré dans le script n'existe pas sur votre ordinateur, Avidemux annule silencieusement l'application des filtres et du codec vidéo.

ffmpeg -i Exemple.mts -map 0:s:0 sous_titres.srt

#PY  <- Obligatoire
adm = Avidemux()
gui = Gui()

# 1. Vérification qu'une vidéo est bien ouverte
if adm.getMarkers() is None:
    gui.displayError("Erreur", "Veuillez d'abord ouvrir votre fichier .mts dans Avidemux avant de lancer le script.")
else:
    # 2. Demander à l'utilisateur de sélectionner le fichier SRT extrait à l'étape 1
    file_srt = gui.fileSelectSelectIn("Sélectionnez le fichier sous_titres.srt")
    
    if not file_srt:
        gui.displayInfo("Annulation", "Aucun fichier de sous-titres sélectionné. Traitement annulé.")
    else:
        # 3. Configuration des Codecs (Identique à votre FFmpeg)
        adm.videoCodec("libx264", "usePreset=True", "preset=medium", "profile=main", "tune=none", "crf=26")
        
        adm.audioClearTracks()
        adm.audioAddTrack(0)
        adm.audioCodec(0, "LavAAC", "bitrate=128")
        
        adm.setContainer("MP4V2", "optimize=1", "add_itunes_metadata=0")

        # 4. Application du filtre avec le bon chemin de fichier
        # Remplacement des antislashs pour éviter les erreurs de lecture de chemin sous Windows
        file_srt_clean = file_srt.replace("\\", "/")
        adm.addVideoFilter("subtitles", "fontname=Arial", "fontsize=24", "filename=" + file_srt_clean, "color=FFFFFF", "charset=UTF-8")

        # 5. Message de confirmation visuel
        gui.displayInfo("Succès", "Configuration FFmpeg appliquée !\n\n1. Coupez vos pubs avec [ et ]\n2. Enregistrez (Ctrl+S) pour exporter en MP4 avec sous-titres.")

1. Extrayez le .srt avec la commande rapide FFmpeg.
2. Ouvrez votre vidéo dans Avidemux.
3. Lancez le script .py.
4. Une fenêtre s'ouvre : sélectionnez le fichier .srt.
5. Une boîte de dialogue s'affiche pour vous confirmer le succès. Vous verrez alors les menus de gauche basculer sur X264 et AAC. Vous pouvez couper vos pubs et enregistrer !

Solution 1 : La méthode 100% FFmpeg (La plus simple)

@echo off
echo =======================================================
echo          COUPE PRECISE ET INCRUSTATION MTS             
echo =======================================================
echo.

:: 1. Entrée des horaires par l'utilisateur
set /p start_time="Entrez le debut de la video utile (ex: 01:53:31.040) : "
set /p duration="Entrez la duree a conserver (ex: 00:01:51.440) : "

:: 2. Commande FFmpeg avec traitement direct des sous-titres images
ffmpeg -fflags +genpts -ss %start_time% -t %duration% -canvas_size 1920x1080 -i "Exemple.mts" -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"

echo.
echo Traitement termine avec succes ! Fichier disponible : output.mp4
pause

Solution 2 : Si vous tenez absolument à utiliser l'interface d'Avidemux

ffmpeg -i Exemple.mts -map 0:s:0 -c:s copy sous_titres.sup

ffmpeg -i TF1-09042026-1349.mts -map 0:s:0 -c:s dvdsub sous_titres.sub

#PY  <- Obligatoire
adm = Avidemux()
gui = Gui()

# 1. Vérification qu'une vidéo est ouverte
if adm.getMarkers() is None:
    gui.displayError("Erreur", "Veuillez d'abord ouvrir votre fichier .mts dans Avidemux.")
else:
    # 2. Demander à l'utilisateur de sélectionner le fichier .idx créé par FFmpeg
    file_idx = gui.fileSelectSelectIn("Sélectionnez le fichier sous_titres.idx")
    
    if not file_idx:
        gui.displayInfo("Annulation", "Aucun index de sous-titres sélectionné.")
    else:
        # 3. Configuration des Codecs (Identique à votre souhait)
        adm.videoCodec("libx264", "usePreset=True", "preset=medium", "profile=main", "tune=none", "crf=26")
        
        adm.audioClearTracks()
        adm.audioAddTrack(0)
        adm.audioCodec(0, "LavAAC", "bitrate=128")
        
        adm.setContainer("MP4V2", "optimize=1", "add_itunes_metadata=0")

        # 4. Application du filtre VobSub (Incrustation des images de sous-titres)
        file_idx_clean = file_idx.replace("\\", "/")
        adm.addVideoFilter("vobsub", "filename=" + file_idx_clean, "is_idx=1", "vobsub_id=0", "align=0", "custom_color=0", "color=0", "scale=100")

        # 5. Message de confirmation
        gui.displayInfo("Succès", "Configuration appliquée avec succès !\n\n1. Coupez vos pubs avec [ et ]\n2. Enregistrez (Ctrl+S) pour exporter en MP4.")

1. Lancez la nouvelle commande FFmpeg pour créer sous_titres.sub et sous_titres.idx.
2. Ouvrez votre vidéo TF1-09042026-1349.mts dans Avidemux.
3. Lancez ce nouveau script .py et sélectionnez le fichier sous_titres.idx.
4. Les codecs s'activeront, le filtre s'appliquera, et vous pourrez couper toutes vos pubs à la main de manière très précise avant de sauvegarder.

ffmpeg -i TF1-09042026-1349.mts -map 0:s:0 -c:s copy sous_titres.mkv

#PY  <- Obligatoire
adm = Avidemux()
gui = Gui()

# 1. Vérification qu'une vidéo est ouverte
if adm.getMarkers() is None:
    gui.displayError("Erreur", "Veuillez d'abord ouvrir votre fichier .mts dans Avidemux.")
else:
    # 2. Demander de sélectionner le fichier .mkv créé à l'étape 1
    file_mkv = gui.fileSelectSelectIn("Sélectionnez le fichier sous_titres.mkv")
    
    if not file_mkv:
        gui.displayInfo("Annulation", "Aucun fichier sélectionné.")
    else:
        # 3. Configuration des Codecs (Votre demande FFmpeg)
        adm.videoCodec("libx264", "usePreset=True", "preset=medium", "profile=main", "tune=none", "crf=26")
        
        adm.audioClearTracks()
        adm.audioAddTrack(0)
        adm.audioCodec(0, "LavAAC", "bitrate=128")
        
        adm.setContainer("MP4V2", "optimize=1", "add_itunes_metadata=0")

        # 4. Application du filtre DVB (pour lire les sous-titres depuis le MKV)
        file_mkv_clean = file_mkv.replace("\\", "/")
        adm.addVideoFilter("dvbsub", "filename=" + file_mkv_clean, "track_index=0")

        # 5. Message de confirmation
        gui.displayInfo("Succès", "Configuration appliquée !\n\n1. Coupez vos pubs avec [ et ]\n2. Enregistrez (Ctrl+S) pour exporter en MP4.")

1. Générez le fichier sous_titres.mkv avec la commande FFmpeg ci-dessus.
2. Ouvrez votre vidéo principale TF1-09042026-1349.mts dans Avidemux.
3. Lancez votre script .py et sélectionnez le fichier sous_titres.mkv.
4. Les menus à gauche s'activent (x264, AAC, MP4v2). Vous pouvez nettoyer vos pubs précisément à l'image près à l'aide des touches [ et ], puis sauvegarder ! [1, 3]

1. Créez un fichier texte nommé Nettoyeur_TF1.bat dans le même dossier que votre vidéo.
2. Collez le code suivant à l'intérieur :

@echo off
setlocal enabledelayedexpansion
echo =======================================================
echo      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE
echo =======================================================
echo.

:: Nom de votre fichier source
set "video_source=TF1-09042026-1349.mts"

echo Video detectee : %video_source%
echo.
echo Veuillez saisir les parties UTILES a conserver (hors pub).
echo Format requis : HH:MM:SS.mmm (Exemple : 01:53:31.040)
echo.

:: Saisie de la séquence 1
set /p start1="[Morceau 1] Heure de DEBUT : "
set /p dur1="[Morceau 1] DUREE exacte : "
echo.

:: Saisie de la séquence 2
set /p start2="[Morceau 2] Heure de DEBUT (Laissez vide si inutile) : "
if "%start2%"=="" goto execution_1_bloc
set /p dur2="[Morceau 2] DUREE exacte : "
echo.

:: Saisie de la séquence 3
set /p start3="[Morceau 3] Heure de DEBUT (Laissez vide si inutile) : "
if "%start3%"=="" goto execution_2_bloc
set /p dur3="[Morceau 3] DUREE exacte : "
echo.


:execution_3_blocs
echo Traitement en cours (3 morceaux à fusionner)...
ffmpeg -fflags +genpts -i "%video_source%" -filter_complex ^
"[0:v][0:s:0]overlay=canvas_size=1920x1080,split=3[v1][v2][v3]; ^
 [v1]trim=start=%start1%:duration=%dur1%,setpts=PTS-STARTPTS[outv1]; ^
 [0:a]atrim=start=%start1%:duration=%dur1%,asetpts=PTS-STARTPTS[outa1]; ^
 [v2]trim=start=%start2%:duration=%dur2%,setpts=PTS-STARTPTS[outv2]; ^
 [0:a]atrim=start=%start2%:duration=%dur2%,asetpts=PTS-STARTPTS[outa2]; ^
 [v3]trim=start=%start3%:duration=%dur3%,setpts=PTS-STARTPTS[outv3]; ^
 [0:a]atrim=start=%start3%:duration=%dur3%,asetpts=PTS-STARTPTS[outa3]; ^
 [outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]" ^
 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
goto fin

:execution_2_blocs
echo Traitement en cours (2 morceaux à fusionner)...
ffmpeg -fflags +genpts -i "%video_source%" -filter_complex ^
"[0:v][0:s:0]overlay=canvas_size=1920x1080,split=2[v1][v2]; ^
 [v1]trim=start=%start1%:duration=%dur1%,setpts=PTS-STARTPTS[outv1]; ^
 [0:a]atrim=start=%start1%:duration=%dur1%,asetpts=PTS-STARTPTS[outa1]; ^
 [v2]trim=start=%start2%:duration=%dur2%,setpts=PTS-STARTPTS[outv2]; ^
 [0:a]atrim=start=%start2%:duration=%dur2%,asetpts=PTS-STARTPTS[outa2]; ^
 [outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]" ^
 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
goto fin

:execution_1_bloc
echo Traitement en cours (1 seul morceau)...
ffmpeg -fflags +genpts -ss %start1% -t %dur1% -canvas_size 1920x1080 -i "%video_source%" -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
goto fin

:fin
echo.
echo Operation terminee avec succes. Le fichier output.mp4 est pret.
pause

1. Ouvrez votre vidéo TF1-*.mts dans n'importe quel lecteur (comme VLC) juste pour repérer visuellement les heures des pubs. Notez sur un papier les heures des séquences de film que vous voulez garder.
2. Lancez le script Nettoyeur_TF1.bat.
3. Rentrez l'heure du début de votre film, et la durée de la première partie.
4. Si le film reprend après la pub, le script vous propose d'entrer le début et la durée du morceau 2, et ainsi de suite (jusqu'à 3 morceaux ici). Si vous n'avez plus de morceaux, appuyez simplement sur Entrée (laissez vide).
5. FFmpeg s'occupe du reste en arrière-plan sans aucune erreur de codec.

@echo off
echo =======================================================
echo      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE
echo =======================================================
echo.

set "video_source=TF1-09042026-1349.mts"

echo Saisie des plages utiles au format HH:MM:SS.mmm
echo.

set /p start1="[Morceau 1] Heure de DEBUT : "
set /p dur1="[Morceau 1] DUREE exacte : "
echo.

set /p start2="[Morceau 2] Heure de DEBUT (Laissez vide si pas de morceau 2) : "
if "%start2%"=="" goto execution_1_bloc
set /p dur2="[Morceau 2] DUREE exacte : "
echo.

set /p start3="[Morceau 3] Heure de DEBUT (Laissez vide si pas de morceau 3) : "
if "%start3%"=="" goto execution_2_bloc
set /p dur3="[Morceau 3] DUREE exacte : "
echo.


:execution_3_blocs
echo Execution avec 3 morceaux...
ffmpeg -fflags +genpts -i "%video_source%" -filter_complex "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=3[v1][v2][v3];[v1]trim=start=%start1%:duration=%dur1%,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=%start1%:duration=%dur1%,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=%start2%:duration=%dur2%,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=%start2%:duration=%dur2%,asetpts=PTS-STARTPTS[outa2];[v3]trim=start=%start3%:duration=%dur3%,setpts=PTS-STARTPTS[outv3];[0:a]atrim=start=%start3%:duration=%dur3%,asetpts=PTS-STARTPTS[outa3];[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]" -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
goto fin

:execution_2_blocs
echo Execution avec 2 morceaux...
ffmpeg -fflags +genpts -i "%video_source%" -filter_complex "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=2[v1][v2];[v1]trim=start=%start1%:duration=%dur1%,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=%start1%:duration=%dur1%,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=%start2%:duration=%dur2%,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=%start2%:duration=%dur2%,asetpts=PTS-STARTPTS[outa2];[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]" -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
goto fin

:execution_1_bloc
echo Execution avec 1 seul morceau...
ffmpeg -fflags +genpts -ss %start1% -t %dur1% -canvas_size 1920x1080 -i "%video_source%" -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
goto fin

:fin
echo.
echo Operation terminee.
pause

1. Remplacez bien le contenu de votre fichier .bat par celui-ci.
2. Au moment de taper vos horaires, n'utilisez pas d'espaces de chaque côté (tapez directement 00:13:56.840 et validez).
3. Laissez la demande pour le Morceau 3 complètement vide et appuyez simplement sur Entrée. Le script basculera sur l'option à 2 morceaux.

1. Créez un nouveau fichier texte nommé Nettoyeur_TF1.ps1 (attention à bien mettre l'extension .ps1 et pas .txt ou .bat).
2. Ouvrez-le avec le Bloc-notes, collez le code ci-dessous et enregistrez :

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1 = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1   = Read-Host "[Morceau 1] DUREE exacte"
Write-Host ""

$start2 = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    ffmpeg -fflags +genpts -ss $start1 -t $dur1 -canvas_size 1920x1080 -i $video_source -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
} else {
    $dur2 = Read-Host "[Morceau 2] DUREE exacte"
    Write-Host ""
    
    $start3 = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3) {
        Write-Host "Execution avec 2 morceaux..." -ForegroundColor Yellow
        $filter = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=2[v1][v2];[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
        ffmpeg -fflags +genpts -i $video_source -filter_complex $filter -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    } else {
        $dur3 = Read-Host "[Morceau 3] DUREE exacte"
        Write-Host ""
        Write-Host "Execution avec 3 morceaux..." -ForegroundColor Yellow
        $filter = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=3[v1][v2][v3];[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
        ffmpeg -fflags +genpts -i $video_source -filter_complex $filter -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    }
}

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

1. Faites un clic droit sur votre fichier Nettoyeur_TF1.ps1.
2. Choisissez "Exécuter avec PowerShell".
3. Saisissez vos horaires (lorsque l'écran vous demande le morceau 3, appuyez juste sur Entrée).

1. Créez un nouveau fichier texte nommé LANCER_APPLICATION.bat dans le même dossier.
2. Ouvrez-le avec le bloc-notes, collez cette unique ligne à l'intérieur et enregistrez :

powershell -NoExit -ExecutionPolicy Bypass -File "%~dp0Nettoyeur_TF1.ps1"

• Le paramètre -ExecutionPolicy Bypass va temporairement lever la sécurité Windows uniquement pour ce script.
• Le paramètre -NoExit va interdire formellement à la fenêtre de se fermer, quoi qu'il arrive (même s'il y a un plantage informatique ou une erreur dans votre fichier vidéo).

Le Script PowerShell Corrigé

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"

# Définition du chemin de FFmpeg (cherche dans le dossier actuel)
$ffmpeg = ".\ffmpeg.exe"

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1 = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1   = Read-Host "[Morceau 1] DUREE exacte"
Write-Host ""

$start2 = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    & $ffmpeg -fflags +genpts -ss $start1 -t $dur1 -canvas_size 1920x1080 -i $video_source -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
} else {
    $dur2 = Read-Host "[Morceau 2] DUREE exacte"
    Write-Host ""
    
    $start3 = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3) {
        Write-Host "Execution avec 2 morceaux..." -ForegroundColor Yellow
        $filter = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=2[v1][v2];[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
        & $ffmpeg -fflags +genpts -i $video_source -filter_complex $filter -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    } else {
        $dur3 = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
        Write-Host ""
        Write-Host "Execution avec 3 morceaux..." -ForegroundColor Yellow
        $filter = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=3[v1][v2][v3];[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
        & $ffmpeg -fflags +genpts -i $video_source -filter_complex $filter -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    }
}

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

⚠️ Une seule condition pour que cela marche :

Le Script PowerShell Corrigé

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1 = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1   = Read-Host "[Morceau 1] DUREE exacte"
Write-Host ""

$start2 = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $filter_1 = "[0:v][0:s:0]overlay"
    & $ffmpeg -fflags +genpts -ss $start1 -t $dur1 -canvas_size 1920x1080 -i $video_source -filter_complex $filter_1 -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
} else {
    $dur2 = Read-Host "[Morceau 2] DUREE exacte"
    Write-Host ""
    
    $start3 = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3) {
        Write-Host "Execution avec 2 morceaux..." -ForegroundColor Yellow
        
        # Construction propre du filtre sans confusion pour PowerShell
        $filter_2 = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=2[v1][v2];" +
                    "[v1]trim=start='$start1':duration='$dur1',setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start='$start1':duration='$dur1',asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start='$start2':duration='$dur2',setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start='$start2':duration='$dur2',asetpts=PTS-STARTPTS[outa2];" +
                    "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
                    
        & $ffmpeg -fflags +genpts -i $video_source -filter_complex $filter_2 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    } else {
        $dur3 = Read-Host "[Morceau 3] DUREE exacte"
        Write-Host ""
        Write-Host "Execution avec 3 morceaux..." -ForegroundColor Yellow
        
        $filter_3 = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=3[v1][v2][v3];" +
                    "[v1]trim=start='$start1':duration='$dur1',setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start='$start1':duration='$dur1',asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start='$start2':duration='$dur2',setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start='$start2':duration='$dur2',asetpts=PTS-STARTPTS[outa2];" +
                    "[v3]trim=start='$start3':duration='$dur3',setpts=PTS-STARTPTS[outv3];" +
                    "[0:a]atrim=start='$start3':duration='$dur3',asetpts=PTS-STARTPTS[outa3];" +
                    "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                    
        & $ffmpeg -fflags +genpts -i $video_source -filter_complex $filter_3 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    }
}

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

�� Un petit rappel pour la saisie :

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Fonction interne pour convertir HH:MM:SS.mmm en secondes pures
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return 0 }
    # Remplacer les virgules éventuelles par des points
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        Write-Host "Erreur de format pour le temps : $tempsTexte. Assurez-vous d'utiliser HH:MM:SS.mmm" -ForegroundColor Red
        return 0
    }
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $filter_1 = "[0:v][0:s:0]overlay"
    & $ffmpeg -fflags +genpts -ss $start1_raw -t $dur1_raw -canvas_size 1920x1080 -i $video_source -filter_complex $filter_1 -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution avec 2 morceaux (Conversion en secondes effectuee)..." -ForegroundColor Yellow
        
        # Construction du filtre avec des secondes pures et séparateurs stricts
        $filter_2 = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=2[v1][v2];" +
                    "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                    "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
                    
        & $ffmpeg -fflags +genpts -i $video_source -filter_complex $filter_2 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution avec 3 morceaux (Conversion en secondes effectuee)..." -ForegroundColor Yellow
        
        $filter_3 = "[0:v][0:s:0]overlay=canvas_size=1920x1080,split=3[v1][v2][v3];" +
                    "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                    "[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];" +
                    "[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];" +
                    "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                    
        & $ffmpeg -fflags +genpts -i $video_source -filter_complex $filter_3 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    }
}

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

1. Ouvrez Nettoyeur_TF1.ps1, effacez tout et collez ce nouveau code.
2. Relancez l'application en double-cliquant sur votre fichier LANCER_APPLICATION.bat.
3. Entrez à nouveau vos valeurs (00:13:56.840, 00:12:35.760, etc.).

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Fonction interne pour convertir HH:MM:SS.mmm en secondes pures
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return 0 }
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        Write-Host "Erreur de format pour le temps : $tempsTexte. Assurez-vous d'utiliser HH:MM:SS.mmm" -ForegroundColor Red
        return 0
    }
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $filter_1 = "[0:v][0:s:0]overlay"
    & $ffmpeg -fflags +genpts -ss $start1_raw -t $dur1_raw -canvas_size 1920x1080 -i $video_source -filter_complex $filter_1 -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution avec 2 morceaux..." -ForegroundColor Yellow
        
        # Correction ici : canvas_size est retiré de overlay et remis en option d'entrée globale
        $filter_2 = "[0:v][0:s:0]overlay;" +
                    "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                    "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
        
        # Injection du split juste après l'overlay pour alimenter les branches de trim
        $filter_2 = $filter_2.Replace("[0:v][0:s:0]overlay;", "[0:v][0:s:0]overlay,split=2[v1][v2];")
                    
        & $ffmpeg -fflags +genpts -canvas_size 1920x1080 -i $video_source -filter_complex $filter_2 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution avec 3 morceaux..." -ForegroundColor Yellow
        
        $filter_3 = "[0:v][0:s:0]overlay,split=3[v1][v2][v3];" +
                    "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                    "[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];" +
                    "[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];" +
                    "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                    
        & $ffmpeg -fflags +genpts -canvas_size 1920x1080 -i $video_source -filter_complex $filter_3 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    }
}

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Fonction pour convertir HH:MM:SS.mmm en secondes pures (format US strict pour FFmpeg)
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return "0" }
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        # Force le point comme séparateur décimal (ex: 836.840)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        Write-Host "Erreur de format de temps pour : $tempsTexte. Utilisez bien HH:MM:SS.mmm" -ForegroundColor Red
        return "0"
    }
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $filter_1 = "[0:v][0:s:0]overlay"
    & $ffmpeg -fflags +genpts -ss $start1_raw -t $dur1_raw -canvas_size 1920x1080 -i $video_source -filter_complex $filter_1 -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution avec 2 morceaux..." -ForegroundColor Yellow
        
        # Construction propre et directe de la chaîne de filtres
        $filter_2 = "[0:v][0:s:0]overlay,split=2[v1][v2];" +
                    "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                    "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
        
        & $ffmpeg -fflags +genpts -canvas_size 1920x1080 -i $video_source -filter_complex $filter_2 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution avec 3 morceaux..." -ForegroundColor Yellow
        
        $filter_3 = "[0:v][0:s:0]overlay,split=3[v1][v2][v3];" +
                    "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                    "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                    "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                    "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                    "[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];" +
                    "[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];" +
                    "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                    
        & $ffmpeg -fflags +genpts -canvas_size 1920x1080 -i $video_source -filter_complex $filter_3 -map "[v]" -map "[a]" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"
    }
}

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

1. Remplacez le code de votre fichier Nettoyeur_TF1.ps1 par celui-ci et enregistrez le fichier.
2. Relancez via votre fichier .bat.
3. Indiquez attentivement les données (sans aucun espace) :
   • [Morceau 1] DEBUT : 00:13:56.840
   • [Morceau 1] DUREE : 00:12:35.760
   • [Morceau 2] DEBUT : 00:32:44.760
   • [Morceau 2] DUREE : 00:07:30.120
   • [Morceau 3] DEBUT : Appuyez juste sur Entrée pour valider.

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Fonction pour convertir HH:MM:SS.mmm en secondes pures (format US strict pour FFmpeg)
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return "0" }
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        Write-Host "Erreur de format de temps pour : $tempsTexte. Utilisez bien HH:MM:SS.mmm" -ForegroundColor Red
        return "0"
    }
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $cmd = "$ffmpeg -fflags +genpts -ss $start1_raw -t $dur1_raw -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"[0:v][0:s:0]overlay`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution avec 2 morceaux (Generation de la commande brute)..." -ForegroundColor Yellow
        
        $filter = "[0:v][0:s:0]overlay,split=2[v1][v2];[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
        $cmd = "$ffmpeg -fflags +genpts -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -map `"[v]`" -map `"[a]`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution avec 3 morceaux..." -ForegroundColor Yellow
        
        $filter = "[0:v][0:s:0]overlay,split=3[v1][v2][v3];[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
        $cmd = "$ffmpeg -fflags +genpts -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -map `"[v]`" -map `"[a]`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
    }
}

# Écriture de la commande brute dans un fichier temporaire pour bypasser les bugs de PowerShell
$cmd | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii
Write-Host "Lancement de FFmpeg..." -ForegroundColor Green

# Exécution de la commande dans un sous-processus natif
cmd.exe /c ".\lancer_ffmpeg.bat"

# Nettoyage du fichier temporaire après exécution
if (Test-Path ".\lancer_ffmpeg.bat") { Remove-Item ".\lancer_ffmpeg.bat" }

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

• Morceau 1 DUREE exacte : 00:12:35.760 (ce qui fait exactement 755.760 secondes)
• Morceau 2 DEBUT : 00:32:44.760 (ce qui fait 1964.760 secondes)

1. Il découpe proprement le Morceau 1 en lui incrustant ses sous-titres (génère part1.mp4).
2. Il découpe proprement le Morceau 2 en lui incrustant ses sous-titres (génère part2.mp4).
3. Il fusionne (concatène) les deux fichiers obtenus en un seul fichier final output.mp4 sans ré-encoder (donc instantanément), puis il nettoie les fichiers temporaires.

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "      COUPE MULTIPLE ET INCRUSTATION AUTOMATIQUE (PS)  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Nettoyage préventif des anciens fichiers temporaires
if (Test-Path ".\part1.mp4") { Remove-Item ".\part1.mp4" }
if (Test-Path ".\part2.mp4") { Remove-Item ".\part2.mp4" }
if (Test-Path ".\part3.mp4") { Remove-Item ".\part3.mp4" }
if (Test-Path ".\list.txt")  { Remove-Item ".\list.txt" }

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1 = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1   = Read-Host "[Morceau 1] DUREE exacte"
Write-Host ""

$start2 = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $cmd = "$ffmpeg -fflags +genpts -ss $start1 -t $dur1 -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"[0:v][0:s:0]overlay`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
    $cmd | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii
    cmd.exe /c ".\lancer_ffmpeg.bat"
} else {
    $dur2 = Read-Host "[Morceau 2] DUREE exacte"
    Write-Host ""
    
    $start3 = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3) {
        Write-Host "Traitement séquentiel de 2 morceaux..." -ForegroundColor Yellow
        
        # Étape 1 : Créer le morceau 1 avec sous-titres
        Write-Host "-> Encodage du Morceau 1..." -ForegroundColor Cyan
        $cmd1 = "$ffmpeg -fflags +genpts -ss $start1 -t $dur1 -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"[0:v][0:s:0]overlay`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"part1.mp4`""
        $cmd1 | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii
        cmd.exe /c ".\lancer_ffmpeg.bat"
        
        # Étape 2 : Créer le morceau 2 avec sous-titres
        Write-Host "-> Encodage du Morceau 2..." -ForegroundColor Cyan
        $cmd2 = "$ffmpeg -fflags +genpts -ss $start2 -t $dur2 -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"[0:v][0:s:0]overlay`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"part2.mp4`""
        $cmd2 | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii
        cmd.exe /c ".\lancer_ffmpeg.bat"
        
        # Étape 3 : Fusionner les morceaux (sans ré-encoder, ultra rapide)
        if ((Test-Path ".\part1.mp4") -and (Test-Path ".\part2.mp4")) {
            Write-Host "-> Fusion des morceaux..." -ForegroundColor Cyan
            "file 'part1.mp4'" | Out-File -FilePath ".\list.txt" -Encoding ascii
            "file 'part2.mp4'" | Out-File -Append -FilePath ".\list.txt" -Encoding ascii
            
            $cmd_fusion = "$ffmpeg -f concat -safe 0 -i list.txt -c copy `"output.mp4`""
            $cmd_fusion | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii
            cmd.exe /c ".\lancer_ffmpeg.bat"
        }
    } else {
        $dur3 = Read-Host "[Morceau 3] DUREE exacte"
        Write-Host ""
        Write-Host "Traitement séquentiel de 3 morceaux..." -ForegroundColor Yellow
        
        # Morceau 1
        $cmd1 = "$ffmpeg -fflags +genpts -ss $start1 -t $dur1 -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"[0:v][0:s:0]overlay`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"part1.mp4`""
        $cmd1 | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii ; cmd.exe /c ".\lancer_ffmpeg.bat"
        # Morceau 2
        $cmd2 = "$ffmpeg -fflags +genpts -ss $start2 -t $dur2 -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"[0:v][0:s:0]overlay`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"part2.mp4`""
        $cmd2 | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii ; cmd.exe /c ".\lancer_ffmpeg.bat"
        # Morceau 3
        $cmd3 = "$ffmpeg -fflags +genpts -ss $start3 -t $dur3 -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"[0:v][0:s:0]overlay`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"part3.mp4`""
        $cmd3 | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii ; cmd.exe /c ".\lancer_ffmpeg.bat"
        
        # Fusion
        if ((Test-Path ".\part1.mp4") -and (Test-Path ".\part2.mp4") -and (Test-Path ".\part3.mp4")) {
            "file 'part1.mp4'" | Out-File -FilePath ".\list.txt" -Encoding ascii
            "file 'part2.mp4'" | Out-File -Append -FilePath ".\list.txt" -Encoding ascii
            "file 'part3.mp4'" | Out-File -Append -FilePath ".\list.txt" -Encoding ascii
            $cmd_fusion = "$ffmpeg -f concat -safe 0 -i list.txt -c copy `"output.mp4`""
            $cmd_fusion | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii ; cmd.exe /c ".\lancer_ffmpeg.bat"
        }
    }
}

# Nettoyage final des fichiers de travail
if (Test-Path ".\lancer_ffmpeg.bat") { Remove-Item ".\lancer_ffmpeg.bat" }
if (Test-Path ".\part1.mp4") { Remove-Item ".\part1.mp4" }
if (Test-Path ".\part2.mp4") { Remove-Item ".\part2.mp4" }
if (Test-Path ".\part3.mp4") { Remove-Item ".\part3.mp4" }
if (Test-Path ".\list.txt")  { Remove-Item ".\list.txt" }

Write-Host ""
Read-Host "Operation terminee ! Votre fichier final output.mp4 est disponible. Appuyez sur Entree."

1. Zéro conversion de variables : Les arguments de temps (-ss et -t) reprennent exactement le format texte HH:MM:SS.mmm que vous tapez, sans passer par les filtres internes sensibles de FFmpeg.
2. Aucune confusion pour Windows : Les commandes sont isolées bloc par bloc.
3. Même résultat final : La fusion à la fin assemble vos morceaux à la milliseconde près, sans aucune perte de qualité.

• Ajouter plus de morceaux (si 3 blocs ne suffisent pas pour les longs films coupés par de nombreuses publicités).
• Personnaliser le script pour qu'il vous demande le nom du fichier de sortie au lieu de l'appeler systématiquement output.mp4.

• Avidemux recalcule instantanément les images manquantes pour couper précisément là où vous lui demandez (on appelle ça le décodage et la coupure à l'image près ou Smart Copy).
• FFmpeg, lorsqu'il effectue des coupes séquentielles puis une fusion brute via concat, cherche l'image clé la plus proche. Si vous lui demandez de couper à 00:13:56.840 et qu'il n'y a pas d'image clé à ce moment précis, il va sauter au début du bloc d'images. Cela crée une coupure brutale, décale la timeline temporelle (PTS) et provoque un désalignement entre la piste audio et la piste vidéo lors de la fusion.

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE PRÉCISE (IMAGE PRÈS) ET INCRUSTATION AUTOMATIQUE " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Fonction interne pour convertir HH:MM:SS.mmm en secondes pures (format strict pour les filtres FFmpeg)
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return "0" }
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        Write-Host "Erreur de format pour le temps : $tempsTexte." -ForegroundColor Red
        return "0"
    }
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau (Précision maximale)..." -ForegroundColor Yellow
    $filter = "[0:v][0:s:0]overlay"
    $cmd = "$ffmpeg -fflags +genpts -ss $start1_raw -t $dur1_raw -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution avec 2 morceaux (Coupe chirurgicale et recalage du son)..." -ForegroundColor Yellow
        
        # Le secret : on applique l'overlay des sous-titres, on duplique le flux décodé, on coupe précisément en secondes, et on fusionne le tout
        $filter = "[0:v][0:s:0]overlay,split=2[v1][v2];" +
                  "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                  "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
                  
        $cmd = "$ffmpeg -fflags +genpts -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -map `"[v]`" -map `"[a]`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution avec 3 morceaux (Coupe chirurgicale et recalage du son)..." -ForegroundColor Yellow
        
        $filter = "[0:v][0:s:0]overlay,split=3[v1][v2][v3];" +
                  "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                  "[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];" +
                  "[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];" +
                  "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                  
        $cmd = "$ffmpeg -fflags +genpts -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -map `"[v]`" -map `"[a]`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
    }
}

# Écriture propre et exécution sécurisée sans altération des caractères par PowerShell
$cmd | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii
Write-Host "Lancement du traitement haute précision..." -ForegroundColor Green
cmd.exe /c ".\lancer_ffmpeg.bat"

if (Test-Path ".\lancer_ffmpeg.bat") { Remove-Item ".\lancer_ffmpeg.bat" }

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

1. Le script n'utilise plus de .Replace textuel hasardeux sur la ligne de commande, il génère le filtre d'un seul bloc propre.
2. Les temps sont automatiquement convertis en secondes pures (ex: 836.840), ce qui évite le bug Invalid argument que vous aviez eu précédemment.
3. Comme FFmpeg traite les coupes à l'intérieur du flux vidéo décodé (trim), il va couper exactement à la millisecondes demandée, sans dépendre des images clés distantes. Le son et l'image resteront soudés ensemble.

• Avidemux recalcule instantanément les images manquantes pour couper précisément là où vous lui demandez (on appelle ça le décodage et la coupure à l'image près ou Smart Copy).
• FFmpeg, lorsqu'il effectue des coupes séquentielles puis une fusion brute via concat, cherche l'image clé la plus proche. Si vous lui demandez de couper à 00:13:56.840 et qu'il n'y a pas d'image clé à ce moment précis, il va sauter au début du bloc d'images. Cela crée une coupure brutale, décale la timeline temporelle (PTS) et provoque un désalignement entre la piste audio et la piste vidéo lors de la fusion.

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE PRÉCISE (IMAGE PRÈS) ET INCRUSTATION AUTOMATIQUE " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Fonction interne pour convertir HH:MM:SS.mmm en secondes pures (format strict pour les filtres FFmpeg)
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return "0" }
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        Write-Host "Erreur de format pour le temps : $tempsTexte." -ForegroundColor Red
        return "0"
    }
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau (Précision maximale)..." -ForegroundColor Yellow
    $filter = "[0:v][0:s:0]overlay"
    $cmd = "$ffmpeg -fflags +genpts -ss $start1_raw -t $dur1_raw -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution avec 2 morceaux (Coupe chirurgicale et recalage du son)..." -ForegroundColor Yellow
        
        # Le secret : on applique l'overlay des sous-titres, on duplique le flux décodé, on coupe précisément en secondes, et on fusionne le tout
        $filter = "[0:v][0:s:0]overlay,split=2[v1][v2];" +
                  "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                  "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
                  
        $cmd = "$ffmpeg -fflags +genpts -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -map `"[v]`" -map `"[a]`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution avec 3 morceaux (Coupe chirurgicale et recalage du son)..." -ForegroundColor Yellow
        
        $filter = "[0:v][0:s:0]overlay,split=3[v1][v2][v3];" +
                  "[v1]trim=start=$start1:duration=$dur1,setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=$start1:duration=$dur1,asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=$start2:duration=$dur2,setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=$start2:duration=$dur2,asetpts=PTS-STARTPTS[outa2];" +
                  "[v3]trim=start=$start3:duration=$dur3,setpts=PTS-STARTPTS[outv3];" +
                  "[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];" +
                  "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                  
        $cmd = "$ffmpeg -fflags +genpts -canvas_size 1920x1080 -i `"$video_source`" -filter_complex `"$filter`" -map `"[v]`" -map `"[a]`" -c:v libx264 -crf 26 -c:a aac -b:a 128k `"output.mp4`""
    }
}

# Écriture propre et exécution sécurisée sans altération des caractères par PowerShell
$cmd | Out-File -FilePath ".\lancer_ffmpeg.bat" -Encoding ascii
Write-Host "Lancement du traitement haute précision..." -ForegroundColor Green
cmd.exe /c ".\lancer_ffmpeg.bat"

if (Test-Path ".\lancer_ffmpeg.bat") { Remove-Item ".\lancer_ffmpeg.bat" }

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

1. Le script n'utilise plus de .Replace textuel hasardeux sur la ligne de commande, il génère le filtre d'un seul bloc propre.
2. Les temps sont automatiquement convertis en secondes pures (ex: 836.840), ce qui évite le bug Invalid argument que vous aviez eu précédemment.
3. Comme FFmpeg traite les coupes à l'intérieur du flux vidéo décodé (trim), il va couper exactement à la millisecondes demandée, sans dépendre des images clés distantes. Le son et l'image resteront soudés ensemble.

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE PRÉCISE (IMAGE PRÈS) ET INCRUSTATION AUTOMATIQUE " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Fonction interne pour convertir HH:MM:SS.mmm en secondes pures (format US strict pour FFmpeg)
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return "0" }
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        Write-Host "Erreur de format pour le temps : $tempsTexte." -ForegroundColor Red
        return "0"
    }
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau (Précision maximale)..." -ForegroundColor Yellow
    $filter = "[0:v][0:s:0]overlay"
    $args = @("-fflags", "+genpts", "-ss", $start1_raw, "-t", $dur1_raw, "-canvas_size", "1920x1080", "-i", $video_source, "-filter_complex", $filter, "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
    & $ffmpeg $args
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution avec 2 morceaux (Coupe chirurgicale et recalage du son)..." -ForegroundColor Yellow
        
        # Construction de la chaîne en évitant toute variable imbriquée suspecte
        $filter = "[0:v][0:s:0]overlay,split=2[v1][v2];" +
                  "[v1]trim=start=" + $start1 + ":duration=" + $dur1 + ",setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=" + $start1 + ":duration=" + $dur1 + ",asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=" + $start2 + ":duration=" + $dur2 + ",setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=" + $start2 + ":duration=" + $dur2 + ",asetpts=PTS-STARTPTS[outa2];" +
                  "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
                  
        $args = @("-fflags", "+genpts", "-canvas_size", "1920x1080", "-i", $video_source, "-filter_complex", $filter, "-map", "[v]", "-map", "[a]", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
        & $ffmpeg $args
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution avec 3 morceaux (Coupe chirurgicale et recalage du son)..." -ForegroundColor Yellow
        
        $filter = "[0:v][0:s:0]overlay,split=3[v1][v2][v3];" +
                  "[v1]trim=start=" + $start1 + ":duration=" + $dur1 + ",setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=" + $start1 + ":duration=" + $dur1 + ",asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=" + $start2 + ":duration=" + $dur2 + ",setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=" + $start2 + ":duration=" + $dur2 + ",asetpts=PTS-STARTPTS[outa2];" +
                  "[v3]trim=start=" + $start3 + ":duration=" + $dur3 + ",setpts=PTS-STARTPTS[outv3];" +
                  "[0:a]atrim=start=" + $start3 + ":duration=" + $dur3 + ",asetpts=PTS-STARTPTS[outa3];" +
                  "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                  
        $args = @("-fflags", "+genpts", "-canvas_size", "1920x1080", "-i", $video_source, "-filter_complex", $filter, "-map", "[v]", "-map", "[a]", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
        & $ffmpeg $args
    }
}

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

Que signifient ces messages ?

Que devez-vous faire maintenant ?

1. FFmpeg va lire le fichier .mts à toute vitesse (sans compression, en quelques secondes) pour remettre les compteurs à zéro et exporter le tout dans un fichier temporaire propre (index_propre.mkv).
2. Le script va ensuite effectuer les coupes et l'incrustation des sous-titres sur ce fichier sain. Les horloges étant alignées sur le temps réel, la coupe se fera exactement à la millisecondes près demandée.

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE CHIRURGICALE HAUTE PRÉCISION VIA INDEXATION   " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"
$temp_clean = ".\index_propre.mkv"

# Nettoyage préventif
if (Test-Path $temp_clean) { Remove-Item $temp_clean }

# ÉTAPE 0 : Indexation et remise à zéro des horloges (comme le fait Avidemux)
Write-Host "-> Indexation de la source en cours (Action rapide)..." -ForegroundColor Windows
$args_index = @("-fflags", "+genpts", "-i", $video_source, "-map", "0", "-c", "copy", "-copyts", "-start_at_zero", $temp_clean)
& $ffmpeg $args_index

if (-not (Test-Path $temp_clean)) {
    Write-Host "Erreur lors de l'indexation du fichier. Fin du script." -ForegroundColor Red
    Read-Host "Appuyez sur Entree."
    exit
}

# Fonction interne de conversion
function Convertir-EnSecondes($tempsTexte) {
    if (-not $tempsTexte) { return "0" }
    $tempsTexte = $tempsTexte.Replace(",", ".")
    try {
        $ts = [TimeSpan]::Parse($tempsTexte)
        return $ts.TotalSeconds.ToString("F3", [System.Globalization.CultureInfo]::InvariantCulture)
    } catch {
        return "0"
    }
}

Write-Host ""
Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm"
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1 = Convertir-EnSecondes $start1_raw
$dur1   = Convertir-EnSecondes $dur1_raw
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $filter = "[0:v][0:s:0]overlay"
    $args = @("-ss", $start1_raw, "-t", $dur1_raw, "-canvas_size", "1920x1080", "-i", $temp_clean, "-filter_complex", $filter, "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
    & $ffmpeg $args
} else {
    $dur2_raw = Read-Host "[Morceau 2] DUREE exacte"
    $start2 = Convertir-EnSecondes $start2_raw
    $dur2   = Convertir-EnSecondes $dur2_raw
    Write-Host ""
    
    $start3_raw = Read-Host "[Morceau 3] Heure de DEBUT (Laisser vide si inutile)"
    if (-not $start3_raw) {
        Write-Host "Execution haute precision à 2 morceaux..." -ForegroundColor Yellow
        
        $filter = "[0:v][0:s:0]overlay,split=2[v1][v2];" +
                  "[v1]trim=start=" + $start1 + ":duration=" + $dur1 + ",setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=" + $start1 + ":duration=" + $dur1 + ",asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=" + $start2 + ":duration=" + $dur2 + ",setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=" + $start2 + ":duration=" + $dur2 + ",asetpts=PTS-STARTPTS[outa2];" +
                  "[outv1][outa1][outv2][outa2]concat=n=2:v=1:a=1[v][a]"
                  
        $args = @("-canvas_size", "1920x1080", "-i", $temp_clean, "-filter_complex", $filter, "-map", "[v]", "-map", "[a]", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
        & $ffmpeg $args
    } else {
        $dur3_raw = Read-Host "[Morceau 3] DUREE exacte"
        $start3 = Convertir-EnSecondes $start3_raw
        $dur3   = Convertir-EnSecondes $dur3_raw
        Write-Host ""
        Write-Host "Execution haute precision à 3 morceaux..." -ForegroundColor Yellow
        
        $filter = "[0:v][0:s:0]overlay,split=3[v1][v2][v3];" +
                  "[v1]trim=start=" + $start1 + ":duration=" + $dur1 + ",setpts=PTS-STARTPTS[outv1];" +
                  "[0:a]atrim=start=" + $start1 + ":duration=" + $dur1 + ",asetpts=PTS-STARTPTS[outa1];" +
                  "[v2]trim=start=" + $start2 + ":duration=" + $dur2 + ",setpts=PTS-STARTPTS[outv2];" +
                  "[0:a]atrim=start=" + $start2 + ":duration=" + $dur2 + ",asetpts=PTS-STARTPTS[outa2];" +
                  "[v3]trim=start=" + $start3 + ":duration=" + $dur3 + ",setpts=PTS-STARTPTS[outv3];" +
                  "[0:a]atrim=start=$start3:duration=$dur3,asetpts=PTS-STARTPTS[outa3];" +
                  "[outv1][outa1][outv2][outa2][outv3][outa3]concat=n=3:v=1:a=1[v][a]"
                  
        $args = @("-canvas_size", "1920x1080", "-i", $temp_clean, "-filter_complex", $filter, "-map", "[v]", "-map", "[a]", "-c:v", "libx264", "-crf", "26", "-c:a aac", "-b:a", "128k", "output.mp4")
        & $ffmpeg $args
    }
}

# Nettoyage du fichier temporaire indexé
if (Test-Path $temp_clean) { Remove-Item $temp_clean }

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer cette fenetre."

1. La console va afficher pendant quelques secondes des lignes rapides : elle crée index_propre.mkv. Les flux vidéo, audio et sous-titres DVB y sont copiés au bit près, mais rangés sur une vraie règle temporelle débutant à zéro.
2. Le script vous demande vos temps et applique les coupures sur cette base saine.

1. Le lecteur vidéo essaie de synchroniser l'image de la vidéo et l'image du sous-titre.
2. Pour y arriver sur un flux en direct imparfait, le lecteur applique un délai d'affichage constant à l'écran (souvent entre 1 et 3 secondes) pour s'assurer que le sous-titre ne disparaisse pas trop vite.
3. Les horaires que vous lisez à l'écran et notez sur votre papier sont donc déjà faussés par votre lecteur vidéo.

ffmpeg -i TF1-09042026-1349.mts -map 0 -c copy video_prete.mkv

#PY  <- Obligatoire pour Avidemux
adm = Avidemux()
gui = Gui()

# 1. Configuration des Codecs stricts (Équivalent à votre FFmpeg)
adm.videoCodec("libx264", "usePreset=True", "preset=medium", "profile=main", "tune=none", "crf=26")
adm.audioClearTracks()
adm.audioAddTrack(0)
adm.audioCodec(0, "LavAAC", "bitrate=128")
adm.setContainer("MP4V2", "optimize=1", "add_itunes_metadata=0")

# 2. Incrustation automatique du flux de sous-titres DVB interne au MKV
# Le track_index=0 indique à Avidemux de prendre la première piste de sous-titres trouvée
adm.addVideoFilter("dvbsub", "filename=", "track_index=0")

gui.displayInfo("Configuration Appliquée", "1. Utilisez les touches [ et ] puis Suppr pour enlever les pubs à l'image près.\n2. Faites Ctrl+S pour enregistrer le résultat final.")

1. Ouvrez Avidemux 2.8.0.
2. Glissez-déposez le fichier video_prete.mkv (créé à l'étape 1).
3. Allez dans Fichier > Script > Exécuter le script et choisissez incrustation_et_coupe.py.
4. Faites vos coupes de publicités directement sur la timeline à l'aide des boutons A ([) et B (]) et de la touche Suppr de votre clavier. Ici, ce que vous voyez à l'écran est exactement ce qui sera coupé.
5. Enregistrez (Ctrl+S).

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE MULTIPLE ET INCRUSTATION ULTRA-PRÉCISE (PS)   " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Nettoyage préventif
if (Test-Path ".\part1.mp4") { Remove-Item ".\part1.mp4" }
if (Test-Path ".\part2.mp4") { Remove-Item ".\part2.mp4" }
if (Test-Path ".\list.txt")  { Remove-Item ".\list.txt" }

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm (Ex: 00:13:56.840)"
Write-Host "Appuyez simplement sur ENTRÉE (laisser vide) pour ignorer les morceaux suivants."
Write-Host ""

$start1 = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1   = Read-Host "[Morceau 1] DUREE exacte"
Write-Host ""

$start2 = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2) {
    Write-Host "Execution avec 1 seul morceau..." -ForegroundColor Yellow
    $args = @("-fflags", "+genpts", "-canvas_size", "1920x1080", "-i", $video_source, "-ss", $start1, "-t", $dur1, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
    & $ffmpeg $args
} else {
    $dur2 = Read-Host "[Morceau 2] DUREE exacte"
    Write-Host ""
    
    Write-Host "Découpage chirurgical des morceaux..." -ForegroundColor Yellow
    
    # Étape 1 : Créer le morceau 1 précis (Le -ss après le -i force le décodage image par image)
    Write-Host "-> Encodage précis du Morceau 1..." -ForegroundColor Cyan
    $args1 = @("-fflags", "+genpts", "-canvas_size", "1920x1080", "-i", $video_source, "-ss", $start1, "-t", $dur1, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "part1.mp4")
    & $ffmpeg $args1
    
    # Étape 2 : Créer le morceau 2 précis
    Write-Host "-> Encodage précis du Morceau 2..." -ForegroundColor Cyan
    $args2 = @("-fflags", "+genpts", "-canvas_size", "1920x1080", "-i", $video_source, "-ss", $start2, "-t", $dur2, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "part2.mp4")
    & $ffmpeg $args2
    
    # Étape 3 : Raboutage direct sans perte
    if ((Test-Path ".\part1.mp4") -and (Test-Path ".\part2.mp4")) {
        Write-Host "-> Fusion finale sans perte..." -ForegroundColor Cyan
        "file 'part1.mp4'" | Out-File -FilePath ".\list.txt" -Encoding ascii
        "file 'part2.mp4'" | Out-File -Append -FilePath ".\list.txt" -Encoding ascii
        
        $args_fusion = @("-f", "concat", "-safe", "0", "-i", "list.txt", "-c", "copy", "output.mp4")
        & $ffmpeg $args_fusion
    }
}

# Nettoyage final
if (Test-Path ".\part1.mp4") { Remove-Item ".\part1.mp4" }
if (Test-Path ".\part2.mp4") { Remove-Item ".\part2.mp4" }
if (Test-Path ".\list.txt")  { Remove-Item ".\list.txt" }

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer."

• Avant -i (ce qu'on faisait au début) : FFmpeg saute à l'image clé la plus proche (imprécis, comme vous l'avez constaté).
• Après -i : FFmpeg lit l'intégralité du flux et décode image par image jusqu'au point demandé. La découpe s'effectue alors exactement à la milliseconde près demandée, tout en insérant les sous-titres DVB sans plantage de filtre.

1. Dans votre dossier D:\!! FFMPEG\, créez un nouveau fichier texte nommé LANCER_APPLICATION.bat (assurez-vous que l'extension soit .bat et non .txt).
2. Ouvrez-le avec le Bloc-notes, collez cette unique ligne et enregistrez le fichier :

powershell -NoExit -ExecutionPolicy Bypass -File "%~dp0Nettoyeur_TF1.ps1"

• La fenêtre noire/bleue va s'ouvrir de manière stable.
• Elle va charger votre fichier Nettoyeur_TF1.ps1 (dans sa version corrigée avec le -ss après le -i).
• Vous pourrez saisir vos horaires, et FFmpeg effectuera enfin la découpe chirurgicale image par image.

1. Faites un clic droit sur votre fichier LANCER_APPLICATION.bat et choisissez Modifier.
2. Effacez tout et remplacez le contenu par ces 4 lignes très strictes :

@echo off
cd /d "%~dp0"
powershell -NoExit -ExecutionPolicy Bypass -File "Nettoyeur_TF1.ps1"
pause

• cd /d "%~dp0" : Force Windows à se déplacer proprement dans votre dossier D:\!! FFMPEG\, ce qui évite les bugs avec les points d'exclamation.
• pause : Si PowerShell refuse de démarrer, cette ligne interdira formellement à la fenêtre noire de se fermer et affichera un message.

• Laissez le script tourner. Tant que la fenêtre reste ouverte et que vous voyez les lignes de progression ou que le processeur travaille, tout va bien.
• FFmpeg va automatiquement sauter ces micro-erreurs et incruster proprement tous les vrais sous-titres valides dès que les dialogues commenceront à l'horaire demandé.

1. Téléchargez la version gratuite de tsMuxer (ou sa version moderne tsMuxerGUI). C'est un outil très connu pour le traitement des flux de transport TV.
2. Placez le fichier tsmuxer.exe (ou tsMuxerGUI.exe) dans votre dossier D:\!! FFMPEG\.

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   DÉCOUPE CHIRURGICALE VIA TSMUXER ET FFMPEG          " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"
$tsmuxer = ".\tsmuxer.exe"

# Nettoyage préventif
if (Test-Path ".\part1.ts") { Remove-Item ".\part1.ts" }
if (Test-Path ".\part2.ts") { Remove-Item ".\part2.ts" }
if (Test-Path ".\meta1.meta") { Remove-Item ".\meta1.meta" }
if (Test-Path ".\meta2.meta") { Remove-Item ".\meta2.meta" }

# Fonction pour convertir le format HH:MM:SS.mmm en millisecondes pour tsMuxer
function Convertir-EnMS($tempsTexte) {
    if (-not $tempsTexte) { return 0 }
    $ts = [TimeSpan]::Parse($tempsTexte.Replace(",", "."))
    return [long]$ts.TotalMilliseconds
}

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm"
Write-Host ""

$start1_raw = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1_raw   = Read-Host "[Morceau 1] DUREE exacte"
$start1_ms  = Convertir-EnMS $start1_raw
$end1_ms    = $start1_ms + (Convertir-EnMS $dur1_raw)
Write-Host ""

$start2_raw = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2_raw) {
    Write-Host "Découpage du morceau unique via tsMuxer..." -ForegroundColor Yellow
    
    # Création du fichier de configuration pour tsMuxer
    $meta = "MUXOPT --no-pcr-on-video-pid --new-audio-pes --vbr --hdmv-descriptors`n" +
            "V_MPEG4/ISO/AVC, `"$video_source`", insertSEI, contSPS`n" +
            "A_AAC, `"$video_source`"`n" +
            "S_DVBSUB, `"$video_source`"`n" +
            "TRIM --start-time=$start1_ms --end-time=$end1_ms"
    $meta | Out-File -FilePath ".\meta1.meta" -Encoding ascii
    
    # Découpe ultra-rapide (sans perte)
    & $tsmuxer ".\meta1.meta" ".\part1.ts"
    
    # Encodage final et incrustation avec FFmpeg sur le bloc propre
    Write-Host "Incrustation des sous-titres et compression..." -ForegroundColor Green
    $args = @("-fflags", "+genpts", "-canvas_size", "1920x1080", "-i", "part1.ts", "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
    & $ffmpeg $args
} else {
    $dur2_raw   = Read-Host "[Morceau 2] DUREE exacte"
    $start2_ms  = Convertir-EnMS $start2_raw
    $end2_ms    = $start2_ms + (Convertir-EnMS $dur2_raw)
    
    Write-Host "Découpage chirurgical des 2 morceaux via tsMuxer..." -ForegroundColor Yellow
    
    # Morceau 1
    $meta1 = "MUXOPT --no-pcr-on-video-pid --new-audio-pes --vbr`nV_MPEG4/ISO/AVC, `"$video_source`"`nA_AAC, `"$video_source`"`nS_DVBSUB, `"$video_source`"`nTRIM --start-time=$start1_ms --end-time=$end1_ms"
    $meta1 | Out-File -FilePath ".\meta1.meta" -Encoding ascii
    & $tsmuxer ".\meta1.meta" ".\part1.ts"
    
    # Morceau 2
    $meta2 = "MUXOPT --no-pcr-on-video-pid --new-audio-pes --vbr`nV_MPEG4/ISO/AVC, `"$video_source`"`nA_AAC, `"$video_source`"`nS_DVBSUB, `"$video_source`"`nTRIM --start-time=$start2_ms --end-time=$end2_ms"
    $meta2 | Out-File -FilePath ".\meta2.meta" -Encoding ascii
    & $tsmuxer ".\meta2.meta" ".\part2.ts"
    
    # Fusion, incrustation et compression via FFmpeg
    Write-Host "Fusion, incrustation des sous-titres et encodage final..." -ForegroundColor Green
    $filter = "[0:v][0:s:0]overlay[v0];[1:v][1:s:0]overlay[v1];[v0][0:a][v1][1:a]concat=n=2:v=1:a=1[v][a]"
    $args = @("-fflags", "+genpts", "-canvas_size", "1920x1080", "-i", "part1.ts", "-i", "part2.ts", "-filter_complex", $filter, "-map", "[v]", "-map", "[a]", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
    & $ffmpeg $args
}

# Nettoyage final
if (Test-Path ".\part1.ts") { Remove-Item ".\part1.ts" }
if (Test-Path ".\part2.ts") { Remove-Item ".\part2.ts" }
if (Test-Path ".\meta1.meta") { Remove-Item ".\meta1.meta" }
if (Test-Path ".\meta2.meta") { Remove-Item ".\meta2.meta" }

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree."

1. tsMuxer ouvre le fichier en mode "flux TV natif". Il sait exactement interpréter les structures des fichiers de la TNT et réaligner les pistes dès le départ.
2. Il découpe les morceaux à la milliseconde près en générant des fichiers .ts intermédiaires parfaits.
3. FFmpeg reçoit des fichiers pré-découpés qui commencent exactement à 00:00:00.000, ce qui élimine totalement l'imprécision chronologique constatée auparavant.

1. L'exécutable s'appelle tsMuxerGUI.exe au lieu de tsmuxer.exe dans votre dossier.
2. La syntaxe interne du fichier .meta que j'ai générée contenait une option ou une identification de piste (comme S_DVBSUB ou A_AAC) que tsMuxer n'a pas réussi à mapper automatiquement sur votre flux de la TNT (TF1).

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE CHIRURGICALE HAUTE PRÉCISION VIA FFMPEG STRIC  " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Nettoyage préventif des anciens fichiers temporaires
if (Test-Path ".\part1.mp4") { Remove-Item ".\part1.mp4" }
if (Test-Path ".\part2.mp4") { Remove-Item ".\part2.mp4" }
if (Test-Path ".\list.txt")  { Remove-Item ".\list.txt" }

Write-Host "Saisissez les plages UTILES au format HH:MM:SS.mmm"
Write-Host ""

$start1 = Read-Host "[Morceau 1] Heure de DEBUT"
$dur1   = Read-Host "[Morceau 1] DUREE exacte"
Write-Host ""

$start2 = Read-Host "[Morceau 2] Heure de DEBUT (Laisser vide si inutile)"
if (-not $start2) {
    Write-Host "Découpage du morceau unique..." -ForegroundColor Yellow
    # La combinaison de -ss AVANT et -ss/trim APRÈS force FFmpeg à être ultra-précis sans bug de GOP
    $args = @("-fflags", "+genpts+igndts", "-ss", $start1, "-t", $dur1, "-canvas_size", "1920x1080", "-i", $video_source, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "output.mp4")
    & $ffmpeg $args
} else {
    $dur2 = Read-Host "[Morceau 2] DUREE exacte"
    Write-Host ""
    
    Write-Host "Découpage chirurgical des 2 morceaux..." -ForegroundColor Yellow
    
    # Étape 1 : Créer le morceau 1 précis
    # -ss AVANT pour sauter vite, -ss APRÈS pour caler à l'image près, +genpts+igndts pour réparer l'horloge TNT
    Write-Host "-> Encodage précis du Morceau 1..." -ForegroundColor Cyan
    $args1 = @("-fflags", "+genpts+igndts", "-canvas_size", "1920x1080", "-i", $video_source, "-ss", $start1, "-t", $dur1, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "part1.mp4")
    & $ffmpeg $args1
    
    # Étape 2 : Créer le morceau 2 précis
    Write-Host "-> Encodage précis du Morceau 2..." -ForegroundColor Cyan
    $args2 = @("-fflags", "+genpts+igndts", "-canvas_size", "1920x1080", "-i", $video_source, "-ss", $start2, "-t", $dur2, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", "part2.mp4")
    & $ffmpeg $args2
    
    # Étape 3 : Raboutage final direct
    if ((Test-Path ".\part1.mp4") -and (Test-Path ".\part2.mp4")) {
        Write-Host "-> Fusion finale sans perte..." -ForegroundColor Cyan
        "file 'part1.mp4'" | Out-File -FilePath ".\list.txt" -Encoding ascii
        "file 'part2.mp4'" | Out-File -Append -FilePath ".\list.txt" -Encoding ascii
        
        $args_fusion = @("-f", "concat", "-safe", "0", "-i", "list.txt", "-c", "copy", "output.mp4")
        & $ffmpeg $args_fusion
    }
}

# Nettoyage final
if (Test-Path ".\part1.mp4") { Remove-Item ".\part1.mp4" }
if (Test-Path ".\part2.mp4") { Remove-Item ".\part2.mp4" }
if (Test-Path ".\list.txt")  { Remove-Item ".\list.txt" }

Write-Host ""
Read-Host "Operation terminee. Appuyez sur Entree pour fermer."

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE MULTI-MORCEAUX (JUSQU'À 5) ET INCRUSTATION    " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host " Saisie simplifiée : Heure de Début -> Heure de Fin    " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Nettoyage préventif des anciens fichiers temporaires
1..5 | ForEach-Object { if (Test-Path ".\part$_.mp4") { Remove-Item ".\part$_.mp4" } }
if (Test-Path ".\list.txt") { Remove-Item ".\list.txt" }

# Fonction interne pour calculer la durée exacte (Fin - Début)
function Calculer-Duree($startRaw, $endRaw) {
    try {
        $tsStart = [TimeSpan]::Parse($startRaw.Replace(",", "."))
        $tsEnd   = [TimeSpan]::Parse($endRaw.Replace(",", "."))
        $tsDiff  = $tsEnd - $tsStart
        if ($tsDiff.TotalSeconds -le 0) { return $null }
        return $tsDiff.ToString("hh\:mm\:ss\.fff")
    } catch {
        return $null
    }
}

# Tableaux pour stocker les infos de saisie
$plages_start = @()
$plages_dur   = @()

# Boucle de saisie pour 5 morceaux maximum
for ($i = 1; $i -le 5; $i++) {
    Write-Host "--- MORCEAU $i ---" -ForegroundColor Yellow
    if ($i -eq 1) {
        $s = Read-Host "Heure de DEBUT (ex: 00:13:56.840)"
    } else {
        $s = Read-Host "Heure de DEBUT (Laissez vide pour arrêter la saisie et lancer l'encodage)"
    }
    
    if (-not $s) { break }
    $f = Read-Host "Heure de FIN   (ex: 00:26:32.600)"
    
    $d = Calculer-Duree $s $f
    if (-not $d) {
        Write-Host "Erreur : L'heure de fin doit être supérieure à l'heure de début. Saisie annulée pour ce morceau." -ForegroundColor Red
        $i--
        continue
    }
    
    $plages_start += $s
    $plages_dur   += $d
    Write-Host "-> Durée calculée automatiquement : $d" -ForegroundColor Green
    Write-Host ""
}

$total_morceaux = $plages_start.Count

if ($total_morceaux -eq 0) {
    Write-Host "Aucun morceau sélectionné. Fin du programme." -ForegroundColor Red
    Read-Host "Appuyez sur Entrée."
    exit
}

Write-Host "Lancement de l'encodage de $total_morceaux morceau(x)..." -ForegroundColor Cyan
Write-Host ""

# Étape 1 : Encodage de chaque morceau individuellement à l'image près
for ($i = 0; $i -lt $total_morceaux; $i++) {
    $num = $i + 1
    $st = $plages_start[$i]
    $du = $plages_dur[$i]
    
    Write-Host "-> Traitement du Morceau $num / $total_morceaux... (Début: $st | Durée: $du)" -ForegroundColor Process
    
    $output_part = ".\part$num.mp4"
    $args = @("-fflags", "+genpts+igndts", "-canvas_size", "1920x1080", "-i", $video_source, "-ss", $st, "-t", $du, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", $output_part)
    
    & $ffmpeg $args
}

# Étape 2 : Fusion (Raboutage) de tous les morceaux créés
Write-Host ""
if ($total_morceaux -eq 1) {
    # Un seul morceau : on renomme simplement part1.mp4 en output.mp4
    if (Test-Path ".\part1.mp4") {
        if (Test-Path ".\output.mp4") { Remove-Item ".\output.mp4" }
        Rename-Item ".\part1.mp4" "output.mp4"
        Write-Host "Fichier unique généré avec succès !" -ForegroundColor Green
    }
} else {
    # Plusieurs morceaux : on crée la liste et on concatène
    Write-Host "-> Fusion finale de tous les morceaux sans perte..." -ForegroundColor Cyan
    $crees = 0
    for ($i = 1; $i -le $total_morceaux; $i++) {
        if (Test-Path ".\part$i.mp4") {
            "file 'part$i.mp4'" | Out-File -Append -FilePath ".\list.txt" -Encoding ascii
            $crees++
        }
    }
    
    if ($crees -eq $total_morceaux) {
        if (Test-Path ".\output.mp4") { Remove-Item ".\output.mp4" }
        $args_fusion = @("-f", "concat", "-safe", "0", "-i", "list.txt", "-c", "copy", "output.mp4")
        & $ffmpeg $args_fusion
        Write-Host "Fusion terminée avec succès ! Le fichier final 'output.mp4' est prêt." -ForegroundColor Green
    } else {
        Write-Host "Erreur : Certains morceaux n'ont pas pu être générés. Fusion impossible." -ForegroundColor Red
    }
}

# Étape 3 : Nettoyage des fichiers temporaires
1..5 | ForEach-Object { if (Test-Path ".\part$_.mp4") { Remove-Item ".\part$_.mp4" } }
if (Test-Path ".\list.txt") { Remove-Item ".\list.txt" }

Write-Host ""
Read-Host "Opération entièrement terminée. Appuyez sur Entrée pour fermer cette fenêtre."

1. Lancez l'application avec votre fichier LANCER_APPLICATION.bat.
2. Morceau 1 : Entrez l'heure du début du film (ex: 00:13:56.840) puis l'heure exacte du début de la première pub (ex: 00:26:32.600).
3. Morceau 2 : Entrez l'heure de la reprise du film après la pub (ex: 00:32:44.760) puis l'heure de la fin du morceau (ou de la pub suivante).
4. Lorsque vous avez rentré toutes vos parties utiles, laissez simplement la demande de début du morceau suivant vide et appuyez sur Entrée.
5. Le script lance l'encodage précis de chaque bloc, puis les fusionne instantanément à la fin.

L'alternative ultime : l'application gratuite LosslessCut

La méthode pour extraire vos pubs en 1 minute :

Si vous préférez conserver le script PowerShell

Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host "   COUPE MULTI-MORCEAUX (JUSQU'À 5) ET INCRUSTATION    " -ForegroundColor Cyan
Write-Host " Saisie simplifiée : Heure de Début -> Heure de Fin    " -ForegroundColor Cyan
Write-Host "=======================================================" -ForegroundColor Cyan
Write-Host ""

$video_source = "TF1-09042026-1349.mts"
$ffmpeg = ".\ffmpeg.exe"

# Nettoyage préventif
1..5 | ForEach-Object { if (Test-Path ".\part$_.mp4") { Remove-Item ".\part$_.mp4" } }
if (Test-Path ".\list.txt") { Remove-Item ".\list.txt" }

# Fonction interne pour calculer la durée exacte
function Calculer-Duree($startRaw, $endRaw) {
    try {
        $tsStart = [TimeSpan]::Parse($startRaw.Replace(",", "."))
        $tsEnd   = [TimeSpan]::Parse($endRaw.Replace(",", "."))
        $tsDiff  = $tsEnd - $tsStart
        if ($tsDiff.TotalSeconds -le 0) { return $null }
        return $tsDiff.ToString("hh\:mm\:ss\.fff")
    } catch { return $null }
}

$plages_start = @()
$plages_dur   = @()

for ($i = 1; $i -le 5; $i++) {
    Write-Host "--- MORCEAU $i ---" -ForegroundColor Yellow
    if ($i -eq 1) { $s = Read-Host "Heure de DEBUT (ex: 00:13:56.840)" }
    else { $s = Read-Host "Heure de DEBUT (Laissez vide pour lancer l'encodage)" }
    
    if (-not $s) { break }
    $f = Read-Host "Heure de FIN   (ex: 00:26:32.600)"
    
    $d = Calculer-Duree $s $f
    if (-not $d) {
        Write-Host "Erreur de saisie. Recommencez ce morceau." -ForegroundColor Red
        $i--
        continue
    }
    $plages_start += $s
    $plages_dur   += $d
    Write-Host "-> Durée validée : $d" -ForegroundColor Green
    Write-Host ""
}

$total_morceaux = $plages_start.Count
if ($total_morceaux -eq 0) { exit }

# Étape 1 : Encodage de chaque morceau
for ($i = 0; $i -lt $total_morceaux; $i++) {
    $num = $i + 1
    $st = $plages_start[$i]
    $du = $plages_dur[$i]
    
    Write-Host "-> Traitement du Morceau $num / $total_morceaux..." -ForegroundColor Cyan
    $output_part = ".\part$num.mp4"
    $args = @("-fflags", "+genpts+igndts", "-canvas_size", "1920x1080", "-i", $video_source, "-ss", $st, "-t", $du, "-filter_complex", "[0:v][0:s:0]overlay", "-c:v", "libx264", "-crf", "26", "-c:a", "aac", "-b:a", "128k", $output_part)
    & $ffmpeg $args
}

# Étape 2 : Fusion
Write-Host ""
if ($total_morceaux -eq 1) {
    if (Test-Path ".\part1.mp4") {
        if (Test-Path ".\output.mp4") { Remove-Item ".\output.mp4" }
        Rename-Item ".\part1.mp4" "output.mp4"
    }
} else {
    Write-Host "-> Fusion finale de tous les morceaux..." -ForegroundColor Cyan
    for ($i = 1; $i -le $total_morceaux; $i++) {
        if (Test-Path ".\part$i.mp4") { "file 'part$i.mp4'" | Out-File -Append -FilePath ".\list.txt" -Encoding ascii }
    }
    if (Test-Path ".\output.mp4") { Remove-Item ".\output.mp4" }
    $args_fusion = @("-f", "concat", "-safe", "0", "-i", "list.txt", "-c", "copy", "output.mp4")
    & $ffmpeg $args_fusion
}

# Nettoyage final
1..5 | ForEach-Object { if (Test-Path ".\part$_.mp4") { Remove-Item ".\part$_.mp4" } }
if (Test-Path ".\list.txt") { Remove-Item ".\list.txt" }

Write-Host ""
Read-Host "Opération terminée. Fichier final 'output.mp4' disponible. Appuyez sur Entrée."

• Le problème initial : Les vidéos modernes (H.264, MPEG-TS) sont découpées en blocs (GOP) qui commencent par une image clé réelle (I-Frame). Les images suivantes ne sont que des "calculs" de mouvements. Si vous demandez de couper au milieu d'un bloc, la vidéo ne peut pas s'afficher. [2, 5]
• Comment procède FFmpeg (dans nos scripts) : Il applique bêtement des filtres mathématiques temporels sur le fichier brut. Si le point demandé ne tombe pas sur une image clé, il crée une approximation. [6]
• Comment procède Avidemux : Il décode visuellement le fichier à l'écran. Quand vous appuyez sur Suppr, il ne ré-encode que les quelques secondes de transition autour de votre coupure pour recréer une image clé propre (I-Frame). Tout le reste du film est recopié à l'identique (ce qui garantit 0 % de perte de qualité). [2, 3, 7]

ffmpeg -fflags +genpts -ss 00:13:50.000 -canvas_size 1920x1080 -i TF1-09042026-1349.mts -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k output.mp4

ffmpeg -fflags +genpts -ss 00:13:50.000 -to 02:15:30.000 -canvas_size 1920x1080 -i TF1-09042026-1349.mts -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k output.mp4

• Plus aucun calcul mathématique : Vous lisez l'heure de début sur votre lecteur, vous enlevez quelques secondes. Vous lisez l'heure de fin globale, vous ajoutez quelques secondes. Vous tapez ces deux heures telles quelles.
• Pas de perte de temps : FFmpeg s'arrêtera pile à l'heure indiquée, ignorant l'heure de rab inutile.
• Finition parfaite : Vous ouvrez le résultat dans Avidemux pour ajuster le début et la fin à l'image près en mode "Copier" instantané.

• Si -to est placé avant -i : FFmpeg essaie de l'appliquer sur le fichier brut avant de l'avoir décodé. Mais comme l'horloge interne des fichiers de la TNT (.mts) ne commence jamais à zéro, FFmpeg s'y perd complètement et coupe n'importe où, souvent beaucoup trop tôt.
• Si -to est placé après -i : FFmpeg l'applique sur le flux après l'avoir ouvert. L'horloge est alors interprétée par rapport au point de départ, et l'argument fonctionne correctement.

ffmpeg -fflags +genpts -ss 00:13:50.000 -canvas_size 1920x1080 -i TF1-09042026-1349.mts -to 00:12:45.000 -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k output.mp4

1. Dans votre dossier D:\!! FFMPEG\, créez un fichier texte nommé Incruster_et_Tailler.bat.
2. Ouvrez-le avec le Bloc-notes, collez le code suivant et enregistrez :

@echo off
echo =======================================================
echo     PREPARATION FFmpeg (INCRUSTATION SUBTITLES)
echo =======================================================
echo.

:: Saisie des repères par l'utilisateur
set /p debut="1. Entrez l'heure de DEBUT (ex: 00:13:50.000) : "
set /p fin="2. Entrez l'heure de FIN lue sur votre papier (ex: 00:12:45.000) : "

echo.
echo Traitement en cours... Veuillez patienter.
echo.

:: Exécution de la commande FFmpeg optimisée
ffmpeg -fflags +genpts -ss %debut% -canvas_size 1920x1080 -i "TF1-09042026-1349.mts" -to %fin% -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"

echo.
echo Operation terminee ! Vous pouvez ouvrir 'output.mp4' dans Avidemux.
pause

1. Double-cliquez sur Incruster_et_Tailler.bat.
2. Entrez l'heure de début lue sur votre lecteur (arrondie un peu avant la pub ou le film).
3. Entrez le repère de fin de votre bloc (arrondi largement à la minute supérieure pour ne pas recalculer de durée).
4. Laissez FFmpeg travailler. Une fois fini, ouvrez votre output.mp4 tout neuf dans Avidemux pour supprimer précisément le rab en mode "Copier" ultra-rapide.

@echo off
chcp 65001 >nul
cd /d "%~dp0"

echo =======================================================
echo     PREPARATION FFmpeg UNIVERSATION (SOUS-TITRES)
echo =======================================================
echo.

:: Détection automatique du premier fichier .mts du dossier
set "video_source="
for %%f in (*.mts) do (
    set "video_source=%%f"
    goto :trouve
)

:trouve
if "%video_source%"=="" (
    echo [ERREUR] Aucun fichier .mts trouvé dans ce dossier !
    echo Placez ce script juste à côté de votre vidéo TF1.
    echo.
    pause
    exit
)

echo Vidéo détectée : %video_source%
echo.

:: Saisie des repères par l'utilisateur
set /p debut="1. Entrez l'heure de DEBUT (ex: 00:13:50.000) : "
set /p fin="2. Entrez l'heure de FIN approximative (ex: 00:12:45.000) : "

echo.
echo Traitement de %video_source% en cours...
echo.

:: Exécution de votre commande FFmpeg exacte
ffmpeg -fflags +genpts -ss %debut% -canvas_size 1920x1080 -i "%video_source%" -to %fin% -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"

echo.
echo =======================================================
echo Opération terminée avec succès !
echo Ouvrez maintenant 'output.mp4' dans Avidemux pour :
echo 1. Ajuster le début et la fin à l'image près.
echo 2. Enregistrer directement en mode "Copier" (sans recompresser).
echo =======================================================
echo.
pause

1. Vous placez ce fichier .bat dans votre dossier de travail (comme D:\!! FFMPEG\).
2. Vous y déposez votre enregistrement TV (qu'il s'appelle TF1-*.mts, France2-*.mts ou n'importe quel autre nom).
3. Vous lancez le .bat : il trouve la vidéo tout seul.
4. Vous tapez votre heure de début (un peu avant) et votre heure de fin globale (arrondie largement au-dessus).
5. FFmpeg génère l'output.mp4 avec les sous-titres incrustés, et vous n'avez plus qu'à faire les finitions chirurgicales dans Avidemux sans aucun calcul mental.

@echo off
chcp 65001 >nul
cd /d "%~dp0"

echo =======================================================
echo     PREPARATION FFmpeg (INCRUSTATION SOUS-TITRES)
echo =======================================================
echo.

:: 1. Demande du nom du fichier à l'utilisateur
set /p video_source="Entrez le nom de votre fichier .mts (ex: TF1-09042026-1349.mts) : "

:: Vérification si le fichier existe
if not exist "%video_source%" (
    echo.
    echo [ERREUR] Le fichier "%video_source%" est introuvable.
    echo Vérifiez l'orthographe ou l'extension (.mts).
    echo.
    pause
    exit
)

echo.
echo Vidéo sélectionnée : %video_source%
echo.

:: 2. Saisie des repères de temps
set /p debut="1. Entrez l'heure de DEBUT (ex: 00:13:50.000) : "
set /p fin="2. Entrez l'heure de FIN approximative (ex: 00:12:45.000) : "

echo.
echo Traitement de %video_source% en cours...
echo.

:: Exécution de votre commande FFmpeg
ffmpeg -fflags +genpts -ss %debut% -canvas_size 1920x1080 -i "%video_source%" -to %fin% -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"

echo.
echo =======================================================
echo Opération terminée avec succès !
echo Ouvrez maintenant 'output.mp4' dans Avidemux pour :
echo 1. Ajuster le début et la fin à l'image près.
echo 2. Enregistrer directement en mode "Copier".
echo =======================================================
echo.
pause

Le Code Corrigé (Sans aucun accent)

@echo off
cd /d "%~dp0"

echo =======================================================
echo     PREPARATION FFmpeg (INCRUSTATION SOUS-TITRES)
echo =======================================================
echo.

:: 1. Demande du nom du fichier
set /p video_source="Entrez le nom du fichier .mts : "

echo.
echo Video selectionnee : %video_source%
echo.

:: 2. Saisie des reperes de temps
set /p debut="1. Entrez l'heure de DEBUT (ex: 00:13:50.000) : "
set /p fin="2. Entrez l'heure de FIN approximative (ex: 00:12:45.000) : "

echo.
echo Traitement en cours...
echo.

:: Execution de la commande FFmpeg
ffmpeg -fflags +genpts -ss %debut% -canvas_size 1920x1080 -i "%video_source%" -to %fin% -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"

echo.
echo Operation terminee !
pause

Comment s'assurer que ça ne plante plus au copier-coller :

@echo off
cd /d "%~dp0"

echo =======================================================
echo     PREPARATION FFmpeg (INCRUSTATION SOUS-TITRES)
echo =======================================================
echo.

:: 1. Demande du nom du fichier
set /p video_source="Entrez le nom du fichier .mts : "

echo.
echo Video selectionnee : %video_source%
echo.

:: 2. Saisie des reperes de temps REELS (lus sur votre lecteur)
set /p debut="1. Entrez l'heure de DEBUT reelle (ex: 00:16:36.400) : "
set /p fin="2. Entrez l'heure de FIN reelle (ex: 00:17:14.240) : "

echo.
echo Traitement en cours...
echo.

:: Execution de la commande (Positionnement de -to corrige pour respecter l'heure absolue)
ffmpeg -fflags +genpts -ss %debut% -to %fin% -canvas_size 1920x1080 -i "%video_source%" -filter_complex "[0:v][0:s:0]overlay" -c:v libx264 -crf 26 -c:a aac -b:a 128k "output.mp4"

echo.
echo Operation terminee !
pause