Convertir un PDF en audiolibro con edge-tts (voz española, por capítulos y sin notas al pie)

· audio, tts, pdf, python, cli

Escuchar este artículo

Descargar MP3 · Ver en Internet Archive

Me pasaron un PDF de 114 páginas (Lo que el Buddha enseñó, de Walpola Rahula) para hacerle una versión en audio. Terminé con 13 MP3 —uno por sección— y un archivo único de 5 horas y 17 minutos con voz femenina española. Acá está todo el proceso, incluido el script.

La gracia no fue tanto el TTS sino limpiar el texto antes: un PDF con notas al pie, números de página y marcadores tipo Buddha2 se escucha horrible si se lo tirás directo al sintetizador.

Qué usé

herramienta para qué
pdftotext (poppler) sacar el texto del PDF
Python (stdlib) limpiar notas al pie y separar capítulos
edge-tts sintetizar con voz neuronal en español
ffmpeg juntar los MP3 en un solo archivo

espeak-ng estaba instalado y funciona offline, pero suena robótico. edge-tts usa las voces neuronales de Microsoft por WebSocket: no necesita API key, pero necesita internet.

1. Instalar

sudo pacman -S poppler ffmpeg python   # o apt install poppler-utils ffmpeg python3
python3 -m venv tts-venv
tts-venv/bin/pip install edge-tts
tts-venv/bin/edge-tts --list-voices | grep -i es-

A mi me gustó es-ES-ElviraNeural. También están es-ES-AlvaroNeural (masculina) y las es-MX-*/es-AR-* si querés otro acento.

2. Extraer el texto

pdfinfo libro.pdf | grep -E "Pages|Encrypted"
pdftotext libro.pdf libro_raw.txt

Primero confirmé que el PDF tuviera capa de texto (pdftotext -f 1 -l 3 libro.pdf - | wc -c devolvió miles de caracteres). Si da casi nada, es un escaneo y hay que pasar ocrmypdf antes.

3. El problema de las notas al pie

El texto crudo sale así, al final de cada página:

... los derivados de estos elementos (upadaya-rupa)10. ...

10

. S. III (PTS), pág. 59
. Abhisamuc., pág. 4.
12
. S. III (PTS), pág 59.

Si se lo mandás tal cual, la voz dice «diez, punto, es es III, páginas cincuenta y nueve…». Las reglas de limpieza que apliqué fueron:

  1. Dentro de cada página (separadas por \f), buscar un número suelto seguido de una línea que empieza con . y cortar ahí el resto de la página: ahí arrancan las notas.
  2. Borrar los números sueltos que quedan (números de página).
  3. Sacar los marcadores pegados a las palabras: Buddha2 → Buddha, sin tocar números legítimos (los 16 años, pág. 62).
  4. Unir las líneas partidas con espacios, porque el TTS respira raro en cada salto de línea.

Con eso desaparecen también los (N. del T.) y (N. del E.).

4. Separar por capítulos

Busqué los encabezados (Capítulo I, Capítulo II, …) y armé un archivo por tramo. Dos detalles del libro original:

  • El último capítulo está mal etiquetado en el PDF: dice Capítulo VII siendo el VIII. Contando los encabezados en orden (en vez de fiarse del rótulo) se arregla solo.
  • Los números romanos se normalizan a palabras: «Capítulo I» se escucha mejor como «Capítulo uno. La actitud mental buddhista».

También salté el ÍNDICE final: esa tabla de puntos y números de página en audio es insufrible.

5. El script completo

Adaptá los if line == ... de build_sections() a los encabezados de tu libro.

#!/usr/bin/env python3
import argparse
import asyncio
import os
import re

import edge_tts

VOICE = "es-ES-ElviraNeural"
ROMAN = {1: "uno", 2: "dos", 3: "tres", 4: "cuatro", 5: "cinco",
         6: "seis", 7: "siete", 8: "ocho"}
TITLES = {
    1: "La actitud mental buddhista",
    2: "La primera Noble Verdad: Dukkha",
    3: "La segunda Noble Verdad: Samudaya, el surgimiento de dukkha",
    4: "La tercera Noble Verdad: Nirodha, la cesación de dukkha",
    5: "La cuarta Noble Verdad: Magga, el Sendero",
    6: "La doctrina de la inexistencia del alma: Anatta",
    7: "Meditación o cultura mental: Bhavana",
    8: "Lo que el Buddha enseñó y el mundo actual",
}


def clean_lines(raw):
    result = []
    for page in raw.split("\f"):
        lines = page.split("\n")
        cut = len(lines)
        for i, line in enumerate(lines):
            if not re.fullmatch(r"\d{1,3}", line.strip()):
                continue
            sig = [x.strip() for x in lines[i + 1:i + 5] if x.strip()]
            if any(x.startswith(". ") for x in sig[:3]):
                cut = i
                break
        for line in lines[:cut]:
            s = line.strip()
            if not s or re.fullmatch(r"\d{1,3}", s) or s.startswith(". "):
                continue
            result.append(s)
    return result


def join_text(lines):
    text = " ".join(lines)
    text = re.sub(r"(?<=[A-Za-zÁÉÍÓÚÜÑáéíóúüñ)\]])\d{1,2}\b", "", text)
    return re.sub(r"\s+", " ", text).strip()


