Créer des sous-titres stylisés avec Whisper GUI et Premiere Pro

Ce guide vous explique comment :

Installer Whisper GUI de Pikurrot
Configurer FFmpeg correctement
Utiliser Whisper GUI pour générer des transcriptions JSON/SRT
Convertir un JSON Whisper en SRT stylisé (mot par mot ou par blocs)
Importer et styliser des sous-titres dans Adobe Premiere Pro
Nettoyer proprement votre système ensuite

✅ ÉTAPE 1 : Installer Whisper GUI de Pikurrot

Rendez-vous sur le repo GitHub : https://github.com/Pikurrot/whisper-gui
Descendez jusqu'à la section Releases : https://github.com/Pikurrot/whisper-gui/releases
Téléchargez le fichier .zip ou .exe (recommandé : WhisperGUI.exe)
Créez un dossier organisé comme C:\Program Files\Whisper
Placez-y l'exécutable WhisperGUI.exe

▶ Important : Lorsque vous lancez WhisperGUI pour la première fois, il ouvre une interface dans votre navigateur à l'adresse http://127.0.0.1:7860. Peut prendre plusieurs secondes, patience.v

✅ ÉTAPE 2 : Installer FFmpeg et l'ajouter au PATH

Whisper a besoin de ffmpeg pour extraire l'audio de vos vidéos.

Allez sur cette page : https://phoenixnap.com/kb/ffmpeg-windows
Clique sur "Release builds", puis choisis la version "essentials" depuis https://www.gyan.dev/ffmpeg/builds/
Extrayez le dossier (ex : ffmpffmpeg-xxxx-win64-essentials) dans C:\Program Files\ffmpeg
Copiez le chemin de C:\Program Files\ffmpeg\bin
Ajoutez-le au PATH système :
- Démarrez > Rechercher "variables d'environnement"
- Cliquez sur "Variables d'environnement"
- Dans la section "Variables système", double-cliquez sur Path
- Cliquez sur "Nouveau" et collez le chemin C:\Program Files\ffmpeg\bin
- Validez avec OK

✅ ÉTAPE 3 : Utiliser Whisper GUI

Lancez WhisperGUI.exe
Dans le navigateur, cliquez sur Upload video et ajoutez votre fichier .mp4 ou .mov
Choisissez :

Paramètres recommandés :

Model : medium ou large-v3 pour de la précision
Output : json + srt (pour avoir les deux)
Compute Type : float16 (bon équilibre précision/vitesse)
Batch Size : 8 ou 16
Chunk Size : 40 ou 80 (selon RAM)
Beam Size : 5 ou 10 (plus élevé = plus précis)

📁 Emplacement des fichiers générés

Les fichiers sont automatiquement enregistrés dans le même dossier que celui d'où est exécuté WhisperGUI.exe.

Exemple :

Si WhisperGUI.exe est dans C:\Program Files\Whisper, les fichiers .json, .srt, .txt seront aussi à cet emplacement

✅ ÉTAPE 4 : Convertir le JSON en SRT par chunks (mot par mot ou groupé)

Nous allons regrouper les mots issus du .json en blocs lisibles.

1. Créer un script `json_to_chunked_srt.py`

import json, sys

