Update app_seedvr.py

app_seedvr.py

@@ -7,27 +7,31 @@ from typing import Optional
 import gradio as gr
 import cv2
 
-# --- SERVER LOGIC INTEGRATION ---
+# --- INTEGRAÇÃO COM A LÓGICA DO SERVIDOR ---
 try:
+    # Importa a classe SeedVRServer que agora atua como nossa biblioteca de inferência.
     from api.seedvr_server import SeedVRServer
 except ImportError as e:
-    print(f"FATAL ERROR: Could not import SeedVRServer. Details: {e}")
+    print(f"ERRO FATAL: Não foi possível importar o SeedVRServer. Detalhes: {e}")
+    # A aplicação não pode rodar sem a lógica do servidor.
     raise
 
-# --- INITIALIZATION ---
+# --- INICIALIZAÇÃO ---
+# Cria uma instância única e persistente do servidor.
+# A inicialização (clonar repo, baixar modelos) acontece apenas uma vez, no início.
 server = SeedVRServer()
 
-# --- HELPER FUNCTIONS ---
+# --- FUNÇÕES AUXILIARES ---
 
 def _is_video(path: str) -> bool:
-    """Checks if a file path corresponds to a video type."""
+    """Verifica se um caminho de arquivo corresponde a um tipo de vídeo."""
     if not path: return False
     import mimetypes
     mime, _ = mimetypes.guess_type(path)
     return (mime or "").startswith("video")
 
 def _extract_first_frame(video_path: str) -> Optional[str]:
-    """Extracts the first frame from a video and saves it as a JPG image."""
+    """Extrai o primeiro frame de um vídeo e o salva como uma imagem JPG."""
     if not video_path or not os.path.exists(video_path): return None
     try:
         vid_cap = cv2.VideoCapture(video_path)
@@ -35,23 +39,32 @@ def _extract_first_frame(video_path: str) -> Optional[str]:
         success, image = vid_cap.read()
         vid_cap.release()
         if not success: return None
+        
+        # Salva o frame no mesmo diretório do vídeo, com extensão .jpg
         image_path = Path(video_path).with_suffix(".jpg")
         cv2.imwrite(str(image_path), image)
         return str(image_path)
     except Exception as e:
-        print(f"Error extracting first frame: {e}")
+        print(f"Erro ao extrair o primeiro frame: {e}")
         return None
 
 def on_file_upload(file_obj):
-    """Callback triggered when a user uploads a file."""
+    """
+    Callback acionado quando o usuário faz o upload de um arquivo.
+    Verifica se o arquivo é um vídeo e sugere um `sp_size` apropriado.
+    """
     if file_obj is None:
-        return 1
+        # Limpa os resultados e o log se o arquivo for removido
+        return 1, None, None, None, None
+    
     if _is_video(file_obj.name):
-        return gr.update(value=4, interactive=True)
+        # Para vídeos, sugere um valor padrão para multi-GPU e torna o slider interativo
+        return gr.update(value=4, interactive=True), None, None, None, None
     else:
-        return gr.update(value=1, interactive=False)
+        # Para imagens, trava o valor em 1
+        return gr.update(value=1, interactive=False), None, None, None, None
 
