Update App.py

App.py

@@ -1,113 +1,133 @@
 import gradio as gr
-import edge_tts
-import asyncio
+import json
+import base64
 import tempfile
 import os
-from moviepy.editor import ImageClip, concatenate_videoclips, AudioFileClip, TextClip, CompositeVideoClip
-from moviepy.config import change_settings
+import wave
+from moviepy.editor import ImageClip, AudioFileClip, concatenate_videoclips
 
-# Tenta configurar o ImageMagick (necessário para TextClip em alguns ambientes Linux)
-# Se der erro de policy.xml no HF, usaremos uma alternativa sem TextClip complexo ou legendas simplificadas
-try:
-    change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
-except:
-    pass
+# Configurações de áudio do Gemini (Default: 24kHz, 16bit, Mono)
+SAMPLE_RATE = 24000
+NUM_CHANNELS = 1
+SAMPWIDTH = 2  # 16 bit = 2 bytes
 
-async def text_to_speech(text, voice="pt-BR-FranciscaNeural"):
-    """Gera áudio a partir de texto usando Edge-TTS (Microsoft Azure Free)"""
-    communicate = edge_tts.Communicate(text, voice)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-        await communicate.save(tmp_file.name)
-        return tmp_file.name
-
-def create_video_segment(image_url, audio_path, text_content):
-    """Cria um segmento de vídeo: Imagem + Áudio + Legenda"""
-    # Carrega o áudio para saber a duração
-    audio_clip = AudioFileClip(audio_path)
-    duration = audio_clip.duration + 0.5 # +0.5s de respiro
-
-    # Cria o clipe de imagem (Baixa da URL se necessário, mas o Gradio já entrega o path local se enviado como arquivo)
-    # Se o input for filepath (caminho local salvo pelo Gradio):
-    image_clip = ImageClip(image_url).set_duration(duration)
-    
-    # Redimensiona para formato Vertical (9:16) se necessário, ou mantém proporção
-    # Aqui forçamos uma altura padrão de HD vertical (ex: 1280x720 invertido ou similar)
-    # Para simplificar, vamos assumir que a imagem gerada já vem no formato certo ou fazemos resize
-    image_clip = image_clip.resize(height=1280)
-    image_clip = image_clip.set_position("center")
-
-    # Legenda (Simples)
-    # Nota: TextClip pode ser chato de configurar no Linux devido ao ImageMagick.
-    # Se der erro, remova este bloco de txt_clip e retorne apenas image_clip.set_audio
+def pcm_to_wav(pcm_base64, output_path):
+    """Decodifica Base64 PCM e salva como arquivo WAV com cabeçalhos corretos."""
     try:
-        txt_clip = TextClip(text_content, fontsize=50, color='white', font='Arial-Bold', 
-                            stroke_color='black', stroke_width=2, size=(image_clip.w - 100, None), method='caption')
-        txt_clip = txt_clip.set_position(('center', 'bottom')).set_duration(duration).set_start(0)
-        video_part = CompositeVideoClip([image_clip, txt_clip])
+        # 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)
+            wav_file.setframerate(SAMPLE_RATE)
+            wav_file.writeframes(pcm_bytes)
+        return True
     except Exception as e:
-        print(f"Erro ao gerar legenda (ImageMagick ausente?): {e}")
-        video_part = image_clip
+        print(f"Erro ao converter audio: {e}")
+        return False
 
-    video_part = video_part.set_audio(audio_clip)
-    return video_part
+def base64_to_image(image_base64, output_path):
+    """Decodifica imagem Base64 e salva 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}")
+        return False
 
-async def process_video(scenes_data):
+def generate_video(project_json):
     """