def build_sections(lines):
    marks = [(0, "01-Prologo", "Prólogo")]
    nchap = 0
    for i, line in enumerate(lines):
        if i == 0:
            continue
        if line == "PREFACIO":
            marks.append((i, "02-Prefacio", "Prefacio"))
        elif line == "EL BUDDHA":
            marks.append((i, "03-El-Buddha", "El Buddha"))
        elif re.fullmatch(r"Capítulo (I|II|III|IV|V|VI|VII)", line):
            nchap += 1
            numeral = "VIII" if nchap == 8 else ROMAN[nchap]
            marks.append((i, f"{nchap + 3:02d}-Capitulo-{numeral}",
                          f"Capítulo {ROMAN[nchap]}. {TITLES[nchap]}"))
        elif line == "BREVE ANTOLOGÍA DE TEXTOS":
            marks.append((i, "12-Breve-Antologia", "Breve antología de textos del canon Pali"))
        elif line == "ABREVIATURAS":
            marks.append((i, "13-Anexos", "Anexos: abreviaturas, bibliografía selecta y glosario"))
        elif line == "ÍNDICE":
            marks.append((i, None, None))
    marks.sort()
    sections = []
    for n, (start, name, intro) in enumerate(marks):
        if name is None:
            break
        end = marks[n + 1][0] if n + 1 < len(marks) else len(lines)
        body = join_text(lines[start:end])
        sections.append((name, intro + ". " + body if body else intro))
    return sections


async def synthesize(text, path):
    for attempt in range(1, 5):
        try:
            await edge_tts.Communicate(text, VOICE).save(path)
            if os.path.getsize(path) > 1000:
                return
            raise RuntimeError("archivo vacío")
        except Exception as exc:
            print(f"intento {attempt} falló: {exc}")
            await asyncio.sleep(2 * attempt)
    raise RuntimeError(f"No se pudo sintetizar {path}")


async def run(sections, out, workers):
    sem = asyncio.Semaphore(workers)

    async def one(i, name, text):
        path = os.path.join(out, name + ".mp3")
        if os.path.exists(path) and os.path.getsize(path) > 1000:
            print(f"[{i}/{len(sections)}] {name}: ya existe")
            return
        async with sem:
            print(f"[{i}/{len(sections)}] {name}: generando", flush=True)
            await synthesize(text, path)
            print(f"[{i}/{len(sections)}] {name}: listo", flush=True)

    await asyncio.gather(*(one(i, n, t) for i, (n, t) in enumerate(sections, 1)))


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--raw", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--workers", type=int, default=6)
    args = ap.parse_args()
    os.makedirs(args.out, exist_ok=True)
    lines = clean_lines(open(args.raw, encoding="utf-8").read())
    sections = build_sections(lines)
    print(f"Secciones: {len(sections)}")
    for i, (name, text) in enumerate(sections, 1):
        print(f"{i:2}. {name}: {len(text):,} caracteres")
    asyncio.run(run(sections, args.out, args.workers))


if __name__ == "__main__":
    main()

6. Generar el audio

tts-venv/bin/python pdf_a_audio.py --raw libro_raw.txt --out audio/ --workers 6

Communicate parte el texto en bloques de ~4096 bytes y los manda por una sola conexión por sección. Los reintentos importan: el servicio corta alguna conexión y sin el for attempt te perdés un capítulo entero.

Lo que más ayudó fue paralelizar por secciones. El cuello no es la CPU sino la latencia de cada bloque:

prueba tiempo
Prólogo solo (4.027 chars → 3:53 de audio) 57 s
3 secciones en paralelo (vs. ~260 s en serie) 43 s
libro completo, 6 workers 8 min 56 s

Si el servicio te limita, bajá --workers a 2 o 3.

7. Verificar y juntar

Chequeo rápido de duración y de que no haya silencio:

ffprobe -v error -show_entries format=duration -of csv=p=0 audio/04-Capitulo-uno.mp3
ffmpeg -t 60 -i audio/04-Capitulo-uno.mp3 -af volumedetect -f null - 2>&1 | grep volume

mean_volume alrededor de -22 dB y max_volume cerca de -4 dB = audio sano.

Para el archivo único, lista los MP3 y concatenás sin recodificar:

python3 - <<'PY'
import glob, os
with open('concatenar.txt', 'w') as f:
    for p in sorted(glob.glob('audio/*.mp3')):
        f.write(f"file '{os.path.abspath(p)}'\n")
PY

ffmpeg -f concat -safe 0 -i concatenar.txt -c copy \
  -metadata title="Lo que el Buddha enseñó" \
  -metadata artist="Walpola Rahula" libro_completo.mp3

-c copy funciona porque todos los MP3 salen del mismo motor y voice, con el mismo bitrate (48 kbps, mono).

Resultado

sección duración tamaño
Prólogo 3:53 1.3 MB
Prefacio 5:13 1.8 MB
El Buddha 2:31 0.9 MB
Capítulo I 29:32 10.1 MB
Capítulo II 27:51 9.6 MB
Capítulo III 10:13 3.5 MB
Capítulo IV 19:58 6.9 MB
Capítulo V 13:00 4.5 MB
Capítulo VI 31:45 10.9 MB
Capítulo VII 20:53 7.2 MB
Capítulo VIII 30:33 10.5 MB
Breve antología 104:14 35.8 MB
Anexos 17:52 6.1 MB
completo 5:17:27 109 MB

Problemas probables

  • Sale poco texto del PDF: es escaneo; pasalo por ocrmypdf primero.
  • Sin internet: edge-tts no funciona. Ahí sí conviene piper (con el modelo es_AR-daniela-high) o espeak-ng -v es.
  • Se cuelan notas: buscá (N. del T.) en el texto limpio. Si aparece, la regla 1 no cortó en la página correcta y hay que ajustar el sig[:3].
  • Capítulos duplicados o mal numerados: contá encabezados en orden, como en el ejemplo; no confíes en el número que dice el PDF.