Update app.py

app.py

@@ -1,192 +1,186 @@
-
-# app_refactored_with_postprod.py (FINAL VERSION with LTX Refinement)
+# app_final_orchestrator.py
 
 import gradio as gr
 import os
 import sys
+import time
 import traceback
 from pathlib import Path
 import torch
 import numpy as np
 from PIL import Image
 
-# --- Import dos Serviços de Backend ---
+# --- 1. Importação e Inicialização dos Serviços de Backend ---
 
-# Serviço LTX para geração de vídeo base e refinamento de textura
-from api.ltx_server_refactored import video_generation_service
+# Importa a classe OrchestratorService, o "cérebro" do nosso sistema
+from api.ltx_server_refactored import OrchestratorService
 
-# Serviço SeedVR para upscaling de alta qualidade
+# Importa o serviço de upscaling de alta qualidade
 from api.seedvr_server import SeedVRServer
 
+# Cria a instância principal do serviço, que decidirá o modo de operação (Single ou Multi-GPU)
+print("[Gradio UI] Criando instância do OrchestratorService...")
+orchestrator_service = OrchestratorService()
+print("[Gradio UI] Instância do OrchestratorService criada.")
+
 # Inicializa o servidor SeedVR uma vez, se disponível
-seedvr_inference_server = SeedVRServer() if SeedVRServer else None
+try:
+    seedvr_inference_server = SeedVRServer() if SeedVRServer else None
+    print("[Gradio UI] Serviço SeedVR inicializado.")
+except Exception as e:
+    seedvr_inference_server = None
+    print(f"[Gradio UI WARNING] Não foi possível inicializar o SeedVRServer: {e}")
+
 
-# --- ESTADO DA SESSÃO ---
+# --- 2. Gerenciamento de Estado da Sessão ---
 def create_initial_state():
+    """Define o estado inicial para cada sessão de usuário."""
+    # O estado foi simplificado, pois o LTX agora produz um único vídeo final.
     return {
-        "low_res_video": None,
-        "low_res_latents": None,
-        "refined_video_ltx": None,
-        "refined_latents_ltx": None,
+        "final_video_path": None,
+        "final_latents_path": None, # Mantido para possíveis futuras funcionalidades
         "used_seed": None
     }
 
-# --- FUNÇÕES WRAPPER PARA A UI ---
+# --- 3. Funções de Interface (Wrappers para o Backend) ---
 
-def run_generate_low(prompt, neg_prompt, start_img, height, width, duration, cfg, seed, randomize_seed, progress=gr.Progress(track_tqdm=True)):
-    """Executa a primeira etapa: geração de um vídeo base em baixa resolução."""
-    print("UI: Chamando generate_low")
-    if True:
-        
+def run_generation_pipeline(prompt, neg_prompt, start_img, height, width, duration, cfg, seed, randomize_seed, progress=gr.Progress(track_tqdm=True)):
+    """
+    Executa o pipeline de geração COMPLETO (Geração Base + Refinamento LTX)
+    chamando o OrchestratorService. Esta é a função principal da UI.
+    """
+    print("UI: Chamando o pipeline de geração completo via Orchestrator...")
+    try:
         image_filepaths = []
         if start_img:
-            image_filepaths.append(start_img)
-
+            # Salva a imagem temporariamente, pois o Gradio pode limpá-la
+            temp_dir = tempfile.mkdtemp()
+            img_pil = Image.fromarray(start_img)
+            temp_path = os.path.join(temp_dir, "start_image.png")
+            img_pil.save(temp_path)
+            image_filepaths.append(temp_path)
             
-        used_seed = None if randomize_seed else seed
+        used_seed = None if randomize_seed else int(seed)
         