-    Função principal chamada pela API.
-    scenes_data esperado: Lista de tuplas/listas [caminho_imagem, texto_narracao]
-    Exemplo: [ ["/tmp/img1.jpg", "Maria apareceu..."], ["/tmp/img2.jpg", "Ela disse..."] ]
+    Recebe um JSON com o manifesto do projeto, 
+    processa cenas e gera um MP4.
     """
-    final_clips = []
-    
-    for scene in scenes_data:
-        image_path = scene[0]
-        text = scene[1]
-        
-        # 1. Gerar Áudio
-        audio_path = await text_to_speech(text)
-        
-        # 2. Criar Clipe
-        clip = create_video_segment(image_path, audio_path, text)
-        final_clips.append(clip)
+    try:
+        # Se o gradio enviar como dict, usa direto, senão faz parse
+        if isinstance(project_json, str):
+            data = json.loads(project_json)
+        else:
+            data = project_json
+            
+        scenes_data = data.get("scenes", [])
+        project_title = data.get("project", "video")
         
-    # 3. Concatenar tudo
-    final_video = concatenate_videoclips(final_clips, method="compose")
-    
-    output_path = tempfile.mktemp(suffix=".mp4")
-    final_video.write_videofile(output_path, fps=24, codec="libx264", audio_codec="aac")
-    
-    return output_path
+        clips = []
+        temp_files = [] # Para limpar depois
+
+        # Criar diretório temporário para processamento
+        with tempfile.TemporaryDirectory() as temp_dir:
+            
+            # Ordenar cenas por ID para garantir sequencia
+            scenes_data.sort(key=lambda x: x.get("id", 0))
 
-# Wrapper síncrono para o Gradio chamar a função async
-def gradio_entry_point(image1, text1, image2, text2, image3, text3, image4, text4):
-    # Por limitações de interface simples do Gradio, vamos aceitar inputs fixos (ex: 4 cenas)
-    # Para 12 cenas, o ideal é enviar um JSON, mas vamos fazer simples para teste visual
-    # Se o frontend enviar JSON, mudamos aqui.
-    
-    # Monta a lista ignorando vazios
-    scenes = []
-    inputs = [(image1, text1), (image2, text2), (image3, text3), (image4, text4)]
-    
-    for img, txt in inputs:
-        if img and txt:
-            scenes.append([img, txt])
+            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
+
+                # Salvar arquivos
+                if not base64_to_image(img_b64, img_path): continue
+                if not pcm_to_wav(audio_b64, audio_path): continue
+                
+                # Criar Clips Moviepy
+                # 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)
+                
+                # Juntar áudio na imagem
+                video_clip = video_clip.set_audio(audio_clip)
+                
+                # Fade in/out suave para transição
+                video_clip = video_clip.crossfadein(0.5)
+                
+                clips.append(video_clip)
+            
+            if not clips:
+                return None
             
-    if not scenes:
-        return None
+            # Concatenar tudo
+            final_video = concatenate_videoclips(clips, method="compose")
+            
+            # Arquivo de saída persistente (fora do temp dir que será deletado)
+            output_filename = f"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:
+        return f"Erro no processamento: {str(e)}"
 
-    return asyncio.run(process_video(scenes))
+# Interface Gradio
+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."
+)
 
-# Interface Visual (Para teste manual no site do HF)
-with gr.Interface(
-    fn=gradio_entry_point,
-    inputs=[
-        gr.Image(type="filepath", label="Cena 1 - Imagem"), gr.Textbox(label="Cena 1 - Texto"),
-        gr.Image(type="filepath", label="Cena 2 - Imagem"), gr.Textbox(label="Cena 2 - Texto"),
-        gr.Image(type="filepath", label="Cena 3 - Imagem"), gr.Textbox(label="Cena 3 - Texto"),
-        gr.Image(type="filepath", label="Cena 4 - Imagem"), gr.Textbox(label="Cena 4 - Texto"),
-    ],
-    outputs=gr.Video(),
-    title="Gerador de Vídeo Nossa Senhora (Backend)",
-    description="Backend API para renderizar vídeo com MoviePy e EdgeTTS"
-) as demo:
-    demo.launch()
+# Habilitar CORS para que seu App local possa chamar essa API
+if __name__ == "__main__":
+    demo.launch(share=False, show_api=True, cors_allowed_origins=["*"])