# Migration AV1-SVT + Opus Implementation Plan

> **For agentic workers:** REQUIRED: Use superpowers:subagent-driven-development (if subagents available) or superpowers:executing-plans to implement this plan. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal :** Migrer `vid_convert.py` de H.265/AAC-LC vers AV1-SVT/Opus avec sélection automatique du CRF via `ab-av1 crf-search`, sortie MKV, et support HDR10/HDR10+/Dolby Vision complet.

**Architecture :** Script Python mono-fichier modifié en place. Les fonctions obsolètes (`mkv_to_mp4`, `is_interlaced`) sont supprimées, la nouvelle fonction `find_crf` est ajoutée, et toutes les fonctions existantes sont mises à jour. Le flux principal perd la logique de chunking.

**Tech Stack :** Python 3, FFmpeg (libsvtav1, libopus), ab-av1, hdr10plus_parser, mkvmerge

**Spec :** `docs/superpowers/specs/2026-03-22-av1-opus-design.md`

---

## Chunk 1 : Nettoyage, corrections et audio Opus

### Task 1 : Correction du bug et suppression du code obsolète

**Fichiers :**
- Modifier : `vid_convert.py`

- [ ] **Étape 1 : Décommenter `get_infos` et supprimer la ligne orpheline**

Dans `vid_convert.py`, ligne 308, remplacer :
```python
    # infos = get_infos(file)
    interlaced = False
    interlaced = is_interlaced(file, infos)
```
Par :
```python
    infos = get_infos(file)
```

- [ ] **Étape 2 : Supprimer la fonction `is_interlaced`**

Supprimer les lignes 81–104 (fonction `is_interlaced` entière).

- [ ] **Étape 3 : Supprimer la fonction `mkv_to_mp4`**

Supprimer les lignes 283–290 (fonction `mkv_to_mp4` entière).

- [ ] **Étape 4 : Mettre à jour les arguments CLI**

Dans le bloc `__main__`, remplacer :
```python
    parser.add_argument("-t", "--starttime", dest="starttime")
    parser.add_argument("-a", "--animation", dest="animation", action="store_true")
    parser.add_argument("-c", "--vhs", dest="vhs", action="store_true")
```
Par :
```python
    parser.add_argument("-a", "--animation", dest="animation", action="store_true")
    parser.add_argument("-c", "--vhs", dest="vhs", action="store_true")
    parser.add_argument("--interlaced", dest="interlaced", action="store_true")
```

- [ ] **Étape 5 : Supprimer le flux principal obsolète**

> ⚠️ Après cette étape, le script sera syntaxiquement valide mais non fonctionnel. Il sera complété au Task 8.

