Update app.py

app.py

@@ -4,20 +4,17 @@ import base64
 import tempfile
 import os
 import wave
-from moviepy.editor import ImageClip, AudioFileClip, concatenate_videoclips
+from moviepy import * from moviepy.video.fx import FadeIn, FadeOut
 
-# Configurações de áudio do Gemini (Default: 24kHz, 16bit, Mono)
+# Configurações de áudio padrão
 SAMPLE_RATE = 24000
 NUM_CHANNELS = 1
-SAMPWIDTH = 2  # 16 bit = 2 bytes
+SAMPWIDTH = 2
 
 def pcm_to_wav(pcm_base64, output_path):
-    """Decodifica Base64 PCM e salva como arquivo WAV com cabeçalhos corretos."""
+    """Converte PCM Base64 para WAV."""
     try:
-        # Decodificar string base64 para bytes
         pcm_bytes = base64.b64decode(pcm_base64)
-        
-        # Escrever arquivo WAV
         with wave.open(output_path, 'wb') as wav_file:
             wav_file.setnchannels(NUM_CHANNELS)
             wav_file.setsampwidth(SAMPWIDTH)
@@ -25,106 +22,127 @@ def pcm_to_wav(pcm_base64, output_path):
             wav_file.writeframes(pcm_bytes)
         return True
     except Exception as e:
-        print(f"Erro ao converter audio: {e}")
+        print(f"Erro Audio: {e}")
         return False
 
 def base64_to_image(image_base64, output_path):
-    """Decodifica imagem Base64 e salva em arquivo."""
+    """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 ao salvar imagem: {e}")
+        print(f"Erro Imagem: {e}")
         return False
 
 def generate_video(project_json):
-    """
-    Recebe um JSON com o manifesto do projeto, 
-    processa cenas e gera um MP4.
-    """
+    print("--- INICIANDO RENDERIZAÇÃO (V2) ---")
+    
+    # Criar pasta temporária para processamento
+    # O 'with' garante que a pasta suma depois, mas o arquivo final precisa persistir
+    # Então vamos criar a estrutura manualmente dentro do temp
+    
+    temp_dir_obj = tempfile.TemporaryDirectory()
+    temp_dir = temp_dir_obj.name
+
     try:
-        # Se o gradio enviar como dict, usa direto, senão faz parse
+        # Tratamento do input JSON
         if isinstance(project_json, str):
-            data = json.loads(project_json)
+            try:
+                data = json.loads(project_json)
+            except:
+                # Caso venha como string mas não seja JSON válido
+                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))
 
-        # Criar diretório temporário para processamento
-        with tempfile.TemporaryDirectory() as temp_dir:
+        for i, scene in enumerate(scenes_data):
+            print(f"Processando cena {i}...")
             
-            # Ordenar cenas por ID para garantir sequencia
-            scenes_data.sort(key=lambda x: x.get("id", 0))
-
-            for i, scene in enumerate(scenes_data):
-                scene_id = scene.get("id", i)
-                print(f"Processando cena {scene_id}...")
-                
-                # Caminhos temporários
-                img_path = os.path.join(temp_dir, f"scene_{scene_id}.jpg")
-                audio_path = os.path.join(temp_dir, f"scene_{scene_id}.wav")
-                
-                # Extrair dados
-                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 {scene_id}: dados incompletos")
-                    continue
+            # Definir caminhos
+            img_path = os.path.join(temp_dir, f"scene_{i}.jpg")
+            audio_path = os.path.join(temp_dir, f"scene_{i}.wav")
+            
+            # Pegar dados
+            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
 
-                # Salvar arquivos
-                if not base64_to_image(img_b64, img_path): continue
-                if not pcm_to_wav(audio_b64, audio_path): continue
+            # Decodificar arquivos
+            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 ---
                 
-                # Criar Clips Moviepy
-                # Audio
+                # 1. Carregar Audio
                 audio_clip = AudioFileClip(audio_path)
                 
-                # Imagem (duração = duração do áudio + 0.5s de respiro)
-                duration = audio_clip.duration + 0.2
-                video_clip = ImageClip(img_path).set_duration(duration)
+                # 2. Carregar Imagem e definir duração = audio + 0.1s
+                duration = audio_clip.duration + 0.1
+                video_clip = ImageClip(img_path).with_duration(duration)
                 
-                # Juntar áudio na imagem
-                video_clip = video_clip.set_audio(audio_clip)
+                # 3. Juntar Audio
+                video_clip = video_clip.with_audio(audio_clip)
                 
-                # Fade in/out suave para transição
-                video_clip = video_clip.crossfadein(0.5)
+                # 4. Aplicar Fade In (Nova Sintaxe v2)
+                # O crossfadein antigo foi depreciado em favor de composition ou fx
+                # Vamos usar FadeIn simples para entrada suave
+                video_clip = video_clip.with_effects([FadeIn(duration=0.5)])
                 
                 clips.append(video_clip)
-            
-            if not clips:
-                return None
-            
-            # Concatenar tudo
-            final_video = concatenate_videoclips(clips, method="compose")
-            
-            # Arquivo de saída persistente
-            output_filename = "video_final.mp4"
-            final_video.write_videofile(
-                output_filename, 
-                fps=24, 
-                codec="libx264", 
-                audio_codec="aac",
-                preset="medium"
-            )
-            
-            return output_filename
+                
+            except Exception as e_clip:
+                print(f"Erro na montagem do clipe {i}: {e_clip}")
+
+        if not clips:
+            raise gr.Error("Nenhum clipe foi gerado. Verifique os dados Base64.")
+
+        print(f"Concatenando {len(clips)} cenas...")
+        
+        # Concatenação
+        final_video = concatenate_videoclips(clips, method="compose")
+        
+        # Output final
+        output_path = os.path.join(temp_dir, "output_final.mp4")
+        
+        final_video.write_videofile(
+            output_path, 
+            fps=24, 
+            codec="libx264", 
+            audio_codec="aac",
+            preset="ultrafast",
+            logger=None 
+        )
+        
+        print("Vídeo gerado com sucesso!")
+        return output_path
 
     except Exception as e:
-        return f"Erro no processamento: {str(e)}"
+        error_msg = f"Erro fatal no backend: {str(e)}"
+        print(error_msg)
+        raise gr.Error(error_msg)
 
-# Interface Gradio
+# Interface Gradio Atualizada
+# api_name="predict" garante que a rota /predict exista para seu frontend
 demo = gr.Interface(
     fn=generate_video,
-    inputs=gr.JSON(label="Manifesto do Projeto (JSON)"),
-    outputs=gr.Video(label="Vídeo Gerado"),
-    title="Marian Studio Renderer",
-    description="Backend de renderização para o Marian Studio AI via MoviePy."
+    inputs=gr.JSON(label="JSON do Projeto"),
+    outputs=gr.Video(label="Vídeo Final"),
+    title="Renderizador AI V2 (Gradio 5 + MoviePy 2)",
+    allow_flagging="never"
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    # Gradio 5 gerencia segurança automaticamente no Spaces
+    demo.launch()