# PDS Batch Exporter

PDS Batch Exporter est une application Windows WPF destinee a automatiser l'export en masse de projets CyberLink PowerDirector `.pds`.

Le logiciel ne convertit jamais les fichiers `.pds` lui-meme. Il pilote PowerDirector comme un operateur humain via Windows UI Automation, raccourcis clavier, detection de fenetres, gestion de popups, watchdog, logs, captures et rapports.

## Etat de cette livraison

Cette version valide le workflow terrain `1 projet .pds -> 1 video exportee` avec PowerDirector reel. Le test confirme a produit le statut `Completed` sur `F:\STREAMING\30p\Agay, Dramont, Antheor streaming UHD.pds`, avec source `.pds` inchangee, video creee et validee, detection UI de fin d'export et fermeture propre de la fenetre `Exporter`.

Elle fournit :

- selection de `PDR.exe`, dossier source et dossier de sortie ;
- scan des `.pds`, recursif ou non ;
- queue persistante dans `jobs/queue_state.json` ;
- etats de jobs complets ;
- lancement ou rattachement a PowerDirector ;
- ouverture des projets `.pds` ;
- gestion defensive des popups courants ;
- execution d'etapes UI configurees sans modification du profil video PowerDirector ;
- surveillance du fichier de sortie ;
- pause, reprise, stop apres projet courant, arret immediat ;
- logs de session ;
- rapports Markdown, HTML et JSON ;
- captures d'ecran et dump UI Automation en cas d'erreur.
- mode batch confirme controle, limite a 3 projets maximum.

Les etapes exactes de chemin de sortie et bouton de demarrage doivent etre calibrees sur l'installation PowerDirector locale, car les noms UI changent selon version, langue, abonnement, popups CyberLink et disposition de l'interface. Le profil video n'est pas calibre ni modifie par PDS Batch Exporter.

## Profil d'export PowerDirector

PDS Batch Exporter ne configure pas le profil video PowerDirector.

Le logiciel utilise le profil actuellement selectionne dans PowerDirector. Avant de lancer un batch, l'operateur doit ouvrir PowerDirector et verifier le profil souhaite : format, codec, resolution, frequence et debit.

PDS Batch Exporter se charge ensuite uniquement d'ouvrir les projets, renseigner le dossier de sortie, renseigner le nom du fichier, lancer l'export et surveiller la creation des fichiers MP4.

Configuration associee :

```json
"PowerDirectorProfileMode": "UseCurrentPowerDirectorProfile",
"AllowProfileChangeFromApp": false
```

Les rapports indiquent explicitement que le profil n'a pas ete modifie par l'application. Pour changer le profil d'export, ouvrez PowerDirector manuellement, choisissez le profil souhaite, puis relancez le batch.

## Version portable

Une archive portable autonome est fournie : `outputs\PDSBatchExporter_Portable_v1.1.0.zip`.

Cette version fonctionne sans installation et stocke ses donnees dans son propre dossier `data`. Le fichier `portable.mode`, place a cote de `PDS Batch Exporter.exe`, active automatiquement le mode portable. Les logs, rapports, diagnostics, captures et la configuration utilisateur sont alors ecrits dans `data\logs`, `data\reports`, `data\diagnostics`, `data\screenshots` et `data\config`, sans melange avec `%LocalAppData%`.

Le mode installe conserve le comportement standard et ecrit dans `%LocalAppData%\PDS Batch Exporter`.

## Compilation

Prerequis :

- Windows 10/11 ;
- Visual Studio 2022 avec workload ".NET desktop development" ou SDK .NET compatible ;
- CyberLink PowerDirector installe.

Commande attendue si le SDK est installe :

```powershell
dotnet build .\PDSBatchExporter.csproj -c Release
```

Build validee sur cette machine avec `C:\Program Files\dotnet\dotnet.exe` :

```text
La generation a reussi.
0 Avertissement(s)
0 Erreur(s)
```

## Compilation avec dotnet hors PATH

Le shell Codex de cette machine ne voit pas toujours `dotnet` via `%PATH%`. Les scripts utilisent donc explicitement :

```text
C:\Program Files\dotnet\dotnet.exe
```

Scripts fournis :

```bat
build_release.bat
publish_win_x64.bat
```

Commandes equivalentes :

```powershell
& 'C:\Program Files\dotnet\dotnet.exe' restore .\PDSBatchExporter.csproj
& 'C:\Program Files\dotnet\dotnet.exe' build .\PDSBatchExporter.csproj -c Release
& 'C:\Program Files\dotnet\dotnet.exe' publish .\PDSBatchExporter.csproj -c Release -r win-x64 --self-contained true
```

La publication livree est self-contained afin de fonctionner meme si le runtime .NET 8 Desktop n'est pas installe sur la machine cible.

## Icone application

L'icone officielle de l'application est `PDSBatchExporter.ico`, placee a la racine du projet WPF, au meme niveau que `PDSBatchExporter.csproj`.

Elle est configuree pour :