Dans le bloc `__main__`, supprimer exactement ce bloc (état du fichier après Step 1, à partir de `file = args.f_input` jusqu'à la fin du fichier) :
```python
    file = args.f_input
    infos = get_infos(file)
    cropsize = cropping(file, infos)
    volumes = volume_audio(file, infos)
    if args.stab:
        stabilization(file)
    if args.animation:
        animation = True
    else:
        animation = False
    if not args.starttime:
        for track in infos['subtitles']:
            extract_subs(file, track['index'], track['language'])
        for track in infos['audio']:
            convert_audio(file, track['index'], volumes[track['index']], track['channels'], track['channel_layout'], track['language'], track['title'])
    if args.starttime:
        vid_part_time = int(args.starttime)
    else:
        vid_part_time = 0
    while vid_part_time < infos['duration']:
        crf = 20
        convert_video(file, infos, vid_part_time, cropsize, crf, animation, interlaced, args.vhs)
        vid_part_time += 300
    create_mkv(file)
    mkv_to_mp4(file)
```

Remplacer par un placeholder temporaire (sera remplacé au Task 8) :
```python
    pass
```

- [ ] **Étape 6 : Vérifier que le script parse sans erreur**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 7 : Commit**

```bash
git add vid_convert.py
git commit -m "refactor: suppression code obsolète (chunks, is_interlaced, mkv_to_mp4, -t)"
```

---

### Task 2 : Encodage audio — libfdk_aac → libopus

**Fichiers :**
- Modifier : `vid_convert.py` (fonction `convert_audio`)

- [ ] **Étape 1 : Vérifier que libopus est disponible dans FFmpeg**

```bash
ffmpeg -codecs 2>/dev/null | grep -i opus
```
Résultat attendu : une ligne contenant `libopus` et `A..... libopus`. Si absent, libopus doit être compilé dans FFmpeg avant de continuer.

- [ ] **Étape 2 : Remplacer la fonction `convert_audio`**

Remplacer l'intégralité de la fonction `convert_audio` par :
```python
def convert_audio(file, track, volume_adj, channels, channel_layout, language, title):
    if channel_layout == "5.1(side)":
        channel_layout = "5.1"
    if channels <= 2:
        bitrate = "128k"
    elif channels == 6:
        bitrate = "320k"
    else:
        bitrate = "450k"
    codec = f'libopus -vbr on -b:a {bitrate}'
    metadatas = f'-metadata language="{language}" -metadata title="{title}"'
    command = f'ffmpeg -loglevel error -i {file} -map 0:{track} -map_metadata -1 -vn -sn -c:a {codec} -mapping_family 1 -filter:a volume={volume_adj},aformat=channel_layouts={channel_layout} {metadatas} -y {file}_audio_{track}_{language}.mka'
    logging.debug(command)
    result = subprocess.getoutput(command)
    if result != "":
        logging.error(result)
```

- [ ] **Étape 3 : Vérifier le parsing**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 4 : Commit**

```bash
git add vid_convert.py
git commit -m "feat: encodage audio libopus VBR avec bitrate adaptatif"
```

---

## Chunk 2 : Sélection CRF et encodage vidéo AV1

### Task 3 : Nouvelle fonction `find_crf`

**Fichiers :**
- Modifier : `vid_convert.py` (ajout de fonction avant `convert_video`)

- [ ] **Étape 1 : Ajouter la fonction `find_crf` dans `vid_convert.py`**

- [ ] **Étape 1 : Ajouter `import os` dans les imports du module**

En haut du fichier, après `from os import listdir, remove`, ajouter :
```python
import os
```

- [ ] **Étape 2 : Ajouter la fonction `find_crf`**

Insérer après la fonction `volume_audio` et avant `stabilization` :
```python
VMAF_HDR_MODEL = '/usr/share/vmaf/model/vmaf_4k_v0.6.1.json'

def find_crf(file, enc_options, hdr=False):
    '''
    Détermine le CRF optimal via ab-av1 crf-search pour atteindre VMAF 96.
    Pour les sources HDR, utilise un modèle VMAF calibré 4K HDR si disponible.
    '''
    logging.info("Recherche du CRF optimal (VMAF 96)...")
    vmaf_model = ''
    if hdr and os.path.exists(VMAF_HDR_MODEL):
        vmaf_model = f'--vmaf-model path={VMAF_HDR_MODEL}'
        logging.debug(f"Modèle VMAF HDR utilisé : {VMAF_HDR_MODEL}")
    cmd = f'ab-av1 crf-search --input {file} --encoder libsvtav1 --vmaf 96 {vmaf_model} --enc {enc_options}'
    logging.debug(cmd)
    result = subprocess.getoutput(cmd)
    logging.debug(result)
    for line in result.splitlines():
        # ab-av1 émet une ligne du type : "crf 32 VMAF 96.21 ..."
        if 'crf' in line and 'VMAF' in line:
            try:
                crf = int(line.split('crf')[1].split()[0])
                logging.info(f"CRF optimal trouvé : {crf}")
                return crf
            except (IndexError, ValueError):
                pass
    logging.warning("ab-av1 crf-search a échoué, utilisation du CRF par défaut (32)")
    return 32
```

- [ ] **Étape 3 : Vérifier le parsing**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 4 : Commit**

```bash
git add vid_convert.py
git commit -m "feat: ajout find_crf via ab-av1 crf-search (VMAF 96)"
```

---

### Task 4 : Encodage vidéo — libx265 → libsvtav1

**Fichiers :**
- Modifier : `vid_convert.py` (fonction `convert_video`)

- [ ] **Étape 1 : Remplacer la signature et les variables de base**

Remplacer le début de `convert_video` :
```python
def convert_video(file, infos, start, crop, crf, animation, interlaced, vhs):
    str_start = "{:05d}".format(start)
    output = f'{file}_video_t{str_start}.mkv'
    fmt = "yuv420p10le"
    track = infos['video']['index']
    codec = 'libx265 -preset slower'
    hdr = ''
    if animation:
        tune = "-tune animation"
    else:
        tune = ""
    if interlaced:
        crop = f"{crop},yadif"
    if vhs:
        crop = f"{crop},hqdn3d,unsharp=5:5:0.8:3:3:0.4"
```
Par :
```python
def convert_video(file, infos, crf, crop, enc_options, interlaced, vhs):
    output = f'{file}_video.mkv'
    fmt = "yuv420p10le"
    track = infos['video']['index']
    codec = 'libsvtav1'
    svtav1_params = enc_options
    hdr = ''
    if interlaced:
        crop = f"{crop},yadif"
    if vhs:
        crop = f"{crop},hqdn3d,unsharp=5:5:0.8:3:3:0.4"
```

- [ ] **Étape 2 : Mettre à jour le bloc HDR10 statique**

Remplacer le bloc `if 'side_data_list' in infos['video'].keys():` jusqu'à sa fin :
```python
    if 'side_data_list' in infos['video'].keys():
        try:
            light_level = f"{infos['video']['side_data_list'][1]['max_content']},{infos['video']['side_data_list'][1]['max_average']}"
            color_primaries = infos['video']['color_primaries']
            color_transfer = infos['video']['color_transfer']
            color_space = infos['video']['color_space']
            green_x = infos['video']['side_data_list'][0]['green_x'].split('/')
            green_x = int(int(green_x[0])*(int(green_x[1])/50000))
            green_y = infos['video']['side_data_list'][0]['green_y'].split('/')
            green_y = int(int(green_y[0])*(int(green_y[1])/50000))
            green = f'G\({green_x},{green_y}\)'
            blue_x = infos['video']['side_data_list'][0]['blue_x'].split('/')
            blue_x = int(int(blue_x[0])*(int(blue_x[1])/50000))
            blue_y = infos['video']['side_data_list'][0]['blue_y'].split('/')
            blue_y = int(int(blue_y[0])*(int(blue_y[1])/50000))
            blue = f'B\({blue_x},{blue_y}\)'
            red_x = infos['video']['side_data_list'][0]['red_x'].split('/')
            red_x = int(int(red_x[0])*(int(red_x[1])/50000))
            red_y = infos['video']['side_data_list'][0]['red_y'].split('/')
            red_y = int(int(red_y[0])*(int(red_y[1])/50000))
            red = f'R\({red_x},{red_y}\)'
            white_point_x = infos['video']['side_data_list'][0]['white_point_x'].split('/')
            white_point_x = int(int(white_point_x[0])*(int(white_point_x[1])/50000))
            white_point_y = infos['video']['side_data_list'][0]['white_point_y'].split('/')
            white_point_y = int(int(white_point_y[0])*(int(white_point_y[1])/50000))
            white_point = f'WP\({white_point_x},{white_point_y}\)'
            min_luminance = infos['video']['side_data_list'][0]['min_luminance'].split('/')
            min_luminance = int(int(min_luminance[0])*(int(min_luminance[1])/10000))
            max_luminance = infos['video']['side_data_list'][0]['max_luminance'].split('/')
            max_luminance = int(int(max_luminance[0])*(int(max_luminance[1])/10000))
            luminance = f'L\({max_luminance},{min_luminance}\)'
            master_display = green + blue + red + white_point + luminance
            hdr = f'mastering-display={master_display}:content-light={light_level}'
            if svtav1_params:
                svtav1_params = f'{svtav1_params}:{hdr}'
            else:
                svtav1_params = hdr
        except Exception as err:
            logging.debug(f"Aucune information HDR statique : {err}")
```

- [ ] **Étape 3 : Mettre à jour l'injection HDR10+ et la commande FFmpeg finale**

Remplacer la fin de `convert_video` (bloc HDR10+ + commande) :
```python
    if 'hdr10plus' in infos['video']:
        hdr10plus_param = f"hdr10plus-json={infos['video']['hdr10plus_metadata']}"
        if svtav1_params:
            svtav1_params = f'{svtav1_params}:{hdr10plus_param}'
        else:
            svtav1_params = hdr10plus_param
    svtav1_args = f'-svtav1-params {svtav1_params}' if svtav1_params else ''
    command = f'ffmpeg -loglevel error -i {file} -map 0:{track} -an -sn -c:v {codec} {svtav1_args} -crf {crf} -pix_fmt {fmt} -filter:v {crop} -y {output}'
    logging.info("Encodage vidéo en cours (AV1-SVT)...")
    logging.debug(command)
    result = subprocess.getoutput(command)
    if result != "":
        logging.error(result)
```

- [ ] **Étape 4 : Vérifier le parsing**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 5 : Commit**

```bash
git add vid_convert.py
git commit -m "feat: encodage vidéo libsvtav1 avec HDR10 statique et HDR10+ via svtav1-params"
```

---

## Chunk 3 : HDR10+, Dolby Vision, MKV et flux principal

### Task 5 : Détection du conteneur source pour HDR10+

**Fichiers :**
- Modifier : `vid_convert.py` (fonction `get_infos`)

- [ ] **Étape 1 : Détecter le format du conteneur dans `get_infos`**

Dans `get_infos`, remplacer le bloc de récupération de la durée ET le bloc d'extraction HDR10+ (les deux appels ffprobe sont fusionnés en un seul) :

Remplacer :
```python
    duration = subprocess.getoutput(f"ffprobe -v quiet -print_format json -show_format {file}")
    duration = json.loads(duration)
    duration = float(duration['format']['duration'])
    hdr10_v_cmd = f'ffmpeg -loglevel panic -i {file} -c:v copy -vbsf hevc_mp4toannexb -f hevc - | hdr10plus_parser -o metadata.json --verify -'
    hdr10_v_raw = subprocess.getoutput(hdr10_v_cmd)
    if 'metadata detected' in hdr10_v_raw:
        hdr10_cmd = f'ffmpeg -loglevel panic -i {file} -c:v copy -vbsf hevc_mp4toannexb -f hevc - | hdr10plus_parser -o /tmp/{file}_hdr10_metadata.json -'
        hdr10_cmd_res = subprocess.getoutput(hdr10_cmd)
        logging.debug(hdr10_cmd_res)
        v_infos.update({'hdr10plus': True, 'hdr10plus_metadata': f'/tmp/{file}_hdr10_metadata.json'})
```
Par :
```python
    format_data = json.loads(subprocess.getoutput(f"ffprobe -v quiet -print_format json -show_format {file}"))
    duration = float(format_data['format']['duration'])
    format_name = format_data.get('format', {}).get('format_name', '')
    is_mp4_container = 'mp4' in format_name or 'mov' in format_name
    bsf = '-vbsf hevc_mp4toannexb' if is_mp4_container else ''
    hdr10_v_cmd = f'ffmpeg -loglevel panic -i {file} -c:v copy {bsf} -f hevc - | hdr10plus_parser --verify -'
    hdr10_v_raw = subprocess.getoutput(hdr10_v_cmd)
    if 'metadata detected' in hdr10_v_raw:
        hdr10_cmd = f'ffmpeg -loglevel panic -i {file} -c:v copy {bsf} -f hevc - | hdr10plus_parser -o /tmp/{file}_hdr10_metadata.json -'
        hdr10_cmd_res = subprocess.getoutput(hdr10_cmd)
        logging.debug(hdr10_cmd_res)
        v_infos.update({'hdr10plus': True, 'hdr10plus_metadata': f'/tmp/{file}_hdr10_metadata.json'})
```

- [ ] **Étape 2 : Vérifier le parsing**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 3 : Commit**

```bash
git add vid_convert.py
git commit -m "fix: détection conteneur source pour extraction HDR10+ (MKV vs MP4)"
```

---

### Task 6 : Détection Dolby Vision

**Fichiers :**
- Modifier : `vid_convert.py` (fonction `get_infos`)

- [ ] **Étape 1 : Ajouter la détection DV après le bloc HDR10+**

Dans `get_infos`, insérer le code suivant **au niveau d'indentation de la fonction** (pas à l'intérieur du `if`), après la ligne `v_infos.update({'hdr10plus': True, ...})` et avant la ligne `infos = {'duration': duration, ...}`.

