Update app.py

app.py

@@ -1,145 +1,63 @@
 import gradio as gr
-import json
-import base64
-import tempfile
 import os
-import wave
-from moviepy import *
-from moviepy.video.fx import FadeIn, FadeOut
-
-# Configurações de áudio padrão
-SAMPLE_RATE = 24000
-NUM_CHANNELS = 1
-SAMPWIDTH = 2
-
-def pcm_to_wav(pcm_base64, output_path):
-    """Converte PCM Base64 para WAV."""
-    try:
-        pcm_bytes = base64.b64decode(pcm_base64)
-        with wave.open(output_path, 'wb') as wav_file:
-            wav_file.setnchannels(NUM_CHANNELS)
-            wav_file.setsampwidth(SAMPWIDTH)
-            wav_file.setframerate(SAMPLE_RATE)
-            wav_file.writeframes(pcm_bytes)
-        return True
-    except Exception as e:
-        print(f"Erro Audio: {e}")
-        return False
-
-def base64_to_image(image_base64, output_path):
-    """Salva imagem Base64 em arquivo."""
-    try:
-        with open(output_path, "wb") as f:
-            f.write(base64.b64decode(image_base64))
-        return True
-    except Exception as e:
-        print(f"Erro Imagem: {e}")
-        return False
-
-def generate_video(project_json):
-    print("--- INICIANDO RENDERIZAÇÃO (V2 - BLOCKS) ---")
+import subprocess
+
+def convert_webm_to_mp4(video_file):
+    """
+    Função simples que recebe um caminho de arquivo de vídeo,
+    converte para MP4 usando FFmpeg e retorna o novo caminho.
+    """
+    print(f"Recebido arquivo: {video_file}")
     
-    # Criar pasta temporária para processamento
-    temp_dir_obj = tempfile.TemporaryDirectory()
-    temp_dir = temp_dir_obj.name
-
-    try:
-        # Tratamento do input JSON
-        if isinstance(project_json, str):
-            try:
-                data = json.loads(project_json)
-            except:
-                raise gr.Error("Erro: O texto fornecido não é um JSON válido.")
-        else:
-            data = project_json
-            
-        scenes_data = data.get("scenes", [])
-        if not scenes_data:
-            raise gr.Error("O JSON não contém a lista de cenas ('scenes').")
-
-        clips = []
-        scenes_data.sort(key=lambda x: x.get("id", 0))
-
-        for i, scene in enumerate(scenes_data):
-            print(f"Processando cena {i}...")
-            
-            img_path = os.path.join(temp_dir, f"scene_{i}.jpg")
-            audio_path = os.path.join(temp_dir, f"scene_{i}.wav")
-            
-            img_b64 = scene.get("image_data_base64")
-            audio_b64 = scene.get("audio_data_base64")
-            
-            if not img_b64 or not audio_b64:
-                print(f"Pulando cena {i}: Falta audio ou imagem.")
-                continue
+    if video_file is None:
+        return None
 
-            if not base64_to_image(img_b64, img_path): continue
-            if not pcm_to_wav(audio_b64, audio_path): continue
-            
-            try:
-                # --- SINTAXE MOVIEPY 2.0 ---
-                audio_clip = AudioFileClip(audio_path)
-                
-                # Definir duração da imagem = audio + 0.1s
-                duration = audio_clip.duration + 0.1
-                video_clip = ImageClip(img_path).with_duration(duration)
-                
-                # Juntar Audio
-                video_clip = video_clip.with_audio(audio_clip)
-                
-                # Aplicar Fade In
-                video_clip = video_clip.with_effects([FadeIn(duration=0.5)])
-                
-                clips.append(video_clip)
-                
-            except Exception as e_clip:
-                print(f"Erro na montagem do clipe {i}: {e_clip}")
+    # Define nomes de arquivo
+    input_path = video_file
+    # Cria um nome de saída garantindo a extensão .mp4
+    output_path = os.path.splitext(input_path)[0] + "_converted.mp4"
 
-        if not clips:
-            raise gr.Error("Nenhum clipe foi gerado. Verifique os dados Base64.")
-
-        print(f"Concatenando {len(clips)} cenas...")
-        
-        final_video = concatenate_videoclips(clips, method="compose")
-        
-        output_path = os.path.join(temp_dir, "output_final.mp4")
+    try:
+        # Comando FFmpeg otimizado para velocidade (ultrafast) e compatibilidade (libx264)
+        # O flag -y sobrescreve se o arquivo já existir
+        command = [
+            "ffmpeg", "-y", 
+            "-i", input_path, 
+            "-c:v", "libx264", 
+            "-preset", "ultrafast",  # Converte rápido para não dar timeout
+            "-crf", "23",            # Qualidade balanceada
+            "-c:a", "aac",           # Audio padrão MP4
+            output_path
+        ]
         
-        final_video.write_videofile(
-            output_path, 
-            fps=24, 
-            codec="libx264", 
-            audio_codec="aac",
-            preset="ultrafast",
-            logger=None 
-        )
+        print(f"Executando FFmpeg: {' '.join(command)}")
+        subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         
-        print("Vídeo gerado com sucesso!")
+        print(f"Conversão concluída: {output_path}")
         return output_path
-
-    except Exception as e:
-        error_msg = f"Erro fatal no backend: {str(e)}"
-        print(error_msg)
-        raise gr.Error(error_msg)
-
-# --- AQUI ESTA A MUDANÇA ---
-# Usamos Blocks para ter controle total sobre o nome da API
-with gr.Blocks(title="Renderizador AI V2") as demo:
-    gr.Markdown("# Renderizador AI Backend")
-    
-    with gr.Row():
-        input_component = gr.JSON(label="JSON do Projeto")
-        output_component = gr.Video(label="Vídeo Final")
-    
-    btn = gr.Button("Renderizar", variant="primary")
-    
-    # O parametro api_name="predict" ABAIXO é o segredo.
-    # Ele obriga o Gradio a expor a rota /predict que seu App procura.
-    btn.click(
-        fn=generate_video, 
-        inputs=input_component, 
-        outputs=output_component, 
-        api_name="predict"
-    )
+        
+    except subprocess.CalledProcessError as e:
+        print(f"Erro no FFmpeg: {e}")
+        return None
+    except Exception as ex:
+        print(f"Erro geral: {ex}")
+        return None
+
+# Interface simples: Entrada de Vídeo -> Saída de Vídeo
+# allow_flagging="never" remove botões desnecessários que podem causar erros
+iface = gr.Interface(
+    fn=convert_webm_to_mp4,
+    inputs=gr.Video(label="Input WebM"),
+    outputs=gr.Video(label="Output MP4"),
+    allow_flagging="never",
+    title="API Conversor WebM para MP4"
+)
 
 if __name__ == "__main__":
-    demo.launch()
+    # O SEGREDO DO SUCESSO: cors_allowed_origins=["*"]
+    # Isso permite que o Preview do nosso editor envie arquivos para seu servidor.
+    iface.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        cors_allowed_origins=["*"]
+    )