Upload app.py

app.py

@@ -1,213 +1,193 @@
-# app.py (Versão Corrigida)
+
+# app_refactored_with_postprod.py (FINAL VERSION with LTX Refinement)
 
 import gradio as gr
-from PIL import Image
 import os
-import imageio
-from api.ltx_server import video_generation_service
-
-
-from huggingface_hub import logging
-
-
-logging.set_verbosity_error()
-logging.set_verbosity_warning()
-logging.set_verbosity_info()
-logging.set_verbosity_debug()
-
-
-
-# --- FUNÇÕES DE AJUDA PARA A UI ---
-# ... (calculate_new_dimensions e handle_media_upload_for_dims permanecem as mesmas) ...
-TARGET_FIXED_SIDE = 768
-MIN_DIM_SLIDER = 256
-MAX_IMAGE_SIZE = 1280
-
-def calculate_new_dimensions(orig_w, orig_h):
-    if orig_w == 0 or orig_h == 0: return int(TARGET_FIXED_SIDE), int(TARGET_FIXED_SIDE)
-    if orig_w >= orig_h:
-        new_h, aspect_ratio = TARGET_FIXED_SIDE, orig_w / orig_h
-        new_w = round((new_h * aspect_ratio) / 32) * 32
-        new_w = max(MIN_DIM_SLIDER, min(new_w, MAX_IMAGE_SIZE))
-        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE)) 
-    else:
-        new_w, aspect_ratio = TARGET_FIXED_SIDE, orig_h / orig_w
-        new_h = round((new_w * aspect_ratio) / 32) * 32
-        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE))
-        new_w = max(MIN_DIM_SLIDER, min(new_w, MAX_IMAGE_SIZE))
-    return int(new_h), int(new_w)
-
-def handle_media_upload_for_dims(filepath, current_h, current_w):
-    if not filepath or not os.path.exists(str(filepath)): return gr.update(value=current_h), gr.update(value=current_w)
-    try:
-        if str(filepath).lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
-            with Image.open(filepath) as img:
-                orig_w, orig_h = img.size
-        else: # Assumir que é um vídeo
-            with imageio.get_reader(filepath) as reader:
-                meta = reader.get_meta_data()
-                orig_w, orig_h = meta.get('size', (current_w, current_h))
-        new_h, new_w = calculate_new_dimensions(orig_w, orig_h)
-        return gr.update(value=new_h), gr.update(value=new_w)
-    except Exception as e:
-        print(f"Erro ao processar mídia para dimensões: {e}")
-        return gr.update(value=current_h), gr.update(value=current_w)
-
-def update_frame_slider(duration):
-    """Atualiza o valor máximo do slider de frame do meio com base na duração."""
-    fps = 24.0
-    max_frames = int(duration * fps)
-    # Garante que o valor padrão não seja maior que o novo máximo
-    new_value = 48 if max_frames >= 48 else max_frames // 2
-    return gr.update(maximum=max_frames, value=new_value)
-
-
-# --- FUNÇÃO WRAPPER PARA CHAMAR O SERVIÇO ---
-def gradio_generate_wrapper(
-    prompt, negative_prompt, mode,
-    # Entradas de Keyframe
-    start_image,
-    middle_image, middle_frame, middle_weight,
-    end_image, end_weight,
-    # Outras entradas
-    input_video, height, width, duration,
-    frames_to_use, seed, randomize_seed,
-    guidance_scale, improve_texture,
-    progress=gr.Progress(track_tqdm=True)
-):
-    try:
-        def progress_handler(step, total_steps):
-            progress(step / total_steps, desc="Salvando vídeo...")
-
-        output_path, used_seed = video_generation_service.generate(
-            prompt=prompt, negative_prompt=negative_prompt, mode=mode,
-            start_image_filepath=start_image,
-            middle_image_filepath=middle_image,
-            middle_frame_number=middle_frame,
-            middle_image_weight=middle_weight,
-            end_image_filepath=end_image,
-            end_image_weight=end_weight,
-            input_video_filepath=input_video,
-            height=int(height), width=int(width), duration=float(duration),
-            frames_to_use=int(frames_to_use), seed=int(seed),
-            randomize_seed=bool(randomize_seed), guidance_scale=float(guidance_scale),
-            improve_texture=bool(improve_texture), progress_callback=progress_handler
-        )
-        return output_path, used_seed
-    except ValueError as e:
-        raise gr.Error(str(e))
-    except Exception as e:
-        print(f"Erro inesperado na geração: {e}")
-        raise gr.Error("Ocorreu um erro inesperado. Verifique os logs.")
+import sys
+import traceback
+from pathlib import Path
+import torch
+import numpy as np
+from PIL import Image
 