Concrètement, le code s'insère entre ces deux ancres exactes :
```python
        v_infos.update({'hdr10plus': True, 'hdr10plus_metadata': f'/tmp/{file}_hdr10_metadata.json'})
    # ← fin du bloc if 'metadata detected' (dés-indentation ici)
    infos = {'duration': duration, 'video': v_infos, 'audio': a_infos, 'subtitles': s_infos}
```

Insérer (au niveau d'indentation de la fonction, soit 4 espaces) :
```python
    try:
        for side_data in full_v_infos['frames'][0].get('side_data_list', []):
            if side_data.get('side_data_type') == 'DOVI configuration record':
                dv_profile = side_data.get('dv_profile', '?')
                logging.warning(
                    f"Dolby Vision détecté (Profile {dv_profile}). "
                    f"Encodage sans couche DV — HDR10 utilisé si disponible."
                )
                v_infos.update({'dolby_vision_profile': dv_profile})
                break
    except (KeyError, IndexError):
        pass
```

- [ ] **Étape 2 : Vérifier le parsing**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 3 : Commit**

```bash
git add vid_convert.py
git commit -m "feat: détection Dolby Vision avec avertissement (fallback HDR10)"
```

---

### Task 7 : Simplification de `create_mkv`

**Fichiers :**
- Modifier : `vid_convert.py` (fonction `create_mkv`)

- [ ] **Étape 1 : Réécrire `create_mkv` pour une seule piste vidéo**

Remplacer l'intégralité de la fonction `create_mkv` par :
```python
def create_mkv(filename):
    json_data = []
    json_data.append("--output")
    json_data.append(f"NEW_{filename}.mkv")
    video_file = f"{filename}_video.mkv"
    json_data += ["--no-track-tags", "--no-global-tags", "--no-chapters",
                  "(", video_file, ")"]
    for file in listdir():
        if f"{filename}_audio" in file:
            lang = file[-7:][:-4]
            json_data += ["--no-track-tags", "--no-global-tags", "--no-chapters",
                          "--language", f"0:{lang}",
                          "(", file, ")"]
    for file in listdir():
        if f"{filename}_subtitle" in file:
            lang = file[-7:][:-4]
            json_data += ["--no-track-tags", "--no-global-tags", "--no-chapters",
                          "--language", f"0:{lang}",
                          "(", file, ")"]
    with open(f"/tmp/{filename}.json", "w") as mkvmerge_options:
        mkvmerge_options.write(json.dumps(json_data))
    command = f"mkvmerge -v @/tmp/{filename}.json"
    logging.debug(command)
    result = subprocess.getoutput(command)
    logging.info(result)
    remove(f"/tmp/{filename}.json")
    for file in listdir():
        if file == video_file:
            remove(file)
        if f"{filename}_audio" in file:
            remove(file)
        if f"{filename}_subtitle" in file:
            remove(file)
```

- [ ] **Étape 2 : Vérifier le parsing**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 3 : Commit**

```bash
git add vid_convert.py
git commit -m "refactor: create_mkv simplifié — une seule piste vidéo, sortie NEW_{filename}.mkv"
```

---

### Task 8 : Mise à jour du flux principal (`__main__`)

**Fichiers :**
- Modifier : `vid_convert.py` (bloc `__main__`)

- [ ] **Étape 1 : Réécrire le flux principal**

Remplacer tout le contenu du bloc `__main__` à partir de `file = args.f_input` jusqu'à la fin du fichier par :
```python
    file = args.f_input
    infos = get_infos(file)
    if args.stab:
        stabilization(file)
    cropsize = cropping(file, infos)
    volumes = volume_audio(file, infos)
    enc_options = 'preset=3:tune=0'
    is_hdr = 'side_data_list' in infos['video'] or 'hdr10plus' in infos['video']
    crf = find_crf(file, enc_options, hdr=is_hdr)
    for track in infos['subtitles']:
        extract_subs(file, track['index'], track['language'])
    for track in infos['audio']:
        convert_audio(file, track['index'], volumes[track['index']], track['channels'],
                      track['channel_layout'], track['language'], track['title'])
    convert_video(file, infos, crf, cropsize, enc_options, args.interlaced, args.vhs)
    create_mkv(file)
```

Note : `tune=0` (VQ) est utilisé pour tous les contenus y compris l'animation, conformément à la spec.

- [ ] **Étape 2 : Vérifier le parsing**

```bash
python3 -c "import ast; ast.parse(open('vid_convert.py').read()); print('OK')"
```
Résultat attendu : `OK`

- [ ] **Étape 3 : Vérifier l'aide CLI**

```bash
python3 vid_convert.py --help
```
Résultat attendu : affichage des arguments `f_input`, `-d`, `-s`, `-a`, `-c`, `--interlaced` — sans `-t`.

- [ ] **Étape 4 : Commit**

```bash
git add vid_convert.py
git commit -m "feat: flux principal AV1+Opus — find_crf, encode one-pass, sortie MKV"
```

---

### Task 9 : Mise à jour du README et du CLAUDE.md

**Fichiers :**
- Modifier : `README.md`
- Modifier : `CLAUDE.md`

- [ ] **Étape 1 : Mettre à jour README.md**

Remplacer (noter l'espace de fin en fin de ligne 2 : `...avec un audio en `) :
```
vid_convert est un script qui utilise ffmpeg pour convertir des vidéos au
format [H.265](https://fr.wikipedia.org/wiki/H.265/HEVC), avec un audio en
[AAC-LC](https://fr.wikipedia.org/wiki/Advanced_Audio_Coding).
```
Par :
```
vid_convert est un script qui utilise ffmpeg pour convertir des vidéos au
format [AV1](https://fr.wikipedia.org/wiki/AV1), avec un audio en
[Opus](https://fr.wikipedia.org/wiki/Opus_(codec)).
```

Remplacer :
```
Le format de sortie est un fichier MPEG-4 (.mp4), lisible sur n'importe quel
appareil (ou presque) disposant d'une puissance de décodage suffisante.
```
Par :
```
Le format de sortie est un fichier Matroska (.mkv), optimisé pour l'archivage
de demux DVD et BluRay.
```

Remplacer la section dépendances :
```
 - [Python](https://www.python.org/) (>= 3.5)
 - [ffmpeg](https://ffmpeg.org/)
 - [hdr10plus_tool](https://github.com/quietvoid/hdr10plus_tool)
```
Par :
```
 - [Python](https://www.python.org/) (>= 3.5)
 - [ffmpeg](https://ffmpeg.org/) (avec libsvtav1 et libopus)
 - [ab-av1](https://github.com/alexheretic/ab-av1)
 - hdr10plus_parser (binaire inclus dans le dépôt)
```

- [ ] **Étape 2 : Mettre à jour CLAUDE.md — section Projet**

Remplacer :
```
Script Python standalone de conversion vidéo vers H.265/AAC-LC en conteneur MP4, avec support HDR10+, désentrelacement, détection de bandes noires, et normalisation audio.
```
Par :
```
Script Python standalone de conversion vidéo vers AV1/Opus en conteneur MKV, avec support HDR10/HDR10+/Dolby Vision (fallback HDR10), sélection automatique du CRF via ab-av1, détection de bandes noires, et normalisation audio. Cible : archivage de demux DVD/BluRay.
```

- [ ] **Étape 3 : Mettre à jour CLAUDE.md — section Utilisation**

Remplacer :
```
./vid_convert.py -t <hh:mm:ss> <fichier>  # reprendre à partir d'une position
```
Par :
```
./vid_convert.py --interlaced <fichier>    # forcer le désentrelacement (yadif)
```

- [ ] **Étape 4 : Mettre à jour CLAUDE.md — section Dépendances**

Remplacer :
```
- `ffmpeg` et `ffprobe` — encodage et extraction de métadonnées
- `mkvmerge` (MkvToolNix) — assemblage du conteneur intermédiaire
- `hdr10plus_tool` (binaire inclus : `hdr10plus_parser`) — métadonnées HDR10+
```
Par :
```
- `ffmpeg` et `ffprobe` — encodage et extraction de métadonnées (libsvtav1 et libopus requis)
- `ab-av1` — sélection automatique du CRF par VMAF
- `mkvmerge` (MkvToolNix) — assemblage du conteneur MKV final
- `hdr10plus_parser` (binaire inclus) — extraction des métadonnées HDR10+
```

- [ ] **Étape 5 : Mettre à jour CLAUDE.md — section Architecture**

Remplacer l'intégralité de la section Architecture (de la ligne `Fichier unique` jusqu'à `deux passes`) par :
```
Fichier unique : `vid_convert.py`. Flux d'exécution séquentiel :

1. **`get_infos(file)`** — ffprobe JSON → métadonnées vidéo/audio/sous-titres + détection HDR10+/DV
2. **`cropping(file, infos)`** — cropdetect FFmpeg → suppression des bandes noires
3. **`volume_audio(file, infos)`** — volumedetect FFmpeg → ajustement par piste audio
4. **`find_crf(file, enc_options, hdr)`** — ab-av1 crf-search VMAF 96 → CRF optimal
5. **`extract_subs(file, track, lang)`** — extraction des pistes de sous-titres
6. **`convert_audio(...)`** — encodage libopus VBR par piste
7. **`convert_video(...)`** — encodage libsvtav1 CRF=auto preset=3, passe unique
8. **`create_mkv(filename)`** — mkvmerge → MKV final `NEW_{filename}.mkv`

### Points clés

- Sortie vidéo : `yuv420p10le` (10 bits), HDR10 via `-svtav1-params`, HDR10+ via `hdr10plus-json`
- `find_crf` utilise le modèle VMAF HDR (`vmaf_4k_v0.6.1.json`) si disponible sur le système
- Les fichiers temporaires passent par `/tmp/` (métadonnées HDR10+, options mkvmerge JSON)
- Dolby Vision Profile 8 → fallback HDR10 automatique ; Profile 5 → avertissement
- Le filtre VHS combine `hqdn3d` + `unsharp`
- La stabilisation utilise `vidstabdetect` + `vidstabtransform` en deux passes
```

- [ ] **Étape 6 : Mettre à jour CLAUDE.md — section Gotchas**

Remplacer l'intégralité de la section Gotchas par :
```
## Gotchas

- **libsvtav1 et libopus requis** : le binaire FFmpeg doit être compilé avec `--enable-libsvtav1` et `--enable-libopus`. Vérifier avec `ffmpeg -codecs | grep -E 'svtav1|opus'`.
- **ab-av1 requis** : doit être installé et disponible dans le PATH. Voir https://github.com/alexheretic/ab-av1.
- **Fichiers temporaires orphelins** : en cas d'interruption, `{fichier}_video.mkv`, `{fichier}_audio_*.mka` et fichiers HDR10+ peuvent rester dans le répertoire courant ou `/tmp/`. Les supprimer manuellement si besoin.
- **Fichier de sortie** : `NEW_{nom_source}.mkv` généré dans le même répertoire que la source.
```

- [ ] **Étape 7 : Vérification**

```bash
grep -c "AV1\|Opus\|MKV\|ab-av1" README.md
grep -c "libsvtav1\|libopus\|ab-av1\|find_crf" CLAUDE.md
```
Résultat attendu : chaque commande retourne un entier > 0.

- [ ] **Étape 8 : Commit**

```bash
git add README.md CLAUDE.md
git commit -m "docs: mise à jour README et CLAUDE.md pour AV1+Opus+MKV"
```