Update app.py

app.py

@@ -2,111 +2,82 @@ import gradio as gr
 import moviepy.editor as mp
 import numpy as np
 import librosa
-import matplotlib.pyplot as plt
-from PIL import Image
+from PIL import Image, ImageDraw
 import tempfile
 import os
-import io
 import logging
 
 # Configuración de logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("app.log"),  # Guardar logs en archivo
-        logging.StreamHandler()  # Mostrar logs en consola
-    ]
-)
-logger = logging.getLogger("audio_to_video")
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
 
-def generate_waveform_video(audio_file, image_file):
+def generate_video(audio_path, image_path):
     try:
-        logger.info("------ Nueva solicitud de generación ------")
-        logger.info(f"Archivo de audio recibido: {audio_file}")
-        logger.info(f"Archivo de imagen recibido: {image_file}")
-
         # 1. Cargar audio
-        logger.info("Cargando archivo de audio...")
-        y, sr = librosa.load(audio_file)
+        y, sr = librosa.load(audio_path, sr=None)
         duration = librosa.get_duration(y=y, sr=sr)
-        logger.info(f"Duración del audio: {duration:.2f} segundos")
+        logging.info(f"Audio cargado ({duration:.1f} segundos)")
 
-        # 2. Procesar imagen
-        logger.info("Cargando imagen y preparando formato...")
-        img = Image.open(image_file).convert('RGB')
-        img_array = np.array(img)
-        img_clip = mp.ImageClip(img_array).set_duration(duration)
-        img_w, img_h = img_clip.size
-        logger.info(f"Resolución de imagen: {img_w}x{img_h}")
+        # 2. Cargar imagen
+        img = Image.open(image_path).convert('RGB')
+        img_w, img_h = img.size
+        logging.info(f"Imagen cargada ({img_w}x{img_h})")
 
-        # 3. Crear efecto de waveform
-        logger.info("Generando efecto de onda de audio...")
-        audio_envelope = np.abs(y)
-        audio_envelope = (audio_envelope / np.max(audio_envelope)) * (img_h // 3)
+        # 3. Crear efecto de onda
+        audio_envelope = np.abs(y) / np.max(np.abs(y))  # Normalizar
+        audio_envelope *= img_h // 4  # Escalar al 25% de la altura
 
+        # 4. Generar frames
         def make_frame(t):
-            fig, ax = plt.subplots(figsize=(img_w/100, img_h/100), dpi=100)
-            fig.patch.set_facecolor('black')
-            ax.set_facecolor('black')
-            ax.set_xlim(0, duration)
-            ax.set_ylim(-img_h//2, img_h//2)
-            ax.axis('off')
-
+            frame = img.copy()
+            draw = ImageDraw.Draw(frame)
+            
+            # Calcular posición en el audio
             time_idx = int(t * sr)
             start = max(0, time_idx - sr//10)
             end = min(len(audio_envelope), time_idx + sr//10)
             wave_slice = audio_envelope[start:end]
-
-            x = np.linspace(t-0.1, t+0.1, len(wave_slice))
-            ax.fill_between(x, wave_slice - img_h//4, -wave_slice + img_h//4, 
-                           facecolor='red', alpha=0.7)
-
-            # Convertir a RGB sin transparencia
-            buf = io.BytesIO()
-            plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0, 
-                       transparent=False, facecolor='black')
-            plt.close(fig)
             
-            img_frame = Image.open(buf).convert('RGB')
-            return np.array(img_frame)
+            # Dibujar onda
+            points = []
+            for i, val in enumerate(wave_slice):
+                x = int((i / len(wave_slice)) * img_w)
+                y_pos = img_h//2 - int(val)
+                y_neg = img_h//2 + int(val)
+                points.extend([(x, y_pos), (x, y_neg)])
+            
+            if len(points) > 2:
+                draw.polygon(points, fill=(255, 0, 0, 128))  # Rojo semitransparente
+            
+            return np.array(frame)
+
+        # 5. Crear video
+        video = mp.VideoClip(make_frame, duration=duration)
+        video.fps = 24
+        video = video.set_audio(mp.AudioFileClip(audio_path))
 
-        # 4. Componer video
-        logger.info("Creando clip de video...")
-        effect_clip = mp.VideoClip(make_frame, duration=duration).set_fps(24)
-        final_clip = mp.CompositeVideoClip([img_clip, effect_clip.set_pos("center")])
-        final_clip = final_clip.set_audio(mp.AudioFileClip(audio_file))
-        logger.info("Video compuesto exitosamente")
+        # 6. Guardar video temporalmente
+        temp_file = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+        video.write_videofile(temp_file.name, codec="libx264", audio_codec="aac", fps=24, logger=None)
+        logging.info(f"Video guardado temporalmente en: {temp_file.name}")
 
-        # 5. Guardar video
-        logger.info("Exportando video final...")
-        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
-            final_clip.write_videofile(
-                tmpfile.name, 
-                fps=24, 
-                codec="libx264", 
-                audio_codec="aac", 
-                logger=None
-            )
-            logger.info(f"Video guardado temporalmente en: {tmpfile.name}")
-            return tmpfile.name
+        # Retornar el archivo como descargable
+        return temp_file.name
 
     except Exception as e:
-        logger.error(f"Error crítico durante la generación: {str(e)}", exc_info=True)
-        raise Exception(f"Error: {str(e)} - Consulta el archivo app.log para más detalles")
+        logging.error(f"Error: {str(e)}")
+        return f"Error: {str(e)}"
 
 # Interfaz Gradio
 iface = gr.Interface(
-    fn=generate_waveform_video,
+    fn=generate_video,
     inputs=[
-        gr.Audio(type="filepath", label="Audio (WAV/MP3)"),
-        gr.Image(type="filepath", label="Imagen de Fondo"),
+        gr.Audio(type="filepath", label="Subir Audio (WAV/MP3)"),
+        gr.Image(type="filepath", label="Subir Imagen de Fondo")
     ],
-    outputs=gr.Video(label="Video Resultante", format="mp4"),
+    outputs=gr.File(label="Descargar Video"),  # Cambiado a gr.File para descargar
     title="Generador de Video Musical",
-    description="Crea videos con efectos de onda de audio sincronizados. Usa imágenes JPG/PNG y audio WAV/MP3."
+    description="Crea videos con efectos de audio sincronizados. Sube un audio y una imagen."
 )
 
 if __name__ == "__main__":
-    logger.info("Iniciando aplicación Gradio...")
     iface.queue().launch()