- l'executable `PDS Batch Exporter.exe` via `ApplicationIcon`;
- la fenetre principale WPF via `Icon="PDSBatchExporter.ico"`;
- la publication win-x64, avec copie du fichier `.ico`;
- l'installateur Inno Setup via `SetupIconFile`;
- les raccourcis menu Demarrer et bureau via `IconFilename`.

Si Windows affiche encore une ancienne icone apres installation, supprimer/recreer le raccourci ou redemarrer l'Explorateur Windows afin de vider le cache d'icones.

## Internationalisation V1.1

PDS Batch Exporter prend en charge cinq langues dans l'interface :

- `fr-FR` : Francais
- `en-US` : English
- `es-ES` : Espanol
- `it-IT` : Italiano
- `de-DE` : Deutsch

La configuration contient :

```json
"Language": "auto",
"SupportedLanguages": ["fr-FR", "en-US", "es-ES", "it-IT", "de-DE"],
"PowerDirectorLanguage": "auto"
```

Au premier lancement, `auto` utilise la langue Windows si elle est supportee, sinon `fr-FR`. Le choix utilisateur est memorise dans `%LocalAppData%\PDS Batch Exporter\config.json`.

L'interface principale propose deux selecteurs :

- `Langue` : langue de PDS Batch Exporter.
- `Langue PowerDirector` : dictionnaire utilise pour reconnaitre les textes PowerDirector. Cette langue est separee de celle de l'application, car PowerDirector peut etre installe dans une autre langue.

Les fichiers de traduction sont dans `Localization/*.json`. Si une cle manque, le fallback est :

1. `fr-FR`
2. `en-US`
3. `[MissingKey]`

Les statuts internes restent stables dans les fichiers JSON et les rapports techniques, par exemple `BatchCompleted`, `ProjectLoadFailed` ou `SkippedExistingValidExport`. L'interface affiche leur traduction utilisateur.

## Mode diagnostic export 1 projet

Depuis l'interface, cliquer sur `Tester export 1 projet`, choisir un `.pds`, puis un dossier de sortie.

En ligne de commande :

```powershell
& '.\PDS Batch Exporter.exe' --diagnostic-powerdirector --pds 'C:\chemin\test.pds' --output 'C:\sortie'
```

Sans `--pds`, le mode diagnostic lance PowerDirector, detecte les fenetres, capture l'ecran, dump l'arbre UI Automation et produit `reports/export_one_project_test.md`, mais n'essaie pas l'export reel.

## Test reel controle F:\STREAMING\30p

Protections par defaut :

- `SourceReadOnly=true`
- `NeverSaveSourceProjects=true`
- `AlwaysAnswerDontSaveOnClose=true`
- `BlockDeleteMoveRenameInSourceFolder=true`
- `KillPowerDirectorOnExit=false`
- `OutputFolder=F:\STREAMING\EXPORTS_PDS_BATCH\30p`

Dry-run scan sans modification :

```powershell
& '.\PDS Batch Exporter.exe' --scan-source 'F:\STREAMING\30p'
```

Test controle sur le premier `.pds` uniquement :

```powershell
& '.\PDS Batch Exporter.exe' --test-export-one 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p'
```

Calibration Produire / Exporter sans lancer le rendu :

```powershell
& '.\PDS Batch Exporter.exe' --calibrate-export 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p'
```

Calibration avec fallback BoundingRectangle explicitement autorise :

```powershell
& '.\PDS Batch Exporter.exe' --calibrate-export 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --allow-safe-bounds-click
```

Par defaut `AllowSafeBoundingRectangleClick=false` et `SafeClickRequiresExplicitCliFlag=true`. Le fallback ne clique jamais sur des coordonnees fixes : il utilise uniquement le `BoundingRectangle` du controle UI Automation detecte, apres validation de la whitelist, de la fenetre active, du rectangle, de la visibilite et de l'etat active du controle.

Calibration de l'ecran Produce Dialog, sans lancer le rendu final :

```powershell
& '.\PDS Batch Exporter.exe' --calibrate-produce-dialog 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --allow-safe-bounds-click
```

Ce mode atteint Produce Dialog avec le fallback deja valide, puis ne fait plus que capturer, dumper et classifier les controles. Les boutons Start/Demarrer/Produce/Export final sont marques `DANGEROUS_FINAL_RENDER_BUTTON` et ne sont jamais actives.

Calibration du chemin de sortie dans Produce Dialog, sans lancer le rendu final :

```powershell
& '.\PDS Batch Exporter.exe' --calibrate-output-path 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --allow-safe-bounds-click
```

Ce mode ouvre uniquement le premier `.pds`, atteint Produce Dialog avec le clic BoundingRectangle deja valide, detecte les champs `AutomationId=29727` et `AutomationId=29728`, renseigne le nom de fichier `NomDuProjet.mp4` et le dossier de sortie, relit les valeurs, puis verifie qu'aucun rendu n'a demarre, qu'aucun fichier video n'a ete cree et que le `.pds` source est inchange. Il ne clique jamais sur le bouton final `Exporter` / `AutomationId=29678`.

Livrables produits par ce mode :