+# --- Import 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
+
+# Serviço SeedVR para upscaling de alta qualidade
+from api.seedvr_server import SeedVRServer
+
+# Inicializa o servidor SeedVR uma vez, se disponível
+seedvr_inference_server = SeedVRServer() if SeedVRServer else None
+
+# --- ESTADO DA SESSÃO ---
+def create_initial_state():
+    return {
+        "low_res_video": None,
+        "low_res_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."""
+    print("UI: Chamando generate_low")
+    if True:
+        
+        conditioning_items = []
+        if start_img:
+            num_frames_estimate = int(duration * 24)
+            items_list = [[start_img, 0, 1.0]]
+            conditioning_items = video_generation_service._prepare_condition_items(items_list, height, width)
+
+            
+        used_seed = None if randomize_seed else seed
+        
+        video_path, tensor_path, final_seed = video_generation_service.generate_low_resolution(
+            prompt=prompt, negative_prompt=neg_prompt,
+            height=height, width=width, duration_secs=duration,
+            guidance_scale=cfg, seed=used_seed,
+            conditioning_items=conditioning_items
+        )
+        
+        new_state = {
+            "low_res_video": video_path,
+            "low_res_latents": tensor_path,
+            "refined_video_ltx": None,
+            "refined_latents_ltx": None,
+            "used_seed": final_seed
+        }
+        
+        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 e upscaling de textura com o pipeline LTX."""
+    print("UI: Chamando run_ltx_refinement (generate_upscale_denoise)")
+    
+    if True:
+        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
+    
+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"]
+    print(f"▶️  Iniciando processo de upscaling SeedVR para o vídeo: {video_path}")
+    
+    if True:
+        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
+        )
+        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 ---
-css = "#col-container { margin: 0 auto; max-width: 900px; }"
-with gr.Blocks(css=css) as demo:
-    gr.Markdown("# LTX Video com Keyframes")
-    gr.Markdown("Guie a geração de vídeo usando imagens de início, meio e fim.")
+with gr.Blocks() as demo:
+    gr.Markdown("# LTX Video - Geração e Pós-Produção por Etapas")
+    
+    app_state = gr.State(value=create_initial_state())
 
+    # --- ETAPA 1: Geração Base ---
     with gr.Row():
-        with gr.Column():
-            with gr.Tab("image-to-video (Keyframes)") as image_tab:
-                i2v_prompt = gr.Textbox(label="Prompt", value="Uma bela transição entre as imagens", lines=2)
-                
+        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"])
+            
+            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)
+                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)
+                seed_input = gr.Number(label="Seed", value=42, precision=0)
+                randomize_seed = gr.Checkbox(label="Randomize Seed", value=True)
+
+            generate_low_btn = gr.Button("1. Gerar Vídeo Base (Low-Res)", variant="primary")
+        
+        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)
+
+    # --- 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. **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)"):
                 with gr.Row():
                     with gr.Column(scale=1):
-                        gr.Markdown("#### Início (Obrigatório)")
-                        start_image_i2v = gr.Image(label="Imagem de Início", type="filepath", sources=["upload", "clipboard"])
+                         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("#### Meio (Opcional)")
-                        middle_image_i2v = gr.Image(label="Imagem do Meio", type="filepath", sources=["upload", "clipboard"])
-                        middle_frame_i2v = gr.Slider(label="Frame Alvo", minimum=0, maximum=200, step=1, value=48)
-                        middle_weight_i2v = gr.Slider(label="Peso/Força", minimum=0.0, maximum=1.0, step=0.05, value=1.0)
+                        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):
-                        gr.Markdown("#### Fim (Opcional)")
-                        end_image_i2v = gr.Image(label="Imagem de Fim", type="filepath", sources=["upload", "clipboard"])
-                        end_weight_i2v = gr.Slider(label="Peso/Força", minimum=0.0, maximum=1.0, step=0.05, value=1.0)
-                
-                i2v_button = gr.Button("Generate Image-to-Video", variant="primary")
-
-            with gr.Tab("text-to-video") as text_tab:
-                t2v_prompt = gr.Textbox(label="Prompt", value="A majestic dragon flying over a medieval castle", lines=3)
-                t2v_button = gr.Button("Generate Text-to-Video", variant="primary")
-
-            with gr.Tab("video-to-video") as video_tab:
-                video_v2v = gr.Video(label="Input Video", sources=["upload", "webcam"])
-                frames_to_use = gr.Slider(label="Frames to use from input video", minimum=9, maximum=257, value=9, step=8, info="Must be N*8+1.")
-                v2v_prompt = gr.Textbox(label="Prompt", value="Change the style to cinematic anime", lines=3)
-                v2v_button = gr.Button("Generate Video-to-Video", variant="primary")
-
-            duration_input = gr.Slider(label="Video Duration (seconds)", minimum=1, maximum=30, value=8, step=0.5)
-            improve_texture = gr.Checkbox(label="Improve Texture (multi-scale)", value=True, visible=True)
-
-        with gr.Column():
-            output_video = gr.Video(label="Generated Video", interactive=False)
-
-    with gr.Accordion("Advanced settings", open=False):
-        mode = gr.Dropdown(["text-to-video", "image-to-video", "video-to-video"], label="task", value="image-to-video", visible=False)
-        negative_prompt_input = gr.Textbox(label="Negative Prompt", value="worst quality, blurry, jittery", lines=2)
-        with gr.Row():
-            seed_input = gr.Number(label="Seed", value=42, precision=0)
-            randomize_seed_input = gr.Checkbox(label="Randomize Seed", value=True)
-        guidance_scale_input = gr.Slider(label="Guidance Scale (CFG)", minimum=1.0, maximum=10.0, value=3.0, step=0.1)
-        with gr.Row():
-            height_input = gr.Slider(label="Height", value=512, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE)
-            width_input = gr.Slider(label="Width", value=704, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE)
+                        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_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>")
+                    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)*")
 
     # --- LÓGICA DE EVENTOS DA UI ---
-    
-    start_image_i2v.upload(fn=handle_media_upload_for_dims, inputs=[start_image_i2v, height_input, width_input], outputs=[height_input, width_input])
-    video_v2v.upload(fn=handle_media_upload_for_dims, inputs=[video_v2v, height_input, width_input], outputs=[height_input, width_input])
-    duration_input.change(fn=update_frame_slider, inputs=duration_input, outputs=middle_frame_i2v)
-    
-    image_tab.select(fn=lambda: "image-to-video", outputs=[mode])
-    text_tab.select(fn=lambda: "text-to-video", outputs=[mode])
-    video_tab.select(fn=lambda: "video-to-video", outputs=[mode])
-    
-    # --- <INÍCIO DA CORREÇÃO> ---
-    # Reescrevendo as listas de inputs de forma explícita para evitar erros.
-    
-    # Placeholders para os botões que não usam certos inputs
-    none_image = gr.Textbox(visible=False, value=None)
-    none_video = gr.Textbox(visible=False, value=None)
-    
-    # Parâmetros comuns a todos
-    shared_params = [
-        height_input, width_input, duration_input, frames_to_use, 
-        seed_input, randomize_seed_input, guidance_scale_input, improve_texture
-    ]
-    
-    i2v_inputs = [
-        i2v_prompt, negative_prompt_input, mode,
-        start_image_i2v, middle_image_i2v, middle_frame_i2v, middle_weight_i2v,
-        end_image_i2v, end_weight_i2v,
-        none_video, # Placeholder para input_video
-        *shared_params
-    ]
-
-    t2v_inputs = [
-        t2v_prompt, negative_prompt_input, mode,
-        none_image, none_image, gr.Number(value=-1, visible=False), gr.Slider(value=0, visible=False), # Placeholders para keyframes
-        none_image, gr.Slider(value=0, visible=False),
-        none_video, # Placeholder para input_video
-        *shared_params
-    ]
-    
-    v2v_inputs = [
-        v2v_prompt, negative_prompt_input, mode,
-        none_image, none_image, gr.Number(value=-1, visible=False), gr.Slider(value=0, visible=False), # Placeholders para keyframes
-        none_image, gr.Slider(value=0, visible=False),
-        video_v2v, # Input de vídeo real
-        *shared_params
-    ]
-    
-    common_outputs = [output_video, seed_input]
-    
-    i2v_button.click(fn=gradio_generate_wrapper, inputs=i2v_inputs, outputs=common_outputs, api_name="image_to_video_keyframes")
-    t2v_button.click(fn=gradio_generate_wrapper, inputs=t2v_inputs, outputs=common_outputs, api_name="text_to_video")
-    v2v_button.click(fn=gradio_generate_wrapper, inputs=v2v_inputs, outputs=common_outputs, api_name="video_to_video")
-    # --- <FIM DA CORREÇÃO> ---
 
+    # 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]
+    )
+
+    # 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]
+    )
 
 if __name__ == "__main__":
-    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)