-        video_path, tensor_path, final_seed = video_generation_service.generate_low_resolution(
+        # Chamada unificada para o backend. O orquestrador lida com a complexidade.
+        result = orchestrator_service.generate_video(
             prompt=prompt, negative_prompt=neg_prompt,
-            height=height, width=width, duration_secs=duration,
-            guidance_scale=cfg, seed=used_seed,
+            height=int(height), width=int(width), duration_secs=float(duration),
+            guidance_scale=float(cfg), seed=used_seed,
             image_filepaths=image_filepaths
         )
-        
+
+        # O backend tem retornos diferentes dependendo do modo, a UI se adapta a isso.
+        if isinstance(result, tuple) and len(result) == 3:
+            # Modo Single-GPU retorna (video_path, latents_path, seed)
+            video_path, tensor_path, final_seed = result
+        else:
+            # Modo Multi-GPU retorna apenas video_path
+            video_path = result
+            tensor_path = None # Latentes não são passados de volta no fluxo multi-gpu
+            final_seed = used_seed if used_seed is not None else "N/A"
+
         new_state = {
-            "low_res_video": video_path,
-            "low_res_latents": tensor_path,
-            "refined_video_ltx": None,
-            "refined_latents_ltx": None,
+            "final_video_path": video_path,
+            "final_latents_path": tensor_path,
             "used_seed": final_seed
         }
         
+        # O resultado já é o vídeo refinado, que é exibido diretamente.
+        # O grupo de pós-produção é ativado para o próximo passo.
         return video_path, new_state, gr.update(visible=True)
 
-def run_ltx_refinement(state, prompt, neg_prompt, cfg, progress=gr.Progress(track_tqdm=True)):
-    """Executa o processo de refinamento secundário."""
-    print("UI: Chamando a função ponte 'apply_secondary_refinement'")
-    
-    try:
-        # AQUI ESTÁ A MUDANÇA: Chamamos a nova função ponte
-        video_path, tensor_path = video_generation_service.apply_secondary_refinement(
-            latents_path=state["low_res_latents"],
-            prompt=prompt,
-            negative_prompt=neg_prompt,
-            guidance_scale=cfg,
-            seed=state["used_seed"]
-        )
-        
-        # Atualiza o estado com os novos artefatos refinados
-        state["refined_video_ltx"] = video_path
-        state["refined_latents_ltx"] = tensor_path
-        
-        return video_path, state
-    
     except Exception as e:
-        print(f"[ERRO na UI] Falha durante o refinamento secundário: {e}")
+        print(f"[ERRO na UI] Falha durante a geração: {e}")
         traceback.print_exc()
-        # Você pode retornar uma mensagem de erro para a UI aqui se quiser
-        # Ex: return None, state
-        raise gr.Error(f"Falha no Refinamento: {e}")
+        raise gr.Error(f"Falha na Geração: {e}")
 
-    
 def run_seedvr_upscaling(state, seed, resolution, batch_size, fps, progress=gr.Progress(track_tqdm=True)):
-    """Executa o processo de upscaling com SeedVR."""
-            
-    video_path = state["low_res_video"]
+    """Executa o processo de upscaling com SeedVR no vídeo gerado."""
+    video_path = state.get("final_video_path")
+    if not video_path or not os.path.exists(video_path):
+        raise gr.Error("Nenhum vídeo foi gerado ainda ou o arquivo não foi encontrado. Por favor, execute a Etapa 1 primeiro.")
+        
     print(f"▶️  Iniciando processo de upscaling SeedVR para o vídeo: {video_path}")
     
-    if True:
+    try:
         def progress_wrapper(p, desc=""):
             progress(p, desc=desc)
+
         output_filepath = seedvr_inference_server.run_inference(
-            file_path=video_path, seed=seed, resolution=resolution,
-            batch_size=batch_size, fps=fps, progress=progress_wrapper
+            file_path=video_path, seed=int(seed), resolution=int(resolution),
+            batch_size=int(batch_size), fps=int(fps), progress=progress_wrapper
         )
         final_message = f"✅ Processo SeedVR concluído!\nVídeo salvo em: {output_filepath}"
         return gr.update(value=output_filepath, interactive=True), gr.update(value=final_message, interactive=False)
-    
-# --- DEFINIÇÃO DA INTERFACE GRADIO ---
-with gr.Blocks() as demo:
-    gr.Markdown("# LTX Video - Geração e Pós-Produção por Etapas")
+    except Exception as e:
+        print(f"[ERRO na UI] Falha durante o upscaling SeedVR: {e}")
+        traceback.print_exc()
+        raise gr.Error(f"Falha no Upscaling SeedVR: {e}")
+
+# --- 4. Definição da Interface Gráfica com Gradio ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# LTX Video Studio: Geração e Pós-Produção")
     
     app_state = gr.State(value=create_initial_state())
 
-    # --- ETAPA 1: Geração Base ---
+    # --- ETAPA 1: Geração Principal (Unificada) ---
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### Etapa 1: Configurações de Geração")
-            prompt_input = gr.Textbox(label="Prompt", value="A majestic dragon flying over a medieval castle", lines=3)
-            neg_prompt_input = gr.Textbox(visible=False, label="Negative Prompt", value="worst quality, blurry, low quality, jittery", lines=2)
-            start_image = gr.Image(label="Imagem de Início (Opcional)", type="filepath", sources=["upload", "clipboard"])
+            gr.Markdown("### Etapa 1: Gerar Vídeo (Base + Refinamento LTX)")
+            prompt_input = gr.Textbox(label="Prompt", value="A majestic dragon flying over a medieval castle, cinematic, epic", lines=3)
+            neg_prompt_input = gr.Textbox(label="Negative Prompt", value="worst quality, blurry, low quality, jittery, watermark, text", lines=2)
+            start_image = gr.Image(label="Imagem de Início (Opcional)", type="numpy", sources=["upload", "clipboard"])
             
             with gr.Accordion("Parâmetros Avançados", open=False):
-                height_input = gr.Slider(label="Height", value=512, step=32, minimum=256, maximum=1024)
-                width_input = gr.Slider(label="Width", value=704, step=32, minimum=256, maximum=1024)
+                height_input = gr.Slider(label="Altura (Height)", value=512, step=64, minimum=256, maximum=1024)
+                width_input = gr.Slider(label="Largura (Width)", value=896, step=64, minimum=256, maximum=1536)
                 duration_input = gr.Slider(label="Duração (s)", value=4, step=1, minimum=1, maximum=10)
-                cfg_input = gr.Slider(label="Guidance Scale (CFG)", value=3.0, step=0.1, minimum=1.0, maximum=10.0)
+                cfg_input = gr.Slider(label="Guidance Scale (CFG)", value=15.0, step=0.5, minimum=1.0, maximum=20.0)
                 seed_input = gr.Number(label="Seed", value=42, precision=0)
-                randomize_seed = gr.Checkbox(label="Randomize Seed", value=True)
+                randomize_seed = gr.Checkbox(label="Usar Seed Aleatória", value=True)
 
-            generate_low_btn = gr.Button("1. Gerar Vídeo Base (Low-Res)", variant="primary")
+            generate_btn = gr.Button("🚀 Gerar Vídeo Completo", variant="primary", scale=2)
         
         with gr.Column(scale=1):
-            gr.Markdown("### Vídeo Base Gerado")
-            low_res_video_output = gr.Video(label="O resultado da Etapa 1 aparecerá aqui", interactive=False)
+            gr.Markdown("### Vídeo Gerado e Refinado (LTX)")
+            final_video_output = gr.Video(label="O resultado final do LTX aparecerá aqui", interactive=False)
 
-    # --- ETAPA 2: Pós-Produção (no rodapé, em abas) ---
+    # --- ETAPA 2: Pós-Produção Adicional ---
     with gr.Group(visible=False) as post_prod_group:
         gr.Markdown("<hr style='margin-top: 20px; margin-bottom: 20px;'>")
-        gr.Markdown("## Etapa 2: Pós-Produção")
-        gr.Markdown("Use o vídeo gerado acima como entrada para as ferramentas abaixo. **O prompt e a CFG da Etapa 1 serão reutilizados.**")
+        gr.Markdown("## Etapa 2: Pós-Produção Adicional")
+        gr.Markdown("Use o vídeo gerado acima como entrada para as ferramentas abaixo.")
 
         with gr.Tabs():
-            # --- ABA LTX REFINEMENT (AGORA FUNCIONAL) ---
-            with gr.TabItem("🚀 Upscaler Textura (LTX)"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                         gr.Markdown("### Parâmetros de Refinamento")
-                         gr.Markdown("Esta etapa reutiliza o prompt, o prompt negativo e a CFG da Etapa 1 para manter a consistência.")
-                         ltx_refine_btn = gr.Button("Aplicar Refinamento de Textura LTX", variant="primary")
-                    with gr.Column(scale=1):
-                        gr.Markdown("### Resultado do Refinamento")
-                        ltx_refined_video_output = gr.Video(label="Vídeo com Textura Refinada (LTX)", interactive=False)
-
             # --- ABA SEEDVR UPSCALER ---
-            with gr.TabItem("✨ Upscaler SeedVR"):
+            with gr.TabItem("✨ Upscaler de Qualidade (SeedVR)"):
                 with gr.Row():
                     with gr.Column(scale=1):
                         gr.Markdown("### Parâmetros do SeedVR")
-                        seedvr_seed = gr.Slider(minimum=0, maximum=999999, value=42, step=1, label="Seed")
-                        seedvr_resolution = gr.Slider(minimum=720, maximum=1440, value=1072, step=8, label="Resolução Vertical (Altura)")
+                        seedvr_seed = gr.Slider(minimum=0, maximum=999999, value=42, step=1, label="Seed do Upscaler")
+                        seedvr_resolution = gr.Slider(minimum=720, maximum=2160, value=1080, step=8, label="Resolução Vertical Final")
                         seedvr_batch_size = gr.Slider(minimum=1, maximum=16, value=4, step=1, label="Batch Size por GPU")
                         seedvr_fps_output = gr.Number(label="FPS de Saída (0 = original)", value=0)
                         run_seedvr_button = gr.Button("Iniciar Upscaling SeedVR", variant="primary", interactive=(seedvr_inference_server is not None))
                         if not seedvr_inference_server:
-                             gr.Markdown("<p style='color: red;'>Serviço SeedVR não disponível.</p>")
+                             gr.Markdown("<p style='color: red; font-weight: bold;'>Serviço SeedVR não disponível.</p>")
                     with gr.Column(scale=1):
                         gr.Markdown("### Resultado do Upscaling")
                         seedvr_video_output = gr.Video(label="Vídeo com Upscale SeedVR", interactive=False)
                         seedvr_status_box = gr.Textbox(label="Status do Processamento", value="Aguardando...", lines=3, interactive=False)
 
             # --- ABA MM-AUDIO ---
-            with gr.TabItem("🔊 Áudio (MM-Audio)"):
+            with gr.TabItem("🔊 Áudio (Futuro)"):
                 gr.Markdown("*(Funcionalidade futura para adicionar som aos vídeos)*")
 
-    # --- LÓGICA DE EVENTOS DA UI ---
+    # --- 5. Lógica de Eventos da UI ---
 
-    # Botão da Etapa 1
-    generate_low_btn.click(
-        fn=run_generate_low,
+    # Botão da Etapa 1 chama a função de geração unificada
+    generate_btn.click(
+        fn=run_generation_pipeline,
         inputs=[prompt_input, neg_prompt_input, start_image, height_input, width_input, duration_input, cfg_input, seed_input, randomize_seed],
-        outputs=[low_res_video_output, app_state, post_prod_group]
-    )
-
-    # Botão da Aba LTX Refinement
-    ltx_refine_btn.click(
-        fn=run_ltx_refinement,
-        inputs=[app_state, prompt_input, neg_prompt_input, cfg_input],
-        outputs=[ltx_refined_video_output, app_state]
+        outputs=[final_video_output, app_state, post_prod_group]
     )
 
     # Botão da Aba SeedVR
@@ -196,5 +190,21 @@ with gr.Blocks() as demo:
         outputs=[seedvr_video_output, seedvr_status_box]
     )
 
+# --- 6. Ponto de Entrada da Aplicação ---
 if __name__ == "__main__":
+    # Garante que os diretórios necessários existem
+    os.makedirs("output", exist_ok=True)
+    
+    # Inicia o servidor Gradio
     demo.queue().launch(server_name="0.0.0.0", server_port=7860, debug=True, show_error=True)
+
+    # Bloco para garantir o desligamento limpo dos workers do backend
+    try:
+        # Mantém o script principal rodando enquanto o Gradio está ativo
+        while True:
+            time.sleep(1)
+    except (KeyboardInterrupt, SystemExit):
+        print("\n[Gradio UI] Desligando... Enviando sinal de shutdown para o Orchestrator.")
+        if orchestrator_service:
+            orchestrator_service.shutdown()
+        print("[Gradio UI] Desligamento concluído. Pode fechar o terminal.")