def fmt(ts):
    h = int(ts // 3600)
    m = int((ts % 3600) // 60)
    s = int(ts % 60)
    ms = int((ts - int(ts)) * 1000)
    return f"{h:02}:{m:02}:{s:02},{ms:03}"

def group_words(words, max_words=6):
    chunks = []
    i = 0
    while i < len(words):
        chunk = words[i:i+max_words]
        start = chunk[0]['start']
        end = chunk[-1]['end']
        text = ' '.join(w['word'].strip() for w in chunk)
        chunks.append((start, end, text))
        i += max_words
    return chunks

def main(json_path):
    with open(json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    words = [w for seg in data['segments'] for w in seg['words']]
    chunks = group_words(words, max_words=5)  # ← ajuste ici pour 4-6 mots par ligne

    out_path = json_path.replace('.json', '_chunked.srt')
    with open(out_path, 'w', encoding='utf-8') as o:
        for i, (start, end, text) in enumerate(chunks, 1):
            o.write(f"{i}\n{fmt(start)} --> {fmt(end)}\n{text}\n\n")

    print("✅ Fichier SRT généré :", out_path)

if __name__ == "__main__":
    main(sys.argv[1])

2. Utilisation :

Glisser output.srt sur json_to_chunked_srt.py

python json_to_chunked_srt.py transcription.json output.srt

✅ ÉTAPE 5 : Importer et styliser les sous-titres dans Premiere Pro

Ouvrir Premiere Pro
Menu Fenêtre > Texte > Importer des sous-titres
Sélectionnez output.srt
Une nouvelle piste de sous-titres s'ajoute dans votre séquence

✨ Styliser les sous-titres

Sélectionnez la première ligne de texte
Menu Fenêtre > Graphiques essentiels > Modifier
Appliquer vos réglages :

Mes réglages précis (influenceur style)

Police : Impact
Taille : 60
All caps : activé
Tracking : -11
Align and Transform : Centre bas, position Y = -200
Remplissage : Blanc
Fond : Noir, opacité 100%, Padding 20/0, arrondi 25

Enregistrer le style

Dans le panneau Graphiques essentiels > Modifier, cliquez sur "+ Créer un style"
Donnez-lui un nom (ex : InfluenceurPop)
Appliquez-le aux autres sous-titres

❌ Désinstaller proprement Whisper GUI et ses dépendances

Supprimer Whisper GUI

Supprimez le dossier C:\Program Files\Whisper

Supprimer FFmpeg du PATH

Recherchez variables d'environnement
Dans les Variables système, ouvrez Path
Supprimez la ligne C:\Program Files\ffmpeg\bin

Nettoyer Python et les scripts (si utilisés)

Supprimez le fichier json_to_chunked_srt.py
Si vous avez installé Python juste pour ça :
- Panneau de configuration > Programmes > Désinstaller Python

🎉 C'est fini !

Vous avez maintenant une solution locale, stylisée et organisée pour créer des sous-titres influenceurs de qualité, sans dépendre de services cloud.

Create Stylish Subtitles with Whisper GUI and Premiere Pro

This guide explains how to:

Install Whisper GUI by Pikurrot
Properly configure FFmpeg
Use Whisper GUI to generate JSON/SRT transcriptions
Convert a Whisper JSON into styled SRT (word-by-word or chunked)
Import and style subtitles in Adobe Premiere Pro
Clean up your system afterward

✅ STEP 1: Install Whisper GUI by Pikurrot

Go to the GitHub repo: https://github.com/Pikurrot/whisper-gui
Scroll down to the Releases section: https://github.com/Pikurrot/whisper-gui/releases
Download the .zip or .exe file (recommended: WhisperGUI.exe)
Create an organized folder like C:\Program Files\Whisper
Place the WhisperGUI.exe executable inside

▶ Important: When you launch WhisperGUI for the first time, it opens an interface in your browser at http://127.0.0.1:7860. It may take several seconds — be patient.

✅ STEP 2: Install FFmpeg and Add to PATH

Whisper needs ffmpeg to extract audio from your videos.

Go to this page: https://phoenixnap.com/kb/ffmpeg-windows
Click "Release builds", then choose the "essentials" version from https://www.gyan.dev/ffmpeg/builds/
Extract the folder (e.g. ffmpeg-xxxx-win64-essentials) to C:\Program Files\ffmpeg
Copy the path C:\Program Files\ffmpeg\bin
Add it to the system PATH:
- Start > Search for "environment variables"
- Click "Environment Variables"
- In the "System variables" section, double-click Path
- Click "New" and paste the path C:\Program Files\ffmpeg\bin
- Confirm with OK

✅ STEP 3: Use Whisper GUI

Launch WhisperGUI.exe
In the browser, click Upload video and add your .mp4 or .mov file
Choose:

Recommended Parameters:

Model: medium or large-v3 for accuracy
Output: json + srt (to get both)
Compute Type: float16 (good balance of speed/accuracy)
Batch Size: 8 or 16
Chunk Size: 40 or 80 (depending on RAM)
Beam Size: 5 or 10 (higher = more accurate)

📁 Location of Generated Files

Files are automatically saved in the same folder where WhisperGUI.exe is located.

Example:

If WhisperGUI.exe is in C:\Program Files\Whisper, then .json, .srt, .txt files will also be there.

✅ STEP 4: Convert JSON to SRT by Chunks (word-by-word or grouped)

We'll group words from the .json into readable chunks.

1. Create the `json_to_chunked_srt.py` script

import json, sys

def fmt(ts):
    h = int(ts // 3600)
    m = int((ts % 3600) // 60)
    s = int(ts % 60)
    ms = int((ts - int(ts)) * 1000)
    return f"{h:02}:{m:02}:{s:02},{ms:03}"

def group_words(words, max_words=6):
    chunks = []
    i = 0
    while i < len(words):
        chunk = words[i:i+max_words]
        start = chunk[0]['start']
        end = chunk[-1]['end']
        text = ' '.join(w['word'].strip() for w in chunk)
        chunks.append((start, end, text))
        i += max_words
    return chunks

def main(json_path):
    with open(json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    words = [w for seg in data['segments'] for w in seg['words']]
    chunks = group_words(words, max_words=5)  # ← adjust here for 4–6 words per line

    out_path = json_path.replace('.json', '_chunked.srt')
    with open(out_path, 'w', encoding='utf-8') as o:
        for i, (start, end, text) in enumerate(chunks, 1):
            o.write(f"{i}\n{fmt(start)} --> {fmt(end)}\n{text}\n\n")

    print("✅ SRT file generated:", out_path)

if __name__ == "__main__":
    main(sys.argv[1])

2. Usage:

Drag transcription.json onto json_to_chunked_srt.py
Or run:

python json_to_chunked_srt.py transcription.json output.srt

✅ STEP 5: Import and Style Subtitles in Premiere Pro

Open Premiere Pro
Menu Window > Text > Import Captions
Select output.srt
A new subtitle track appears in your sequence

✨ Style the subtitles

Select the first text line
Menu Window > Essential Graphics > Edit
Apply your settings:

My exact settings (influencer style):

Font: Impact
Size: 60
All caps: enabled
Tracking: -11
Align and Transform: Center bottom, Y position = -200
Fill: White
Background: Black, 100% opacity, Padding 20/0, roundness 25

Save the style

In Essential Graphics > Edit, click "+ Create Style"
Name it (e.g. InfluenceurPop)
Apply it to the other captions

❌ Cleanly Uninstall Whisper GUI and Dependencies

Delete Whisper GUI

Delete the folder C:\Program Files\Whisper

Remove FFmpeg from PATH

Search environment variables
In System variables, open Path
Delete the line C:\Program Files\ffmpeg\bin

Clean Python and scripts (if used)

Delete json_to_chunked_srt.py
If you installed Python just for this:
- Control Panel > Programs > Uninstall Python

🎉 Done!

You now have a local, stylized, and organized workflow to create influencer-quality subtitles — without relying on cloud services.