Idioma auto y subtitulos incrustados palabra a palabra con color por hablante

app.py

@@ -65,6 +65,7 @@ from audio import get_audio_from_video
 from transcribe import transcribe, get_language_dict
 from diarize_library import diarize_audio
 from youtube_download import download_video, get_video_info, is_valid_youtube_url
+from subtitle_render import render_subtitled_video
 import traceback
 
 # Carpetas de trabajo del pipeline. Se crean al arrancar porque el Space pierde
@@ -84,6 +85,9 @@ WORK_FOLDERS = [
 
 for _folder in WORK_FOLDERS:
     os.makedirs(_folder, exist_ok=True)
+
+# Opción del selector de idioma que deja que el modelo lo identifique solo
+AUTO_LANGUAGE = "auto"
 import json
 
 NUMBER = 100
@@ -318,14 +322,16 @@ def trascribe_audio(input_audio_path, source_languaje):
                 gr.update(value=transcription)
             ]
 
-    # Get language dict
+    # Get language dict. Con "auto" no se le pasa idioma a transcribe(), que
+    # entonces lo identifica con Whisper sobre los primeros 30 segundos.
     language_dict = get_language_dict()
+    language = None if source_languaje == AUTO_LANGUAGE else language_dict[source_languaje]["transcriber"]
 
     # Transcribe audio file. Se informa del fallo en la propia interfaz: si la
     # excepción sube hasta gradio, el cliente solo recibe el nombre de la clase
     # y hay que rebuscar en los logs del Space para saber qué pasó.
     try:
-        transcription_str, transcription_dict = transcribe(input_audio_path, language_dict[source_languaje]["transcriber"], DEVICE, CHUNK_SECONDS, CHUNK_OVERLAP_SECONDS)
+        transcription_str, transcription_dict = transcribe(input_audio_path, language, DEVICE, CHUNK_SECONDS, CHUNK_OVERLAP_SECONDS)
     except Exception:
         error = traceback.format_exc()
         print(error)
@@ -390,6 +396,51 @@ def translate_transcription(transcription_path, diarization_path, source_languaj
         gr.Textbox(value=translated_transcription)
     )
 
+def subtitle_video(original_video_path, source_languaje, target_languaje):
+    """
+    Burn the subtitles into the video, one word at a time and colour-coded per
+    speaker.
+
+    Only runs when source and target languages match: there is nothing to
+    translate, so the video just gets its own words on screen. Each word appears
+    highlighted at its own timestamp, which makes a timing drift obvious.
+    """
+    print('*'*NUMBER)
+    print("Subtitle video")
+
+    if source_languaje != target_languaje:
+        return [
+            gr.update(value=None, visible=False),
+            gr.update(value="Translation pipeline not implemented yet")
+        ]
+
+    merged_path = "merged_transcription_diarization/merged.json"
+    if not os.path.exists(merged_path):
+        return [
+            gr.update(value=None, visible=False),
+            gr.update(value=f"No existe {merged_path}")
+        ]
+
+    try:
+        with open(merged_path, encoding="utf-8") as f:
+            merged = json.load(f)
+
+        output_path = "videos/download_video_with_subtitles.mp4"
+        render_subtitled_video(original_video_path, merged.get("chunks", []), output_path)
+    except Exception:
+        error = traceback.format_exc()
+        print(error)
+        return [
+            gr.update(value=None, visible=False),
+            gr.update(value=error)
+        ]
+
+    return [
+        gr.update(value=output_path, visible=True),
+        gr.update(value="Ok")
+    ]
+
+
 def add_translated_subtitles_to_video(original_video_path, original_audio_path, original_audio_translated_path):
     print('*'*NUMBER)
     print("Add subtitles to video")
@@ -717,7 +768,7 @@ def subtify():
             config_block = gr.Column(scale=1, visible=visible)
             with config_block:
                 with gr.Row():
-                    source_languaje = gr.Dropdown(visible=True, label="Source languaje", show_label=True, value="English", choices=language_dict, scale=1, interactive=True, info="Language of the video")
+                    source_languaje = gr.Dropdown(visible=True, label="Source languaje", show_label=True, value=AUTO_LANGUAGE, choices=[AUTO_LANGUAGE] + list(language_dict), scale=1, interactive=True, info="Language of the video, or auto to detect it")
                     target_languaje = gr.Dropdown(visible=True, label="Target languaje", show_label=True, value="Español", choices=language_dict, scale=1, interactive=True, info="Language to translate the subtitles")
                 with gr.Accordion("Advanced settings", open=True, visible=True) as Advanced_setings:
                     number_of_speakers = gr.Number(visible=True, label="Number of speakers", show_label=True, value=0, interactive=True, info="Number of speakers in the video, if you don't know, select 0")