- `reports/calibrate_output_path.md`
- `screenshots/output_path_before.png`
- `screenshots/output_path_after.png`
- `diagnostics/ui_tree_output_path_before.json`
- `diagnostics/ui_tree_output_path_after.json`

Export reel confirme d'un seul projet, avec refus par defaut du clic final :

```powershell
& '.\PDS Batch Exporter.exe' --export-one-confirmed 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --allow-safe-bounds-click
```

Cette commande atteint Produce Dialog, renseigne les champs de sortie et genere `reports/export_one_confirmed.md`, mais refuse d'activer le bouton final `Exporter` tant que `--confirm-final-render` est absent.

Export reel confirme avec lancement du rendu final :

```powershell
& '.\PDS Batch Exporter.exe' --export-one-confirmed 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --allow-safe-bounds-click --confirm-final-render
```

Ce mode ne modifie pas le profil PowerDirector. Il lance le rendu seulement si les champs de sortie `AutomationId=29727` et `AutomationId=29728` sont relus avec les valeurs attendues, si le bouton final `AutomationId=29678` est detecte, et si `--confirm-final-render` est present. Si un fichier MP4 valide existe deja pour le projet, le mode par defaut `SkipExistingValidExports` ignore le projet sans creer de doublon.

Pendant le rendu, l'attente ne depend pas uniquement du fichier de sortie. Le logiciel surveille aussi la fenetre PowerDirector `Exporter` et considere l'export termine si au moins deux signaux UI sont presents :

- texte `Production terminee !`
- progression `100%`
- `Temps restant 00:00:00`

Quand ces signaux sont detectes, l'attente s'arrete proprement, une capture de fin est generee, puis le fichier video est valide dans le dossier de sortie. Le rapport indique le texte detecte, la progression, le temps restant, le temps ecoule et le resultat de validation du fichier.

Une fois l'export termine et valide, le logiciel tente de fermer proprement la fenetre PowerDirector `Exporter` avant de continuer le workflow. Cette fermeture ramene PowerDirector hors de la fenetre de progression/export.

La fermeture est encadree par des garde-fous stricts : elle n'est tentee que si `Production terminee !`, `100%` et `Temps restant 00:00:00` sont detectes dans la fenetre `Exporter`. Le logiciel utilise d'abord le bouton de fermeture UI Automation si disponible, puis un fallback BoundingRectangle limite a la zone de la croix de cette fenetre. Il n'utilise jamais Alt+F4 global et ne tue pas PowerDirector. Si la fermeture echoue, le rapport marque seulement `ExportCompletedButExporterWindowStillOpen`.

Pour tester uniquement la fermeture d'une fenetre `Exporter` deja terminee :

```powershell
& '.\PDS Batch Exporter.exe' --close-exporter-after-completion 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p'
```

Ce test ne lance aucun export et met a jour `reports/export_one_confirmed.md` avec la methode de fermeture, l'etat de la fenetre `Exporter`, l'etat du fichier video et la verification du `.pds` source.

Le workflow 1 projet est considere valide sur cette machine avec ces garanties observees :

- `JobStatus=Completed`
- `.pds` source inchange
- fichier video unique cree sans ecraser l'existant
- fichier video valide et superieur a 10 Mo
- fin d'export detectee via l'interface PowerDirector
- fenetre `Exporter` fermee proprement
- PowerDirector principal preserve
- `Failed=False`, `Timeout=False`, `CancelledByUser=False`, `StoppedByUser=False`

PowerDirector peut ouvrir une boite Windows parasite `Selectionner un dossier` pendant le flux. Elle est maintenant connue dans `PopupHandler` et fermee uniquement si elle est detectee comme dialogue `#32770` du processus `PDR`, nomme `Selectionner un dossier`, contenant le bouton `Annuler`, et sans controles Produce Dialog `AutomationId=29727/29728`. Le logiciel ne ferme pas une vraie fenetre utile PowerDirector avec cette regle.

Test dedie popup parasite :

```powershell
& '.\PDS Batch Exporter.exe' --test-folder-picker-popup
```

Rapport produit :

- `reports/folder_picker_popup_test.md`

Mode batch confirme controle, limite a 50 projets maximum :

```powershell
& '.\PDS Batch Exporter.exe' --export-batch-confirmed 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --max-projects 50 --file-size-check-seconds 60 --output-stable-confirm-minutes 2 --max-no-file-growth-minutes 10 --max-render-minutes 120 --allow-safe-bounds-click --confirm-final-render
```

Le batch applique les memes garde-fous que le mode 1 projet pour chaque `.pds` : snapshot source avant/apres, nom video unique, dossier de sortie verifie, lancement du rendu final seulement avec `--confirm-final-render`, detection de fin via UI PowerDirector, validation video, fermeture de la fenetre `Exporter`, tentative de fermeture projet sans enregistrer, puis passage au projet suivant.

