Update app.py

app.py

@@ -1,4 +1,4 @@
-# app_refactored_with_postprod.py
+# app_refactored_with_postprod.py (FINAL VERSION with LTX Refinement)
 
 import gradio as gr
 import os
@@ -13,7 +13,6 @@ try:
     from api.ltx_server_refactored import video_generation_service
 except ImportError:
     print("ERRO FATAL: Não foi possível importar 'video_generation_service' de 'api.ltx_server_refactored'.")
-    print("Verifique se o arquivo existe e se o ambiente está configurado corretamente.")
     sys.exit(1)
 
 # Serviço SeedVR para upscaling de alta qualidade
@@ -21,47 +20,34 @@ try:
     from api.seedvr_server import SeedVRServer
 except ImportError:
     print("AVISO: Não foi possível importar SeedVRServer. A aba de upscaling SeedVR será desativada.")
-    SeedVRServer = None # Define como None para tratamento gracioso de erro
+    SeedVRServer = None
 
 # Inicializa o servidor SeedVR uma vez, se disponível
-if SeedVRServer:
-    print("Inicializando o servidor de inferência SeedVR...")
-    seedvr_inference_server = SeedVRServer()
-else:
-    seedvr_inference_server = None
+seedvr_inference_server = SeedVRServer() if SeedVRServer else None
 
 # --- ESTADO DA SESSÃO ---
-# Mantém os caminhos dos arquivos entre os cliques dos botões
 def create_initial_state():
     return {
         "low_res_video": None,
         "low_res_latents": None,
-        "refined_video": None,
-        "refined_latents": None,
+        "refined_video_ltx": None,
+        "refined_latents_ltx": None,
         "used_seed": None
     }
 
 # --- FUNÇÕES WRAPPER PARA A UI ---
 
 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.
