Upload 30 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: veureu-tts  
+title: tts  
 emoji: 🔊  
 colorFrom: indigo  
 colorTo: blue  
@@ -8,12 +8,12 @@ app_file: app.py
 pinned: false  
 ---
 
-# 🗣️ veureu-tts
+# 🗣️ tts
 
-**veureu-tts** es un servicio **Docker** basado en **FastAPI** que forma parte del ecosistema **Veureu**.  
+**tts** es un servicio **Docker** basado en **FastAPI** que forma parte del ecosistema **Veureu**.  
 Su función es generar **pistas de audio o audiodescripción (AD)** en catalán a partir de texto o de archivos **SRT**, utilizando el plugin **Matxa-Alvocat TTS**.
 
-Este Space está diseñado para ser **invocado externamente** por otros Spaces (como `veureu-app` o `veureu-engine`) o por **servicios locales**.
+Este Space está diseñado para ser **invocado externamente** por otros Spaces (como `app` o `engine`) o por **servicios locales**.
 
 ---
 

local/local_tts_ad_from_srt.py

@@ -90,347 +90,347 @@ def tts_to_wav(
     out_path: str,
     voice: str = "central/grau",
     tts: Optional[MatxaCatalanTTSPlugin] = None
-) -> Tuple[int, np.ndarray]:
-    created_tts = tts is None
-    if tts is None:
-        tts = MatxaCatalanTTSPlugin(config={})
-
-    tts.get_tts(text, out_path, voice=voice)
-
-    data, sr = sf.read(out_path, dtype="float32", always_2d=False)
-    if created_tts:
-        del tts
-    if data.ndim == 2:
-        data = data.mean(axis=1)
-    return sr, data
-
-
-def trim_or_pad_to_duration(data: np.ndarray, sr: int, target_sec: float) -> np.ndarray:
-    target_len = int(round(target_sec * sr))
-    cur_len = len(data)
-    if cur_len > target_len:
-        return data[:target_len]
-    elif cur_len < target_len:
-        pad = np.zeros(target_len - cur_len, dtype=data.dtype)
-        return np.concatenate([data, pad])
-    return data
-
-
-def _resample_np(x: np.ndarray, sr_from: int, sr_to: int) -> np.ndarray:
-    if sr_from == sr_to:
-        return x
-    ratio = sr_to / sr_from
-    new_len = int(round(len(x) * ratio))
-    xp = np.linspace(0, 1, num=len(x), endpoint=False)
-    fp = x
-    xq = np.linspace(0, 1, num=new_len, endpoint=False)
-    yq = np.interp(xq, xp, fp).astype(np.float32)
-    return yq
-
-
-def mix_segments_on_timeline(
-    segments: List[Segment],
-    voice: str,
-    out_final: str,
-    target_sr: Optional[int] = None
-) -> str:
-    """
-    Genera un master de todos los segmentos AD, colocándolos en su timestamp SRT.
-    Si out_final termina en .mp3, escribe MP3 (vía ffmpeg/pydub); si no, WAV.
-    """
-    if not segments:
-        raise ValueError("No hay segmentos (AD) con contenido en el SRT.")
-
-    total_dur = max(s.end_s for s in segments)
-    tts = MatxaCatalanTTSPlugin(config={})
-
-    tmpdir = tempfile.mkdtemp(prefix="matxa_ad_")
-    tmp_clips: List[Tuple[int, np.ndarray, float, float]] = []
-
-    for seg in segments:
-        seg_wav = os.path.join(tmpdir, f"ad_{seg.idx}.wav")
-        sr, data = tts_to_wav(seg.text, seg_wav, voice=voice, tts=tts)
-        seg_dur = seg.end_s - seg.start_s
-        data = trim_or_pad_to_duration(data, sr, seg_dur)
-        tmp_clips.append((sr, data, seg.start_s, seg.end_s))
-
-    master_sr = target_sr or tmp_clips[0][0]
-    master_len = int(round(total_dur * master_sr))
-    master = np.zeros(master_len, dtype=np.float32)
-
-    for sr, data, start_s, _ in tmp_clips:
-        d = _resample_np(data, sr, master_sr)
-        start_i = int(round(start_s * master_sr))
-        end_i = start_i + len(d)
-        if end_i > len(master):
-            end_i = len(master)
-            d = d[: end_i - start_i]
-        master[start_i:end_i] += d
-
-    peak = np.max(np.abs(master)) if master.size else 0.0
-    if peak > 0.999:
-        master = (master / peak * 0.98).astype(np.float32)
-
-    base, ext = os.path.splitext(out_final)
-    if ext.lower() == ".mp3":
-        tmp_wav = base + ".__tmp_master__.wav"
-        sf.write(tmp_wav, master, master_sr, subtype="PCM_16")
-        au = AudioSegment.from_wav(tmp_wav)
-        au.export(out_final, format="mp3")
-        os.remove(tmp_wav)
-        return out_final
-    else:
-        out_wav = base + ".wav" if ext.lower() != ".wav" else out_final
-        sf.write(out_wav, master, master_sr, subtype="PCM_16")
-        return out_wav
-
-
-# ---------- (2) extraer audio de MP4 y mezclarlo con AD (simultáneo) ----------
-
-def ffmpeg_extract_audio_mp4_to_mp3(mp4_path: str, out_mp3_path: str, bitrate: str = "192k") -> str:
-    """
-    Extrae el audio del MP4 y lo guarda como MP3 (requiere ffmpeg).
-    """
-    cmd = [
-        "ffmpeg", "-y",
-        "-i", mp4_path,
-        "-vn",
-        "-acodec", "libmp3lame", "-b:a", bitrate,
-        out_mp3_path
-    ]
-    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    return out_mp3_path
-
-
-def mix_two_audios_simultaneous(mp3_a_path: str, mp3_b_path: str, out_mp3_path: str, normalise: bool = True) -> str:
-    """
-    Mezcla simultáneamente dos MP3 (p.ej., audio original + AD) y exporta un MP3.
-    - Ajusta la duración al máximo de ambas (rellena silencio si hace falta).
-    - Si normalise=True, aplica una normalización suave para evitar clipping.
-    """
-    a = AudioSegment.from_file(mp3_a_path)
-    b = AudioSegment.from_file(mp3_b_path)
-
-    # Igualamos duración: fondo del más largo
-    max_len = max(len(a), len(b))
-    if len(a) < max_len:
-        a = a.append(AudioSegment.silent(duration=max_len - len(a)), crossfade=0)
-    if len(b) < max_len:
-        b = b.append(AudioSegment.silent(duration=max_len - len(b)), crossfade=0)
-
-    # Mezcla: simple overlay. Puedes bajar el AD o el original si lo deseas (dB).
-    mixed = a.overlay(b)  # overlay simultáneo
-
-    if normalise:
-        peak = mixed.max_dBFS  # valor negativo, cercano a 0 dBFS
-        headroom = -1.0  # deja 1 dB de margen
-        gain = headroom - peak
-        mixed = mixed.apply_gain(gain)
-
-    mixed.export(out_mp3_path, format="mp3")
-    return out_mp3_path
-
-
-# ---------- (3) generar MP4 final: vídeo mudo + pista mezclada ----------
-
-def ffmpeg_mux_video_with_audio(video_mp4: str, audio_mp3: str, out_mp4: str) -> str:
-    """
-    Crea un MP4 con el vídeo mudo del original y la pista de audio proporcionada.
-    Mantiene el vídeo sin recomprimir (-c:v copy).
-    """
-    cmd = [
-        "ffmpeg", "-y",
-        "-i", video_mp4,
-        "-i", audio_mp3,
-        "-map", "0:v:0",  # coge el vídeo de la 1ª entrada
-        "-map", "1:a:0",  # coge el audio de la 2ª entrada
-        "-c:v", "copy",
-        "-shortest",
-        out_mp4
-    ]
-    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    return out_mp4
-
-
-# --------------------------- pipeline convenientes ----------------------------
-
-def build_ad_track_from_srt(srt_path: str, output_path: str = "ad_master.mp3", voice: str = "central/grau") -> str:
-    segs = parse_srt_ad_only(srt_path)
-    if not segs:
-        raise SystemExit("No se encontraron bloques (AD) con contenido en el SRT.")
-    result = mix_segments_on_timeline(segs, voice=voice, out_final=output_path)
-    return result
-
-def generate_audio_from_free_ad(video_name: str, version_name: str, voice: str = "central/grau") -> Optional[str]:
-    """
-    Genera un archivo de audio MP3 a partir del free_ad.txt para un vídeo y versión específicos.
-    """
-    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "veureu-app", "videos"))
-    file_path = os.path.join(base_path, video_name, version_name, "free_ad.txt")
-    output_mp3_path = os.path.join(base_path, video_name, version_name, "free_ad.mp3")
-
-    if not os.path.exists(file_path):
-        print(f"Advertencia: No se encontró {file_path}. Saltando.")
-        return None
-
-    with open(file_path, "r", encoding="utf-8") as f:
-        text = f.read().strip()
-
-    if not text:
-        print(f"Advertencia: El archivo {file_path} está vacío. Saltando.")
-        return None
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        tmp_wav = os.path.join(tmpdir, "temp_audio.wav")
-        tts_to_wav(text, tmp_wav, voice=voice)
-        audio = AudioSegment.from_wav(tmp_wav)
-        audio.export(output_mp3_path, format="mp3")
-
-    print(f"✔ Audio generado para {video_name}/{version_name} en: {output_mp3_path}")
-    return output_mp3_path
-
-
-def iterate_generate_audio_from_free_ad(voice: str = "central/grau"):
-    """
-    Itera sobre todos los vídeos y versiones, y genera el audio para cada free_ad.txt.
-    """
-    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "veureu-app", "videos"))
-    if not os.path.isdir(base_path):
-        print(f"Error: El directorio de vídeos no existe: {base_path}")
-        return
-
-    for video_name in os.listdir(base_path):
-        video_path = os.path.join(base_path, video_name)
-        if os.path.isdir(video_path):
-            for version_name in os.listdir(video_path):
-                version_path = os.path.join(video_path, version_name)
-                if os.path.isdir(version_path):
-                    generate_audio_from_free_ad(video_name, version_name, voice=voice)
-
-
-def generate_video_from_une_ad(video_name: str, version_name: str, voice: str = "central/grau") -> Optional[str]:
-    """
-    Genera un vídeo con audiodescripción a partir del une_ad.srt para un vídeo y versión específicos.
-    """
-    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "veureu-app", "videos"))
-    video_path = os.path.join(base_path, video_name, f"{video_name}.mp4")
-    srt_path = os.path.join(base_path, video_name, version_name, "une_ad.srt")
-    output_video_path = os.path.join(base_path, video_name, version_name, f"{video_name}_ad.mp4")
-    
-    if not os.path.exists(video_path) or not os.path.exists(srt_path):
-        print(f"Advertencia: No se encontró el vídeo o el SRT para {video_name}/{version_name}. Saltando.")
-        return None
-
-    # Rutas para los archivos intermedios
-    out_ad_mp3 = os.path.join(base_path, video_name, version_name, "ad_master.mp3")
-    out_mix_mp3 = os.path.join(base_path, video_name, version_name, "mix_original_plus_ad.mp3")
-
-    try:
-        make_final_assets_from_video_and_srt(
-            video_mp4=video_path,
-            srt_path=srt_path,
-            out_ad_mp3=out_ad_mp3,
-            out_mix_mp3=out_mix_mp3,
-            out_final_mp4=output_video_path,
-            voice=voice
-        )
-        print(f"✔ Vídeo con AD generado para {video_name}/{version_name} en: {output_video_path}")
-        return output_video_path
-    except Exception as e:
-        print(f"Error al procesar {video_name}/{version_name}: {e}")
-        return None
-
-def iterate_generate_video_from_une_ad(voice: str = "central/grau"):
-    """
-    Itera sobre todos los vídeos y versiones, y genera el vídeo con AD para cada une_ad.srt.
-    """
-    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "veureu-app", "videos"))
-    if not os.path.isdir(base_path):
-        print(f"Error: El directorio de vídeos no existe: {base_path}")
-        return
-
-    for video_name in os.listdir(base_path):
-        video_path = os.path.join(base_path, video_name)
-        if os.path.isdir(video_path):
-            for version_name in os.listdir(video_path):
-                version_path = os.path.join(video_path, version_name)
-                if os.path.isdir(version_path):
-                    generate_video_from_une_ad(video_name, version_name, voice=voice)
-
-def make_final_assets_from_video_and_srt(
-    video_mp4: str,
-    srt_path: str,
-    out_ad_mp3: str = "ad_master.mp3",
-    out_mix_mp3: str = "mix_original_plus_ad.mp3",
-    out_final_mp4: str = "video_con_ad.mp4",
-    voice: str = "central/grau"
-) -> Tuple[str, str, str]:
-    """
-    Pipeline completo:
-      1) genera la pista AD desde el SRT,
-      2) extrae audio del MP4 a MP3,
-      3) mezcla simultánea original+AD a MP3,
-      4) remuxa vídeo mudo + pista mezclada a MP4 final.
-    Devuelve rutas: (ad_mp3, mix_mp3, final_mp4)
-    """
-    ad_mp3 = build_ad_track_from_srt(srt_path, output_path=out_ad_mp3, voice=voice)
-
-    ori_mp3 = ffmpeg_extract_audio_mp4_to_mp3(video_mp4, out_mp3_path=os.path.splitext(out_ad_mp3)[0] + "_original.mp3")
-    mix_mp3 = mix_two_audios_simultaneous(ori_mp3, ad_mp3, out_mix_mp3)
-
-    final_mp4 = ffmpeg_mux_video_with_audio(video_mp4, mix_mp3, out_final_mp4)
-    return ad_mp3, mix_mp3, final_mp4
-
-
-# -------------------------------- CLI ---------------------------------------
-
-if __name__ == "__main__":
-    import argparse
-    ap = argparse.ArgumentParser(description="Genera AD desde SRT y compone con video/audio usando Matxa + ffmpeg.")
-    
-    # Argumentos existentes
-    ap.add_argument("--srt", help="Ruta al archivo .srt")
-    ap.add_argument("--video", help="Ruta al archivo .mp4 (para mezclar con AD y remux final)")
-    ap.add_argument("-o", "--output", default="ad_master.mp3", help="Salida de la pista AD (mp3 o wav).")
-    ap.add_argument("--voice", default="central/grau", help="Voz Matxa (ej: central/grau, central/elia)")
-    ap.add_argument("--do-pipeline", action="store_true",
-                    help="Ejecuta pipeline completo: genera AD, extrae audio del video, mezcla ambos y crea MP4 final.")
-    ap.add_argument("--mix-output", default="mix_original_plus_ad.mp3", help="Salida de audio mezclado (original+AD)")
-    ap.add_argument("--final-mp4", default="video_con_ad.mp4", help="Salida del MP4 final con AD")
-
-    # Nuevos argumentos para las funciones de iteración
-    ap.add_argument("--generate-free-ad-audio", action="store_true", help="Genera audio para todos los archivos free_ad.txt existentes.")
-    ap.add_argument("--generate-une-ad-video", action="store_true", help="Genera vídeo con AD para todos los archivos une_ad.srt existentes.")
-
-    args = ap.parse_args()
-
-    if args.generate_free_ad_audio:
-        print("--- Iniciando generación de audios desde free_ad.txt ---")
-        iterate_generate_audio_from_free_ad(voice=args.voice)
-        print("--- Proceso de generación de audios completado ---")
-    
-    elif args.generate_une_ad_video:
-        print("--- Iniciando generación de vídeos con AD desde une_ad.srt ---")
-        iterate_generate_video_from_une_ad(voice=args.voice)
-        print("--- Proceso de generación de vídeos completado ---")
-
-    elif args.do_pipeline:
-        if not args.srt or not args.video:
-            raise SystemExit("Para --do-pipeline necesitas --srt y --video.")
-        ad_mp3, mix_mp3, final_mp4 = make_final_assets_from_video_and_srt(
-            args.video, args.srt,
-            out_ad_mp3=args.output,
-            out_mix_mp3=args.mix_output,
-            out_final_mp4=args.final_mp4,
-            voice=args.voice
-        )
-        print(f"✔ AD:   {ad_mp3}")
-        print(f"✔ MIX:  {mix_mp3}")
-        print(f"✔ MP4:  {final_mp4}")
-    else:
-        if not args.srt:
-            # Si no se especifica ninguna acción, mostrar ayuda
-            ap.print_help()
-            raise SystemExit("Debes especificar una acción, como --generate-free-ad-audio, --generate-une-ad-video o --do-pipeline.")
-        result = build_ad_track_from_srt(args.srt, output_path=args.output, voice=args.voice)
-        print(f"✔ Audio AD escrito en: {result}")
+) -> Tuple[int, np.ndarray]:
+    created_tts = tts is None
+    if tts is None:
+        tts = MatxaCatalanTTSPlugin(config={})
+
+    tts.get_tts(text, out_path, voice=voice)
+
+    data, sr = sf.read(out_path, dtype="float32", always_2d=False)
+    if created_tts:
+        del tts
+    if data.ndim == 2:
+        data = data.mean(axis=1)
+    return sr, data
+
+
+def trim_or_pad_to_duration(data: np.ndarray, sr: int, target_sec: float) -> np.ndarray:
+    target_len = int(round(target_sec * sr))
+    cur_len = len(data)
+    if cur_len > target_len:
+        return data[:target_len]
+    elif cur_len < target_len:
+        pad = np.zeros(target_len - cur_len, dtype=data.dtype)
+        return np.concatenate([data, pad])
+    return data
+
+
+def _resample_np(x: np.ndarray, sr_from: int, sr_to: int) -> np.ndarray:
+    if sr_from == sr_to:
+        return x
+    ratio = sr_to / sr_from
+    new_len = int(round(len(x) * ratio))
+    xp = np.linspace(0, 1, num=len(x), endpoint=False)
+    fp = x
+    xq = np.linspace(0, 1, num=new_len, endpoint=False)
+    yq = np.interp(xq, xp, fp).astype(np.float32)
+    return yq
+
+
+def mix_segments_on_timeline(
+    segments: List[Segment],
+    voice: str,
+    out_final: str,
+    target_sr: Optional[int] = None
+) -> str:
+    """
+    Genera un master de todos los segmentos AD, colocándolos en su timestamp SRT.
+    Si out_final termina en .mp3, escribe MP3 (vía ffmpeg/pydub); si no, WAV.
+    """
+    if not segments:
+        raise ValueError("No hay segmentos (AD) con contenido en el SRT.")
+
+    total_dur = max(s.end_s for s in segments)
+    tts = MatxaCatalanTTSPlugin(config={})
+
+    tmpdir = tempfile.mkdtemp(prefix="matxa_ad_")
+    tmp_clips: List[Tuple[int, np.ndarray, float, float]] = []
+
+    for seg in segments:
+        seg_wav = os.path.join(tmpdir, f"ad_{seg.idx}.wav")
+        sr, data = tts_to_wav(seg.text, seg_wav, voice=voice, tts=tts)
+        seg_dur = seg.end_s - seg.start_s
+        data = trim_or_pad_to_duration(data, sr, seg_dur)
+        tmp_clips.append((sr, data, seg.start_s, seg.end_s))
+
+    master_sr = target_sr or tmp_clips[0][0]
+    master_len = int(round(total_dur * master_sr))
+    master = np.zeros(master_len, dtype=np.float32)
+
+    for sr, data, start_s, _ in tmp_clips:
+        d = _resample_np(data, sr, master_sr)
+        start_i = int(round(start_s * master_sr))
+        end_i = start_i + len(d)
+        if end_i > len(master):
+            end_i = len(master)
+            d = d[: end_i - start_i]
+        master[start_i:end_i] += d
+
+    peak = np.max(np.abs(master)) if master.size else 0.0
+    if peak > 0.999:
+        master = (master / peak * 0.98).astype(np.float32)
+
+    base, ext = os.path.splitext(out_final)
+    if ext.lower() == ".mp3":
+        tmp_wav = base + ".__tmp_master__.wav"
+        sf.write(tmp_wav, master, master_sr, subtype="PCM_16")
+        au = AudioSegment.from_wav(tmp_wav)
+        au.export(out_final, format="mp3")
+        os.remove(tmp_wav)
+        return out_final
+    else:
+        out_wav = base + ".wav" if ext.lower() != ".wav" else out_final
+        sf.write(out_wav, master, master_sr, subtype="PCM_16")
+        return out_wav
+
+
+# ---------- (2) extraer audio de MP4 y mezclarlo con AD (simultáneo) ----------
+
+def ffmpeg_extract_audio_mp4_to_mp3(mp4_path: str, out_mp3_path: str, bitrate: str = "192k") -> str:
+    """
+    Extrae el audio del MP4 y lo guarda como MP3 (requiere ffmpeg).
+    """
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", mp4_path,
+        "-vn",
+        "-acodec", "libmp3lame", "-b:a", bitrate,
+        out_mp3_path
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    return out_mp3_path
+
+
+def mix_two_audios_simultaneous(mp3_a_path: str, mp3_b_path: str, out_mp3_path: str, normalise: bool = True) -> str:
+    """
+    Mezcla simultáneamente dos MP3 (p.ej., audio original + AD) y exporta un MP3.
+    - Ajusta la duración al máximo de ambas (rellena silencio si hace falta).
+    - Si normalise=True, aplica una normalización suave para evitar clipping.
+    """
+    a = AudioSegment.from_file(mp3_a_path)
+    b = AudioSegment.from_file(mp3_b_path)
+
+    # Igualamos duración: fondo del más largo
+    max_len = max(len(a), len(b))
+    if len(a) < max_len:
+        a = a.append(AudioSegment.silent(duration=max_len - len(a)), crossfade=0)
+    if len(b) < max_len:
+        b = b.append(AudioSegment.silent(duration=max_len - len(b)), crossfade=0)
+
+    # Mezcla: simple overlay. Puedes bajar el AD o el original si lo deseas (dB).
+    mixed = a.overlay(b)  # overlay simultáneo
+
+    if normalise:
+        peak = mixed.max_dBFS  # valor negativo, cercano a 0 dBFS
+        headroom = -1.0  # deja 1 dB de margen
+        gain = headroom - peak
+        mixed = mixed.apply_gain(gain)
+
+    mixed.export(out_mp3_path, format="mp3")
+    return out_mp3_path
+
+
+# ---------- (3) generar MP4 final: vídeo mudo + pista mezclada ----------
+
+def ffmpeg_mux_video_with_audio(video_mp4: str, audio_mp3: str, out_mp4: str) -> str:
+    """
+    Crea un MP4 con el vídeo mudo del original y la pista de audio proporcionada.
+    Mantiene el vídeo sin recomprimir (-c:v copy).
+    """
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", video_mp4,
+        "-i", audio_mp3,
+        "-map", "0:v:0",  # coge el vídeo de la 1ª entrada
+        "-map", "1:a:0",  # coge el audio de la 2ª entrada
+        "-c:v", "copy",
+        "-shortest",
+        out_mp4
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    return out_mp4
+
+
+# --------------------------- pipeline convenientes ----------------------------
+
+def build_ad_track_from_srt(srt_path: str, output_path: str = "ad_master.mp3", voice: str = "central/grau") -> str:
+    segs = parse_srt_ad_only(srt_path)
+    if not segs:
+        raise SystemExit("No se encontraron bloques (AD) con contenido en el SRT.")
+    result = mix_segments_on_timeline(segs, voice=voice, out_final=output_path)
+    return result
+
+def generate_audio_from_free_ad(video_name: str, version_name: str, voice: str = "central/grau") -> Optional[str]:
+    """
+    Genera un archivo de audio MP3 a partir del free_ad.txt para un vídeo y versión específicos.
+    """
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "app", "videos"))
+    file_path = os.path.join(base_path, video_name, version_name, "free_ad.txt")
+    output_mp3_path = os.path.join(base_path, video_name, version_name, "free_ad.mp3")
+
+    if not os.path.exists(file_path):
+        print(f"Advertencia: No se encontró {file_path}. Saltando.")
+        return None
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        text = f.read().strip()
+
+    if not text:
+        print(f"Advertencia: El archivo {file_path} está vacío. Saltando.")
+        return None
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_wav = os.path.join(tmpdir, "temp_audio.wav")
+        tts_to_wav(text, tmp_wav, voice=voice)
+        audio = AudioSegment.from_wav(tmp_wav)
+        audio.export(output_mp3_path, format="mp3")
+
+    print(f"✔ Audio generado para {video_name}/{version_name} en: {output_mp3_path}")
+    return output_mp3_path
+
+
+def iterate_generate_audio_from_free_ad(voice: str = "central/grau"):
+    """
+    Itera sobre todos los vídeos y versiones, y genera el audio para cada free_ad.txt.
+    """
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "app", "videos"))
+    if not os.path.isdir(base_path):
+        print(f"Error: El directorio de vídeos no existe: {base_path}")
+        return
+
+    for video_name in os.listdir(base_path):
+        video_path = os.path.join(base_path, video_name)
+        if os.path.isdir(video_path):
+            for version_name in os.listdir(video_path):
+                version_path = os.path.join(video_path, version_name)
+                if os.path.isdir(version_path):
+                    generate_audio_from_free_ad(video_name, version_name, voice=voice)
+
+
+def generate_video_from_une_ad(video_name: str, version_name: str, voice: str = "central/grau") -> Optional[str]:
+    """
+    Genera un vídeo con audiodescripción a partir del une_ad.srt para un vídeo y versión específicos.
+    """
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "app", "videos"))
+    video_path = os.path.join(base_path, video_name, f"{video_name}.mp4")
+    srt_path = os.path.join(base_path, video_name, version_name, "une_ad.srt")
+    output_video_path = os.path.join(base_path, video_name, version_name, f"{video_name}_ad.mp4")
+    
+    if not os.path.exists(video_path) or not os.path.exists(srt_path):
+        print(f"Advertencia: No se encontró el vídeo o el SRT para {video_name}/{version_name}. Saltando.")
+        return None
+
+    # Rutas para los archivos intermedios
+    out_ad_mp3 = os.path.join(base_path, video_name, version_name, "ad_master.mp3")
+    out_mix_mp3 = os.path.join(base_path, video_name, version_name, "mix_original_plus_ad.mp3")
+
+    try:
+        make_final_assets_from_video_and_srt(
+            video_mp4=video_path,
+            srt_path=srt_path,
+            out_ad_mp3=out_ad_mp3,
+            out_mix_mp3=out_mix_mp3,
+            out_final_mp4=output_video_path,
+            voice=voice
+        )
+        print(f"✔ Vídeo con AD generado para {video_name}/{version_name} en: {output_video_path}")
+        return output_video_path
+    except Exception as e:
+        print(f"Error al procesar {video_name}/{version_name}: {e}")
+        return None
+
+def iterate_generate_video_from_une_ad(voice: str = "central/grau"):
+    """
+    Itera sobre todos los vídeos y versiones, y genera el vídeo con AD para cada une_ad.srt.
+    """
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "app", "videos"))
+    if not os.path.isdir(base_path):
+        print(f"Error: El directorio de vídeos no existe: {base_path}")
+        return
+
+    for video_name in os.listdir(base_path):
+        video_path = os.path.join(base_path, video_name)
+        if os.path.isdir(video_path):
+            for version_name in os.listdir(video_path):
+                version_path = os.path.join(video_path, version_name)
+                if os.path.isdir(version_path):
+                    generate_video_from_une_ad(video_name, version_name, voice=voice)
+
+def make_final_assets_from_video_and_srt(
+    video_mp4: str,
+    srt_path: str,
+    out_ad_mp3: str = "ad_master.mp3",
+    out_mix_mp3: str = "mix_original_plus_ad.mp3",
+    out_final_mp4: str = "video_con_ad.mp4",
+    voice: str = "central/grau"
+) -> Tuple[str, str, str]:
+    """
+    Pipeline completo:
+      1) genera la pista AD desde el SRT,
+      2) extrae audio del MP4 a MP3,
+      3) mezcla simultánea original+AD a MP3,
+      4) remuxa vídeo mudo + pista mezclada a MP4 final.
+    Devuelve rutas: (ad_mp3, mix_mp3, final_mp4)
+    """
+    ad_mp3 = build_ad_track_from_srt(srt_path, output_path=out_ad_mp3, voice=voice)
+
+    ori_mp3 = ffmpeg_extract_audio_mp4_to_mp3(video_mp4, out_mp3_path=os.path.splitext(out_ad_mp3)[0] + "_original.mp3")
+    mix_mp3 = mix_two_audios_simultaneous(ori_mp3, ad_mp3, out_mix_mp3)
+
+    final_mp4 = ffmpeg_mux_video_with_audio(video_mp4, mix_mp3, out_final_mp4)
+    return ad_mp3, mix_mp3, final_mp4
+
+
+# -------------------------------- CLI ---------------------------------------
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser(description="Genera AD desde SRT y compone con video/audio usando Matxa + ffmpeg.")
+    
+    # Argumentos existentes
+    ap.add_argument("--srt", help="Ruta al archivo .srt")
+    ap.add_argument("--video", help="Ruta al archivo .mp4 (para mezclar con AD y remux final)")
+    ap.add_argument("-o", "--output", default="ad_master.mp3", help="Salida de la pista AD (mp3 o wav).")
+    ap.add_argument("--voice", default="central/grau", help="Voz Matxa (ej: central/grau, central/elia)")
+    ap.add_argument("--do-pipeline", action="store_true",
+                    help="Ejecuta pipeline completo: genera AD, extrae audio del video, mezcla ambos y crea MP4 final.")
+    ap.add_argument("--mix-output", default="mix_original_plus_ad.mp3", help="Salida de audio mezclado (original+AD)")
+    ap.add_argument("--final-mp4", default="video_con_ad.mp4", help="Salida del MP4 final con AD")
+
+    # Nuevos argumentos para las funciones de iteración
+    ap.add_argument("--generate-free-ad-audio", action="store_true", help="Genera audio para todos los archivos free_ad.txt existentes.")
+    ap.add_argument("--generate-une-ad-video", action="store_true", help="Genera vídeo con AD para todos los archivos une_ad.srt existentes.")
+
+    args = ap.parse_args()
+
+    if args.generate_free_ad_audio:
+        print("--- Iniciando generación de audios desde free_ad.txt ---")
+        iterate_generate_audio_from_free_ad(voice=args.voice)
+        print("--- Proceso de generación de audios completado ---")
+    
+    elif args.generate_une_ad_video:
+        print("--- Iniciando generación de vídeos con AD desde une_ad.srt ---")
+        iterate_generate_video_from_une_ad(voice=args.voice)
+        print("--- Proceso de generación de vídeos completado ---")
+
+    elif args.do_pipeline:
+        if not args.srt or not args.video:
+            raise SystemExit("Para --do-pipeline necesitas --srt y --video.")
+        ad_mp3, mix_mp3, final_mp4 = make_final_assets_from_video_and_srt(
+            args.video, args.srt,
+            out_ad_mp3=args.output,
+            out_mix_mp3=args.mix_output,
+            out_final_mp4=args.final_mp4,
+            voice=args.voice
+        )
+        print(f"✔ AD:   {ad_mp3}")
+        print(f"✔ MIX:  {mix_mp3}")
+        print(f"✔ MP4:  {final_mp4}")
+    else:
+        if not args.srt:
+            # Si no se especifica ninguna acción, mostrar ayuda
+            ap.print_help()
+            raise SystemExit("Debes especificar una acción, como --generate-free-ad-audio, --generate-une-ad-video o --do-pipeline.")
+        result = build_ad_track_from_srt(args.srt, output_path=args.output, voice=args.voice)
+        print(f"✔ Audio AD escrito en: {result}")

test/client_veureu_tts.py

@@ -1,6 +1,6 @@
 import requests
 
-BASE = "https://jesusfigueres-veureu-tts.hf.space"  # o http://127.0.0.1:7860 si local
+BASE = "https://veureu-tts.hf.space"  # o http://127.0.0.1:7860 si local
 
 def tts_text(text, voice="central/grau", fmt="mp3", out_path="out.mp3"):
     url = f"{BASE}/tts/text"