Chargement projet robuste : avant l'export, le logiciel applique `ProjectLoadRetry`. `MaxProjectLoadAttempts` vaut 3 par defaut et `ProjectLoadRetryDelaySeconds` vaut 5. Si un `.pds` ne se charge pas, PowerDirector est verifie repondant, les popups connues sont fermees, l'etat UI est relu, puis l'ouverture est retentee. La methode principale lance directement `PDR.exe` avec le chemin du projet `.pds` en argument. L'ouverture via association Windows du `.pds` n'est gardee qu'en dernier recours, car elle peut declencher des dialogues parasites. Chaque echec de tentative genere capture et dump UI.

Pendant le chargement d'un projet existant, la boite `Selectionner un dossier` ne doit pas s'ouvrir. Si elle apparait, le logiciel la ferme par `Annuler`, considere la tentative comme invalide pour le chargement du `.pds`, journalise l'anomalie, capture l'ecran, dumpe l'UI et retente avec la strategie suivante. Cette boite n'est donc plus traitee comme une etape normale du chargement projet.

La validation du chargement compare maintenant le titre PowerDirector et le nom `.pds` sous forme normalisee : accents, `&`, ponctuation et espaces multiples sont ignores. Par exemple, `Calern  Haut Montet Streaming UHD` est reconnu comme projet charge pour `Calern & Haut Montet Streaming UHD.pds`. Si ce titre normalise est deja visible, le logiciel ne relance pas une nouvelle ouverture du `.pds`.

Si PowerDirector affiche pendant le chargement une popup d'erreur de type `fichier non trouve`, `fichier introuvable`, `missing file`, `media source` ou media introuvable, le logiciel ne tente pas d'atteindre le bouton `Exporter`. Il clique uniquement sur `Annuler`. Comme PowerDirector peut afficher une popup par fichier manquant, le logiciel draine la serie de popups similaires, jusqu'a 25 annulations maximum par projet, puis attend une courte periode sans nouvelle popup. Il capture l'ecran, dumpe l'UI, ferme le projet courant sans enregistrer, marque le projet en `ProjectLoadFailed` isole avec `ProjectLoadErrorPopupDetected=True`, indique `ProjectLoadErrorPopupCancelCount`, puis passe au projet suivant si PowerDirector est sain.

Regle finale `ProjectLoadFailed` isole : apres epuisement des tentatives, seul le projet courant est marque `ProjectLoadFailed`. Ce statut ne provoque jamais `Failed` global, ne stoppe pas tout le batch, ne genere pas de cascade, ne modifie/enregistre/deplace/supprime jamais le `.pds`, et ne supprime aucune video existante. Le batch passe au projet suivant si PowerDirector est sain. Les projets concernes sont listes dans la section `A traiter manuellement` du rapport batch avec la cause, la capture et le dump UI.

Projets actuellement connus comme non chargeables automatiquement apres retry et a traiter manuellement :

- `F:\STREAMING\30p\Belvedere de la Dent d'aire & Point Sublime Streaming UHD.pds`
- `F:\STREAMING\30p\Calern & Haut Montet Streaming UHD.pds`

Test cible sans export :

```powershell
& '.\PDS Batch Exporter.exe' --test-load-project "F:\STREAMING\30p\Belvedere de la Dent d'aire & Point Sublime Streaming UHD.pds"
& '.\PDS Batch Exporter.exe' --test-load-project "F:\STREAMING\30p\Calern & Haut Montet Streaming UHD.pds"
```

Options utiles :

```powershell
--max-project-load-attempts 3 --project-load-retry-delay-seconds 5
```

Le test de chargement ne lance pas Produce, ne lance pas l'export, ne modifie pas le `.pds`, ne supprime aucune video et ne tue pas PowerDirector. Il produit un rapport `reports/test_load_project_*.md`.

Avant de demarrer chaque projet apres le premier, le logiciel execute `EnsurePowerDirectorReadyForNextProject()`. Cette verification interdit les erreurs en cascade : la fenetre `Exporter` doit etre absente, aucune fin de production ne doit rester visible, PowerDirector principal doit etre present et repondant, aucune popup parasite connue ne doit bloquer, et les controles de base necessaires au projet suivant doivent etre retrouvables.

Apres chaque export valide, `CloseExporterWindowWithRetries()` effectue jusqu'a 3 fermetures douces de la fenetre `Exporter`, avec capture avant/apres et dump UI en cas d'echec. Il n'utilise pas Alt+F4 global, ne ferme pas la fenetre principale PowerDirector et ne tue jamais PowerDirector. Si l'etat PowerDirector reste non sain, le batch s'arrete proprement en `BatchStoppedForUnsafePowerDirectorState`, marque les projets restants en `SkippedDueToUnsafePowerDirectorState`, conserve les videos deja creees et evite les erreurs en cascade.

Etat intermediaire `RenderFinalizing` : si PowerDirector affiche `100%` et `Temps restant 00:00:00` mais indique encore `En production`, le logiciel ne ferme pas immediatement la fenetre `Exporter`. Il attend par tranches de 10 secondes, jusqu'a 180 secondes par defaut, en surveillant l'apparition de `Production terminee !`, la disparition de `En production`, la stabilite du fichier video pendant 30 secondes, le deverrouillage du fichier et la reponse de PowerDirector. La fermeture de `Exporter` n'est tentee qu'apres cette finalisation ou apres validation explicite du fichier video stable/non verrouille.