-    """
+    """Executa a primeira etapa: geração de um vídeo base em baixa resolução."""
     print("UI: Chamando generate_low")
-    
     try:
-        # 1. Preparar conditioning_items (se uma imagem de início for fornecida)
         conditioning_items = []
         if start_img:
-            # A função `prepare_condition_items` precisa de uma estimativa do número de frames
             num_frames_estimate = int(duration * 24)
-            items_list = [[start_img, 0, 1.0]] # Imagem de início, no frame 0, com peso 1.0
+            items_list = [[start_img, 0, 1.0]]
             conditioning_items = video_generation_service.prepare_condition_items(items_list, height, width, num_frames_estimate)
 
-        # Determina a seed a ser usada
         used_seed = None if randomize_seed else seed
-        
-        # 2. Chamar a função de geração de baixa resolução do backend
         video_path, tensor_path, final_seed = video_generation_service.generate_low(
             prompt=prompt, negative_prompt=neg_prompt,
             height=height, width=width, duration=duration,
@@ -69,74 +55,73 @@ def run_generate_low(prompt, neg_prompt, start_img, height, width, duration, cfg
             conditioning_items=conditioning_items
         )
         
-        # 3. Atualizar o estado da aplicação com os caminhos dos arquivos resultantes
         new_state = {
             "low_res_video": video_path,
             "low_res_latents": tensor_path,
-            "refined_video": None, # Limpa resultados de execuções anteriores
-            "refined_latents": None,
+            "refined_video_ltx": None,
+            "refined_latents_ltx": None,
             "used_seed": final_seed
         }
         
-        # 4. Retorna os resultados para a UI
-        #    - O caminho do vídeo para o componente de vídeo
-        #    - O novo estado para o componente gr.State
-        #    - Um update para tornar o grupo de pós-produção visível
         return video_path, new_state, gr.update(visible=True)
-        
     except Exception as e:
         error_message = f"❌ Ocorreu um erro na Geração Base:\n{e}"
         print(f"{error_message}\nDetalhes: {traceback.format_exc()}")
         raise gr.Error(error_message)
 
+def run_ltx_refinement(state, prompt, neg_prompt, cfg, progress=gr.Progress(track_tqdm=True)):
+    """Executa o processo de refinamento e upscaling de textura com o pipeline LTX."""
+    print("UI: Chamando run_ltx_refinement (generate_upscale_denoise)")
+    if not state or not state.get("low_res_latents"):
+        raise gr.Error("Erro: Gere um vídeo base primeiro na Etapa 1.")
+
+    try:
+        video_path, tensor_path = video_generation_service.generate_upscale_denoise(
+            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:
+        error_message = f"❌ Ocorreu um erro durante o Refinamento LTX:\n{e}"
+        print(f"{error_message}\nDetalhes: {traceback.format_exc()}")
+        raise gr.Error(error_message)
 
 def run_seedvr_upscaling(state, seed, resolution, batch_size, fps, progress=gr.Progress(track_tqdm=True)):
-    """
-    Função de callback que executa o processo de upscaling com SeedVR.
-    """
+    """Executa o processo de upscaling com SeedVR."""
     if not state or not state.get("low_res_video"):
         raise gr.Error("Erro: Gere um vídeo base primeiro na Etapa 1.")
     if not seedvr_inference_server:
-        raise gr.Error("Erro: O servidor SeedVR não está disponível. Verifique a instalação e os logs.")
+        raise gr.Error("Erro: O servidor SeedVR não está disponível.")
         
     video_path = state["low_res_video"]
-    
-    progress(0, desc="Iniciando SeedVR Upscaling...")
     print(f"▶️  Iniciando processo de upscaling SeedVR para o vídeo: {video_path}")
     
     try:
-        # Wrapper para a barra de progresso do Gradio
         def progress_wrapper(p, desc=""):
             progress(p, desc=desc)
-            print(f"⌛ Progresso SeedVR: {p*100:.1f}% - {desc}")
-
-        # Chama o método de inferência do servidor SeedVR
         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=seed, resolution=resolution,
+            batch_size=batch_size, fps=fps, progress=progress_wrapper
         )
-        
         final_message = f"✅ Processo SeedVR concluído!\nVídeo salvo em: {output_filepath}"
-        print(final_message)
-        # Retorna o vídeo e a mensagem de sucesso para a UI
         return gr.update(value=output_filepath, interactive=True), gr.update(value=final_message, interactive=False)
-
     except Exception as e:
         error_message = f"❌ Ocorreu um erro grave durante o upscaling com SeedVR:\n{e}"
         print(f"{error_message}\nDetalhes: {traceback.format_exc()}")
-        # Retorna None para o vídeo e a mensagem de erro para o status box
         return None, gr.update(value=error_message, interactive=False)
 
-
 # --- DEFINIÇÃO DA INTERFACE GRADIO ---
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Aduc-Srd Studio") as demo:
-    gr.Markdown("✨ Video - Geração e Pós-Produção")
+with gr.Blocks(css="#col-container { margin: 0 auto; max-width: 900px; }", theme=gr.themes.Monochrome()) as demo:
+    gr.Markdown("# LTX Video - Geração e Pós-Produção por Etapas")
     
-    # Componente invisível para armazenar o estado da aplicação (caminhos de arquivos, etc.)
     app_state = gr.State(value=create_initial_state())
 
     # --- ETAPA 1: Geração Base ---
@@ -163,17 +148,22 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Aduc-Srd Studio"
 
     # --- ETAPA 2: Pós-Produção (no rodapé, em abas) ---
     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.")
+        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.**")
 
         with gr.Tabs():
+            # --- ABA LTX REFINEMENT (AGORA FUNCIONAL) ---
             with gr.TabItem("🚀 Upscaler Textura (LTX)"):
-                gr.Markdown("*(Funcionalidade a ser implementada no futuro)*")
-                # Aqui iriam os componentes para o refinamento LTX
-                # refine_ltx_btn = gr.Button("Aplicar Refinamento de Textura LTX")
-                # refined_ltx_video_output = gr.Video(label="Vídeo com Textura Refinada")
+                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.Row():
                     with gr.Column(scale=1):
@@ -185,47 +175,37 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Aduc-Srd Studio"
                         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>")
-
                     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)"):
                 gr.Markdown("*(Funcionalidade futura para adicionar som aos vídeos)*")
-                # Componentes para a geração de áudio viriam aqui
 
     # --- LÓGICA DE EVENTOS DA UI ---
 
-    # Conecta o botão da Etapa 1 à sua função de backend
+    # Botão da Etapa 1
     generate_low_btn.click(
         fn=run_generate_low,
         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]
     )
 
-    # Conecta o botão da Aba SeedVR à sua função de backend
+    # 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]
+    )
+
+    # Botão da Aba SeedVR
     run_seedvr_button.click(
         fn=run_seedvr_upscaling,
-        inputs=[
-            app_state,
-            seedvr_seed,
-            seedvr_resolution,
-            seedvr_batch_size,
-            seedvr_fps_output
-        ],
-        outputs=[
-            seedvr_video_output,
-            seedvr_status_box
-        ]
+        inputs=[app_state, seedvr_seed, seedvr_resolution, seedvr_batch_size, seedvr_fps_output],
+        outputs=[seedvr_video_output, seedvr_status_box]
     )
 
-
 if __name__ == "__main__":
-    # Inicia a aplicação Gradio
-    demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        debug=True,
-        show_error=True
-    )
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, debug=True, show_error=True)