Upload 41 files

.gitignore

@@ -8,4 +8,9 @@ VIRALS
 *.zip
 api_config.json
 versions
-*.gguf
+*.gguf
+.gradio
+__pycache__
+temp_subtitle_config.json
+This is a PREVIEW of your subtitles.json
+webui\PREVIEW\*

i18n/locale/en_US.json

@@ -67,6 +67,7 @@
     "Input Source": "Input Source",
     "YouTube URL": "YouTube URL",
     "Existing Project": "Existing Project",
+    "Upload Video": "Upload Video",
     "Select Project": "Select Project",
     "Segments": "Segments",
     "Viral Mode": "Viral Mode",
@@ -207,5 +208,71 @@
     "Video Quality": "Video Quality",
     "⚡ Render This Segment (Very-Fast)": "⚡ Render This Segment (Very-Fast)",
     "🎬 Render All (Fast)": "🎬 Render All (Fast)",
-    "💾 Save Changes": "💾 Save Changes"
+    "💾 Save Changes": "💾 Save Changes",
+    "No models found": "No models found",
+    "Error starting render: {}": "Error starting render: {}",
+    "Error: No video file uploaded.": "Error: No video file uploaded.",
+    "Default (Balanced)": "Default (Balanced)",
+    "Stable (Focus Main)": "Stable (Focus Main)",
+    "Sensitive (Catch All)": "Sensitive (Catch All)",
+    "High Precision": "High Precision",
+    "Default (Off)": "Default (Off)",
+    "Active Speaker (Balanced)": "Active Speaker (Balanced)",
+    "Active Speaker (Sensitive)": "Active Speaker (Sensitive)",
+    "Active Speaker (Stable)": "Active Speaker (Stable)",
+    "Loaded subtitle config from {}": "Loaded subtitle config from {}",
+    "Error loading subtitle config: {}. Using defaults.": "Error loading subtitle config: {}. Using defaults.",
+    "Burn only mode activated. Switching to Workflow 3...": "Burn only mode activated. Switching to Workflow 3...",
+    "No segments count provided and skip-prompts is ON. Using default 3.": "No segments count provided and skip-prompts is ON. Using default 3.",
+    "Viral mode not set, defaulting to True.": "Viral mode not set, defaulting to True.",
+    "No AI backend selected, defaulting to Manual.": "No AI backend selected, defaulting to Manual.",
+    "\nNo .gguf models found in 'models' directory.": "\nNo .gguf models found in 'models' directory.",
+    "Please place a module file in: {}": "Please place a module file in: {}",
+    "Falling back to Manual...": "Falling back to Manual...",
+    "\nAvailable Models:": "\nAvailable Models:",
+    "Select Model (Number): ": "Select Model (Number): ",
+    "Invalid selection. Using first model.": "Invalid selection. Using first model.",
+    "Invalid input. Using first model.": "Invalid input. Using first model.",
+    "Gemini API key missing, but skip-prompts is ON. Might fail.": "Gemini API key missing, but skip-prompts is ON. Might fail.",
+    "Workflow 3: Skipping Transcribe.": "Workflow 3: Skipping Transcribe.",
+    "Workflow 3 (Subtitles Only): Skipping Cut and Edit.": "Workflow 3 (Subtitles Only): Skipping Cut and Edit.",
+    "Workflow 3: Skipping Face Crop.": "Workflow 3: Skipping Face Crop.",
+    "Renaming existing files with titles...": "Renaming existing files with titles...",
+    "Tip: If you are using Workflow 3 (Subtitles Only), ensure the 'subs' folder exists and contains valid JSON files.": "Tip: If you are using Workflow 3 (Subtitles Only), ensure the 'subs' folder exists and contains valid JSON files.",
+    "Translating subtitles to: {}": "Translating subtitles to: {}",
+    "Translation failed: {}": "Translation failed: {}",
+    "Configuration saved to: {}": "Configuration saved to: {}",
+    "Error saving configuration JSON: {}": "Error saving configuration JSON: {}",
+    "MrBeast Clean Hook": "MrBeast Clean Hook",
+    "Beasty (Loud)": "Beasty (Loud)",
+    "Rapid Fire (Sprint)": "Rapid Fire (Sprint)",
+    "Podcast Viral (Centered)": "Podcast Viral (Centered)",
+    "Story Subtitle (Netflix Style)": "Story Subtitle (Netflix Style)",
+    "Retro Pixel": "Retro Pixel",
+    "Hormozi (Classic)": "Hormozi (Classic)",
+    "Extracting video information...": "Extracting video information...",
+    "Warning: Failed to extract info with cookies: {}": "Warning: Failed to extract info with cookies: {}",
+    "Error getting video info (without cookies): {}": "Error getting video info (without cookies): {}",
+    "Detected title: {}": "Detected title: {}",
+    "WARNING: Title could not be obtained. Using 'Unknown_Video'.": "WARNING: Title could not be obtained. Using 'Unknown_Video'.",
+    "Video already exists at: {}": "Video already exists at: {}",
+    "Skipping download and reusing local file.": "Skipping download and reusing local file.",
+    "Existing file found but seems corrupted/empty. Downloading again...": "Existing file found but seems corrupted/empty. Downloading again...",
+    "Configuring download quality: {} -> {}": "Configuring download quality: {} -> {}",
+    "Downloading video to: {}...": "Downloading video to: {}...",
+    "\n[CRITICAL ERROR] Connection Failure: Could not access YouTube.": "\n[CRITICAL ERROR] Connection Failure: Could not access YouTube.",
+    "Check your internet connection or if there is any DNS block.": "Check your internet connection or if there is any DNS block.",
+    "Details: {}": "Details: {}",
+    "\nWarning: Error downloading subtitles ({}).": "\nWarning: Error downloading subtitles ({}).",
+    "Retrying ONLY the video (without subtitles)...": "Retrying ONLY the video (without subtitles)...",
+    "Fatal error on second attempt: {}": "Fatal error on second attempt: {}",
+    "Error: the entered link is not valid.": "Error: the entered link is not valid.",
+    "Download error: {}": "Download error: {}",
+    "Unexpected error: {}": "Unexpected error: {}",
+    "Formatting complex VTT subtitle ({}) to clean SRT...": "Formatting complex VTT subtitle ({}) to clean SRT...",
+    "Subtitle converted and cleaned: {}": "Subtitle converted and cleaned: {}",
+    "Failed to convert VTT: {}. Keeping original.": "Failed to convert VTT: {}. Keeping original.",
+    "SRT subtitle renamed to: {}": "SRT subtitle renamed to: {}",
+    "Error processing subtitles: {}": "Error processing subtitles: {}",
+    "Unknown_Video": "Unknown_Video"
 }

i18n/locale/pt_BR.json

@@ -67,6 +67,7 @@
     "Input Source": "Fonte de Entrada",
     "YouTube URL": "URL do YouTube",
     "Existing Project": "Projeto Existente",
+    "Upload Video": "Upar Vídeo",
     "Select Project": "Selecionar Projeto",
     "Segments": "Segmentos",
     "Viral Mode": "Modo Viral",
@@ -207,5 +208,71 @@
     "Video Quality": "Qualidade de Vídeo",
     "⚡ Render This Segment (Very-Fast)": "⚡ Renderizar Este Segmento (Muito Rápido)",
     "🎬 Render All (Fast)": "🎬 Renderizar Tudo (Rápido)",
-    "💾 Save Changes": "💾 Salvar Alterações"
+    "💾 Save Changes": "💾 Salvar Alterações",
+    "No models found": "Nenhum modelo encontrado",
+    "Error starting render: {}": "Erro ao iniciar renderização: {}",
+    "Error: No video file uploaded.": "Erro: Nenhum arquivo de vídeo enviado.",
+    "Default (Balanced)": "Padrão (Equilibrado)",
+    "Stable (Focus Main)": "Estável (Foco Principal)",
+    "Sensitive (Catch All)": "Sensível (Pega Tudo)",
+    "High Precision": "Alta Precisão",
+    "Default (Off)": "Padrão (Desligado)",
+    "Active Speaker (Balanced)": "Falante Ativo (Equilibrado)",
+    "Active Speaker (Sensitive)": "Falante Ativo (Sensível)",
+    "Active Speaker (Stable)": "Falante Ativo (Estável)",
+    "Loaded subtitle config from {}": "Configuração de legenda carregada de {}",
+    "Error loading subtitle config: {}. Using defaults.": "Erro ao carregar configuração de legenda: {}. Usando padrões.",
+    "Burn only mode activated. Switching to Workflow 3...": "Modo apenas queimar ativado. Alternando para Fluxo de Trabalho 3...",
+    "No segments count provided and skip-prompts is ON. Using default 3.": "Nenhuma contagem de segmentos fornecida e pular prompts está LIGADO. Usando padrão 3.",
+    "Viral mode not set, defaulting to True.": "Modo viral não definido, padronizando para Verdadeiro.",
+    "No AI backend selected, defaulting to Manual.": "Nenhum backend de IA selecionado, padronizando para Manual.",
+    "\nNo .gguf models found in 'models' directory.": "\nNenhum modelo .gguf encontrado no diretório 'models'.",
+    "Please place a module file in: {}": "Por favor, coloque um arquivo de modelo em: {}",
+    "Falling back to Manual...": "Voltando para Manual...",
+    "\nAvailable Models:": "\nModelos Disponíveis:",
+    "Select Model (Number): ": "Selecione o Modelo (Número): ",
+    "Invalid selection. Using first model.": "Seleção inválida. Usando o primeiro modelo.",
+    "Invalid input. Using first model.": "Entrada inválida. Usando o primeiro modelo.",
+    "Gemini API key missing, but skip-prompts is ON. Might fail.": "Chave da API Gemini ausente, mas pular prompts está LIGADO. Pode falhar.",
+    "Workflow 3: Skipping Transcribe.": "Fluxo de Trabalho 3: Pulando Transcrição.",
+    "Workflow 3 (Subtitles Only): Skipping Cut and Edit.": "Fluxo de Trabalho 3 (Apenas Legendas): Pulando Corte e Edição.",
+    "Workflow 3: Skipping Face Crop.": "Fluxo de Trabalho 3: Pulando Recorte de Rosto.",
+    "Renaming existing files with titles...": "Renomeando arquivos existentes com títulos...",
+    "Tip: If you are using Workflow 3 (Subtitles Only), ensure the 'subs' folder exists and contains valid JSON files.": "Dica: Se você está usando o Fluxo de Trabalho 3 (Apenas Legendas), certifique-se de que a pasta 'subs' existe e contém arquivos JSON válidos.",
+    "Translating subtitles to: {}": "Traduzindo legendas para: {}",
+    "Translation failed: {}": "Tradução falhou: {}",
+    "Configuration saved to: {}": "Configuração salva em: {}",
+    "Error saving configuration JSON: {}": "Erro ao salvar JSON de configuração: {}",
+    "MrBeast Clean Hook": "MrBeast (Gancho Limpo)",
+    "Beasty (Loud)": "Beasty (Alto)",
+    "Rapid Fire (Sprint)": "Tiro Rápido (Sprint)",
+    "Podcast Viral (Centered)": "Podcast Viral (Centralizado)",
+    "Story Subtitle (Netflix Style)": "Legenda de História (Estilo Netflix)",
+    "Retro Pixel": "Retro Pixel",
+    "Hormozi (Classic)": "Hormozi (Clássico)",
+    "Extracting video information...": "Extraindo informações do vídeo...",
+    "Warning: Failed to extract info with cookies: {}": "Aviso: Falha ao extrair info com cookies: {}",
+    "Error getting video info (without cookies): {}": "Erro ao obter informações do vídeo (sem cookies): {}",
+    "Detected title: {}": "Título detectado: {}",
+    "WARNING: Title could not be obtained. Using 'Unknown_Video'.": "AVISO: Título não pôde ser obtido. Usando 'Unknown_Video'.",
+    "Video already exists at: {}": "Vídeo já existe em: {}",
+    "Skipping download and reusing local file.": "Pulando download e reutilizando arquivo local.",
+    "Existing file found but seems corrupted/empty. Downloading again...": "Arquivo existente encontrado mas parece corrompido/vazio. Baixando novamente...",
+    "Configuring download quality: {} -> {}": "Configurando qualidade de download: {} -> {}",
+    "Downloading video to: {}...": "Baixando vídeo para: {}...",
+    "\n[CRITICAL ERROR] Connection Failure: Could not access YouTube.": "\n[ERRO CRÍTICO] Falha de Conexão: Não foi possível acessar o YouTube.",
+    "Check your internet connection or if there is any DNS block.": "Verifique sua conexão com a internet ou se há algum bloqueio de DNS.",
+    "Details: {}": "Detalhes: {}",
+    "\nWarning: Error downloading subtitles ({}).": "\nAviso: Erro ao baixar legendas ({}).",
+    "Retrying ONLY the video (without subtitles)...": "Tentando novamente APENAS o vídeo (sem legendas)...",
+    "Fatal error on second attempt: {}": "Erro fatal na segunda tentativa: {}",
+    "Error: the entered link is not valid.": "Erro: o link inserido não é válido.",
+    "Download error: {}": "Erro no download: {}",
+    "Unexpected error: {}": "Erro inesperado: {}",
+    "Formatting complex VTT subtitle ({}) to clean SRT...": "Formatando legenda VTT complexa ({}) para SRT limpo...",
+    "Subtitle converted and cleaned: {}": "Legenda convertida e limpa: {}",
+    "Failed to convert VTT: {}. Keeping original.": "Falha ao converter VTT: {}. Mantendo original.",
+    "SRT subtitle renamed to: {}": "Legenda SRT renomeada para: {}",
+    "Error processing subtitles: {}": "Erro ao processar legendas: {}",
+    "Unknown_Video": "Unknown_Video"
 }

install_dependencies.bat

@@ -18,7 +18,6 @@ echo ==========================================
 :: Ativa o venv temporariamente para o install (uv gerencia isso automaticamente se detectar o venv, mas vamos garantir)
 :: Se o uv venv criou a pasta .venv, o uv pip install vai usar ela por padrao se estiver na raiz.
 uv pip install -r requirements.txt
-uv pip install auto-editor
 
 echo.
 echo ==========================================

main_improved.py

@@ -81,9 +81,9 @@ def get_subtitle_config(config_path=None):
             with open(config_path, 'r', encoding='utf-8') as f:
                 loaded_config = json.load(f)
                 config.update(loaded_config)