@@ -802,6 +853,13 @@ def subtify():
             inputs=[source_languaje],
             outputs=[merged_transcription_progress_info, merged_transcription]
         )
+        # Con el mismo idioma de origen y destino no hay nada que traducir, así
+        # que se pasa directo a incrustar los subtítulos en el vídeo
+        merged_transcription_progress_info.change(
+            fn=subtitle_video,
+            inputs=[original_video_path, source_languaje, target_languaje],
+            outputs=[subtitled_video, video_subtitled_progress_info]
+        )
         # merged_transcription_progress_info.change(
         #     fn=translate_transcription,
         #     inputs=[transcription, diarization, source_languaje, target_languaje],

subtitle_render.py

@@ -0,0 +1,224 @@
+"""Genera el vídeo con los subtítulos incrustados, palabra a palabra.
+
+Cada hablante tiene su color, tomado del degradado del logo de subtify, y dentro
+de cada frase la palabra que se está pronunciando se resalta en el momento exacto
+que marca su timestamp. Eso hace que un desajuste de tiempos se vea a simple vista.
+
+Se usa el formato ASS con etiquetas de karaoke y se incrusta con ffmpeg, que ya
+forma parte del proyecto: renderizar con Remotion exigiría Node y Chromium, que el
+Space no tiene.
+"""
+
+import os
+import subprocess
+
+# Degradado del logo de subtify: púrpura -> magenta -> naranja salmón.
+# El orden alterna tonos para que dos hablantes seguidos no se parezcan.
+SPEAKER_COLORS = [
+    "#6C2A8E",  # púrpura
+    "#E8734A",  # naranja salmón
+    "#B83C6E",  # magenta
+    "#4A2A7A",  # índigo
+    "#F0A05A",  # ámbar
+    "#D94F8C",  # rosa
+]
+
+FONT_NAME = "DejaVu Sans"
+FONT_SIZE = 42
+
+# Reagrupación de palabras en frases legibles
+MAX_CHARS = 60
+MAX_DURATION = 5.0
+MAX_GAP = 0.8
+
+
+def _hex_to_ass(color, alpha=0):
+    """Convierte #RRGGBB al formato de color de ASS, que es &HAABBGGRR."""
+    color = color.lstrip("#")
+    r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)
+    return f"&H{alpha:02X}{b:02X}{g:02X}{r:02X}"
+
+
+def _text_color_for(background):
+    """Elige texto claro u oscuro según lo luminoso que sea el fondo."""
+    color = background.lstrip("#")
+    r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)
+    luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
+    return "#101827" if luminance > 0.6 else "#FFFFFF"
+
+
+def _dim(color, factor=0.45):
+    """Versión atenuada de un color, para las palabras aún no pronunciadas."""
+    color = color.lstrip("#")
+    r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)
+    return "#%02X%02X%02X" % (int(r * factor), int(g * factor), int(b * factor))
+
+
+def _timestamp(seconds):
+    """Formato de tiempo de ASS: h:mm:ss.cc"""
+    if seconds < 0:
+        seconds = 0.0
+    centis = int(round(seconds * 100))
+    hours, centis = divmod(centis, 360000)
+    minutes, centis = divmod(centis, 6000)
+    secs, centis = divmod(centis, 100)
+    return f"{hours}:{minutes:02d}:{secs:02d}.{centis:02d}"
+
+
+def speaker_order(chunks):
+    """Asigna un índice estable a cada hablante, por orden de aparición."""
+    order = {}
+    for chunk in chunks:
+        speaker = chunk.get("speaker") or "SPEAKER_00"
+        if speaker not in order:
+            order[speaker] = len(order)
+    return order
+
+
+def group_into_phrases(chunks):
+    """Agrupa las palabras en frases de subtítulo.
+
+    Una frase se corta cuando cambia el hablante, cuando se hace demasiado larga
+    o cuando hay un silencio apreciable.
+    """
+    phrases = []
+    current = None
+
+    for chunk in chunks:
+        text = (chunk.get("text") or "").strip()
+        if not text:
+            continue
+
+        start = float(chunk["start"])
+        end = float(chunk["end"])
+        speaker = chunk.get("speaker") or "SPEAKER_00"
+
+        if current is None:
+            current = {"speaker": speaker, "start": start, "end": end, "words": []}
+
+        candidate_len = sum(len(w["text"]) + 1 for w in current["words"]) + len(text)
+        breaks = (
+            speaker != current["speaker"]
+            or candidate_len > MAX_CHARS
+            or end - current["start"] > MAX_DURATION
+            or start - current["end"] > MAX_GAP
+        )
+
+        if breaks and current["words"]:
+            phrases.append(current)
+            current = {"speaker": speaker, "start": start, "end": end, "words": []}
+
+        current["words"].append({"text": text, "start": start, "end": end})
+        current["end"] = end
+
+    if current and current["words"]:
+        phrases.append(current)
+
+    return phrases
+
+
+def build_ass(chunks, width=1920, height=1080):
+    """Construye el contenido del fichero ASS con el karaoke por palabra."""
+    order = speaker_order(chunks)
+    phrases = group_into_phrases(chunks)
+
+    lines = [
+        "[Script Info]",
+        "ScriptType: v4.00+",
+        f"PlayResX: {width}",
+        f"PlayResY: {height}",
+        "WrapStyle: 0",
+        "ScaledBorderAndShadow: yes",
+        "",
+        "[V4+ Styles]",
+        "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, "
+        "OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, "
+        "ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, "
+        "MarginL, MarginR, MarginV, Encoding",
+    ]
+
+    # Un estilo por hablante. BorderStyle 3 pinta una caja sólida con BackColour,
+    # que es lo que da el fondo de color de cada hablante.
+    for speaker, index in order.items():
+        background = SPEAKER_COLORS[index % len(SPEAKER_COLORS)]
+        text_color = _text_color_for(background)
+        lines.append(
+            f"Style: S{index},{FONT_NAME},{FONT_SIZE},"
+            f"{_hex_to_ass(text_color)},{_hex_to_ass(_dim(text_color))},"
+            f"{_hex_to_ass(background)},{_hex_to_ass(background)},"
+            f"-1,0,0,0,100,100,0,0,3,6,0,2,60,60,60,1"
+        )
+
+    lines += ["", "[Events]",
+              "Format: Layer, Start, End, Style, Name, MarginL, MarginR, "
+              "MarginV, Effect, Text"]
+
+    for phrase in phrases:
+        index = order[phrase["speaker"]]
+        parts = []
+        cursor = phrase["start"]
+
+        for word in phrase["words"]:
+            # Un hueco antes de la palabra se rellena con un karaoke vacío, o el
+            # resaltado se adelantaría respecto al audio
+            gap = int(round((word["start"] - cursor) * 100))
+            if gap > 0:
+                parts.append(f"{{\\k{gap}}}")
+
+            duration = max(1, int(round((word["end"] - word["start"]) * 100)))
+            parts.append(f"{{\\k{duration}}}{word['text']} ")
+            cursor = word["end"]
+
+        text = "".join(parts).strip()
+        lines.append(
+            f"Dialogue: 0,{_timestamp(phrase['start'])},{_timestamp(phrase['end'])},"
+            f"S{index},,0,0,0,,{text}"
+        )
+
+    return "\n".join(lines) + "\n"
+
+
+def get_video_size(video_path):
+    """Devuelve (ancho, alto) del vídeo, para que el ASS use su misma resolución."""
+    result = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "v:0",
+         "-show_entries", "stream=width,height", "-of", "csv=p=0:s=x", video_path],
+        capture_output=True, text=True, check=True,
+    )
+    width, height = result.stdout.strip().split("x")[:2]
+    return int(width), int(height)
+
+
+def render_subtitled_video(video_path, chunks, output_path, ass_path=None):
+    """Incrusta los subtítulos en el vídeo.
+
+    Args:
+        video_path: vídeo original.
+        chunks: lista de palabras con start, end, text y speaker.
+        output_path: dónde guardar el vídeo resultante.
+        ass_path: dónde dejar el ASS generado; junto al vídeo si no se indica.
+
+    Returns:
+        str: ruta del vídeo generado.
+    """
+    if not chunks:
+        raise ValueError("No hay palabras que subtitular")
+
+    width, height = get_video_size(video_path)
+    ass_path = ass_path or os.path.splitext(output_path)[0] + ".ass"
+
+    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+    with open(ass_path, "w", encoding="utf-8") as f:
+        f.write(build_ass(chunks, width, height))
+
+    # El filtro subtitles no admite rutas con caracteres sin escapar
+    escaped = ass_path.replace("\\", "\\\\").replace(":", r"\:").replace("'", r"\'")
+
+    subprocess.run(
+        ["ffmpeg", "-y", "-v", "error", "-i", video_path,
+         "-vf", f"subtitles='{escaped}'",
+         "-c:a", "copy", output_path],
+        check=True,
+    )
+
+    return output_path