-# --- CORE INFERENCE FUNCTION ---
+# --- FUNÇÃO PRINCIPAL DE INFERÊNCIA DA UI ---
 
 def run_inference_ui(
     input_file_path: Optional[str],
@@ -61,66 +74,63 @@ def run_inference_ui(
     progress=gr.Progress(track_tqdm=True)
 ):
     """
-    The main callback function for Gradio, using generators (`yield`)
-    for real-time UI updates.
+    A função de callback principal do Gradio. Usa geradores (`yield`)
+    para permitir atualizações da UI em tempo real durante a tarefa de longa duração.
     """
-    # 1. Initial State & Validation
+    # 1. Estado Inicial e Validação
+    # No início, desabilita o botão, limpa resultados anteriores e mostra a janela de log.
     yield (
         gr.update(interactive=False, value="Processing... 🚀"),
         gr.update(value=None, visible=False),
         gr.update(value=None, visible=False),
         gr.update(value=None, visible=False),
-        gr.update(value="Waiting for logs...", visible=True)
+        gr.update(value="▶ Starting inference process...\n", visible=True)
     )
 
     if not input_file_path:
         gr.Warning("Please upload a media file first.")
-        yield (
-            gr.update(interactive=True, value="Restore Media"),
-            None, None, None, gr.update(visible=False)
-        )
+        # Reabilita o botão e esconde os componentes de saída
+        yield (gr.update(interactive=True, value="Restore Media"), None, None, None, gr.update(visible=False))
         return
 
     log_buffer = ["▶ Starting inference process...\n"]
-    yield gr.update(), None, None, None, ''.join(log_buffer)
-
-    # CORREÇÃO APLICADA AQUI
-    def progress_callback(step: float, desc: str):
-        """A simple callback to append messages to our log buffer."""
-        log_buffer.append(f"⏳ [{int(step*100)}%] {desc}\n")
-        # A chamada correta para a API de progresso do Gradio
-        progress(step, desc=desc)
-
     was_input_video = _is_video(input_file_path)
 
     try:
-        # 2. Execute Inference
-        progress_callback(0.1, "Calling backend engine...")
-        yield gr.update(), None, None, None, ''.join(log_buffer)
-
+        # Define um callback que será chamado pelo backend para atualizar o progresso e o log
+        def progress_callback_wrapper(step: float, desc: str):
+            """ Wrapper para formatar logs e atualizar o progresso. """
+            # Adiciona a nova mensagem de log ao buffer
+            log_buffer.append(f"⏳ [{int(step*100)}%] {desc}\n")
+            # Atualiza o objeto de progresso do Gradio
+            progress(step, desc=desc)
+
+        # 2. Executa a Inferência
+        # Chama o método direto do servidor, passando o nosso callback.
         video_result_path = server.run_inference_direct(
             file_path=input_file_path,
-            seed=42,
+            seed=42, # Semente fixa conforme solicitado
             res_h=int(resolution),
-            res_w=int(resolution),
+            res_w=int(resolution), # Largura igual à altura
             sp_size=int(sp_size),
             fps=float(fps) if fps and fps > 0 else None,
-            progress=progress,
+            progress=progress_callback_wrapper, # Passa nossa função de callback
         )
         
-        progress_callback(1.0, "Inference complete! Processing final output...")
-        yield gr.update(), None, None, None, ''.join(log_buffer)
+        progress(1.0, desc="Complete!")
+        log_buffer.append("✅ Inference complete! Processing final output...\n")
         
-        # 3. Process and Display Results
+        # 3. Processa e Exibe os Resultados
         final_image, final_video = None, None
         if was_input_video:
             final_video = video_result_path
-            log_buffer.append(f"✅ Video result is ready.\n")
-        else:
+            log_buffer.append("✅ Video result is ready.\n")
+        else: # Se a entrada foi uma imagem
             final_image = _extract_first_frame(video_result_path)
-            final_video = video_result_path
-            log_buffer.append(f"✅ Image result extracted from video.\n")
+            final_video = video_result_path # Também disponibiliza o vídeo de 1 frame
+            log_buffer.append("✅ Image result extracted from video.\n")
         
+        # Yield final para mostrar os resultados e reabilitar o botão
         yield (
             gr.update(interactive=True, value="Restore Media"),
             gr.update(value=final_image, visible=final_image is not None),
@@ -132,20 +142,21 @@ def run_inference_ui(
     except Exception as e:
         error_message = f"❌ Inference failed: {e}"
         gr.Error(error_message)
-        print(error_message)
+        log_buffer.append(f"\n{error_message}")
         import traceback
         traceback.print_exc()
         
+        # Yield para estado de erro: reabilita o botão e mostra o log com o erro
         yield (
             gr.update(interactive=True, value="Restore Media"),
             None, None, None,
-            gr.update(value=f"{''.join(log_buffer)}\n{error_message}", visible=True)
+            gr.update(value=''.join(log_buffer), visible=True)
         )
 
+# --- LAYOUT DA INTERFACE GRÁFICA (GRADIO) ---
 
-# --- GRADIO UI LAYOUT ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="SeedVR Media Restoration") as demo:
-    # Header
+    # Cabeçalho
     gr.Markdown(
         """
         <div style='text-align: center; margin-bottom: 20px;'>
@@ -154,34 +165,50 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="SeedVR Media Res
         </div>
         """
     )
+
     with gr.Row():
+        # --- Coluna da Esquerda: Entradas e Controles ---
         with gr.Column(scale=1):
             gr.Markdown("### 1. Upload Media")
-            input_media = gr.File(label="Input File (Video or Image)", type="filepath")
+            # Componente de upload agora mostra apenas o link, não a pré-visualização.
+            input_media = gr.File(label="Input File (Video or Image)", type="filepath", interactive=True)
+            
             gr.Markdown("### 2. Configure Settings")
             with gr.Accordion("Generation Parameters", open=True):
                 resolution_select = gr.Dropdown(
-                    label="Resolution (Short Edge)",
+                    label="Resolution",
                     choices=["480", "560", "720", "960", "1024"],
                     value="480",
-                    info="The output height and width will be set to this value."
+                    info="Sets the output height and width to this value."
                 )
+                
                 sp_size_slider = gr.Slider(
-                    label="Sequence Parallelism (sp_size)",
+                    label="Frames per Batch (sp_size)",
                     minimum=1, maximum=16, step=1, value=4,
-                    info="For multi-GPU videos. This will be set to 1 for images."
+                    info="For multi-GPU videos. Automatically set to 1 for images."
                 )
+
                 fps_out = gr.Number(label="Output FPS (for Videos)", value=24, precision=0, info="Set to 0 to use the original FPS.")
+
             run_button = gr.Button("Restore Media", variant="primary", icon="✨")
+
+        # --- Coluna da Direita: Resultados ---
         with gr.Column(scale=2):
             gr.Markdown("### 3. Results")
+            
+            # Janela de Log
             log_window = gr.Textbox(
-                label="Inference Log 📝", lines=8, max_lines=15,
-                interactive=False, visible=False, autoscroll=True,
+                label="Inference Log 📝",
+                lines=8, max_lines=15,
+                interactive=False, visible=False, autoscroll=True
             )
+
+            # Componentes de saída (começam invisíveis)
             output_image = gr.Image(label="Image Result", show_download_button=True, type="filepath", visible=False)
             output_video = gr.Video(label="Video Result", visible=False)
             output_download = gr.File(label="Download Full Result (Video)", visible=False)
+
+    # --- Rodapé ---
     gr.Markdown(
         """
         ---
@@ -190,8 +217,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="SeedVR Media Res
         """
     )
     
-    input_media.upload(fn=on_file_upload, inputs=[input_media], outputs=[sp_size_slider])
+    # --- Lógica de Eventos da UI ---
+    
+    # Ao fazer upload de um arquivo, ajusta o slider `sp_size` e limpa saídas antigas.
+    input_media.upload(
+        fn=on_file_upload,
+        inputs=[input_media],
+        outputs=[sp_size_slider, output_image, output_video, output_download, log_window]
+    )
     
+    # Ao clicar no botão, executa a função de inferência principal.
     run_button.click(
         fn=run_inference_ui,
         inputs=[input_media, resolution_select, sp_size_slider, fps_out],