Limite de duree de rendu par projet : `MaxRenderDurationMinutes` vaut 120 par defaut dans `config.json` et peut etre surcharge par `--max-render-minutes 120`. Si un rendu depasse cette limite, le logiciel n'annule plus automatiquement l'export et ne clique jamais sur `Oui` dans une popup d'annulation. Le batch s'arrete proprement avec `RenderDurationLimitReached` / `BatchStoppedDueToRenderTooLong`, conserve tout fichier partiel eventuel, ne modifie pas le `.pds` source et demande une verification manuelle PowerDirector.

Controle principal par croissance du fichier video : `RenderFileSizeCheckIntervalSeconds` vaut 60 par defaut et peut etre surcharge par `--file-size-check-seconds 60`. `OutputStableConfirmMinutes` vaut 2 par defaut, soit `OutputStableConfirmSeconds=120`. La valeur peut etre surchargee en minutes avec `--output-stable-confirm-minutes 2` ou plus finement en secondes avec `--output-stable-confirm-seconds 45`. `MaxNoFileGrowthMinutes` vaut 10 par defaut et peut etre surcharge par `--max-no-file-growth-minutes 10`. Les anciens alias `--progress-check-seconds` et `--max-no-progress-minutes` restent acceptes, mais la logique prioritaire est la taille du fichier de sortie.

Pendant l'export, tant que le fichier video grandit entre deux controles, le rendu est considere `RenderInProgress`, meme si l'UI PowerDirector affiche deja `100%`. Chaque controle prend une capture dans `screenshots/progress/` et journalise l'heure, la taille precedente, la taille courante, le delta et la vitesse moyenne approximative. Si le fichier devient stable, le logiciel entre en `OutputFileStableCandidate` et attend `OutputStableConfirmSeconds`; il ne marque `RenderCompleted` que si le fichier existe, fait plus de 10 Mo, est stable, non verrouille, et si PowerDirector confirme `100%` + `Temps restant 00:00:00` via UI Automation. Le texte `Production terminee !` est utilise comme signal positif supplementaire, mais `100%` seul ou `Temps restant 00:00:00` seul ne suffit jamais.

Surveillance du debit MP4 : `RenderThroughputMonitoringEnabled=true` active le calcul du debit instantane, du debit moyen et de la moyenne glissante d'ecriture du fichier. Les options CLI sont `--throughput-monitoring true`, `--throughput-check-seconds 60`, `--throughput-warmup-minutes 3`, `--max-throughput-multiplier 2.0`, `--throughput-anomaly-consecutive-checks 2` et `--restart-powerdirector-after-throughput-anomaly`. Pendant le warmup et avant `MinThroughputSamples`, aucune anomalie n'est declenchee. Un pic unique ne suffit pas. Si deux controles consecutifs depassent le multiplicateur configure et que la fin normale n'est pas deja confirmee par fichier stable + UI `100%` + `00:00:00`, le projet est marque `RenderThroughputAnomalyStopped`, le fichier partiel est conserve, le `.pds` source reste inchange, PowerDirector est redemarre si l'option explicite est active, puis le batch passe au projet suivant si l'etat est sain.

## Profilage performance et optimisation des temps morts

`PerformanceMode` vaut `Safe` par defaut dans `config.json`. Les modes disponibles sont :

- `Conservative` : conserve les delais les plus prudents.
- `Safe` : remplace les attentes fixes inutiles par des boucles conditionnelles courtes, tout en gardant les garde-fous.
- `FastButGuarded` : poll plus rapide, reserve aux tests valides.

Option CLI :

```powershell
& '.\PDS Batch Exporter.exe' --export-batch-confirmed 'F:\STREAMING\30p' --output 'D:\UHD_H264' --allow-safe-bounds-click --confirm-final-render --existing-output-mode SkipExistingValidExports --performance-mode Safe
```

Le batch mesure maintenant les timestamps suivants pour chaque projet : `ProjectLoadStart`, `ProjectLoaded`, `ProduceDialogRequested`, `ProduceDialogReady`, `OutputPathConfigured`, `FinalExportClicked`, `FirstOutputFileDetected`, `FirstFileGrowthDetected`, `OutputStableCandidate`, `RenderCompletedByFileAndUi`, `ExporterWindowClosed`, `PowerDirectorReadyForNextProject` et `NextProjectStarted`.

Les rapports affichent les durees derivees : chargement projet, ouverture Produce Dialog, configuration sortie, latence de lancement export, rendu, finalisation, fermeture Exporter, retour a l'etat sain, trou inter-projet et duree totale projet. Un rapport dedie est genere :

- `reports/performance_batch_report.md`
- `reports/performance_batch_report.json`

Les optimisations restent conditionnelles : le logiciel continue des qu'une condition sure est vraie, mais ne passe jamais au projet suivant si PowerDirector n'est pas confirme sain, si la fenetre `Exporter` est encore active, si une popup bloque, ou si le fichier video n'est pas valide.

