Update app.py

app.py

@@ -3,64 +3,83 @@ import moviepy.editor as mp
 import numpy as np
 import librosa
 import matplotlib.pyplot as plt
-import io
+from io import BytesIO
+import logging
 
-def audio_to_video(audio_file, image_file, effect_type="waveform"):
+# Configuración de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("audio_to_video")
+
+def generate_waveform_video(audio_path, image_path):
     try:
-        # Cargar audio
-        y, sr = librosa.load(audio_file)
+        # 1. Cargar audio
+        logger.info("Cargando archivo de audio...")
+        y, sr = librosa.load(audio_path)
         duration = librosa.get_duration(y=y, sr=sr)
+        logger.info(f"Duración del audio: {duration:.2f} segundos")
 
-        # Cargar imagen
-        img_clip = mp.ImageClip(image_file).set_duration(duration)
-
-        # Generar efecto visual (waveform)
-        if effect_type == "waveform":
-            audio_envelope = np.abs(y)  # Envelope del audio
-            audio_envelope = (audio_envelope / np.max(audio_envelope)) * (img_clip.h / 2)
+        # 2. Cargar imagen
+        logger.info("Procesando imagen...")
+        img_clip = mp.ImageClip(image_path).set_duration(duration)
+        img_width, img_height = img_clip.size
 
-            def make_frame(t):
-                fig, ax = plt.subplots(figsize=(img_clip.w/100, img_clip.h/100), dpi=100)
-                ax.set_xlim(0, duration)
-                ax.set_ylim(-img_clip.h/2, img_clip.h/2)
-                ax.axis('off')
-                
-                time_index = int(t * sr)
-                wave_slice = audio_envelope[max(0, time_index - sr//10):min(len(audio_envelope), time_index + sr//10)]
-                ax.plot(np.linspace(t-0.1, t+0.1, len(wave_slice)), wave_slice - img_clip.h/4, color='red')
-                ax.plot(np.linspace(t-0.1, t+0.1, len(wave_slice)), -wave_slice + img_clip.h/4, color='red')
-                
-                buf = io.BytesIO()
-                fig.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
-                plt.close(fig)
-                return np.array(Image.open(buf))  # Convertir a array de imagen
+        # 3. Crear efecto de waveform
+        logger.info("Generando efecto visual...")
+        audio_envelope = np.abs(y)  # Envelope del audio
+        audio_envelope = (audio_envelope / np.max(audio_envelope)) * (img_height // 3)
 
-            effect_clip = mp.VideoClip(make_frame, duration=duration).set_fps(24)
-            final_clip = mp.CompositeVideoClip([img_clip, effect_clip.set_pos("center")])
-        else:
-            return "Error: Efecto no soportado."
+        def make_frame(t):
+            fig, ax = plt.subplots(figsize=(img_width/100, img_height/100), dpi=100)
+            ax.set_xlim(0, duration)
+            ax.set_ylim(-img_height//2, img_height//2)
+            ax.axis('off')
+            
+            time_index = int(t * sr)
+            start = max(0, time_index - sr//10)
+            end = min(len(audio_envelope), time_index + sr//10)
+            wave_slice = audio_envelope[start:end]
+            
+            x_values = np.linspace(t-0.1, t+0.1, len(wave_slice))
+            ax.fill_between(x_values, wave_slice - img_height//4, -wave_slice + img_height//4, 
+                           facecolor='red', alpha=0.7)
+            
+            buf = BytesIO()
+            plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
+            plt.close(fig)
+            return mp.ImageClip(buf).get_frame(0)
 
-        # Agregar audio al video
-        final_clip = final_clip.set_audio(mp.AudioFileClip(audio_file))
-        output_path = "output.mp4"
-        final_clip.write_videofile(output_path, fps=24, codec="libx264", audio_codec="aac")
-        return output_path
+        logger.info("Renderizando video...")
+        effect_clip = mp.VideoClip(make_frame, duration=duration).set_fps(24)
+        final_clip = mp.CompositeVideoClip([img_clip, effect_clip.set_pos("center")])
+        
+        # 4. Combinar con audio
+        final_clip = final_clip.set_audio(mp.AudioFileClip(audio_path))
+        
+        # 5. Guardar en memoria
+        buffer = BytesIO()
+        final_clip.write_videofile(buffer, fps=24, codec="libx264", 
+                                  audio_codec="aac", logger=None)
+        buffer.seek(0)
+        logger.info("Video generado exitosamente")
+        return buffer
 
     except Exception as e:
+        logger.error(f"Error durante la generación: {str(e)}")
         return f"Error: {str(e)}"
 
-# Interfaz de Gradio
+# Interfaz Gradio
 iface = gr.Interface(
-    fn=audio_to_video,
+    fn=generate_waveform_video,
     inputs=[
-        gr.Audio(type="filepath", label="Subir Audio (WAV/MP3)"),
-        gr.Image(type="filepath", label="Subir Imagen"),
-        gr.Radio(["waveform"], value="waveform", label="Efecto Visual")
+        gr.Audio(type="filepath", label="Audio (WAV/MP3)"),
+        gr.Image(type="filepath", label="Imagen de Fondo"),
     ],
-    outputs=gr.Video(label="Video Generado"),
-    title="Audio + Imagen → Video con Efecto Sincronizado",
-    description="Sube un audio y una imagen para generar un video con efecto visual sincronizado (waveform)."
+    outputs=gr.Video(label="Video Resultante", format="mp4"),
+    title="Generador de Video con Efectos de Audio",
+    description="Crea videos con efectos visuales sincronizados con el audio. Actualmente soporta efecto de waveform.",
+    allow_flagging="never"
 )
 
 if __name__ == "__main__":
-    iface.queue().launch()
+    logger.info("Iniciando aplicación Gradio...")
+    iface.queue().launch(share=False, debug=True)