-                print(f"Loaded subtitle config from {config_path}")
+                print(i18n("Loaded subtitle config from {}").format(config_path))
         except Exception as e:
-            print(f"Error loading subtitle config: {e}. Using defaults.")
+            print(i18n("Error loading subtitle config: {}. Using defaults.").format(e))
     
     return config
 
@@ -250,7 +250,7 @@ def main():
         num_segments = args.segments
         if not num_segments:
             if args.skip_prompts:
-                print("No segments count provided and skip-prompts is ON. Using default 3.")
+                print(i18n("No segments count provided and skip-prompts is ON. Using default 3."))
                 num_segments = 3
             else:
                 num_segments = interactive_input_int("Enter the number of viral segments to create: ")
@@ -258,7 +258,7 @@ def main():
         viral_mode = args.viral
         if not args.viral and not args.themes:
             if args.skip_prompts:
-                print("Viral mode not set, defaulting to True.")
+                print(i18n("Viral mode not set, defaulting to True."))
                 viral_mode = True
             else:
                 response = input(i18n("Do you want viral mode? (yes/no): ")).lower()
@@ -303,7 +303,7 @@ def main():
 
         if not ai_backend:
             if args.skip_prompts:
-                print("No AI backend selected, defaulting to Manual.")
+                print(i18n("No AI backend selected, defaulting to Manual."))
                 ai_backend = "manual"
             else:
                 print("\n" + i18n("Select AI Backend for Viral Analysis:"))
@@ -340,10 +340,10 @@ def main():
                             if 0 <= m_idx < len(models):
                                 args.ai_model_name = models[m_idx] # Set global arg
                             else:
-                                print("Invalid selection. Using first model.")
+                                print(i18n("Invalid selection. Using first model."))
                                 args.ai_model_name = models[0]
                         except:
-                             print("Invalid input. Using first model.")
+                             print(i18n("Invalid input. Using first model."))
                              args.ai_model_name = models[0]
                              
                 else:
@@ -358,7 +358,7 @@ def main():
         
         if ai_backend == "gemini" and not api_key:
              if args.skip_prompts:
-                 print("Gemini API key missing, but skip-prompts is ON. Might fail.")
+                 print(i18n("Gemini API key missing, but skip-prompts is ON. Might fail."))
              else:
                  print(i18n("Gemini API Key not found in api_config.json or arguments."))
                  api_key = input(i18n("Enter your Gemini API Key: ")).strip()
@@ -559,7 +559,7 @@ def main():
                  final_folder = os.path.join(project_folder, "final")
                  subs_folder = os.path.join(project_folder, "subs")
                  
-                 print("Renaming existing files with titles...")
+                 print(i18n("Renaming existing files with titles..."))
                  for idx, segment in enumerate(segments_data):
                      title = segment.get("title", f"Segment_{idx}")
                      safe_title = "".join([c for c in title if c.isalnum() or c in " _-"]).strip()

requirements.txt

@@ -1,17 +1,23 @@
-g4f[all]
-yt-dlp
-ffmpeg-python
-whisperx
-mediapipe
-google-genai
-insightface
-onnxruntime-gpu
-gradio
-opencv-python
-numpy
-psutil
-fastapi
-uvicorn
-torch
-deep-translator
-tqdm
+g4f[all]
+yt-dlp
+ffmpeg-python
+whisperx
+mediapipe
+google-genai
+insightface
+onnxruntime-gpu
+gradio
+opencv-python
+numpy
+psutil
+fastapi
+uvicorn
+torch
+deep-translator
+tqdm
+
+
+
+# Local LLM Support with CUDA 12.4
+--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124
+llama-cpp-python

scripts/download_video.py

@@ -1,275 +1,284 @@
-import os
-import re
-import yt_dlp
-import sys
-
-def sanitize_filename(name):
-    """Remove caracteres inválidos para nomes de arquivos/pastas."""
-    cleaned = re.sub(r'[\\/*?:"<>|]', "", name)
-    cleaned = cleaned.strip()
-    return cleaned
-
-def progress_hook(d):
-    if d['status'] == 'downloading':
-        try:
-            p = d.get('_percent_str', '').replace('%','')
-            print(f"[download] {p}% - {d.get('_eta_str', 'N/A')} remaining", flush=True)
-        except:
-            pass
-    elif d['status'] == 'finished':
-        print(f"[download] Download concluído: {d['filename']}", flush=True)
-
-def download(url, base_root="VIRALS", download_subs=True, quality="best"):
-    # 1. Extrair informações do vídeo para pegar o título
-    print("Extraindo informações do vídeo...")
-    title = None
-    
-    # ... (Keep existing title extraction logic) ...
-    # Instead of repeating it effectively, I will rely on the diff to keep it or re-write it if I have to replace the whole block.
-    # Since replace_file_content works on line ranges, I should be careful.
-    # Let's assume I'm replacing the whole function body or significant parts.
-    
-    # Tentativa 1: Com cookies
-    try:
-        with yt_dlp.YoutubeDL({'quiet': True, 'no_warnings': True, 'cookiesfrombrowser': ('chrome',)}) as ydl:
-            info = ydl.extract_info(url, download=False)
-            title = info.get('title')
-    except Exception as e:
-        print(f"Aviso: Falha ao extrair info com cookies: {e}")
-        
-    # Tentativa 2: Sem cookies
-    if not title:
-        try:
-             with yt_dlp.YoutubeDL({'quiet': True, 'no_warnings': True}) as ydl:
-                info = ydl.extract_info(url, download=False)
-                title = info.get('title')
-        except Exception as e:
-            print(f"Erro ao obter informações do vídeo (sem cookies): {e}")
-
-    # Fallback final
-    if title:
-        safe_title = sanitize_filename(title)
-        print(f"Título detectado: {title}")
-    else:
-        print("AVISO: Título não pôde ser obtido. Usando 'Unknown_Video'.")
-        safe_title = "Unknown_Video"
-
-    # 2. Criar estrutura de pastas
-    project_folder = os.path.join(base_root, safe_title)
-    os.makedirs(project_folder, exist_ok=True)
-    
-    # Caminho final do vídeo
-    output_filename = 'input' 
-    output_path_base = os.path.join(project_folder, output_filename)
-    final_video_path = f"{output_path_base}.mp4"
-
-    # Verificação inteligente
-    if os.path.exists(final_video_path):
-        if os.path.getsize(final_video_path) > 1024: 
-            print(f"Vídeo já existe em: {final_video_path}")
-            print("Pulando download e reutilizando arquivo local.")
-            return final_video_path, project_folder
-        else:
-            print("Arquivo existente encontrado mas parece corrompido/vazio. Baixando novamente...")
-            try:
-                os.remove(final_video_path)
-            except:
-                pass
-
-    # Limpeza de temp
-    temp_path = f"{output_path_base}.temp.mp4"
-    if os.path.exists(temp_path):
-        try:
-            os.remove(temp_path)
-        except:
-            pass
-
-    # Mapeamento de Qualidade
-    quality_map = {
-        "best": 'bestvideo+bestaudio/best',
-        "1080p": 'bestvideo[height<=1080]+bestaudio/best[height<=1080]',
-        "720p": 'bestvideo[height<=720]+bestaudio/best[height<=720]',
-        "480p": 'bestvideo[height<=480]+bestaudio/best[height<=480]'
-    }
-    selected_format = quality_map.get(quality, 'bestvideo+bestaudio/best')
-    print(f"Configurando qualidade de download: {quality} -> {selected_format}")
-
-    ydl_opts = {
-        'format': selected_format,
-        'overwrites': True,
-        'outtmpl': output_path_base, 
-        'postprocessor_args': [
-            '-movflags', 'faststart'
-        ],
-        'merge_output_format': 'mp4',
-        'progress_hooks': [progress_hook],
-        # Opções de Legenda
-        'writesubtitles': download_subs,
-        'writeautomaticsub': download_subs,
-        'subtitleslangs': ['pt.*', 'en.*', 'sp.*'], # Prioritize generic PT, EN, SP
-        'http_headers': {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        },
-        'skip_download': False,
-        'quiet': False,
-        'no_warnings': False,
-        'force_ipv4': True,
-    }
-    
-
-    
-    if download_subs:
-        ydl_opts['postprocessors'] = [{
-            'key': 'FFmpegSubtitlesConvertor',
-            'format': 'srt',
-        }]
-
-    print(f"Baixando vídeo para: {project_folder}...")
-    
-    # Tentativa 1: Com configuração original
-    try:
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([url])
-    except yt_dlp.utils.DownloadError as e:
-        error_str = str(e)
-        if download_subs and ("Unable to download video subtitles" in error_str or "429" in error_str):
-            print(f"\nAviso: Erro ao baixar legendas ({e}).")
-            print("Tentando novamente APENAS o vídeo (sem legendas)...")
-            
-            ydl_opts['writesubtitles'] = False
-            ydl_opts['writeautomaticsub'] = False
-            ydl_opts['postprocessors'] = [p for p in ydl_opts.get('postprocessors', []) if 'Subtitle' not in p.get('key', '')]
-            
-            try:
-                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                    ydl.download([url])
-            except Exception as e2:
-                print(f"Erro fatal na segunda tentativa: {e2}")
-                raise
-        elif "is not a valid URL" in error_str:
-             print("Erro: o link inserido não é válido.")
-             raise 
-        else:
-            print(f"Erro no download: {e}")
-            raise
-    except Exception as e:
-        print(f"Erro inesperado: {e}")
-        raise
-
-    # RENOMEAR LEGENDA PARA PADRÃO (input.vtt ou input.srt)
-    # Se for VTT, converte para SRT para garantir compatibilidade.
-    try:
-        import glob
-        # Pega a primeira que encontrar
-        potential_subs = glob.glob(os.path.join(project_folder, "input.*.vtt")) + glob.glob(os.path.join(project_folder, "input.*.srt"))
-        
-        if potential_subs:
-            best_sub = potential_subs[0]
-            ext = os.path.splitext(best_sub)[1]
-            new_name = os.path.join(project_folder, "input.srt") # Vamos padronizar tudo para .srt
-            
-            if ext.lower() == '.vtt':
-                print(f"Formatando legenda VTT complexa ({os.path.basename(best_sub)}) para SRT limpo...")
-                try:
-                    with open(best_sub, 'r', encoding='utf-8') as f:
-                        lines = f.readlines()
-                    
-                    srt_content = []
-                    counter = 1
-                    
-                    seen_texts = set()
-                    last_text = ""
-                    
-                    for line in lines:
-                        clean_line = line.strip()
-                        # Ignora Headers e Metadados do VTT/Youtube
-                        if clean_line.startswith("WEBVTT") or \
-                           clean_line.startswith("X-TIMESTAMP") or \
-                           clean_line.startswith("NOTE") or \
-                           clean_line.startswith("Kind:") or \
-                           clean_line.startswith("Language:"):
-                            continue
-                        
-                        if "-->" in clean_line:
-                            # Parse Timestamp
-                            parts = clean_line.split("-->")
-                            start = parts[0].strip()
-                            # Remove tags de posicionamento "align:start position:0%"
-                            end = parts[1].strip().split(' ')[0] 
-                            
-                            def fix_time(t):
-                                t = t.replace('.', ',')
-                                if t.count(':') == 1: 
-                                    t = "00:" + t
-                                return t
-                            
-                            current_start = fix_time(start)
-                            current_end = fix_time(end)
-                            
-                        elif clean_line:
-                             # Texto: remover tags complexas <00:00:00.560><c> etc
-                             # O YouTube usa formato karaoke. Ex: "Quanto<...> custa<...>"
-                             # Precisamos do texto limpo.
-                             text = re.sub(r'<[^>]+>', '', clean_line).strip()
-                             
-                             if not text: continue
-                             
-                             # Lógica para remover duplicatas do estilo "Roll-up" ou "Karaoke"
-                             # O YouTube repete a linha anterior às vezes.
-                             # Ex:
-                             # 1: "Quanto custa"
-                             # 2: "Quanto custa\nQuantos quilos"
-                             
-                             # Vamos pegar apenas a ULTIMA linha se tiver quebras
-                             lines_in_text = text.split('\n')
-                             final_line = lines_in_text[-1].strip()
-                             
-                             if not final_line: continue
-
-                             # Filtro de duplicidade consecutivo
-                             if final_line == last_text:
-                                 continue
-                             
-                             # Evita blocos ultra curtos (glitch de 10ms) que repetem texto
-                             # Mas aqui estamos processando texto.
-                             
-                             srt_content.append(f"{counter}\n")
-                             srt_content.append(f"{current_start} --> {current_end}\n")
-                             srt_content.append(f"{final_line}\n\n")
-                             
-                             last_text = final_line
-                             counter += 1
-                    
-                    with open(new_name, 'w', encoding='utf-8') as f_out:
-                        f_out.writelines(srt_content)
-                    
-                    print(f"Legenda convertida e limpa: {new_name}")
-                    try: os.remove(best_sub) 
-                    except: pass
-                    
-                except Exception as e_conv:
-                    print(f"Falha ao converter VTT: {e_conv}. Mantendo original.")
-                    # Fallback: rename apenas
-                    new_name_fallback = os.path.join(project_folder, "input.vtt")
-                    if os.path.exists(new_name_fallback) and new_name_fallback != best_sub:
-                        try: os.remove(new_name_fallback)
-                        except: pass
-                    os.rename(best_sub, new_name_fallback)
-
-            else:
-                # Já é SRT, só renomeia
-                if os.path.exists(new_name) and new_name != best_sub:
-                    try: os.remove(new_name)
-                    except: pass
-                os.rename(best_sub, new_name)
-                print(f"Legenda SRT renomeada para: {new_name}")
-            
-            # Limpa sobras
-            for extra in potential_subs[1:]:
-                try: os.remove(extra)
-                except: pass
-
-    except Exception as e_ren:
-        print(f"Erro ao processar legendas: {e_ren}")
-
+import os
+import re
+import yt_dlp
+import sys
+from i18n.i18n import I18nAuto
+i18n = I18nAuto()
+
+def sanitize_filename(name):
+    """Remove caracteres inválidos para nomes de arquivos/pastas."""
+    cleaned = re.sub(r'[\\/*?:"<>|]', "", name)
+    cleaned = cleaned.strip()
+    return cleaned
+
+def progress_hook(d):
+    if d['status'] == 'downloading':
+        try:
+            p = d.get('_percent_str', '').replace('%','')
+            print(f"[download] {p}% - {d.get('_eta_str', 'N/A')} remaining", flush=True)
+        except:
+            pass
+    elif d['status'] == 'finished':
+        print(f"[download] Download concluído: {d['filename']}", flush=True)
+
+def download(url, base_root="VIRALS", download_subs=True, quality="best"):
+    # 1. Extrair informações do vídeo para pegar o título
+    # 1. Extrair informações do vídeo para pegar o título
+    print(i18n("Extracting video information..."))
+    title = None
+    
+    # ... (Keep existing title extraction logic) ...
+    # Instead of repeating it effectively, I will rely on the diff to keep it or re-write it if I have to replace the whole block.
+    # Since replace_file_content works on line ranges, I should be careful.
+    # Let's assume I'm replacing the whole function body or significant parts.
+    
+    # Tentativa 1: Com cookies
+    try:
+        with yt_dlp.YoutubeDL({'quiet': True, 'no_warnings': True, 'cookiesfrombrowser': ('chrome',)}) as ydl:
+            info = ydl.extract_info(url, download=False)
+            title = info.get('title')
+    except Exception as e:
+        print(i18n("Warning: Failed to extract info with cookies: {}").format(e))
+        
+    # Tentativa 2: Sem cookies
+    if not title:
+        try:
+             with yt_dlp.YoutubeDL({'quiet': True, 'no_warnings': True}) as ydl:
+                info = ydl.extract_info(url, download=False)
+                title = info.get('title')
+        except Exception as e:
+            print(i18n("Error getting video info (without cookies): {}").format(e))
+
+    # Fallback final
+    if title:
+        safe_title = sanitize_filename(title)
+        print(i18n("Detected title: {}").format(title))
+    else:
+        print(i18n("WARNING: Title could not be obtained. Using 'Unknown_Video'."))
+        safe_title = i18n("Unknown_Video")
+
+    # 2. Criar estrutura de pastas
+    project_folder = os.path.join(base_root, safe_title)
+    os.makedirs(project_folder, exist_ok=True)
+    
+    # Caminho final do vídeo
+    output_filename = 'input' 
+    output_path_base = os.path.join(project_folder, output_filename)
+    final_video_path = f"{output_path_base}.mp4"
+
+    # Verificação inteligente
+    if os.path.exists(final_video_path):
+        if os.path.getsize(final_video_path) > 1024: 
+            print(i18n("Video already exists at: {}").format(final_video_path))
+            print(i18n("Skipping download and reusing local file."))
+            return final_video_path, project_folder
+        else:
+            print(i18n("Existing file found but seems corrupted/empty. Downloading again..."))
+            try:
+                os.remove(final_video_path)
+            except:
+                pass
+
+    # Limpeza de temp
+    temp_path = f"{output_path_base}.temp.mp4"
+    if os.path.exists(temp_path):
+        try:
+            os.remove(temp_path)
+        except:
+            pass
+
+    # Mapeamento de Qualidade
+    quality_map = {
+        "best": 'bestvideo+bestaudio/best',
+        "1080p": 'bestvideo[height<=1080]+bestaudio/best[height<=1080]',
+        "720p": 'bestvideo[height<=720]+bestaudio/best[height<=720]',
+        "480p": 'bestvideo[height<=480]+bestaudio/best[height<=480]'
+    }
+    selected_format = quality_map.get(quality, 'bestvideo+bestaudio/best')
+    print(i18n("Configuring download quality: {} -> {}").format(quality, selected_format))
+
+    ydl_opts = {
+        'format': selected_format,
+        'overwrites': True,
+        'outtmpl': output_path_base, 
+        'postprocessor_args': [
+            '-movflags', 'faststart'
+        ],
+        'merge_output_format': 'mp4',
+        'progress_hooks': [progress_hook],
+        # Opções de Legenda
+        'writesubtitles': download_subs,
+        'writeautomaticsub': download_subs,
+        'subtitleslangs': ['pt.*', 'en.*', 'sp.*'], # Prioritize generic PT, EN, SP
+        'http_headers': {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        },
+        'skip_download': False,
+        'quiet': False,
+        'no_warnings': False,
+        'force_ipv4': True,
+    }
+    
+
+    
+    if download_subs:
+        ydl_opts['postprocessors'] = [{
+            'key': 'FFmpegSubtitlesConvertor',
+            'format': 'srt',
+        }]
+
+    print(i18n("Downloading video to: {}...").format(project_folder))
+    
+    # Tentativa 1: Com configuração original
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+    except yt_dlp.utils.DownloadError as e:
+        error_str = str(e)
+        if "No address associated with hostname" in error_str or "Failed to resolve" in error_str:
+            print(i18n("\n[CRITICAL ERROR] Connection Failure: Could not access YouTube."))
+            print(i18n("Check your internet connection or if there is any DNS block."))
+            print(i18n("Details: {}").format(e))
+            sys.exit(1)
+        
+        elif download_subs and ("Unable to download video subtitles" in error_str or "429" in error_str):
+            print(i18n("\nWarning: Error downloading subtitles ({}).").format(e))
+            print(i18n("Retrying ONLY the video (without subtitles)..."))
+            
+            ydl_opts['writesubtitles'] = False
+            ydl_opts['writeautomaticsub'] = False
+            ydl_opts['postprocessors'] = [p for p in ydl_opts.get('postprocessors', []) if 'Subtitle' not in p.get('key', '')]
+            
+            try:
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    ydl.download([url])
+            except Exception as e2:
+                print(i18n("Fatal error on second attempt: {}").format(e2))
+                raise
+        elif "is not a valid URL" in error_str:
+             print(i18n("Error: the entered link is not valid."))
+             raise 
+        else:
+            print(i18n("Download error: {}").format(e))
+            raise
+    except Exception as e:
+        print(i18n("Unexpected error: {}").format(e))
+        raise
+
+    # RENOMEAR LEGENDA PARA PADRÃO (input.vtt ou input.srt)
+    # Se for VTT, converte para SRT para garantir compatibilidade.
+    try:
+        import glob
+        # Pega a primeira que encontrar
+        potential_subs = glob.glob(os.path.join(project_folder, "input.*.vtt")) + glob.glob(os.path.join(project_folder, "input.*.srt"))
+        
+        if potential_subs:
+            best_sub = potential_subs[0]
+            ext = os.path.splitext(best_sub)[1]
+            new_name = os.path.join(project_folder, "input.srt") # Vamos padronizar tudo para .srt
+            
+            if ext.lower() == '.vtt':
+                print(i18n("Formatting complex VTT subtitle ({}) to clean SRT...").format(os.path.basename(best_sub)))
+                try:
+                    with open(best_sub, 'r', encoding='utf-8') as f:
+                        lines = f.readlines()
+                    
+                    srt_content = []
+                    counter = 1
+                    
+                    seen_texts = set()
+                    last_text = ""
+                    
+                    for line in lines:
+                        clean_line = line.strip()
+                        # Ignora Headers e Metadados do VTT/Youtube
+                        if clean_line.startswith("WEBVTT") or \
+                           clean_line.startswith("X-TIMESTAMP") or \
+                           clean_line.startswith("NOTE") or \
+                           clean_line.startswith("Kind:") or \
+                           clean_line.startswith("Language:"):
+                            continue
+                        
+                        if "-->" in clean_line:
+                            # Parse Timestamp
+                            parts = clean_line.split("-->")
+                            start = parts[0].strip()
+                            # Remove tags de posicionamento "align:start position:0%"
+                            end = parts[1].strip().split(' ')[0] 
+                            
+                            def fix_time(t):
+                                t = t.replace('.', ',')
+                                if t.count(':') == 1: 
+                                    t = "00:" + t
+                                return t
+                            
+                            current_start = fix_time(start)
+                            current_end = fix_time(end)
+                            
+                        elif clean_line:
+                             # Texto: remover tags complexas <00:00:00.560><c> etc
+                             # O YouTube usa formato karaoke. Ex: "Quanto<...> custa<...>"
+                             # Precisamos do texto limpo.
+                             text = re.sub(r'<[^>]+>', '', clean_line).strip()
+                             
+                             if not text: continue
+                             
+                             # Lógica para remover duplicatas do estilo "Roll-up" ou "Karaoke"
+                             # O YouTube repete a linha anterior às vezes.
+                             # Ex:
+                             # 1: "Quanto custa"
+                             # 2: "Quanto custa\nQuantos quilos"
+                             
+                             # Vamos pegar apenas a ULTIMA linha se tiver quebras
+                             lines_in_text = text.split('\n')
+                             final_line = lines_in_text[-1].strip()
+                             
+                             if not final_line: continue
+
+                             # Filtro de duplicidade consecutivo
+                             if final_line == last_text:
+                                 continue
+                             
+                             # Evita blocos ultra curtos (glitch de 10ms) que repetem texto
+                             # Mas aqui estamos processando texto.
+                             
+                             srt_content.append(f"{counter}\n")
+                             srt_content.append(f"{current_start} --> {current_end}\n")
+                             srt_content.append(f"{final_line}\n\n")
+                             
+                             last_text = final_line
+                             counter += 1
+                    
+                    with open(new_name, 'w', encoding='utf-8') as f_out:
+                        f_out.writelines(srt_content)
+                    
+                    print(i18n("Subtitle converted and cleaned: {}").format(new_name))
+                    try: os.remove(best_sub) 
+                    except: pass
+                    
+                except Exception as e_conv:
+                    print(i18n("Failed to convert VTT: {}. Keeping original.").format(e_conv))
+                    # Fallback: rename apenas
+                    new_name_fallback = os.path.join(project_folder, "input.vtt")
+                    if os.path.exists(new_name_fallback) and new_name_fallback != best_sub:
+                        try: os.remove(new_name_fallback)
+                        except: pass
+                    os.rename(best_sub, new_name_fallback)
+
+            else:
+                # Já é SRT, só renomeia
+                if os.path.exists(new_name) and new_name != best_sub:
+                    try: os.remove(new_name)
+                    except: pass
+                os.rename(best_sub, new_name)
+                print(i18n("SRT subtitle renamed to: {}").format(new_name))
+            
+            # Limpa sobras
+            for extra in potential_subs[1:]:
+                try: os.remove(extra)
+                except: pass
+
+    except Exception as e_ren:
+        print(i18n("Error processing subtitles: {}").format(e_ren))
+
     return final_video_path, project_folder