Si aucun fichier n'est cree apres le delai de demarrage raisonnable, le projet est marque `OutputFileNotCreated`. Avant de conclure a cette erreur, le logiciel cherche aussi un MP4 recent correspondant au nom du projet dans les dossiers de sortie connus, dont le dossier relu dans l'interface PowerDirector et le dossier terrain `F:\STREAMING\EXPORTS_PDS_BATCH\30p`. Si PowerDirector a bien exporte mais dans un autre dossier que celui demande, le projet est marque `OutputCreatedOutsideRequestedFolder` et le batch s'arrete proprement sans cascade. Le rapport indique le fichier reel detecte et recommande de corriger le champ dossier de sortie ou d'utiliser le bouton PowerDirector `Aller au dossier` pour confirmer le chemin. Si le fichier existe mais ne grandit plus pendant `MaxNoFileGrowthMinutes` sans confirmation UI de fin, le projet est marque `RenderNoFileGrowthDetected`, le batch s'arrete en `BatchStoppedDueToNoFileGrowth`, les projets suivants sont marques `SkippedDueToNoFileGrowth`, aucun fichier partiel n'est supprime et PowerDirector n'est pas tue.

Fin de batch : `ClosePowerDirectorAtBatchEnd=true` par defaut. Quand tous les projets sont couverts et qu'aucun rendu actif n'est detecte, le logiciel tente de fermer PowerDirector proprement. Si PowerDirector reste ouvert alors qu'aucune fenetre `Exporter`, aucun etat `En production`, aucune pause et aucune popup d'annulation ne sont visibles, `SafeKillPowerDirectorAtBatchEnd=true` autorise un kill final de `PDR.exe`. Cette fermeture finale est refusee si un rendu ou une popup d'annulation est encore detecte. Le rapport indique si la fermeture douce a ete envoyee, si PowerDirector a ete ferme, et si un kill final a ete necessaire.

Popup annulation export : la popup PowerDirector `Etes-vous sur de vouloir annuler ?` est traitee comme popup connue. Le logiciel ne clique jamais `Oui`; il repond uniquement `Non`. Si `Production en pause` ou le bouton `Reprendre` est visible, il tente une reprise par le controle UI Automation `Reprendre` avant toute fermeture. `CloseExporterWindowAfterCompletion()` refuse toujours de fermer `Exporter` tant que `Production en pause`, `Reprendre` ou la popup d'annulation sont visibles.

Popup mise a jour PowerDirector au demarrage : si PowerDirector affiche une demande de mise a jour de type `Voulez-vous mettre a jour PowerDirector ?`, le logiciel la traite comme popup connue distincte. C'est la seule exception ou le bouton `Oui` est autorise : il clique `Oui` uniquement si le texte mentionne PowerDirector/CyberLink et une mise a jour, puis attend la disparition de la popup ou la fin de l'installeur avant de reprendre le batch. Cette exception ne s'applique jamais aux popups d'annulation d'export, de remplacement de fichier, de dossier manquant ou d'erreur de chargement projet.

Recovery etat PowerDirector herite, avant batch :

```powershell
& '.\PDS Batch Exporter.exe' --recover-powerdirector-state 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p'
```

Ce mode est separe du batch. Il detecte PowerDirector, la fenetre `Exporter`, `Production terminee !`, `Production en pause`, `En production...`, `100%`, `Temps restant 00:00:00`, le bouton `Reprendre` et la popup `Etes-vous sur de vouloir annuler ?`. Il repond uniquement `Non` a la popup d'annulation, tente `Reprendre` au maximum 3 fois avec 10 secondes entre les tentatives, puis demande une action manuelle si PowerDirector reste bloque. Il ne tue pas PowerDirector, ne supprime aucune video et ne modifie aucun `.pds`.

Option explicite reservee aux cas valides :

```powershell
& '.\PDS Batch Exporter.exe' --recover-powerdirector-state 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --force-close-exporter-after-valid-output
```

Cette option n'est acceptee que si la video existe, fait plus de 10 Mo, est stable, non verrouillee, et si `100%` + `Temps restant 00:00:00` sont detectes. Meme avec ce flag, `Oui` n'est jamais clique; si une popup d'annulation apparait, le logiciel clique `Non` et stoppe.

Reprise intelligente actuellement active : `ExistingOutputMode = SkipExistingValidExports` par defaut. Avant chaque export, le logiciel cherche dans le dossier de sortie un MP4 correspondant au nom de base du projet : `NomProjet.mp4`, `NomProjet_001.mp4`, `NomProjet_002.mp4`, etc. Si au moins un MP4 existe, fait plus de 10 Mo, n'est pas verrouille et possede une date de modification valide, le projet est considere deja exporte.

Dans ce mode par defaut, le projet est marque `SkippedExistingValidExport`, le MP4 existant est conserve comme preuve, aucun nouveau suffixe `_001`, `_002`, `_003` n'est cree, PowerDirector n'est pas relance pour ce projet, et le batch passe au projet suivant. Ce comportement evite les reexports inutiles sur les gros batchs.

Modes de sortie disponibles :