scripts/edit_video.py

@@ -445,6 +445,8 @@ def generate_short_insightface(input_file, output_file, index, project_folder, f
 
     fps = cap.get(cv2.CAP_PROP_FPS)
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     
     # Using mp4v for container, but final mux will fix encoding
     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
@@ -926,13 +928,30 @@ def generate_short_insightface(input_file, output_file, index, project_folder, f
              timeline_frames.append((frame_index, "1"))
              
         # Capture Coordinates (Frame-by-Frame)
-        coords_entry = {"frame": frame_index, "faces": []}
+        coords_entry = {"frame": frame_index, "src_size": [frame_width, frame_height], "faces": []}
         try:
+            # We want to store [x1, y1, x2, y2, rh] for each face
             if isinstance(current_faces, (list, tuple)):
-                # Convert numpy to list if needed
-                coords_entry["faces"] = [list(map(int, f)) for f in current_faces]
+                processed_faces_log = []
+                for f in current_faces:
+                    f_list = list(map(int, f[:4])) # Standard bbox
+                    # Calculate rh (relative height)
+                    face_h = f_list[3] - f_list[1]
+                    rh = face_h / float(frame_height)
+                    f_list.append(float(f"{rh:.4f}")) # Append as 5th element
+                    processed_faces_log.append(f_list)
+                coords_entry["faces"] = processed_faces_log
+                
             elif isinstance(current_faces, np.ndarray):
-                coords_entry["faces"] = current_faces.astype(int).tolist()
+                # Similar logic for numpy
+                processed_faces_log = []
+                for f in current_faces:
+                    f_list = f[:4].astype(int).tolist()
+                    face_h = f_list[3] - f_list[1]
+                    rh = face_h / float(frame_height)
+                    f_list.append(float(f"{rh:.4f}"))
+                    processed_faces_log.append(f_list)
+                coords_entry["faces"] = processed_faces_log
         except: pass
         coordinate_log.append(coords_entry)
 

scripts/export_xml.py

@@ -1,484 +1,11 @@
-import os
-import json
-import subprocess
-import uuid
-import sys
 import argparse
-import shutil
-import zipfile
-from datetime import timedelta
-
-def timestamp_to_srt(seconds):
-    td = timedelta(seconds=seconds)
-    total_seconds = int(td.total_seconds())
-    micros = td.microseconds
-    hours, remainder = divmod(total_seconds, 3600)
-    minutes, seconds = divmod(remainder, 60)
-    return f"{hours:02}:{minutes:02}:{seconds:02},{micros//1000:03}"
-
-def json_to_srt(json_data):
-    """
-    Converts internal JSON subtitle format to SRT.
-    If 'words' key is present, generates word-level timestamps (Karaoke/Editing style).
-    Otherwise, uses segment-level timestamps.
-    """
-    srt_content = ""
-    counter = 1
-    
-    for block in json_data:
-        # Check if words detail is available for Word-Level SRT
-        if isinstance(block, dict) and "words" in block and block["words"]:
-            for word_obj in block["words"]:
-                start = word_obj.get('start', 0)
-                end = word_obj.get('end', 0)
-                text = word_obj.get('word', "")
-                
-                srt_content += f"{counter}\n"
-                srt_content += f"{timestamp_to_srt(start)} --> {timestamp_to_srt(end)}\n"
-                srt_content += f"{text}\n\n"
-                counter += 1
-        else:
-            # Fallback to segment level
-            start = 0
-            end = 0
-            text = ""
-            if isinstance(block, dict):
-                start = block.get('start', 0)
-                end = block.get('end', 0)
-                text = block.get('text', "")
-            elif isinstance(block, (list, tuple)) and len(block) >= 3:
-                start, end, text = block[0], block[1], block[2]
-                
-            srt_content += f"{counter}\n"
-            srt_content += f"{timestamp_to_srt(start)} --> {timestamp_to_srt(end)}\n"
-            srt_content += f"{text}\n\n"
-            counter += 1
-            
-    return srt_content
-
-
-
-# ... (rest of the file until export_pack end)
-
-    # 8. ZIP IT
-    zip_filename = f"{export_name}.zip"
-    zip_path = os.path.join(project_path, zip_filename)
-    
-    # Create zip from stage_dir (base_name is without extension)
-    shutil.make_archive(os.path.join(project_path, export_name), 'zip', stage_dir)
-    
-    print(f"SUCCESS: Export Pack created at {zip_path}")
-    
-    # Cleanup
-    try:
-        shutil.rmtree(stage_dir)
-    except: pass
-    
-    return zip_path
-
-
-
-
-def get_video_dims(vid_path):
-    """Returns (width, height, duration_frames)"""
-    try:
-        cmd_w = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
-        width = int(subprocess.check_output(cmd_w).decode().strip())
-        
-        cmd_h = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=height", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
-        height = int(subprocess.check_output(cmd_h).decode().strip())
-        
-        cmd_dur = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
-        dur_sec = float(subprocess.check_output(cmd_dur).decode().strip())
-        
-        # Assume 30fps for calculation if not probed, but probing is better
-        cmd_fps = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=r_frame_rate", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
-        fps_str = subprocess.check_output(cmd_fps).decode().strip()
-        num, den = map(int, fps_str.split('/'))
-        fps = num / den if den > 0 else 30.0
-        
-        return width, height, int(dur_sec * fps), fps
-    except Exception as e:
-        print(f"Error probing video: {e}")
-        return 1920, 1080, 300, 30.0
-
-def render_segmented_overlays(ass_path, segments, video_path, output_dir):
-    """
-    Renders segments using a physical transparent PNG canvas to ensure alpha correctness.
-    """
-    width, height, _, fps = get_video_dims(video_path)
-    ass_path_sanitized = ass_path.replace("\\", "/").replace(":", "\\:")
-    
-    # Generate Base Canvas (Robust Way)
-    canvas_png = os.path.join(output_dir, "base_canvas.png")
-    # FFmpeg create transparent png
-    subprocess.run([
-        "ffmpeg", "-y", "-f", "lavfi", "-i", f"color=c=black@0.0:s={width}x{height}", 
-        "-frames:v", "1", "-c:v", "png", canvas_png
-    ], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-    
-    overlay_data = []
-    print(f"Rendering {len(segments)} subtitle segments (Mode: Canvas Overlay)...")
-    
-    for i, seg in enumerate(segments):
-        start = seg.get('start', 0)
-        end = seg.get('end', 0)
-        duration = end - start
-        if duration <= 0: continue
-        
-        filename = f"caption_{i}.mov"
-        out_path = os.path.join(output_dir, filename)
-        
-        # Input is PNG LOOP (Infinite) -> Trim duration -> Apply ASS -> Encode PNG Codec
-        cmd = [
-            "ffmpeg", "-y",
-            "-loop", "1", "-i", canvas_png,
-            "-vf", f"format=rgba,setpts=PTS+{start}/TB,ass='{ass_path_sanitized}',setpts=PTS-{start}/TB,format=rgba",
-            "-t", str(duration),
-            "-c:v", "png",
-            "-pix_fmt", "rgba",
-            "-an",
-            out_path
-        ]
-        
-        try:
-            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-            rel_path = os.path.join("captions", filename).replace("\\", "/")
-            overlay_data.append({ "path": rel_path, "start": start, "end": end, "index": i })
-            print(f"  [Seg {i}] Rendered {duration:.2f}s")
-        except subprocess.CalledProcessError as e:
-            print(f"  [Seg {i}] Failed: {e}")
-            
-    # Cleanup canvas
-    if os.path.exists(canvas_png): os.remove(canvas_png)
-
-    return overlay_data
-
-def create_premiere_xml(project_name, video_path, overlay_segments, duration_frames, width=1080, height=1920, timebase=30, video_file_id=None, audio_file_id=None, scale_value=100.0, face_data=None, source_width=1920, source_height=1080):
-    """
-    Generates a Premiere Pro XML (xmeml version 4) with segmented cuts and overlays.
-    overlay_segments: List of dicts [{'path', 'start', 'end', 'index'}]
-    """
-    
-    # Generate unique IDs
-    def get_uid(): return str(uuid.uuid4())[:12]
-    
-    if not video_file_id: video_file_id = f"file-video-{get_uid()}"
-    if not audio_file_id: audio_file_id = f"file-audio-{get_uid()}"
-    
-    sequence_uuid = str(uuid.uuid4())
-    
-    # helper for file blocks
-    def get_file_block(fid, fpath, is_audio_only=False):
-       audio_blk = "" if is_audio_only else "<audio><samplecharacteristics><depth>16</depth><samplerate>48000</samplerate></samplecharacteristics><channelcount>2</channelcount></audio>"
-       width_f = source_width
-       height_f = source_height
-       return f"""<file id="{fid}"><name>{os.path.basename(fpath)}</name><pathurl>{fpath}</pathurl><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><duration>{duration_frames}</duration><media><video><samplecharacteristics><width>{width_f}</width><height>{height_f}</height><alpha>straight</alpha></samplecharacteristics></video>{audio_blk}</media></file>"""
-
-    # --- VIDEO TRACK SEGMENTATION ---
-    cuts = []
-    
-    frame_face_map = {}
-    if face_data:
-        s_factor = scale_value / 100.0
-        src_cx = source_width / 2.0
-        src_cy = source_height / 2.0
-        
-        for entry in face_data:
-            frame_idx = entry.get('frame')
-            faces = entry.get('faces', [])
-            if not faces: continue
-            
-            best_face = max(faces, key=lambda f: (f[2]-f[0]) * (f[3]-f[1]))
-            cx = (best_face[0] + best_face[2]) / 2.0
-            cy = (best_face[1] + best_face[3]) / 2.0
-            
-            off_x = cx - src_cx
-            off_y = cy - src_cy
-            tgt_h = - (off_x * s_factor) / width
-            tgt_v = - (off_y * s_factor) / height
-            frame_face_map[frame_idx] = (tgt_h, tgt_v)
-
-    fps_float = float(timebase)
-    
-    if overlay_segments:
-        current_frame = 0
-        last_cam_center = (0.0, 0.0)
-        if 0 in frame_face_map: last_cam_center = frame_face_map[0]
-        
-        sorted_segs = sorted(overlay_segments, key=lambda x: x['start'])
-        
-        for seg in sorted_segs:
-            start_f = int(seg['start'] * fps_float)
-            end_f = int(seg['end'] * fps_float)
-            
-            if start_f > current_frame:
-                cuts.append({
-                    "start": current_frame, 
-                    "end": start_f, 
-                    "center": last_cam_center
-                })
-            
-            # Determine Mode Center (Avoid Middle Split)
-            candidates_h = []
-            candidates_v = []
-            for f_idx in range(start_f, end_f):
-                if f_idx in frame_face_map:
-                    pos = frame_face_map[f_idx]
-                    candidates_h.append(round(pos[0], 2)) # Round to cluster
-                    candidates_v.append(round(pos[1], 2))
-            
-            if candidates_h:
-                import statistics
-                try:
-                    # MODE: Pick the most frequent position
-                    # Multi-mode handling: min(multimode) ensures consistency
-                    best_h = min(statistics.multimode(candidates_h))
-                    best_v = min(statistics.multimode(candidates_v))
-                    current_cam_center = (best_h, best_v)
-                except:
-                    current_cam_center = last_cam_center
-            else:
-                current_cam_center = last_cam_center
-
-            cuts.append({"start": start_f, "end": end_f, "center": current_cam_center})
-            last_cam_center = current_cam_center
-            current_frame = end_f
-            
-        if current_frame < duration_frames:
-            cuts.append({"start": current_frame, "end": duration_frames, "center": last_cam_center})
-    else:
-        cuts.append({"start": 0, "end": duration_frames, "center": (0.0, 0.0)})
-
-    video_track_items = ""
-    for cut in cuts:
-        seg_start = cut['start']
-        seg_end = cut['end']
-        c_h, c_v = cut['center']
-        if seg_end - seg_start <= 0: continue
-        
-        seg_id = f"clipitem-video-{get_uid()}"
-        basic_motion = f"""<filter><effect><name>Basic Motion</name><effectid>basic</effectid><effectcategory>motion</effectcategory><effecttype>motion</effecttype><mediatype>video</mediatype><parameter authoringApp="PremierePro"><parameterid>scale</parameterid><name>Scale</name><value>{scale_value}</value></parameter><parameter authoringApp="PremierePro"><parameterid>center</parameterid><name>Center</name><value><horiz>{c_h:.5f}</horiz><vert>{c_v:.5f}</vert></value></parameter><parameter authoringApp="PremierePro"><parameterid>centerOffset</parameterid><name>Anchor Point</name><value><horiz>-0.5</horiz><vert>-0.5</vert></value></parameter></effect></filter>"""
-        video_track_items += f"""<clipitem id="{seg_id}"><name>{os.path.basename(video_path)}</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>{seg_start}</start><end>{seg_end}</end><in>{seg_start}</in><out>{seg_end}</out>{get_file_block(video_file_id, video_path)}{basic_motion}</clipitem>"""
-
-    # --- OVERLAY TRACK SEGMENTATION (Opus Style) ---
-    track_overlay_block = ""
-    if overlay_segments and len(overlay_segments) > 0:
-        overlay_clips = ""
-        fps_float = float(timebase) # Assuming roughly match
-        
-        for seg in overlay_segments:
-            start_f = int(seg['start'] * fps_float)
-            end_f = int(seg['end'] * fps_float)
-            clip_dur = end_f - start_f
-            if clip_dur <= 0: continue
-            
-            ov_name = seg['path']
-            ov_fid = f"file-ov-{seg['index']}-{get_uid()}"
-            ov_cid = f"clip-ov-{seg['index']}-{get_uid()}"
-            
-            # File block specifically for this WebP
-            file_blk = f"""<file id="{ov_fid}"><name>{os.path.basename(seg['path'])}</name><pathurl>{seg['path']}</pathurl><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><duration>{clip_dur}</duration><media><video><samplecharacteristics><width>{width}</width><height>{height}</height><alpha>straight</alpha></samplecharacteristics></video></media></file>"""
-            
-            overlay_clips += f"""<clipitem id="{ov_cid}"><name>{os.path.basename(seg['path'])}</name><duration>{clip_dur}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>{start_f}</start><end>{end_f}</end><in>0</in><out>{clip_dur}</out>{file_blk}<compositemode>normal</compositemode></clipitem>"""
-            
-        track_overlay_block = f"<track>{overlay_clips}</track>"
-    else:
-        track_overlay_block = "<track></track>"
-
-    # --- ASSEMBLE ---
-    timecode_block = f"""<timecode><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><string>00:00:00:00</string><frame>0</frame><displayformat>NDF</displayformat></timecode>"""
-    audio_blk = f"""<track><clipitem id="{audio_file_id}"><name>{os.path.basename(video_path)}</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>0</start><end>{duration_frames}</end>{get_file_block(video_file_id, video_path)}<sourcetrack><mediatype>audio</mediatype><trackindex>1</trackindex></sourcetrack></clipitem></track>"""
-
-    return f"""<?xml version="1.0" encoding="UTF-8"?><xmeml version="4"><sequence id="{sequence_uuid}"><name>{project_name}_CutRef</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate>{timecode_block}<media><video><format><samplecharacteristics><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><width>{width}</width><height>{height}</height><pixelaspectratio>square</pixelaspectratio></samplecharacteristics></format><track>{video_track_items}</track>{track_overlay_block}</video><audio>{audio_blk}</audio></media></sequence></xmeml>"""
-
-def export_pack(project_path, segment_index, output_format="premiere"):
-    """
-    Generates a ZIP Pack for the segment.
-    """
-    print(f"Starting Export Pack for Project: {os.path.basename(project_path)}, Segment: {segment_index}")
-    
-    # Paths
-    proj_name = os.path.basename(project_path)
-    cut_dir = os.path.join(project_path, "cuts")
-    
-    # 1. IDENTIFY VIDEO FILE
-    video_file = None
-    original_scale_file = None
-    
-    if os.path.exists(cut_dir):
-        files = os.listdir(cut_dir)
-        # Search for {index}_..._original_scale.mp4 or similar
-        prefix_idx = f"{segment_index:03d}_"
-        
-        for f in files:
-            if f.startswith(prefix_idx) and (f.endswith(".mp4") or f.endswith(".mov")):
-                 video_file = os.path.join(cut_dir, f)
-                 break
-    
-    if not video_file:
-        print(f"Error: No video file found for segment {segment_index} in {cut_dir}")
-        return
-        
-    print(f"Selected Video: {video_file}")
-
-    # 2. IDENTIFY SUBTITLE FILES
-    subs_dir = os.path.join(project_path, "subs_ass")
-    ass_file = None
-    
-    if os.path.exists(subs_dir):
-        sub_files = os.listdir(subs_dir)
-        prefix_idx = f"{segment_index:03d}_"
-        # Prioritize Clean Processed > Processed > Any
-        patterns = [
-            (lambda f: f.endswith(".ass") and f.startswith(prefix_idx) and "processed" in f and "original" not in f), 
-            (lambda f: f.endswith(".ass") and f.startswith(prefix_idx) and "processed" in f), 
-            (lambda f: f.endswith(".ass") and f.startswith(prefix_idx))
-        ]
-        for p in patterns:
-            if ass_file: break
-            for f in sub_files:
-                if p(f):
-                    ass_file = os.path.join(subs_dir, f)
-                    break
-    
-    # JSON in 'subs' usually
-    subs_json_dir = os.path.join(project_path, "subs")
-    json_file = None
-    if os.path.exists(subs_json_dir):
-        sub_files = os.listdir(subs_json_dir)
-        prefix_idx = f"{segment_index:03d}_"
-        # Same pattern priority
-        json_patterns = [
-            (lambda f: f.endswith(".json") and f.startswith(prefix_idx) and "processed" in f),
-            (lambda f: f.endswith(".json") and f.startswith(prefix_idx))
-        ]
-        for p in json_patterns:
-            if json_file: break
-            for f in sub_files:
-                if p(f):
-                    json_file = os.path.join(subs_json_dir, f)
-                    break
-
-    # 2.1 IDENTIFY FACE COORDS
-    final_dir = os.path.join(project_path, "final")
-    face_data = None
-    if os.path.exists(final_dir):
-        final_files = os.listdir(final_dir)
-        prefix_idx = f"{segment_index:03d}_"
-        for f in final_files:
-            if f.startswith(prefix_idx) and f.endswith("_coords.json"):
-                try:
-                    with open(os.path.join(final_dir, f), 'r') as fd:
-                        face_data = json.load(fd)
-                        print(f"Found Face Coordinates: {f}")
-                except Exception as e:
-                    print(f"Face coords load error: {e}")
-                break
-
-    # 3. PREPARE STAGING
-    export_name = f"export_{proj_name}_seg{segment_index}"
-    stage_dir = os.path.join(project_path, export_name)
-    
-    if os.path.exists(stage_dir):
-        try:
-            shutil.rmtree(stage_dir)
-        except Exception:
-            import random
-            stage_dir += f"_{random.randint(1000,9999)}"
-            
-    os.makedirs(stage_dir, exist_ok=True)
-    
-    # 4. COPY VIDEO
-    dest_video = os.path.join(stage_dir, "video_cut.mp4")
-    shutil.copy2(video_file, dest_video)
-    
-    # 5. RENDER OVERLAYS (SEGMENTED)
-    overlay_segments = []
-    if ass_file and json_file:
-         try:
-             with open(json_file, 'r', encoding='utf-8') as f:
-                 jdata = json.load(f)
-             
-             # Extract segment list
-             jdata_segs = []
-             if isinstance(jdata, dict) and "segments" in jdata:
-                 jdata_segs = jdata["segments"]
-             elif isinstance(jdata, list):
-                 jdata_segs = jdata
-             
-             if jdata_segs:
-                 # Create 'captions' subfolder for organization
-                 captions_dir = os.path.join(stage_dir, "captions")
-                 os.makedirs(captions_dir, exist_ok=True)
-                 
-                 # Render into subfolder
-                 overlay_segments = render_segmented_overlays(ass_file, jdata_segs, video_file, captions_dir)
-             
-         except Exception as e:
-             print(f"Error preparing overlay segments: {e}")
-    else:
-        print("Missing ASS or JSON for subtitles. Skipping overlays.")
-
-    # 6. GENERATE SRT (Standard)
-    dest_srt = os.path.join(stage_dir, f"{proj_name}_Seg{segment_index}.srt")
-    if json_file:
-        try:
-            with open(json_file, 'r', encoding='utf-8') as f:
-                jdata_srt = json.load(f)
-            if isinstance(jdata_srt, dict) and "segments" in jdata_srt:
-                jdata_srt = jdata_srt["segments"]
-            srt_content = json_to_srt(jdata_srt)
-            with open(dest_srt, 'w', encoding='utf-8') as f:
-                f.write(srt_content)
-        except Exception: pass
-
-    # 7. GENERATE XML
-    width_src, height_src, frames, fps = get_video_dims(dest_video)
-    
-    # Validation for resolution mismatch (same as before)
-    if face_data:
-        max_x = 0
-        for entry in face_data:
-            for f in entry.get('faces', []):
-                if len(f) >= 3 and f[2] > max_x: max_x = f[2]
-        if max_x > width_src:
-            print(f"Correction: Detecting 4K source based on face coords ({max_x} > {width_src})")
-            width_src = 3840
-            height_src = 2160
-            
-    print(f"Using Source Resolution: {width_src}x{height_src}")
+import sys
+import os
 
-    xml_content = create_premiere_xml(
-        project_name=f"{proj_name}_Seg{segment_index}",
-        video_path="video_cut.mp4", 
-        overlay_segments=overlay_segments, # LIST PASSED HERE
-        duration_frames=frames,
-        width=1080, # Target Vertical Width
-        height=1920,
-        timebase=int(float(fps) + 0.5), 
-        source_width=width_src,
-        source_height=height_src
-    )
-    
-    xml_output = os.path.join(stage_dir, "timeline.xml")
-    with open(xml_output, "w", encoding="utf-8") as f:
-        f.write(xml_content)
-        
-    print("Generated Custom Premiere XML (Opus-Style Segments).")
+# Add the script directory to path so we can import the lib if needed
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-    # 8. ZIP IT
-    zip_path = f"{stage_dir}.zip"
-    shutil.make_archive(stage_dir, 'zip', stage_dir)
-    
-    print(f"SUCCESS: Export Pack created at {zip_path}")
-    
-    # Cleanup
-    try:
-        shutil.rmtree(stage_dir)
-    except: pass
-    
-    return zip_path
+from export_xml_lib.exporter import export_pack
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()

scripts/export_xml_lib/exporter.py

@@ -0,0 +1,246 @@
+import os
+import json
+import shutil
+import zipfile
+from .utils import json_to_srt, get_video_dims
+from .face_detection import detect_faces_jit
+from .rendering import render_segmented_overlays
+from .xml_generator import create_premiere_xml
+
+def export_pack(project_path, segment_index, output_format="premiere"):
+    """
+    Generates a ZIP Pack for the segment.
+    """
+    print(f"Starting Export Pack for Project: {os.path.basename(project_path)}, Segment: {segment_index}")
+    
+    # Paths
+    proj_name = os.path.basename(project_path)
+    cut_dir = os.path.join(project_path, "cuts")
+    
+    # 1. IDENTIFY VIDEO FILE
+    video_file = None
+    original_scale_file = None
+    
+    if os.path.exists(cut_dir):
+        files = os.listdir(cut_dir)
+        # Search for {index}_..._original_scale.mp4 or similar
+        prefix_idx = f"{segment_index:03d}_"
+        
+        for f in files:
+            if f.startswith(prefix_idx) and (f.endswith(".mp4") or f.endswith(".mov")):
+                 video_file = os.path.join(cut_dir, f)
+                 break
+    
+    if not video_file:
+        print(f"Error: No video file found for segment {segment_index} in {cut_dir}")
+        return
+        
+    print(f"Selected Video: {video_file}")
+
+    # 2. IDENTIFY SUBTITLE FILES
+    subs_dir = os.path.join(project_path, "subs_ass")
+    ass_file = None
+    
+    if os.path.exists(subs_dir):
+        sub_files = os.listdir(subs_dir)
+        prefix_idx = f"{segment_index:03d}_"
+        # Prioritize Clean Processed > Processed > Any
+        patterns = [
+            (lambda f: f.endswith(".ass") and f.startswith(prefix_idx) and "processed" in f and "original" not in f), 
+            (lambda f: f.endswith(".ass") and f.startswith(prefix_idx) and "processed" in f), 
+            (lambda f: f.endswith(".ass") and f.startswith(prefix_idx))
+        ]
+        for p in patterns:
+            if ass_file: break
+            for f in sub_files:
+                if p(f):
+                    ass_file = os.path.join(subs_dir, f)
+                    break
+    
+    # JSON in 'subs' usually
+    subs_json_dir = os.path.join(project_path, "subs")
+    json_file = None
+    if os.path.exists(subs_json_dir):
+        sub_files = os.listdir(subs_json_dir)
+        prefix_idx = f"{segment_index:03d}_"
+        # Same pattern priority
+        json_patterns = [
+            (lambda f: f.endswith(".json") and f.startswith(prefix_idx) and "processed" in f),
+            (lambda f: f.endswith(".json") and f.startswith(prefix_idx))
+        ]
+        for p in json_patterns:
+            if json_file: break
+            for f in sub_files:
+                if p(f):
+                    json_file = os.path.join(subs_json_dir, f)
+                    break
+
+    # 2.1 IDENTIFY FACE COORDS
+    final_dir = os.path.join(project_path, "final")
+    face_data = None
+    if os.path.exists(final_dir):
+        final_files = os.listdir(final_dir)
+        prefix_idx = f"{segment_index:03d}_"
+        for f in final_files:
+            if f.startswith(prefix_idx) and f.endswith("_coords.json"):
+                try:
+                    with open(os.path.join(final_dir, f), 'r') as fd:
+                        face_data = json.load(fd)
+                        print(f"Found Face Coordinates: {f}")
+                except Exception as e:
+                    print(f"Face coords load error: {e}")
+                break
+    
+    if face_data is None:
+        print("No pre-computed face data found. Attempting JIT detection...")
+        face_data = detect_faces_jit(video_file)
+
+    # 3. PREPARE STAGING
+    export_name = f"export_{proj_name}_seg{segment_index}"
+    stage_dir = os.path.join(project_path, export_name)
+    
+    if os.path.exists(stage_dir):
+        try:
+            shutil.rmtree(stage_dir)
+        except Exception:
+            import random
+            stage_dir += f"_{random.randint(1000,9999)}"
+            
+    os.makedirs(stage_dir, exist_ok=True)
+    
+    # 4. COPY VIDEO (Prefer Original Scale for XML editing)
+    source_video_to_copy = video_file
+    dest_filename = "video_cut.mp4"
+    
+    # Try to find original scale version in 'cuts' folder
+    # video_file is usually in 'cuts', lets check there
+    try:
+        cuts_dir = os.path.dirname(video_file)
+        # Attempt 1: Direct suffix replacement
+        original_scale_candidate = video_file.replace(".mp4", "_original_scale.mp4")
+        
+        if not os.path.exists(original_scale_candidate):
+             # Attempt 2: Search by prefix
+             prefix_idx = f"{segment_index:03d}_"
+             if os.path.exists(cuts_dir):
+                 for f in os.listdir(cuts_dir):
+                     if f.startswith(prefix_idx) and "original_scale" in f and f.endswith(".mp4"):
+                         original_scale_candidate = os.path.join(cuts_dir, f)
+                         break
+        
+        if os.path.exists(original_scale_candidate):
+            print(f"Using Original Scale Source for Export: {original_scale_candidate}")
+            source_video_to_copy = original_scale_candidate
+            dest_filename = "video_source.mp4" # Distinct name
+    except Exception as e:
+        print(f"Error checking for original scale video: {e}")
+    
+    dest_video = os.path.join(stage_dir, dest_filename)
+    shutil.copy2(source_video_to_copy, dest_video)
+    
+    # 5. RENDER OVERLAYS (SEGMENTED)
+    overlay_segments = []
+    if ass_file and json_file:
+         try:
+             with open(json_file, 'r', encoding='utf-8') as f:
+                 jdata = json.load(f)
+             
+             # Extract segment list
+             jdata_segs = []
+             if isinstance(jdata, dict) and "segments" in jdata:
+                 jdata_segs = jdata["segments"]
+             elif isinstance(jdata, list):
+                 jdata_segs = jdata
+             
+             if jdata_segs:
+                 # Create 'captions' subfolder for organization
+                 captions_dir = os.path.join(stage_dir, "captions")
+                 os.makedirs(captions_dir, exist_ok=True)
+                 
+                 # Render into subfolder
+                 overlay_segments = render_segmented_overlays(ass_file, jdata_segs, video_file, captions_dir)
+             
+         except Exception as e:
+             print(f"Error preparing overlay segments: {e}")
+    else:
+        print("Missing ASS or JSON for subtitles. Skipping overlays.")
+
+    # 6. GENERATE SRT (Standard)
+    dest_srt = os.path.join(stage_dir, f"{proj_name}_Seg{segment_index}.srt")
+    if json_file:
+        try:
+            with open(json_file, 'r', encoding='utf-8') as f:
+                jdata_srt = json.load(f)
+            if isinstance(jdata_srt, dict) and "segments" in jdata_srt:
+                jdata_srt = jdata_srt["segments"]
+            srt_content = json_to_srt(jdata_srt)
+            with open(dest_srt, 'w', encoding='utf-8') as f:
+                f.write(srt_content)
+        except Exception: pass
+
+    # 7. GENERATE XML
+    width_src, height_src, frames, fps = get_video_dims(dest_video)
+    
+    # Validation for resolution mismatch (same as before)
+    if face_data:
+        max_x = 0
+        for entry in face_data:
+            for f in entry.get('faces', []):
+                if len(f) >= 3 and f[2] > max_x: max_x = f[2]
+        if max_x > width_src:
+            print(f"Correction: Detecting 4K source based on face coords ({max_x} > {width_src})")
+            width_src = 3840
+            height_src = 2160
+         # 6. XML GENERATION
+    width, height, duration, fps = get_video_dims(video_file)
+    
+    print(f"DEBUG: Passing face_data to XML: {len(face_data) if face_data else 'None'}")
+    
+    # Logic to Determine Sequence Resolution
+    # Default 1080p Vertical
+    seq_w = 1080
+    seq_h = 1920
+    
+    # If source is 4K (Width > 2000 or Height > 2000), upgrade to 4K Vertical
+    # Note: width_src from 'get_video_dims' usually returns width. 
+    # Normal 4K is 3840x2160.
+    if width_src > 3000 or height_src > 3000:
+        print("Detected 4K Source Content. Setting Sequence to 4K Vertical (2160x3840).")
+        seq_w = 2160
+        seq_h = 3840
+    else:
+        print("Source is 1080p or lower. Setting Sequence to 1080p Vertical (1080x1920).")
+
+    xml_content = create_premiere_xml(
+        project_name=proj_name, 
+        video_path=dest_video,
+        overlay_segments=overlay_segments,
+        duration_frames=duration,
+        width=seq_w, 
+        height=seq_h,
+        timebase=int(fps),
+        scale_value=100.0,
+        face_data=face_data,
+        source_width=width_src,
+        source_height=height_src
+    )
+    
+    xml_output = os.path.join(stage_dir, "timeline.xml")
+    with open(xml_output, "w", encoding="utf-8") as f:
+        f.write(xml_content)
+        
+    print("Generated Custom Premiere XML (Opus-Style Segments).")
+
+    # 8. ZIP IT
+    zip_path = f"{stage_dir}.zip"
+    shutil.make_archive(stage_dir, 'zip', stage_dir)
+    
+    print(f"SUCCESS: Export Pack created at {zip_path}")
+    
+    # Cleanup
+    try:
+        # shutil.rmtree(stage_dir)
+        pass
+    except: pass
+    
+    return zip_path

scripts/export_xml_lib/face_detection.py

@@ -0,0 +1,72 @@
+import os
+try:
+    import cv2
+    import numpy as np
+    from insightface.app import FaceAnalysis
+    INSIGHTFACE_AVAILABLE = True
+except ImportError:
+    INSIGHTFACE_AVAILABLE = False
+    print("Warning: InsightFace not available. Dynamic cuts may fail if coords missing.")
+
+def detect_faces_jit(video_path):
+    """
+    Runs face detection on the fly if pre-computed coords are missing.
+    Returns: list of {'frame': int, 'faces': [[x1,y1,x2,y2]]}
+    """
+    if not INSIGHTFACE_AVAILABLE: 
+        print("ERROR: InsightFace not loaded.")
+        return []
+    
+    # Normalize path for Windows OpenCV
+    video_path = os.path.abspath(video_path)
+    print(f"Running JIT Face Detection on: {video_path}")
+    
+    # Initialize InsightFace
+    try:
+        app = FaceAnalysis(name='buffalo_l', providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
+        app.prepare(ctx_id=0, det_size=(640, 640))
+    except Exception as e:
+        print(f"InsightFace Init Error: {e}. Trying CPU only.")
+        app = FaceAnalysis(name='buffalo_l', providers=['CPUExecutionProvider'])
+        app.prepare(ctx_id=0, det_size=(640, 640))
+        
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print(f"CRITICAL ERROR: Could not open video file for JIT detection: {video_path}")
+        # Try handling unicode path issues if any, though abspath helps
+        return []
+
+    face_data = []
+    frame_idx = 0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    print(f"Video opened. Total frames: {total_frames}")
+    
+    faces_found_count = 0
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret: break
+        
+        faces = app.get(frame)
+        current_faces = []
+        for face in faces:
+            bbox = face.bbox.astype(int).tolist()
+            current_faces.append(bbox)
+        
+        if current_faces:
+            face_data.append({
+                "frame": frame_idx,
+                "faces": current_faces
+            })
+            faces_found_count += 1
+            if faces_found_count <= 5: # Debug first few detections
+                print(f"  [DEBUG] Frame {frame_idx}: Found {len(faces)} faces: {current_faces}")
+            
+        if frame_idx % 200 == 0:
+            print(f"  Scanning faces: {frame_idx}/{total_frames}...")
+            
+        frame_idx += 1
+        
+    cap.release()
+    print(f"JIT Detection Complete. Found faces in {len(face_data)} frames.")
+    return face_data

scripts/export_xml_lib/rendering.py

@@ -0,0 +1,54 @@
+import os
+import subprocess
+from .utils import get_video_dims
+
+def render_segmented_overlays(ass_path, segments, video_path, output_dir):
+    """
+    Renders segments using a physical transparent PNG canvas to ensure alpha correctness.
+    """
+    width, height, _, fps = get_video_dims(video_path)
+    ass_path_sanitized = ass_path.replace("\\", "/").replace(":", "\\:")
+    
+    # Generate Base Canvas
+    canvas_png = os.path.join(output_dir, "base_canvas.png")
+    subprocess.run([
+        "ffmpeg", "-y", "-f", "lavfi", "-i", f"color=c=black@0.0:s={width}x{height}", 
+        "-frames:v", "1", "-c:v", "png", canvas_png
+    ], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
+    
+    overlay_data = []
+    print(f"Rendering {len(segments)} subtitle segments (Mode: Canvas + QTRLE)...")
+    
+    for i, seg in enumerate(segments):
+        start = seg.get('start', 0)
+        end = seg.get('end', 0)
+        duration = end - start
+        if duration <= 0: continue
+        
+        filename = f"caption_{i}.mov"
+        out_path = os.path.join(output_dir, filename)
+        
+        # QTRLE (QuickTime Animation) - The absolute reference for Alpha.
+        # Slightly larger files than PNG, but 100% compatible.
+        cmd = [
+            "ffmpeg", "-y",
+            "-loop", "1", "-i", canvas_png,
+            "-vf", f"format=rgba,setpts=PTS+{start}/TB,ass='{ass_path_sanitized}',setpts=PTS-{start}/TB,format=rgba",
+            "-t", str(duration),
+            "-c:v", "qtrle",
+            "-pix_fmt", "argb", # qtrle uses argb pixel format usually
+            "-an",
+            out_path
+        ]
+        
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
+            rel_path = os.path.join("captions", filename).replace("\\", "/")
+            overlay_data.append({ "path": rel_path, "start": start, "end": end, "index": i })
+            print(f"  [Seg {i}] Rendered {duration:.2f}s")
+        except subprocess.CalledProcessError as e:
+            print(f"  [Seg {i}] Failed: {e}")
+            
+    if os.path.exists(canvas_png): os.remove(canvas_png)
+
+    return overlay_data

scripts/export_xml_lib/utils.py

@@ -0,0 +1,73 @@
+from datetime import timedelta
+import subprocess
+
+def timestamp_to_srt(seconds):
+    td = timedelta(seconds=seconds)
+    total_seconds = int(td.total_seconds())
+    micros = td.microseconds
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{hours:02}:{minutes:02}:{seconds:02},{micros//1000:03}"
+
+def json_to_srt(json_data):
+    """
+    Converts internal JSON subtitle format to SRT.
+    If 'words' key is present, generates word-level timestamps (Karaoke/Editing style).
+    Otherwise, uses segment-level timestamps.
+    """
+    srt_content = ""
+    counter = 1
+    
+    for block in json_data:
+        # Check if words detail is available for Word-Level SRT
+        if isinstance(block, dict) and "words" in block and block["words"]:
+            for word_obj in block["words"]:
+                start = word_obj.get('start', 0)
+                end = word_obj.get('end', 0)
+                text = word_obj.get('word', "")
+                
+                srt_content += f"{counter}\n"
+                srt_content += f"{timestamp_to_srt(start)} --> {timestamp_to_srt(end)}\n"
+                srt_content += f"{text}\n\n"
+                counter += 1
+        else:
+            # Fallback to segment level
+            start = 0
+            end = 0
+            text = ""
+            if isinstance(block, dict):
+                start = block.get('start', 0)
+                end = block.get('end', 0)
+                text = block.get('text', "")
+            elif isinstance(block, (list, tuple)) and len(block) >= 3:
+                start, end, text = block[0], block[1], block[2]
+                
+            srt_content += f"{counter}\n"
+            srt_content += f"{timestamp_to_srt(start)} --> {timestamp_to_srt(end)}\n"
+            srt_content += f"{text}\n\n"
+            counter += 1
+            
+    return srt_content
+
+def get_video_dims(vid_path):
+    """Returns (width, height, duration_frames)"""
+    try:
+        cmd_w = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
+        width = int(subprocess.check_output(cmd_w).decode().strip())
+        
+        cmd_h = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=height", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
+        height = int(subprocess.check_output(cmd_h).decode().strip())
+        
+        cmd_dur = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
+        dur_sec = float(subprocess.check_output(cmd_dur).decode().strip())
+        
+        # Assume 30fps for calculation if not probed, but probing is better
+        cmd_fps = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=r_frame_rate", "-of", "default=noprint_wrappers=1:nokey=1", vid_path]
+        fps_str = subprocess.check_output(cmd_fps).decode().strip()
+        num, den = map(int, fps_str.split('/'))
+        fps = num / den if den > 0 else 30.0
+        
+        return width, height, int(dur_sec * fps), fps
+    except Exception as e:
+        print(f"Error probing video: {e}")
+        return 1920, 1080, 300, 30.0

scripts/export_xml_lib/xml_generator copy.py

@@ -0,0 +1,342 @@
+import os
+import uuid
+import statistics
+
+def create_premiere_xml(project_name, video_path, overlay_segments, duration_frames, width=1080, height=1920, timebase=30, video_file_id=None, audio_file_id=None, scale_value=100.0, face_data=None, source_width=1920, source_height=1080):
+    """
+    Generates a Premiere Pro XML with segmented cuts, supporting Dual-Track (Split Screen) for multi-face scenarios.
+    """
+    
+    def get_uid(): return str(uuid.uuid4())[:12]
+    
+    if not video_file_id: video_file_id = f"file-video-{get_uid()}"
+    if not audio_file_id: audio_file_id = f"file-audio-{get_uid()}"
+    sequence_uuid = str(uuid.uuid4())
+    
+    # helper for file blocks
+    def get_file_block(fid, fpath, is_audio_only=False):
+       audio_blk = "" if is_audio_only else "<audio><samplecharacteristics><depth>16</depth><samplerate>48000</samplerate></samplecharacteristics><channelcount>2</channelcount></audio>"
+       width_f = int(source_width)
+       height_f = int(source_height)
+       return f"""<file id="{fid}"><name>{os.path.basename(fpath)}</name><pathurl>{fpath}</pathurl><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><duration>{duration_frames}</duration><media><video><samplecharacteristics><width>{width_f}</width><height>{height_f}</height><alpha>straight</alpha></samplecharacteristics></video>{audio_blk}</media></file>"""
+
+    # --- PROCESS FACE DATA (Per Frame) ---
+    # We store raw faces per frame to decide clustering later
+    faces_per_frame = {} 
+    
+    # Dimensions for Coordinate Normalization (Default to source if not in JSON)
+    coords_w = source_width
+    coords_h = source_height
+    
+    if face_data:
+        # Check for Metadata in first entry to determine Coordinate System Scale
+        if len(face_data) > 0:
+             first_entry = face_data[0]
+             if "src_size" in first_entry:
+                 try:
+                     w_json, h_json = first_entry["src_size"]
+                     if w_json > 0 and h_json > 0:
+                         coords_w = w_json
+                         coords_h = h_json
+                         print(f"Coordinate System Reference: {coords_w}x{coords_h}")
+                         # DO NOT overwrite source_width/source_height (Actual Media Dims)
+                 except: pass
+
+        print(f"Processing {len(face_data)} face entries for Dual-Track logic...")
+        for entry in face_data:
+            f_idx = entry.get('frame')
+            faces = entry.get('faces', [])
+            if not faces: continue
+            
+            processed_faces = []
+            for f in faces:
+                cx = (f[0] + f[2]) / 2.0
+                cy = (f[1] + f[3]) / 2.0
+                area = (f[2]-f[0]) * (f[3]-f[1])
+                
+                # Calculate Normalized Center using COORDS Dimensions
+                # nx, ny are 0..1 relative to the original detection frame
+                nx = cx / max(1.0, float(coords_w))
+                ny = cy / max(1.0, float(coords_h))
+                
+                # rh uses coords_h
+                rh_val = 0.1
+                if len(f) > 4:
+                    rh_val = float(f[4])
+                else:
+                    rh_val = (f[3] - f[1]) / max(1.0, float(coords_h))
+                
+                processed_faces.append({
+                    'cx': cx, 
+                    'cy': cy,
+                    'nx': nx, 
+                    'ny': ny,
+                    'area': area,
+                    'rh': rh_val 
+                })
+            
+            faces_per_frame[f_idx] = processed_faces
+    
+    # Ensure source_width/height are floats for calculation later
+    source_width = float(source_width)
+    source_height = float(source_height)
+
+    # --- SEGMENTATION LOGIC ---
+    cuts_v1 = [] # Track 1 (Main / Left)
+    cuts_v2 = [] # Track 2 (Secondary / Right)
+    
+    fps_float = float(timebase)
+    
+    # Store dynamic scale suggestion per cut if possible
+    # (Not fully implemented per-cut yet, but we can compute a global or per-segment average if we stored it)
+    
+    if overlay_segments:
+        current_frame = 0
+        
+        # Defaults (Normalized Centers)
+        last_center_v1 = (0.5, 0.5)
+        last_center_v2 = (0.5, 0.5)
+        
+        # We also want to track optimal scale for the segment
+        last_opt_scale = None
+        
+        sorted_segs = sorted(overlay_segments, key=lambda x: x['start'])
+        is_last_dual = False # Initialize is_last_dual
+
+        for idx, seg in enumerate(sorted_segs):
+            start_f = int(seg['start'] * fps_float)
+            end_f = int(seg['end'] * fps_float)
+            
+            # Fill Gaps
+            if start_f > current_frame:
+                cuts_v1.append({"start": current_frame, "end": start_f, "center": last_center_v1, "opt_scale": last_opt_scale})
+                if is_last_dual: 
+                     cuts_v2.append({"start": current_frame, "end": start_f, "center": last_center_v2, "opt_scale": last_opt_scale})
+                pass 
+            
+            # Analyze Faces
+            segment_faces = []
+            frame_count = 0
+            dual_face_frames = 0
+            
+            for f_idx in range(start_f, end_f):
+                if f_idx in faces_per_frame:
+                    fs = faces_per_frame[f_idx]
+                    segment_faces.append(fs)
+                    if len(fs) >= 2:
+                        dual_face_frames += 1
+                frame_count += 1
+            
+            is_dual_track = False
+            if frame_count > 0:
+                dual_ratio = dual_face_frames / frame_count
+                if dual_ratio > 0.3:
+                    is_dual_track = True
+                elif frame_count < 15 and dual_face_frames > 0:
+                     is_dual_track = True
+            
+            center_v1 = last_center_v1
+            center_v2 = last_center_v2
+            
+            # Coordinate lists for mode calculation
+            cand_v1_x, cand_v1_y = [], []
+            cand_v2_x, cand_v2_y = [], []
+            cand_rh = [] # Relative heights
+            
+            if segment_faces:
+                for fs in segment_faces:
+                    # Filter Top 2 by Area
+                    top_faces = sorted(fs, key=lambda x: x['area'], reverse=True)[:2]
+                    # Sort by X (Left to Right)
+                    fs_sorted = sorted(top_faces, key=lambda x: x['nx'])
+                    
+                    if is_dual_track and len(fs_sorted) >= 2:
+                        # Left -> V2 (Top Track, Upper Screen)
+                        # Right -> V1 (Bottom Track, Lower Screen)
+                        f_left = fs_sorted[0]
+                        f_right = fs_sorted[-1] 
+                        
+                        cand_rh.append(f_left.get('rh', 0.1))
+                        cand_rh.append(f_right.get('rh', 0.1))
+                        
+                        if abs(f_left['nx'] - f_right['nx']) < 0.20:
+                             # Fallback to single
+                             f_main = max(fs, key=lambda x: x['area'])
+                             cand_v1_x.append(f_main['nx'])
+                             cand_v1_y.append(f_main['ny'])
+                             if 'rh' in f_main: cand_rh[-2:] = [f_main['rh']]
+                        else:
+                            # Swap Assignment Here: 
+                            # Left Face -> V2 (Top)
+                            cand_v2_x.append(f_left['nx'])
+                            cand_v2_y.append(f_left['ny'])
+                            
+                            # Right Face -> V1 (Bottom)
+                            cand_v1_x.append(f_right['nx'])
+                            cand_v1_y.append(f_right['ny'])
+                        
+                    elif fs_sorted:
+                        # Single -> V1
+                        f1 = max(fs_sorted, key=lambda x: x['area'])
+                        cand_v1_x.append(f1['nx'])
+                        cand_v1_y.append(f1['ny'])
+                        cand_rh.append(f1.get('rh', 0.1))
+
+            # Smart Scale Logic REMOVED per user request
+            # We will rely on strict "Fill Split Pane Height" logic in make_video_track
+            opt_scale = None
+            last_opt_scale = None
+
+            # Apply Mode (Robust avg)
+            def get_mode_avg(vals):
+                if not vals: return 0.5
+                try: return statistics.mean(vals)
+                except: return vals[0]
+            
+            # If after filtering we have no valid V2 candidates, revert to Single Track
+            if is_dual_track and not cand_v2_x:
+                is_dual_track = False
+                
+            if cand_v1_x:
+                center_v1 = (get_mode_avg(cand_v1_x), get_mode_avg(cand_v1_y))
+            
+            if is_dual_track:
+                if cand_v2_x:
+                     center_v2 = (get_mode_avg(cand_v2_x), get_mode_avg(cand_v2_y))
+                else:
+                     # This branch should rarely be hit now due to check above
+                     if last_center_v2 != (0.5, 0.5): center_v2 = last_center_v2
+                     else: center_v2 = (center_v1[0] + 0.25, center_v1[1]) 
+                
+            # Append Cuts
+            cuts_v1.append({"start": start_f, "end": end_f, "center": center_v1, "opt_scale": opt_scale})
+            
+            if is_dual_track:
+                cuts_v2.append({"start": start_f, "end": end_f, "center": center_v2, "opt_scale": opt_scale})
+                last_center_v2 = center_v2
+                is_last_dual = True
+            else:
+                is_last_dual = False
+            
+            last_center_v1 = center_v1
+            current_frame = end_f
+            
+        # Final gap
+        if current_frame < duration_frames:
+             cuts_v1.append({"start": current_frame, "end": duration_frames, "center": last_center_v1, "opt_scale": last_opt_scale})
+
+    else:
+        cuts_v1.append({"start": 0, "end": duration_frames, "center": (0.5, 0.5), "opt_scale": None})
+
+    print(f"Generated {len(cuts_v1)} V1 cuts and {len(cuts_v2)} V2 cuts.")
+
+    # --- GENERATE XML TRACKS ---
+    dual_starts = set(c['start'] for c in cuts_v2)
+    
+    def make_video_track(cuts_list, track_type="main"):
+        items = ""
+        for cut in cuts_list:
+            seg_start, seg_end = cut['start'], cut['end']
+            nx, ny = cut['center'] # These are Normalized Source Coords (0..1)
+            
+            if seg_end - seg_start <= 0: continue
+            
+            is_dual = (seg_start in dual_starts)
+            
+            # --- DIMENSION CHECKS ---
+            src_w = float(source_width)
+            src_h = float(source_height)
+            if src_h < 100: src_h = 1080.0 # Safety default
+            
+            # --- SCALE LOGIC ---
+            # Fill Sequence Height (Matches User's Request for correct scaling)
+            # Use the actual Sequence Height passed to create_premiere_xml
+            # Fill Sequence Height (Matches User's Request for correct scaling)
+            # Use the actual Sequence Height passed to create_premiere_xml
+            target_h = float(height)
+            
+            # ALWAYS scale to fill the sequence height
+            final_scale = (target_h / src_h) * 100.0
+
+            if final_scale < 10.0: final_scale = 100.0
+            
+            s_val = final_scale / 100.0
+
+            # --- POSITIONING LOGIC (Shift-Based) ---
+            # We assume Anchor Point is (0,0) -> CENTER of Clip.
+            # We want to move the Face (nx, ny) to the Target Screen Position.
+            
+            # 1. Face Offset from Clip Center (in Source Pixels)
+            # Center of Source is 0.5, 0.5
+            off_x_src = (nx - 0.5) * src_w
+            off_y_src = (ny - 0.5) * src_h
+            
+            # 2. Face Offset in Screen Pixels (after Scale)
+            off_x_seq = off_x_src * s_val
+            off_y_seq = off_y_src * s_val
+            
+            # 3. Target Screen Position (Pixels)
+            # Sequence Dimensions: width, height (e.g. 1080, 1920)
+            target_screen_x = 0.5 * width # Center X
+            target_screen_y = 0.5 * height # Center Y (Default)
+            
+            if track_type == "secondary": 
+                target_screen_y = 0.25 * height # Top Quarter
+            elif track_type == "main" and is_dual: 
+                target_screen_y = 0.75 * height # Bottom Quarter
+            
+            # 4. Required Clip Center Position
+            # To place Face at Target, we shift Clip Center by -Offset
+            req_center_x = target_screen_x - off_x_seq
+            req_center_y = target_screen_y - off_y_seq
+            
+            # 5. Normalize for XML (0..1 relative to Sequence)
+            # XML Coordinate System is Relative to Center (0,0 is Center).
+            # Absolute 0..1 maps to -0.5..0.5 in XML.
+            pos_h = (req_center_x / float(width)) - 0.5
+            pos_v = (req_center_y / float(height)) - 0.5
+            
+            seg_id = f"clipitem-video-{get_uid()}"
+            
+            # EXPLICITLY REMOVE Anchor Point (centerOffset) to use Default (Center of Clip).
+            # We calculate pos_h/pos_v assuming we are placing the Clip Center.
+            
+            basic_motion = f"""<filter><effect><name>Basic Motion</name><effectid>basic</effectid><effectcategory>motion</effectcategory><effecttype>motion</effecttype><mediatype>video</mediatype><parameter authoringApp="PremierePro"><parameterid>scale</parameterid><name>Scale</name><value>{final_scale:.2f}</value></parameter><parameter authoringApp="PremierePro"><parameterid>center</parameterid><name>Center</name><value><horiz>{pos_h:.5f}</horiz><vert>{pos_v:.5f}</vert></value></parameter></effect></filter>"""
+            
+            # --- CROP LOGIC ---
+            crop_xml = ""
+            if track_type == "secondary":
+                 crop_xml = f"""<filter><effect><name>Crop</name><effectid>crop</effectid><effectcategory>transform</effectcategory><effecttype>video</effecttype><mediatype>video</mediatype><parameter authoringApp="PremierePro"><parameterid>bottom</parameterid><name>Bottom</name><value>50.0</value></parameter></effect></filter>"""
+            elif track_type == "main" and is_dual:
+                 crop_xml = f"""<filter><effect><name>Crop</name><effectid>crop</effectid><effectcategory>transform</effectcategory><effecttype>video</effecttype><mediatype>video</mediatype><parameter authoringApp="PremierePro"><parameterid>top</parameterid><name>Top</name><value>50.0</value></parameter></effect></filter>"""
+
+            items += f"""<clipitem id="{seg_id}"><name>{os.path.basename(video_path)}</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>{seg_start}</start><end>{seg_end}</end><in>{seg_start}</in><out>{seg_end}</out>{get_file_block(video_file_id, video_path)}{basic_motion}{crop_xml}</clipitem>"""
+        return f"<track>{items}</track>"
+
+    track_v1 = make_video_track(cuts_v1, "main")
+    track_v2 = make_video_track(cuts_v2, "secondary")
+
+    # --- OVERLAY TRACK ---
+    track_overlay_block = ""
+    if overlay_segments:
+        overlay_clips = ""
+        for seg in overlay_segments:
+            # ... (overlay logic same as before)
+            # Re-implement simple loop here to ensure variable scope
+            start_f = int(seg['start'] * fps_float)
+            end_f = int(seg['end'] * fps_float)
+            clip_dur = end_f - start_f
+            if clip_dur <= 0: continue
+            ov_fid = f"file-ov-{seg['index']}-{get_uid()}"
+            ov_cid = f"clip-ov-{seg['index']}-{get_uid()}"
+            file_blk = f"""<file id="{ov_fid}"><name>{os.path.basename(seg['path'])}</name><pathurl>{seg['path']}</pathurl><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><duration>{clip_dur}</duration><media><video><samplecharacteristics><width>{width}</width><height>{height}</height><alpha>straight</alpha></samplecharacteristics></video></media></file>"""
+            overlay_clips += f"""<clipitem id="{ov_cid}"><name>{os.path.basename(seg['path'])}</name><duration>{clip_dur}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>{start_f}</start><end>{end_f}</end><in>0</in><out>{clip_dur}</out>{file_blk}<compositemode>normal</compositemode></clipitem>"""
+        track_overlay_block = f"<track>{overlay_clips}</track>"
+    else:
+        track_overlay_block = "<track></track>"
+
+    # --- ASSEMBLE ---
+    timecode_block = f"""<timecode><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><string>00:00:00:00</string><frame>0</frame><displayformat>NDF</displayformat></timecode>"""
+    audio_blk = f"""<track><clipitem id="{audio_file_id}"><name>{os.path.basename(video_path)}</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>0</start><end>{duration_frames}</end>{get_file_block(video_file_id, video_path)}<sourcetrack><mediatype>audio</mediatype><trackindex>1</trackindex></sourcetrack></clipitem></track>"""
+
+    return f"""<?xml version="1.0" encoding="UTF-8"?><xmeml version="4"><sequence id="{sequence_uuid}"><name>{project_name}_CutRef</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate>{timecode_block}<media><video><format><samplecharacteristics><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><width>{width}</width><height>{height}</height><pixelaspectratio>square</pixelaspectratio></samplecharacteristics></format>{track_v1}{track_v2}{track_overlay_block}</video><audio>{audio_blk}</audio></media></sequence></xmeml>"""

scripts/export_xml_lib/xml_generator.py

@@ -0,0 +1,388 @@
+import os
+import uuid
+import statistics
+
+def create_premiere_xml(project_name, video_path, overlay_segments, duration_frames, width=1080, height=1920, timebase=30, video_file_id=None, audio_file_id=None, scale_value=100.0, face_data=None, source_width=1920, source_height=1080):
+    """
+    Generates a Premiere Pro XML with segmented cuts, supporting Dual-Track (Split Screen) for multi-face scenarios.
+    """
+    
+    def get_uid(): return str(uuid.uuid4())[:12]
+    
+    if not video_file_id: video_file_id = f"file-video-{get_uid()}"
+    if not audio_file_id: audio_file_id = f"file-audio-{get_uid()}"
+    sequence_uuid = str(uuid.uuid4())
+    
+    # helper for file blocks
+    def get_file_block(fid, fpath, is_audio_only=False):
+       audio_blk = "" if is_audio_only else "<audio><samplecharacteristics><depth>16</depth><samplerate>48000</samplerate></samplecharacteristics><channelcount>2</channelcount></audio>"
+       width_f = int(source_width)
+       height_f = int(source_height)
+       return f"""<file id="{fid}"><name>{os.path.basename(fpath)}</name><pathurl>{fpath}</pathurl><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><duration>{duration_frames}</duration><media><video><samplecharacteristics><width>{width_f}</width><height>{height_f}</height><alpha>straight</alpha></samplecharacteristics></video>{audio_blk}</media></file>"""
+
+    # --- PROCESS FACE DATA (Per Frame) ---
+    # We store raw faces per frame to decide clustering later
+    faces_per_frame = {} 
+    
+    # Dimensions for Coordinate Normalization (Default to source if not in JSON)
+    coords_w = source_width
+    coords_h = source_height
+    
+    if face_data:
+        # Check for Metadata in first entry to determine Coordinate System Scale
+        if len(face_data) > 0:
+             first_entry = face_data[0]
+             if "src_size" in first_entry:
+                 try:
+                     w_json, h_json = first_entry["src_size"]
+                     if w_json > 0 and h_json > 0:
+                         coords_w = w_json
+                         coords_h = h_json
+                         print(f"Coordinate System Reference: {coords_w}x{coords_h}")
+                         # DO NOT overwrite source_width/source_height (Actual Media Dims)
+                 except: pass
+
+        print(f"Processing {len(face_data)} face entries for Dual-Track logic...")
+        for entry in face_data:
+            f_idx = entry.get('frame')
+            faces = entry.get('faces', [])
+            if not faces: continue
+            
+            processed_faces = []
+            for f in faces:
+                cx = (f[0] + f[2]) / 2.0
+                cy = (f[1] + f[3]) / 2.0
+                area = (f[2]-f[0]) * (f[3]-f[1])
+                
+                # Calculate Normalized Center using COORDS Dimensions
+                # nx, ny are 0..1 relative to the original detection frame
+                nx = cx / max(1.0, float(coords_w))
+                ny = cy / max(1.0, float(coords_h))
+                
+                # rh uses coords_h
+                rh_val = 0.1
+                if len(f) > 4:
+                    rh_val = float(f[4])
+                else:
+                    rh_val = (f[3] - f[1]) / max(1.0, float(coords_h))
+                
+                processed_faces.append({
+                    'cx': cx, 
+                    'cy': cy,
+                    'nx': nx, 
+                    'ny': ny,
+                    'area': area,
+                    'rh': rh_val 
+                })
+            
+            faces_per_frame[f_idx] = processed_faces
+    
+    # Ensure source_width/height are floats for calculation later
+    source_width = float(source_width)
+    source_height = float(source_height)
+
+    # --- SEGMENTATION LOGIC ---
+    cuts_v1 = [] # Track 1 (Main / Left)
+    cuts_v2 = [] # Track 2 (Secondary / Right)
+    
+    fps_float = float(timebase)
+    
+    # Store dynamic scale suggestion per cut if possible
+    # (Not fully implemented per-cut yet, but we can compute a global or per-segment average if we stored it)
+    
+    if overlay_segments:
+        current_frame = 0
+        
+        # Defaults (Normalized Centers)
+        last_center_v1 = (0.5, 0.5)
+        last_center_v2 = (0.5, 0.5)
+        
+        # We also want to track optimal scale for the segment
+        last_opt_scale = None
+        
+        sorted_segs = sorted(overlay_segments, key=lambda x: x['start'])
+        is_last_dual = False # Initialize is_last_dual
+
+        for idx, seg in enumerate(sorted_segs):
+            start_f = int(seg['start'] * fps_float)
+            end_f = int(seg['end'] * fps_float)
+            
+            # Fill Gaps
+            if start_f > current_frame:
+                cuts_v1.append({"start": current_frame, "end": start_f, "center": last_center_v1, "opt_scale": last_opt_scale})
+                if is_last_dual: 
+                     cuts_v2.append({"start": current_frame, "end": start_f, "center": last_center_v2, "opt_scale": last_opt_scale})
+                pass 
+            
+            # Analyze Faces
+            segment_faces = []
+            frame_count = 0
+            dual_face_frames = 0
+            
+            for f_idx in range(start_f, end_f):
+                if f_idx in faces_per_frame:
+                    fs = faces_per_frame[f_idx]
+                    segment_faces.append(fs)
+                    if len(fs) >= 2:
+                        dual_face_frames += 1
+                frame_count += 1
+            
+            is_dual_track = False
+            if frame_count > 0:
+                dual_ratio = dual_face_frames / frame_count
+                if dual_ratio > 0.3:
+                    is_dual_track = True
+                elif frame_count < 15 and dual_face_frames > 0:
+                     is_dual_track = True
+            
+            center_v1 = last_center_v1
+            center_v2 = last_center_v2
+            
+            # Coordinate lists for mode calculation
+            cand_v1_x, cand_v1_y = [], []
+            cand_v2_x, cand_v2_y = [], []
+            cand_rh = [] # Relative heights
+            
+            if segment_faces:
+                for fs in segment_faces:
+                    # Filter Top 2 by Area
+                    top_faces = sorted(fs, key=lambda x: x['area'], reverse=True)[:2]
+                    # Sort by X (Left to Right)
+                    fs_sorted = sorted(top_faces, key=lambda x: x['nx'])
+                    
+                    if is_dual_track and len(fs_sorted) >= 2:
+                        # Left -> V2 (Top Track, Upper Screen)
+                        # Right -> V1 (Bottom Track, Lower Screen)
+                        f_left = fs_sorted[0]
+                        f_right = fs_sorted[-1] 
+                        
+                        cand_rh.append(f_left.get('rh', 0.1))
+                        cand_rh.append(f_right.get('rh', 0.1))
+                        
+                        if abs(f_left['nx'] - f_right['nx']) < 0.20:
+                             # Fallback to single
+                             f_main = max(fs, key=lambda x: x['area'])
+                             cand_v1_x.append(f_main['nx'])
+                             cand_v1_y.append(f_main['ny'])
+                             if 'rh' in f_main: cand_rh[-2:] = [f_main['rh']]
+                        else:
+                            # Swap Assignment Here: 
+                            # Left Face -> V2 (Top)
+                            cand_v2_x.append(f_left['nx'])
+                            cand_v2_y.append(f_left['ny'])
+                            
+                            # Right Face -> V1 (Bottom)
+                            cand_v1_x.append(f_right['nx'])
+                            cand_v1_y.append(f_right['ny'])
+                        
+                    elif fs_sorted:
+                        # Single -> V1
+                        f1 = max(fs_sorted, key=lambda x: x['area'])
+                        cand_v1_x.append(f1['nx'])
+                        cand_v1_y.append(f1['ny'])
+                        cand_rh.append(f1.get('rh', 0.1))
+
+            # Smart Scale Logic REMOVED per user request
+            # We will rely on strict "Fill Split Pane Height" logic in make_video_track
+            opt_scale = None
+            last_opt_scale = None
+
+            # Apply Mode (Robust avg)
+            def get_mode_avg(vals):
+                if not vals: return 0.5
+                try: return statistics.mean(vals)
+                except: return vals[0]
+            
+            # If after filtering we have no valid V2 candidates, revert to Single Track
+            if is_dual_track and not cand_v2_x:
+                is_dual_track = False
+                
+            if cand_v1_x:
+                center_v1 = (get_mode_avg(cand_v1_x), get_mode_avg(cand_v1_y))
+            
+            if is_dual_track:
+                if cand_v2_x:
+                     center_v2 = (get_mode_avg(cand_v2_x), get_mode_avg(cand_v2_y))
+                else:
+                     # This branch should rarely be hit now due to check above
+                     if last_center_v2 != (0.5, 0.5): center_v2 = last_center_v2
+                     else: center_v2 = (center_v1[0] + 0.25, center_v1[1]) 
+                
+            # Append Cuts
+            cuts_v1.append({"start": start_f, "end": end_f, "center": center_v1, "opt_scale": opt_scale})
+            
+            if is_dual_track:
+                cuts_v2.append({"start": start_f, "end": end_f, "center": center_v2, "opt_scale": opt_scale})
+                last_center_v2 = center_v2
+                is_last_dual = True
+            else:
+                is_last_dual = False
+            
+            last_center_v1 = center_v1
+            current_frame = end_f
+            
+        # Final gap
+        if current_frame < duration_frames:
+             cuts_v1.append({"start": current_frame, "end": duration_frames, "center": last_center_v1, "opt_scale": last_opt_scale})
+
+    else:
+        cuts_v1.append({"start": 0, "end": duration_frames, "center": (0.5, 0.5), "opt_scale": None})
+
+    print(f"Generated {len(cuts_v1)} V1 cuts and {len(cuts_v2)} V2 cuts.")
+
+    # --- GENERATE XML TRACKS ---
+    dual_starts = set(c['start'] for c in cuts_v2)
+    
+    def make_video_track(cuts_list, track_type="main"):
+        items = ""
+        for cut in cuts_list:
+            seg_start, seg_end = cut['start'], cut['end']
+            nx, ny = cut['center'] # These are Normalized Source Coords (0..1)
+            
+            if seg_end - seg_start <= 0: continue
+            
+            is_dual = (seg_start in dual_starts)
+            
+            # --- DIMENSION CHECKS ---
+            src_w = float(source_width)
+            src_h = float(source_height)
+            if src_h < 100: src_h = 1080.0 # Safety default
+            
+            # --- SCALE LOGIC ---
+            # Fill Sequence Height (Matches User's Request for correct scaling)
+            # Use the actual Sequence Height passed to create_premiere_xml
+            target_h = float(height)
+            
+            # ALWAYS scale to fill the sequence height
+            final_scale = (target_h / src_h) * 100.0
+            
+            # Boost scale for split screen to frame faces tighter (User request: "zoom is larger when split")
+            if track_type == "secondary" or is_dual:
+                final_scale *= 1.2
+
+            if final_scale < 10.0: final_scale = 100.0
+            
+            s_val = final_scale / 100.0
+
+            # --- POSITIONING LOGIC (Shift-Based) ---
+            # We assume Anchor Point is (0,0) -> CENTER of Clip.
+            # We want to move the Face (nx, ny) to the Target Screen Position.
+            
+            # 1. Face Offset from Clip Center (in Source Pixels)
+            # Center of Source is 0.5, 0.5
+            off_x_src = (nx - 0.5) * src_w
+            off_y_src = (ny - 0.5) * src_h
+            
+            # 2. Face Offset in Screen Pixels (after Scale)
+            off_x_seq = off_x_src * s_val
+            off_y_seq = off_y_src * s_val
+            
+            # 3. Target Screen Position (Pixels)
+            # Sequence Dimensions: width, height (e.g. 1080, 1920)
+            target_screen_x = 0.5 * width # Center X
+            target_screen_y = 0.5 * height # Center Y (Default)
+            
+            if track_type == "secondary": 
+                target_screen_y = 0.25 * height # Top Quarter
+            elif track_type == "main" and is_dual: 
+                target_screen_y = 0.75 * height # Bottom Quarter
+            
+            # 4. Required Clip Center Position
+            # To place Face at Target, we shift Clip Center by -Offset
+            req_center_x = target_screen_x - off_x_seq
+            req_center_y = target_screen_y - off_y_seq
+            
+            # 5. Normalize for XML (0..1 relative to Sequence)
+            # XML Coordinate System is Relative to Center (0,0 is Center).
+            # Absolute 0..1 maps to -0.5..0.5 in XML.
+            pos_h = (req_center_x / float(width)) - 0.5
+            pos_v = (req_center_y / float(height)) - 0.5
+            
+            seg_id = f"clipitem-video-{get_uid()}"
+            
+            # EXPLICITLY REMOVE Anchor Point (centerOffset) to use Default (Center of Clip).
+            # We calculate pos_h/pos_v assuming we are placing the Clip Center.
+            
+            basic_motion = f"""<filter><effect><name>Basic Motion</name><effectid>basic</effectid><effectcategory>motion</effectcategory><effecttype>motion</effecttype><mediatype>video</mediatype><parameter authoringApp="PremierePro"><parameterid>scale</parameterid><name>Scale</name><value>{final_scale:.2f}</value></parameter><parameter authoringApp="PremierePro"><parameterid>center</parameterid><name>Center</name><value><horiz>{pos_h:.5f}</horiz><vert>{pos_v:.5f}</vert></value></parameter></effect></filter>"""
+            
+            # --- CROP LOGIC (Pane Masking) ---
+            # We calculate crops based on the Screen Boundaries of the Pane.
+            # This ensures the split line is perfectly respected.
+            
+            crop_xml = ""
+            pane_top_y = 0.0
+            pane_bottom_y = float(height) # Default Full Screen
+            
+            should_crop = False
+            
+            if track_type == "secondary":
+                 # Top Pane (0.0 to 0.5)
+                 pane_bottom_y = height / 2.0
+                 should_crop = True
+            elif track_type == "main" and is_dual:
+                 # Bottom Pane (0.5 to 1.0)
+                 pane_top_y = height / 2.0
+                 should_crop = True
+            
+            if should_crop:
+                 # 1. Calculate Clip's Screen Coordinates
+                 # req_center_y is the Screen Y of the Clip Center
+                 clip_screen_h = src_h * s_val
+                 clip_top_screen_y = req_center_y - (clip_screen_h / 2.0)
+                 clip_bottom_screen_y = req_center_y + (clip_screen_h / 2.0)
+                 
+                 # 2. Calculate Required Crop in Screen Pixels
+                 # Pixels to remove from Top: Distance from ClipTop to PaneTop
+                 # max(0, PaneTop - ClipTop)
+                 crop_top_px = max(0.0, pane_top_y - clip_top_screen_y)
+                 
+                 # Pixels to remove from Bottom: Distance from PaneBottom to ClipBottom
+                 # max(0, ClipBottom - PaneBottom)
+                 crop_bottom_px = max(0.0, clip_bottom_screen_y - pane_bottom_y)
+                 
+                 # 3. Convert to Source Percentage
+                 # CropPx / Scale = SourcePx
+                 # SourcePx / SourceHeight * 100 = %
+                 pct_top = (crop_top_px / s_val) / src_h * 100.0
+                 pct_bottom = (crop_bottom_px / s_val) / src_h * 100.0
+                 
+                 # Clamp 0-100
+                 pct_top = max(0.0, min(100.0, pct_top))
+                 pct_bottom = max(0.0, min(100.0, pct_bottom))
+                 
+                 crop_parameters = ""
+                 crop_parameters += f"""<parameter authoringApp="PremierePro"><parameterid>top</parameterid><name>Top</name><value>{pct_top:.2f}</value></parameter>"""
+                 crop_parameters += f"""<parameter authoringApp="PremierePro"><parameterid>bottom</parameterid><name>Bottom</name><value>{pct_bottom:.2f}</value></parameter>"""
+                 
+                 crop_xml = f"""<filter><effect><name>Crop</name><effectid>crop</effectid><effectcategory>transform</effectcategory><effecttype>video</effecttype><mediatype>video</mediatype>{crop_parameters}</effect></filter>"""
+
+            items += f"""<clipitem id="{seg_id}"><name>{os.path.basename(video_path)}</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>{seg_start}</start><end>{seg_end}</end><in>{seg_start}</in><out>{seg_end}</out>{get_file_block(video_file_id, video_path)}{basic_motion}{crop_xml}</clipitem>"""
+        return f"<track>{items}</track>"
+
+    track_v1 = make_video_track(cuts_v1, "main")
+    track_v2 = make_video_track(cuts_v2, "secondary")
+
+    # --- OVERLAY TRACK ---
+    track_overlay_block = ""
+    if overlay_segments:
+        overlay_clips = ""
+        for seg in overlay_segments:
+            # ... (overlay logic same as before)
+            # Re-implement simple loop here to ensure variable scope
+            start_f = int(seg['start'] * fps_float)
+            end_f = int(seg['end'] * fps_float)
+            clip_dur = end_f - start_f
+            if clip_dur <= 0: continue
+            ov_fid = f"file-ov-{seg['index']}-{get_uid()}"
+            ov_cid = f"clip-ov-{seg['index']}-{get_uid()}"
+            file_blk = f"""<file id="{ov_fid}"><name>{os.path.basename(seg['path'])}</name><pathurl>{seg['path']}</pathurl><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><duration>{clip_dur}</duration><media><video><samplecharacteristics><width>{width}</width><height>{height}</height><alpha>straight</alpha></samplecharacteristics></video></media></file>"""
+            overlay_clips += f"""<clipitem id="{ov_cid}"><name>{os.path.basename(seg['path'])}</name><duration>{clip_dur}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>{start_f}</start><end>{end_f}</end><in>0</in><out>{clip_dur}</out>{file_blk}<compositemode>normal</compositemode></clipitem>"""
+        track_overlay_block = f"<track>{overlay_clips}</track>"
+    else:
+        track_overlay_block = "<track></track>"
+
+    # --- ASSEMBLE ---
+    timecode_block = f"""<timecode><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><string>00:00:00:00</string><frame>0</frame><displayformat>NDF</displayformat></timecode>"""
+    audio_blk = f"""<track><clipitem id="{audio_file_id}"><name>{os.path.basename(video_path)}</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><start>0</start><end>{duration_frames}</end>{get_file_block(video_file_id, video_path)}<sourcetrack><mediatype>audio</mediatype><trackindex>1</trackindex></sourcetrack></clipitem></track>"""
+
+    return f"""<?xml version="1.0" encoding="UTF-8"?><xmeml version="4"><sequence id="{sequence_uuid}"><name>{project_name}_CutRef</name><duration>{duration_frames}</duration><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate>{timecode_block}<media><video><format><samplecharacteristics><rate><timebase>{timebase}</timebase><ntsc>FALSE</ntsc></rate><width>{width}</width><height>{height}</height><pixelaspectratio>square</pixelaspectratio></samplecharacteristics></format>{track_v1}{track_v2}{track_overlay_block}</video><audio>{audio_blk}</audio></media></sequence></xmeml>"""

temp_subtitle_config.json

@@ -0,0 +1,23 @@
+{
+    "font": "Arial",
+    "base_size": 34,
+    "base_color": "&H00FFFFFF&",
+    "highlight_color": "&H000000FF&",
+    "outline_color": "&H00000000&",
+    "outline_thickness": 3,
+    "shadow_color": "&H00000000&",
+    "shadow_size": 3,
+    "vertical_position": 190,
+    "alignment": 2,
+    "bold": 1,
+    "italic": 0,
+    "underline": 0,
+    "strikeout": 0,
+    "border_style": 1,
+    "words_per_block": 3,
+    "gap_limit": 0.4,
+    "mode": "highlight",
+    "highlight_size": 40,
+    "remove_punctuation": true,
+    "uppercase": 1
+}