- `SkipExistingValidExports` : mode par defaut et recommande; ignore les projets deja exportes.
- `ReexportWithUniqueName` : cree volontairement un nouveau nom unique, uniquement avec l'option CLI `--reexport-with-unique-name`.
- `ReplaceExisting` : mode dangereux, uniquement avec `--replace-existing --confirm-replace-existing`.
- `AskEachTime` : reserve a l'interface graphique.

Commande batch par defaut :

```powershell
& '.\PDS Batch Exporter.exe' --export-batch-confirmed 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --max-projects 50 --allow-safe-bounds-click --confirm-final-render --file-size-check-seconds 60 --output-stable-confirm-seconds 45 --max-no-file-growth-minutes 10 --max-render-minutes 120
```

Commande de reexport volontaire avec nom unique :

```powershell
& '.\PDS Batch Exporter.exe' --export-batch-confirmed 'F:\STREAMING\30p' --output 'F:\STREAMING\EXPORTS_PDS_BATCH\30p' --max-projects 50 --reexport-with-unique-name --allow-safe-bounds-click --confirm-final-render
```

Le rapport batch ajoute `ExistingOutputMode`, `ExistingValidExportsDetected`, `SkippedExistingValidExportCount`, `ReexportedBecauseUserRequestedCount`, `ReplacedExistingCount` et `ExistingExportFileUsedAsProof`. Pour chaque projet ignore, il indique le fichier MP4 detecte, sa taille, sa date de modification et la raison `MP4 deja present et valide`.

Rapport produit :

- `reports/export_batch_confirmed_N.md`, par exemple `reports/export_batch_confirmed_10.md`

Statuts batch :

- `BatchCompleted` si les projets demandes sont exportes.
- `BatchCompletedWithErrors` si un ou plusieurs projets echouent mais que la file continue.
- `BatchStoppedForUnsafePowerDirectorState` si PowerDirector ne revient pas dans un etat sain apres un export valide.
- `BatchStoppedDueToRenderTooLong` si un projet depasse `MaxRenderDurationMinutes`; ce n'est pas un `Failed` global brutal.
- `BatchStoppedDueToNoFileGrowth` si le fichier video ne grandit plus pendant `MaxNoFileGrowthMinutes` sans confirmation UI de fin; ce n'est pas un `Failed` global brutal.
- `BatchStoppedDueToOutputFileNotCreated` si aucun fichier video de sortie n'est cree apres le delai de demarrage.
- `BatchStoppedDueToOutputCreatedOutsideRequestedFolder` si PowerDirector cree le MP4 dans un autre dossier que celui demande; verifier `Aller au dossier` et corriger le champ dossier de sortie avant reprise.
- `BatchStoppedDueToNoRenderProgress` reste affiche seulement pour compatibilite avec les anciens rapports.
- Pas de `Failed` global pour une erreur isolee projet.

Livrables produits par ce mode :

- `reports/export_one_confirmed.md`
- `screenshots/export_one_before_final_click.png`
- `screenshots/export_one_after_final_click.png`
- `screenshots/export_one_render_progress.png` si possible
- `screenshots/export_one_finished.png` si possible
- `diagnostics/ui_tree_export_one_before_final_click.json`
- `diagnostics/ui_tree_export_one_after_final_click.json`
- `diagnostics/ui_tree_export_one_finished.json` si possible

Le logiciel refuse de lancer si le dossier de sortie est identique au dossier source, ou si le dossier de sortie est un sous-dossier du dossier source. Les rapports produits sont :

- `reports/source_scan_F_STREAMING_30p.md`
- `reports/export_one_project_real_F_STREAMING_30p.md`
- `reports/calibrate_export_powerdirector.md`
- `reports/calibrate_output_path.md`
- `reports/export_one_confirmed.md`

## Version installable Windows

La version publiee est autonome `win-x64 self-contained`: aucun runtime .NET separe n'est requis sur la machine cible.

Publication :

```powershell
cmd /c publish_win_x64.bat
```

Commande equivalente :

```powershell
& 'C:\Program Files\dotnet\dotnet.exe' publish -c Release -r win-x64 --self-contained true
```

Le dossier publie est `publish/win-x64` et contient notamment `PDS Batch Exporter.exe`, `config.json`, `profiles.json` et `README.md`.

Les donnees utilisateur ne sont pas stockees dans `Program Files`. Au premier lancement, l'application cree automatiquement :

- `%LocalAppData%\PDS Batch Exporter\logs`
- `%LocalAppData%\PDS Batch Exporter\reports`
- `%LocalAppData%\PDS Batch Exporter\diagnostics`
- `%LocalAppData%\PDS Batch Exporter\screenshots`

Installateur Inno Setup :

```powershell
& 'C:\Program Files (x86)\Inno Setup 6\ISCC.exe' 'installer\PDSBatchExporter_Setup.iss'
```

Livrable genere :

- `outputs/PDSBatchExporter_Setup_v1.0.0.exe`

L'installateur installe l'application dans `{autopf}\PDS Batch Exporter`, cree un raccourci Menu Demarrer et propose un raccourci Bureau optionnel. Si une ancienne instance est ouverte, il tente une fermeture douce de la fenetre `PDS Batch Exporter`; si elle reste ouverte, il demande une fermeture manuelle. Il ne tue pas brutalement l'application par defaut.

## Interface graphique principale

Sans argument, `PDS Batch Exporter.exe` ouvre directement l'interface graphique. L'utilisateur peut choisir le dossier des projets `.pds`, choisir le dossier de sortie, analyser les projets, voir les MP4 existants valides, choisir le mode fichiers existants, decocher des projets, lancer le batch confirme, suivre la progression globale et ouvrir le rapport final.

Le mode par defaut reste `SkipExistingValidExports`: si un MP4 valide existe deja pour un projet, ce projet est ignore et n'est pas reexporte.

Le dossier de sortie choisi par l'utilisateur est la destination obligatoire du batch. Avant chaque rendu, le logiciel reecrit le champ `Dossier` de PowerDirector par saisie interactive securisee, relit la valeur affichee, puis refuse de continuer si PowerDirector semble encore utiliser un dossier herite. Si PowerDirector demande de remplacer un fichier alors qu'aucun MP4 correspondant n'existe dans le dossier choisi, le logiciel repond `Non`, conserve les fichiers existants et arrete proprement le batch pour diagnostic.

## Version installable V1 validee

`PDS Batch Exporter v1.0.0` est valide comme version Windows installable et autonome.

Points valides :

- lancement sans ligne de commande : double-clic sur `PDS Batch Exporter.exe`, raccourci Bureau ou Menu Demarrer;
- selection du dossier source contenant les projets PowerDirector `.pds`;
- selection manuelle du dossier de sortie des videos;
- analyse des MP4 deja existants dans le dossier de sortie;
- mode par defaut `SkipExistingValidExports`;
- aucun doublon `_001`, `_002`, `_003` recree par defaut si un MP4 valide existe deja;
- grille de preview avec projets cochables/decochables;
- progression globale pendant le batch;
- affichage du projet et du fichier video en cours d'export;
- rapports, logs, diagnostics et captures stockes dans `%LocalAppData%\PDS Batch Exporter`;
- protection des `.pds` source: pas de modification, pas de deplacement, pas de suppression, pas d'enregistrement;
- installateur `PDSBatchExporter_Setup_v1.0.0.exe` genere par Inno Setup.

Livrables V1 :

- `outputs/PDSBatchExporter_Setup_v1.0.0.exe`
- `outputs/PDSBatchExporter_win-x64_publish.zip`
- `outputs/PDSBatchExporter_source.zip`
- `RELEASE_NOTES_v1.0.0.md`
- `reports/test_gui_installable.md`
- `reports/test_inno_setup.md`

## Utilisation

1. Ouvrir l'application.
2. Verifier le chemin PowerDirector, detecte ici comme `C:\Program Files\CyberLink\PowerDirector\24.5.1707.1\PDR.exe`.
3. Choisir le dossier source contenant les `.pds`.
4. Choisir le dossier de sortie.
5. Verifier dans PowerDirector que le profil d'export souhaite est deja selectionne.
6. Cliquer sur `Scanner .pds`.
7. Cliquer sur `Lancer`.

Par defaut, l'application ne modifie pas les `.pds` originaux et repond de maniere conservative aux popups de sauvegarde.

## Calibration PowerDirector

Modifier `profiles.json` pour ajouter les etapes UI reelles :

- `Invoke` : invoque un controle par `ControlName` ou `AutomationId`.
- `InvokeAny` : tente plusieurs libelles courants.
- `SendKeys` : envoie un raccourci clavier Windows Forms.
- `SetFocus` : donne le focus a un controle.

Variables disponibles dans les etapes :

- `{ProjectPath}`
- `{OutputPath}`

La bonne methode de calibration consiste a lancer un export manuel, provoquer un dump UI en cas d'erreur, puis reporter les `Name` ou `AutomationId` fiables pour le dossier de sortie, le nom de fichier et le bouton final. Le profil video reste configure directement dans PowerDirector et ne doit pas etre ajoute comme action modifiable.

## Fichiers generes

- `config.json`
- `profiles.json`
- `jobs/queue_state.json`
- `logs/session_*.log`
- `reports/batch_report.md`
- `reports/batch_report.html`
- `reports/batch_report.json`
- `screenshots/errors/*.png`
- `diagnostics/ui_tree_dump_*.json`

## Limites connues

- Le batch 3 projets reel a ete valide en `BatchCompleted`.
- Le batch 10 bis a valide le garde-fou anti-cascade : apres un projet rendu et video validee mais fenetre `Exporter` non confirmee fermee, le batch s'arrete en `BatchStoppedForUnsafePowerDirectorState` au lieu de produire des erreurs en cascade sur les projets suivants.
- Certains controles PowerDirector sont custom et peuvent ne pas exposer tous leurs boutons a UI Automation.
- Le fallback BoundingRectangle est limite aux zones explicitement documentees, par exemple la croix de la fenetre `Exporter`.
