Despliegue desde GitHub

app.py

@@ -74,11 +74,11 @@ def _preset_label(db) -> str:
     return DEFAULT_PRESET
 
 
-def _settings(prof, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mono=None) -> pipeline.Settings:
+def _settings(prof, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mono=None, clean=False) -> pipeline.Settings:
     return pipeline.Settings.from_profile(
         prof, reduccion_db=PRESETS[preset], paso_alto_hz=float(hp) or None,
         conservar_ultrasonidos=ultra, escalar_reduccion=escalate, dnsmos=use_dnsmos, usar_gpu=use_gpu,
-        forzar_mono=mono,
+        forzar_mono=mono, limpiar_siempre=clean,
     )
 
 
@@ -104,14 +104,18 @@ def _profile_info(pid: str):
 
 # ── Comprobar ────────────────────────────────────────────────────────────────
 
-def cb_analyze(files, pid, progress=gr.Progress()):
+def _prof(pid: str, pause_max: float) -> dict:
+    return {**PROFILES[pid], "_pausa_max_s": float(pause_max)}
+
+
+def cb_analyze(files, pid, pause_max, progress=gr.Progress()):
     paths = _paths(files)
     if not paths:
         yield ui_html.empty("Primero sube uno o varios audios (paso 2)."), ""
         return
-    prof = PROFILES[pid]
+    prof = _prof(pid, pause_max)
     cards, durs = [], []
-    n_ok = n_fix = n_err = 0
+    n_ok = n_fix = n_err = n_pauses = 0
     for i, p in enumerate(paths):
         progress(i / len(paths), desc=f"Analizando {Path(p).name}")
         a = pipeline.analyze(p, prof)
@@ -127,8 +131,13 @@ def cb_analyze(files, pid, progress=gr.Progress()):
             else:
                 n_fix += 1
                 badge = ("fix", "⚡ HAY QUE CORREGIR")
+            n_pauses += bool(profiles.long_pauses(a.m, prof))
             cards.append(ui_html.card(name, a.meta.describe(), badge, a.rows))
-        yield _summary(prof, len(paths), n_ok, n_fix, n_err, durs, "Por corregir"), "".join(reversed(cards))
+        summary = _summary(prof, len(paths), n_ok, n_fix, n_err, durs, "Por corregir")
+        if n_pauses and i == len(paths) - 1:
+            summary = ui_html.banner("info", f"✂️ {n_pauses} audio(s) con pausas de más de {pause_max:.1f} s. "
+                                             "Si quieres acortarlas, marca «Acortar pausas largas» antes de corregir.") + summary
+        yield summary, "".join(reversed(cards))
     progress(1.0)
 
 
@@ -153,14 +162,15 @@ def _file_url(path: str) -> str:
 
 
 def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, process_all, mono,
-               progress=gr.Progress()):
+               cut_pauses, pause_max, progress=gr.Progress()):
     hidden = gr.update(visible=False)
     paths = _paths(files)
     if not paths:
         yield ui_html.empty("Primero sube uno o varios audios (paso 2)."), "", hidden, hidden
         return
-    prof = PROFILES[pid]
-    settings = _settings(prof, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mono)
+    prof = _prof(pid, pause_max)
+    settings = _settings(prof, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mono, process_all)
+    settings.acortar_pausas = bool(cut_pauses)
     job = _new_job_dir()
     out_dir = job / "corregidos"
     cards, durs, items, outputs = [], [], [], []
@@ -178,18 +188,6 @@ def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, pro
             n_err += 1
             cards.append(ui_html.card(name, "", ("bad", "✗ ERROR"), [], error=pre.error))
             items.append({"nombre": name, "estado_inicial": "ERROR", "estado_final": "ERROR", "notas": [pre.error]})
-        elif pre.ok and not process_all:
-            n_ok += 1
-            durs.append((name, pre.meta.duration))
-            dst = out_dir / name
-            out_dir.mkdir(parents=True, exist_ok=True)
-            shutil.copy(p, dst)
-            outputs.append(str(dst))
-            cards.append(ui_html.card(name, pre.meta.describe(), ("ok", "✓ YA CUMPLE"), pre.rows,
-                                      notes=["Ya cumplía: se incluye tal cual, sin tocarlo."],
-                                      download=_file_url(dst)))
-            items.append({"nombre": name, "duracion_s": pre.meta.duration, "estado_inicial": "PASA", "estado_final": "PASA",
-                          "formato": pre.meta.describe(), "antes": pre.m, "despues": pre.m, "notas": ["Sin cambios"]})
         else:
             r = pipeline.correct(p, prof, settings, out_dir, progress=prog, before=pre)
             if r.error or r.after is None or r.after.error:
@@ -201,18 +199,24 @@ def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, pro
                 ok = r.after.ok
                 durs.append((Path(r.out_path).name, r.after.meta.duration))
                 outputs.append(r.out_path)
-                if ok:
+                untouched = r.after is r.before
+                if ok and untouched:
+                    n_ok += 1
+                    badge = ("ok", "✓ YA CUMPLE · sin tocar")
+                elif ok:
                     n_fixed += 1
                     badge = ("ok", "✓ CORREGIDO") if not r.before.ok else ("ok", "✓ PROCESADO")
                 else:
                     n_err += 1
                     badge = ("bad", "✗ NO SE HA PODIDO DEJAR BIEN")
-                cards.append(ui_html.card(name, f"{r.before.meta.describe()}  →  {r.after.meta.describe()}", badge,
-                                          r.before.rows, r.after.rows, notes=r.notes, download=_file_url(r.out_path)))
+                cards.append(ui_html.card(name, r.before.meta.describe() if untouched else
+                                          f"{r.before.meta.describe()}  →  {r.after.meta.describe()}", badge,
+                                          r.before.rows, None if untouched else r.after.rows, notes=r.notes,
+                                          download=_file_url(r.out_path)))
                 items.append({
                     "nombre": Path(r.out_path).name, "duracion_s": r.after.meta.duration,
                     "estado_inicial": "PASA" if r.before.ok else "CORREGIBLE",
-                    "estado_final": "CORREGIDO" if ok else "NO CUMPLE",
+                    "estado_final": ("PASA" if untouched else "CORREGIDO") if ok else "NO CUMPLE",
                     "formato": r.before.meta.describe(), "antes": r.before.m, "despues": r.after.m,
                     "fallos": profiles.failed(r.before.rows), "notas": r.notes,
                 })
@@ -366,7 +370,7 @@ HELP = """
    - 🔴 **ERROR**: el fichero no se puede abrir. Vuelve a exportarlo desde Audacity.
 4. Pulsa **✨ Corregir y descargar**. Cuando termine aparece **Descarga**:
    - El **ZIP** lo contiene todo: los audios corregidos, **con el mismo nombre que tenían**, y un informe en Excel.
-   - Los audios que ya cumplían se incluyen tal cual, sin tocarlos.
+   - **Solo se corrige lo que no cumple.** Si un audio solo tiene mal el volumen, solo se ajusta el volumen; si ya cumple todo, se entrega tal cual, sin tocarlo.
 5. **Entrega los audios del ZIP.**
 
 Revisar no cambia nada; es solo para mirar. Puedes pasar directamente al paso 4: también revisa antes de corregir.
@@ -391,6 +395,10 @@ Debajo de cada tarjeta, **«Qué se ha hecho»** resume los arreglos aplicados a
 
 Si marcas **«Poner nota de calidad al corregir»**, cada tarjeta muestra una nota de 1 a 5 **antes** y **después**: es cómo valoraría el audio una persona escuchándolo (por encima de 3,5 suena muy bien). Sirve para quedarte tranquila de que la limpieza **mejora** el sonido y no lo estropea. Como hace que cada audio tarde bastante más (más o menos el triple), viene **desmarcada**: márcala cuando quieras comprobarlo, por ejemplo con el primer audio de un encargo.
 
+## Acortar pausas largas (✂️)
+
+Al revisar, cada tarjeta indica si el audio tiene **pausas largas** entre frases, por ejemplo «2 · la más larga 4,3 s». Si quieres acortarlas, marca **«Acortar pausas largas»** y elige la **pausa máxima** (2 segundos por defecto) antes de pulsar «Corregir». Solo se acortan las pausas que pasan de esa duración: se quita el trozo del medio y se conservan el principio y el final de la pausa, con un fundido para que el corte no se note. Las pausas normales no se tocan.
+
 ## Antes de corregir muchos audios, prueba uno
 
 En la pestaña **🎧 Probar** subes un audio, eliges un trozo y pulsas **▶ Probar este tramo**. Oirás el original y el limpio, uno al lado del otro.
@@ -407,7 +415,7 @@ Normalmente **no hace falta tocarlas**: cada proyecto ya trae las suyas.
 - **Cuánto ruido quitar**: *Natural* es lo recomendado. *Suave* deja algo de ambiente; *Fuerte* y *Máximo* son para grabaciones con mucho ruido.
 - **Quitar retumbes y golpes graves**: elimina golpes de vecinos, de la mesa o del pie del micro.
 - **Convertir a mono**: si no lo marcas, el audio sale con los mismos canales con los que entró.
-- **Limpiar también los audios que ya cumplen**: por si quieres pasarlos todos por el limpiador.
+- **Quitar ruido aunque ya cumpla**: por si quieres pasar el limpiador de ruido aunque el audio ya cumpla.
 
 ## Si algo no va bien
 
@@ -446,7 +454,8 @@ with gr.Blocks(title="Limpieza y control de voz", delete_cache=(3600, 86400)) as
                              info="Golpes de vecinos, de la mesa, del pie del micro…")
             mono = gr.Checkbox(value=False, label="Convertir a mono",
                                info="Si no lo marcas, sale con los mismos canales que entró.")
-        process_all = gr.Checkbox(value=False, label="Limpiar también los audios que ya cumplen")
+        process_all = gr.Checkbox(value=False, label="Quitar ruido aunque ya cumpla",
+                                  info="Normalmente no hace falta: la app solo corrige lo que no cumple.")
         escalate = gr.Checkbox(value=True, label="Si sigue habiendo ruido, insistir automáticamente")
         use_gpu = gr.Checkbox(value=True, label="Usar la tarjeta gráfica si está libre (solo audios largos)",
                               visible=gpu_available())
@@ -457,6 +466,11 @@ with gr.Blocks(title="Limpieza y control de voz", delete_cache=(3600, 86400)) as
             files = gr.File(label="2 · Sube aquí los audios (puedes arrastrar varios a la vez)",
                             file_count="multiple", file_types=AUDIO_EXTENSIONS)
             use_dnsmos = gr.Checkbox(value=False, label=QUALITY_LABEL, info=QUALITY_INFO, elem_classes="ad-quality")
+            with gr.Row(elem_classes="ad-quality"):
+                cut_pauses = gr.Checkbox(value=False, label="✂️ Acortar pausas largas", scale=2,
+                                         info="Recorta las pausas entre frases que pasen de la duración máxima. "
+                                              "Conserva el principio y el final de cada pausa para que suene natural.")
+                pause_max = gr.Slider(0.5, 5.0, value=2.0, step=0.1, label="Pausa máxima (segundos)", scale=1)
             with gr.Row():
                 analyze_btn = gr.Button("🔍 3 · Revisar", variant="secondary")
                 correct_btn = gr.Button("✨ 4 · Corregir y descargar", variant="primary")
@@ -494,8 +508,9 @@ with gr.Blocks(title="Limpieza y control de voz", delete_cache=(3600, 86400)) as
 
     profile_dd.change(_profile_info, profile_dd, [profile_md, preset, hp, ultra, process_all, mono])
     app.load(_profile_info, profile_dd, [profile_md, preset, hp, ultra, process_all, mono])
-    analyze_btn.click(cb_analyze, [files, profile_dd], [summary, results])
-    correct_btn.click(cb_correct, [files, profile_dd, preset, hp, ultra, escalate, use_dnsmos, use_gpu, process_all, mono],
+    analyze_btn.click(cb_analyze, [files, profile_dd, pause_max], [summary, results])
+    correct_btn.click(cb_correct, [files, profile_dd, preset, hp, ultra, escalate, use_dnsmos, use_gpu, process_all, mono,
+                       cut_pauses, pause_max],
                       [summary, results, zip_btn, downloads])
     p_audio.change(cb_load_preview, p_audio, [p_overview, p_start, p_info])
     p_btn.click(cb_preview, [p_audio, p_start, p_len, preset, hp, ultra, p_dnsmos, use_gpu],

dsp.py

@@ -152,6 +152,97 @@ def detect_voice(mono: np.ndarray, sr: int, start_above: float = 14.0, end_above
     return VoiceRegion(start, end, noise, start_th, fdb, flen, True)
 
 
+def detect_voice_v4(mono: np.ndarray, sr: int) -> VoiceRegion:
+    """
+    Réplica exacta de detectVoiceRegion() del «Analizador de audio v4» (HTML):
+    ruido = media en dB de las tramas de los primeros y últimos 0,4 s; inicio = primeras 6 tramas
+    seguidas ≥ ruido + 14 dB; final = últimas 6 tramas seguidas ≥ ruido + 10 dB.
+    Así lo que mide y corrige la app coincide con lo que mide esa herramienta.
+    """
+    flen = max(64, round(sr * FRAME_MS / 1000))
+    nfr = max(1, int(np.ceil(len(mono) / flen)))
+    x = np.asarray(mono, dtype=np.float64)
+    padded = np.pad(x, (0, nfr * flen - len(x)))
+    sums = (padded.reshape(nfr, flen) ** 2).sum(axis=1)
+    counts = np.full(nfr, flen, dtype=np.float64)
+    counts[-1] = len(x) - (nfr - 1) * flen  # la última trama puede ser más corta (como en el HTML)
+    with np.errstate(divide="ignore"):
+        fdb = 10 * np.log10(sums / counts)
+    edge = max(3, int(0.4 * sr / flen))
+    vals = np.concatenate([fdb[: min(edge, nfr)], fdb[max(0, nfr - edge) :]])
+    vals = vals[np.isfinite(vals)]
+    noise = float(vals.mean()) if vals.size else -90.0
+    start_th, end_th = noise + 14, noise + 10
+    k = max(2, round(120 / FRAME_MS))
+    fdb_safe = np.where(np.isfinite(fdb), fdb, -1e9)
+    if nfr < k:
+        return VoiceRegion(0, len(mono) - 1, noise, start_th, fdb_safe, flen, False)
+    win_min = sliding_window_view(fdb_safe, k).min(axis=1)
+    starts = np.flatnonzero(win_min >= start_th)
+    if starts.size == 0:
+        return VoiceRegion(0, len(mono) - 1, noise, start_th, fdb_safe, flen, False)
+    first = int(starts[0])
+    ends = np.flatnonzero(win_min[first:] >= end_th)
+    last = first + int(ends[-1]) + k - 1 if ends.size else nfr - 1
+    return VoiceRegion(first * flen, min(len(mono) - 1, (last + 1) * flen - 1), noise, start_th, fdb_safe, flen, True)
+
+
+def voice_region(mono: np.ndarray, sr: int, method: str | None = None) -> VoiceRegion:
+    """Detector de voz según el perfil: «analizador_v4» (compatible con el HTML) o el propio por defecto."""
+    return detect_voice_v4(mono, sr) if method == "analizador_v4" else detect_voice(mono, sr)
+
+
+def find_pauses(mono: np.ndarray, sr: int, region: VoiceRegion, min_s: float = 0.3) -> list[tuple[int, int]]:
+    """
+    Pausas internas (entre la primera y la última voz) de al menos `min_s`, en muestras [ini, fin).
+    Una trama es pausa si queda por debajo del umbral de «fin de voz» (ruido + 10 dB).
+    """
+    if not region.found:
+        return []
+    flen, fdb = region.frame_len, region.frame_db
+    quiet = fdb < max(region.start_th_db - 4, DIGITAL_SILENCE_DB)
+    f0, f1 = region.start // flen, region.end // flen
+    pauses, run = [], None
+    for f in range(f0, f1 + 1):
+        if quiet[f] and run is None:
+            run = f
+        elif not quiet[f] and run is not None:
+            if (f - run) * flen >= min_s * sr:
+                pauses.append((run * flen, f * flen))
+            run = None
+    return pauses
+
+
+def shorten_pauses(x: np.ndarray, sr: int, region: VoiceRegion, max_s: float) -> tuple[np.ndarray, list[float]]:
+    """
+    Acorta a `max_s` las pausas internas más largas. Conserva la mitad de `max_s` pegada a cada lado
+    (respiraciones y finales de palabra intactos), quita el centro y une con un fundido de 30 ms.
+    Devuelve (audio, duraciones originales de las pausas acortadas).
+    """
+    mono = to_mono(x)[:, 0]
+    long_ones = [(a, b) for a, b in find_pauses(mono, sr, region) if (b - a) > max_s * sr + 0.05 * sr]
+    if not long_ones:
+        return x, []
+    half = int(max_s * sr / 2)
+    xf = min(int(0.03 * sr), half // 2)
+    fade = np.sin(np.linspace(0, np.pi / 2, xf, dtype=np.float32))[:, None] if xf else None
+    pieces, pos = [], 0
+    for a, b in long_ones:
+        cut_a, cut_b = a + half, b - half - xf  # se elimina [cut_a, cut_b); el fundido solapa xf muestras
+        left = x[pos:cut_a].copy()
+        right_start = cut_b
+        if xf:
+            # fundido de potencia constante entre el final del tramo izquierdo y el inicio del derecho
+            tail = left[-xf:] * fade[::-1]
+            head = x[right_start : right_start + xf] * fade
+            left[-xf:] = tail + head
+            right_start += xf
+        pieces.append(left)
+        pos = right_start
+    pieces.append(x[pos:])
+    return np.concatenate(pieces).astype(np.float32), [(b - a) / sr for a, b in long_ones]
+
+
 def _room_tone(x: np.ndarray, region: VoiceRegion, length: int, sr: int) -> np.ndarray:
     """
     Construye `length` muestras de "tono de sala" a partir del tramo sin voz más silencioso
@@ -189,8 +280,11 @@ def _room_tone(x: np.ndarray, region: VoiceRegion, length: int, sr: int) -> np.n
 
 
 def set_edge_silences(x: np.ndarray, sr: int, region: VoiceRegion, target_s: float,
-                      fill: str = "tono_sala") -> tuple[np.ndarray, list[str]]:
-    """Deja exactamente `target_s` antes de la primera voz y después de la última."""
+                      fill: str = "tono_sala", sides=("ini", "fin")) -> tuple[np.ndarray, list[str]]:
+    """
+    Deja exactamente `target_s` antes de la primera voz («ini») y/o después de la última («fin»).
+    Solo toca los lados indicados en `sides`; el resto queda idéntico.
+    """
     notes = []
     tgt = int(round(target_s * sr))
     head, tail = region.start, x.shape[0] - 1 - region.end
@@ -199,6 +293,8 @@ def set_edge_silences(x: np.ndarray, sr: int, region: VoiceRegion, target_s: flo
              (lambda n: np.zeros((n, x.shape[1]), dtype=np.float32))
 
     def edge(seg_len, side):
+        if side not in sides:  # lado que ya cumple: intacto
+            return x[: region.start] if side == "ini" else x[region.end + 1 :]
         if seg_len >= tgt:  # recortar (se conserva el tramo pegado a la voz)
             return x[region.start - tgt : region.start] if side == "ini" else x[region.end + 1 : region.end + 1 + tgt]
         extra = filler(tgt - seg_len)
@@ -212,10 +308,12 @@ def set_edge_silences(x: np.ndarray, sr: int, region: VoiceRegion, target_s: flo
     f = min(int(0.005 * sr), len(out) // 2)
     if f:
         ramp = np.linspace(0, 1, f, dtype=np.float32)[:, None]
-        out[:f] *= ramp
-        out[-f:] *= ramp[::-1]
-    for nombre, antes in (("inicial", head), ("final", tail)):
-        if abs(antes - tgt) > sr * 0.001:
+        if "ini" in sides:
+            out[:f] *= ramp
+        if "fin" in sides:
+            out[-f:] *= ramp[::-1]
+    for nombre, antes, side in (("inicial", head, "ini"), ("final", tail, "fin")):
+        if side in sides and abs(antes - tgt) > sr * 0.001:
             accion = "recortado" if antes > tgt else ("alargado con el silencio natural de la sala" if fill == "tono_sala" else "alargado con silencio")
             notes.append(f"Silencio {nombre}: {antes / sr:.2f} s → {target_s:.2f} s ({accion})")
     return out, notes

metrics.py

@@ -39,12 +39,12 @@ def true_peak_db(mono: np.ndarray, sr: int, block_s: float = 30.0) -> float:
     return dsp.db(peak)
 
 
-def measure(data: np.ndarray, sr: int, with_lufs: bool = True) -> dict:
+def measure(data: np.ndarray, sr: int, with_lufs: bool = True, detector: str | None = None) -> dict:
     """data: (n, ch) float32. Devuelve un dict de métricas (floats en dB / segundos)."""
     mono = dsp.to_mono(data)[:, 0]
     n = len(mono)
     peak_abs = float(np.abs(data).max()) if n else 0.0
-    region = dsp.detect_voice(mono, sr)
+    region = dsp.voice_region(mono, sr, detector)
     voice = mono[region.start : region.end + 1] if region.found else mono
 
     fdb = region.frame_db
@@ -73,6 +73,7 @@ def measure(data: np.ndarray, sr: int, with_lufs: bool = True) -> dict:
         "silencio_fin_s": (n - 1 - region.end) / sr if region.found else np.nan,
         "voz_detectada": region.found,
         "silencio_digital": bool(not live.any()) or bool(noise_frames.size == 0),
+        "pausas_s": [(b - a) / sr for a, b in dsp.find_pauses(mono, sr, region)],
     }
     if with_lufs:
         m["lufs"] = lufs(data, sr)

perfiles/analizador_v4.yaml

@@ -10,6 +10,7 @@ explicacion: |
   - **Qué hace la corrección:** quita el ruido, pasa a mono, ajusta el volumen de la voz, controla los picos y deja 0,6 s de silencio natural al principio y al final.
   - **Objetivo de entrega:** 12 h 30 min en total; arriba verás cuánto llevas.
 orden: 2
+deteccion_voz: analizador_v4   # mismo detector de voz que el HTML: lo que mide la app coincide con lo que mide él
 
 formato:
   contenedor: WAV

perfiles/multiling_es-es_01.yaml

@@ -1,28 +1,35 @@
 # Perfil de entrega: MultiLing_es-es_01 (FEMALE, Spanish Spain)
 # Fuente: especificación del cliente (PDF «MultiLing_es-es_01»), apartado «Audio Requirements».
 nombre: "MultiLing · voz femenina es-ES (40 min)"
-descripcion: "WAV PCM · 48 kHz · ≥ 24 bits · SNR ≥ 50 dB · sin ruido de fondo"
+descripcion: "Reglas del analizador v4 + SNR ≥ 50 dB: WAV PCM 24 bits · 48 kHz · mono · pico ≤ −3 · RMS voz −30…−20 · silencios 0,5–0,7 s"
 explicacion: |
   Encargo **MultiLing es-ES 01** (voz femenina, 40 minutos en total).
-  - **Qué pide el cliente:** WAV, 48 000 Hz, 24 bits, voz limpia y sin ruido de fondo.
-  - **Qué hace la corrección:** quita el ruido y deja el formato correcto. No recorta el principio ni el final ni cambia el volumen (solo suaviza algún pico que pudiera saturar), porque el cliente quiere la grabación entera, sin editar.
+  - **Qué se comprueba:** lo que pide el cliente (WAV, 48 000 Hz, 24 bits, voz limpia: relación señal/ruido de 50 dB o más) **y las mismas reglas que el analizador v4**: mono, nada por encima de −3 dB, volumen medio de la voz entre −30 y −20 dB, ruido muy bajo y entre 0,5 y 0,7 s de silencio al principio y al final.
+  - **Qué hace la corrección:** solo arregla lo que no cumple. Si un audio ya está bien, no se toca.
   - **Ficheros que espera:** nonverbal_laughter, nonverbal_crying y nonverbal_filler words (30 s cada uno), más full recording_part 1, 2 y 3.
 orden: 1
+deteccion_voz: analizador_v4   # mismo detector de voz que el HTML v4 (Gemma comprueba con él)
 
 formato:
   contenedor: WAV        # «Format: WAV (PCM)»
   pcm_entero: true
-  bits_min: 24           # «Bit depth: 24-bit or higher»
-  frecuencia: 48000      # El PDF dice «48.1 kHz»: se asume errata de 48 kHz (estándar). Cámbialo si el cliente confirma otra cosa.
-  canales: null          # El PDF no lo exige: se conservan los canales de la entrada (casilla «Convertir a mono» en la app).
+  bits: 24               # El PDF admite «24-bit or higher»; el analizador v4 exige exactamente 24.
+  frecuencia: 48000      # El PDF dice «48.1 kHz»: errata de 48 kHz (confirmado).
+  canales: 1             # Regla del analizador v4.
 
 niveles:
-  pico_max_dbfs: -1.0    # No lo exige el PDF; margen de seguridad para no saturar.
+  pico_max_dbfs: -3.0
+  rms_voz: {min: -30.0, max: -20.0, objetivo: -25.0}
 
 ruido:
   snr_min_db: 50         # «Signal-to-Noise Ratio (SNR): 50 dB or higher»
+  ruido_relativo_max_db: -40.0
 
-silencios: null          # El PDF pide audio sin cortar: no se tocan inicio ni final.
+silencios:
+  min_s: 0.5
+  max_s: 0.7
+  objetivo_s: 0.6
+  relleno: tono_sala
 
 saturacion_max_muestras: 0
 

pipeline.py

@@ -1,15 +1,14 @@
 """
 pipeline.py — Analizar y corregir ficheros según un perfil de especificación.
 
-Cadena de corrección (en este orden):
- 1. Canales: se conservan los de la entrada salvo que se pida mono.
- 2. Paso alto: quita retumbes, golpes graves y offset de continua.
- 3. Frecuencia de muestreo: remuestreo de alta calidad si hace falta.
- 4. Reducción de ruido (DeepFilterNet3). Si el resultado no cumple el ruido exigido,
-    se repite con más reducción (escalonado) antes de darse por vencido.
- 5. Silencios inicial/final: recorte o relleno con tono de sala.
- 6. Nivel: ganancia hasta el RMS objetivo y limitador de picos transparente.
- 7. Escritura en el formato pedido y nueva medición del fichero escrito (verificación real).
+Principio: corrección MÍNIMA. Se mide, se ve qué comprobaciones no cumplen y se aplica SOLO
+la corrección de cada una (si solo falla el volumen, solo se ajusta el volumen). Después se
+vuelve a medir: si una corrección provoca un fallo nuevo (p. ej. al subir el volumen asoma el
+ruido), se añade solo la corrección de ese fallo y se repite. Si un audio cumple, no se toca.
+
+Correcciones posibles (se aplican en este orden, solo las necesarias):
+  mono → frecuencia → ruido (paso alto + DeepFilterNet, escalonado) → silencios (solo el lado
+  que falla) → volumen (ganancia + limitador) o solo picos (limitador) → formato de escritura.
 """
 
 from __future__ import annotations
@@ -27,6 +26,18 @@ from audio_io import AudioMeta, output_format, read_audio, read_meta, write_audi
 
 NOISE_CHECKS = {"Relación señal/ruido (SNR)", "Ruido relativo (inicio/fin)"}
 
+# Qué corrección arregla cada comprobación del perfil
+FIX_FOR = {
+    "Formato": "formato", "Codificación": "formato", "Frecuencia": "frecuencia", "Canales": "mono",
+    "Pico máximo": "picos", "Saturación": "picos", "RMS de voz": "volumen",
+    "Ruido relativo (inicio/fin)": "ruido", "Relación señal/ruido (SNR)": "ruido",
+    "Silencio inicial": "sil_ini", "Silencio final": "sil_fin",
+}
+
+
+def _fixes_for(rows) -> set[str]:
+    return {FIX_FOR[r.parametro] for r in rows if r.ok is False and r.parametro in FIX_FOR}
+
 
 @dataclass
 class Settings:
@@ -37,6 +48,8 @@ class Settings:
     usar_gpu: bool = True
     escalar_reduccion: bool = True
     dnsmos: bool = False
+    limpiar_siempre: bool = False  # quitar ruido aunque el ruido ya cumpla
+    acortar_pausas: bool = False   # acortar pausas internas más largas que profiles.pause_max()
 
     @classmethod
     def from_profile(cls, prof: dict, **overrides) -> "Settings":
@@ -91,7 +104,7 @@ def analyze(path: str, prof: dict, with_dnsmos: bool = False) -> Analysis:
         data, sr, meta = read_audio(path)
         if data.shape[0] == 0:
             raise ValueError("El fichero está vacío")
-        m = metrics.measure(data, sr)
+        m = metrics.measure(data, sr, detector=prof.get("deteccion_voz"))
         if with_dnsmos:
             import dnsmos
 
@@ -101,44 +114,115 @@ def analyze(path: str, prof: dict, with_dnsmos: bool = False) -> Analysis:
         return Analysis(path, None, error=f"{type(e).__name__}: {e}")
 
 
-def _level(y: np.ndarray, sr: int, prof: dict, notes: list) -> np.ndarray:
-    lvl = prof.get("niveles") or {}
-    peak_max = lvl.get("pico_max_dbfs")
-    ceiling = (peak_max if peak_max is not None else -0.1) - 0.05
-    rv = lvl.get("rms_voz") or {}
+def _voice_rms(a: np.ndarray, sr: int, prof: dict) -> float:
+    mono = dsp.to_mono(a)[:, 0]
+    r = dsp.voice_region(mono, sr, prof.get("deteccion_voz"))
+    return dsp.rms_db(mono[r.start : r.end + 1]) if r.found else dsp.rms_db(mono)
+
+
+def _ceiling(prof: dict) -> float:
+    peak_max = (prof.get("niveles") or {}).get("pico_max_dbfs")
+    return (peak_max if peak_max is not None else -0.1) - 0.05
+
+
+def _fix_volume(y: np.ndarray, sr: int, prof: dict, notes: list) -> np.ndarray:
+    """Ganancia hasta el RMS de voz objetivo; el limitador solo actúa si algún pico pasa del techo."""
+    rv = (prof.get("niveles") or {}).get("rms_voz") or {}
+    target = rv.get("objetivo", (rv["min"] + rv["max"]) / 2)
+    total, lim = 0.0, None
+    for _ in range(4):
+        cur = _voice_rms(y, sr, prof)
+        if not math.isfinite(cur) or abs(target - cur) < 0.05:
+            break
+        y = y * np.float32(10 ** ((target - cur) / 20))
+        total += target - cur
+        y, lim = dsp.peak_limit(y, sr, _ceiling(prof))
+    notes.append(f"Volumen de la voz {total:+.1f} dB → {_voice_rms(y, sr, prof):.1f} dBFS (objetivo {target:.1f})".replace("-", "−"))
+    if lim and lim["muestras_afectadas"]:
+        notes.append(f"Picos suavizados para no pasar del límite ({lim['muestras_afectadas'] / sr * 1000:.0f} ms en total, "
+                     f"como mucho {lim['reduccion_max_db']:.1f} dB)")
+    return y
+
+
+def _fix_peaks(y: np.ndarray, sr: int, prof: dict, notes: list, clipped: bool) -> np.ndarray:
+    """Solo baja los picos que pasan del techo; el resto del audio no cambia."""
+    y, info = dsp.peak_limit(y, sr, _ceiling(prof))
+    if info["muestras_afectadas"]:
+        notes.append(f"Picos suavizados para no pasar de {_ceiling(prof) + 0.05:.1f} dBFS "
+                     f"({info['muestras_afectadas'] / sr * 1000:.0f} ms en total, como mucho "
+                     f"{info['reduccion_max_db']:.1f} dB); el resto del audio no cambia".replace("-", "−"))
+    if clipped:
+        notes.append("Había muestras saturadas: se han bajado, pero si se oye distorsión conviene regrabar ese trozo")
+    return y
+
 
-    def voice_rms(a):
-        r = dsp.detect_voice(dsp.to_mono(a)[:, 0], sr)
-        return dsp.rms_db(dsp.to_mono(a)[r.start : r.end + 1, 0]) if r.found else dsp.rms_db(a)
+def _apply(data, sr, meta, prof, settings, fixes, att, expander, cache, progress):
+    """Aplica al original solo las correcciones de `fixes`. Devuelve (audio, sr, notas)."""
+    fmt = prof.get("formato") or {}
+    notes, x = [], data
+    if "mono" in fixes and x.shape[1] > 1:
+        x = dsp.to_mono(x)
+        notes.append(f"{meta.channels} canales → mono")
+    if "frecuencia" in fixes and fmt.get("frecuencia") and fmt["frecuencia"] != sr:
+        x = dsp.resample(x, sr, fmt["frecuencia"])
+        notes.append(f"Frecuencia de muestreo cambiada de {sr} a {fmt['frecuencia']} Hz")
+        sr = fmt["frecuencia"]
+    if "ruido" in fixes:
+        key = (sr, x.shape[1], att)
+        if key not in cache:
+            def prog(f):
+                if progress:
+                    progress(f, f"Reduciendo ruido ({'sin límite' if att is None else f'{att:.0f} dB'})")
 
-    if rv:
-        target = rv.get("objetivo", (rv["min"] + rv["max"]) / 2)
-        total_gain, lim_info = 0.0, None
+            xh = dsp.highpass(x, sr, settings.paso_alto_hz) if settings.paso_alto_hz else x
+            cache[key] = dsp.denoise(xh, sr, att, keep_ultrasonic=settings.conservar_ultrasonidos,
+                                     use_gpu=settings.usar_gpu, progress=prog)
+        x, info = cache[key]
+        if settings.paso_alto_hz:
+            notes.append(f"Retumbes y golpes graves quitados (por debajo de {settings.paso_alto_hz:.0f} Hz)")
+        notes.append(f"Ruido de fondo reducido ({'al máximo' if att is None else f'hasta {att:.0f} dB'})"
+                     f" · procesado en {info['dispositivo']}")
+        notes += info["avisos"]
+        if expander:
+            x, ex = dsp.pause_expander(x, sr)
+            notes.append(f"Ruido que quedaba en las pausas bajado 15 dB más ({ex['pausas_pct']:.0f} % del audio son pausas)")
+    if "pausas" in fixes:
+        region = dsp.voice_region(dsp.to_mono(x)[:, 0], sr, prof.get("deteccion_voz"))
+        x, cut = dsp.shorten_pauses(x, sr, region, profiles.pause_max(prof))
+        if cut:
+            notes.append(f"Pausas largas acortadas a {profiles.pause_max(prof):.1f} s: {len(cut)} "
+                         f"(duraban {', '.join(f'{c:.1f}' for c in cut)} s)")
+    sides = tuple(s for s in ("ini", "fin") if f"sil_{s}" in fixes)
+    sil = prof.get("silencios") or None
+    if sides and sil:
+        # Iterativo: el detector (sobre todo el del analizador v4) estima el ruido con los extremos del
+        # audio, así que al cambiarlos puede mover un poco dónde «empieza» o «acaba» la voz.
+        target = sil.get("objetivo_s", 0.6)
+        first = True
         for _ in range(4):
-            cur = voice_rms(y)
-            if not math.isfinite(cur):
+            region = dsp.voice_region(dsp.to_mono(x)[:, 0], sr, prof.get("deteccion_voz"))
+            if not region.found:
+                notes.append("No se detecta voz: no se pueden ajustar los silencios")
                 break
-            gain = target - cur
-            if abs(gain) < 0.05:
+            head, tail = region.start / sr, (x.shape[0] - 1 - region.end) / sr
+            pending = tuple(sd for sd in sides if abs((head if sd == "ini" else tail) - target) > 0.02)
+            if not pending:
                 break
-            y = y * np.float32(10 ** (gain / 20))
-            total_gain += gain
-            y, lim_info = dsp.peak_limit(y, sr, ceiling)
-        notes.append(f"Volumen de la voz ajustado {total_gain:+.1f} dB → {voice_rms(y):.1f} dBFS (objetivo {target:.1f})".replace("-", "−"))
-        if lim_info and lim_info["muestras_afectadas"]:
-            notes.append(f"Picos suavizados para no pasar del límite ({lim_info['muestras_afectadas'] / sr * 1000:.0f} ms en total, "
-                         f"como mucho {lim_info['reduccion_max_db']:.1f} dB)")
-    else:
-        y, info = dsp.peak_limit(y, sr, ceiling)
-        if info["muestras_afectadas"]:
-            notes.append(f"Picos suavizados para no pasar de {ceiling + 0.05:.1f} dBFS".replace("-", "−"))
-    return y
+            x, sn = dsp.set_edge_silences(x, sr, region, target, sil.get("relleno", "tono_sala"), pending)
+            if first:
+                notes += sn
+                first = False
+    if "volumen" in fixes and (prof.get("niveles") or {}).get("rms_voz"):
+        x = _fix_volume(x, sr, prof, notes)
+    elif "picos" in fixes:
+        x = _fix_peaks(x, sr, prof, notes, clipped=bool((np.abs(data) >= 0.999).any()))
+    return x, sr, notes
 
 
 def correct(path: str, prof: dict, settings: Settings, out_dir: Path, progress=None,
             before: Analysis | None = None) -> Correction:
     """
-    Corrige `path` según `prof`. progress(fracción, texto) opcional.
+    Corrige `path` según `prof` con la corrección mínima. progress(fracción, texto) opcional.
     `before`: análisis ya hecho del original (se reutiliza para no medir dos veces).
     """
     if before is None:
@@ -149,81 +233,79 @@ def correct(path: str, prof: dict, settings: Settings, out_dir: Path, progress=N
         return res
     try:
         data, sr, meta = read_audio(path)
-        fmt = prof.get("formato") or {}
         notes = res.notes
-        x = data
         if settings.dnsmos and "dnsmos" not in before.m:
             import dnsmos
 
             before.m["dnsmos"] = dnsmos.score(dsp.to_mono(data)[:, 0], sr)
             before.rows = profiles.check(meta, before.m, prof)
 
-        if settings.forzar_mono and x.shape[1] > 1:
-            x = dsp.to_mono(x)
-            notes.append(f"{meta.channels} canales → mono")
-        if settings.paso_alto_hz:
-            x = dsp.highpass(x, sr, settings.paso_alto_hz)
-            notes.append(f"Retumbes y golpes graves quitados (por debajo de {settings.paso_alto_hz:.0f} Hz)")
-        target_sr = fmt.get("frecuencia") or sr
-        if target_sr != sr:
-            x = dsp.resample(x, sr, target_sr)
-            notes.append(f"Frecuencia de muestreo cambiada de {sr} a {target_sr} Hz")
-            sr = target_sr
-
-        # Escalado si no se cumple el ruido: más reducción y, como último recurso, expansor en pausas.
-        # Si el original ya tiene mucho más ruido del permitido, se empieza directamente por el escalón
-        # necesario (evita pasar el modelo varias veces).
+        fixes = _fixes_for(before.rows)
+        if settings.limpiar_siempre:
+            fixes.add("ruido")
+        if settings.forzar_mono and meta.channels > 1:  # pedido expresamente aunque el perfil no lo exija
+            fixes.add("mono")
+        if settings.acortar_pausas and profiles.long_pauses(before.m, prof):
+            fixes.add("pausas")
+        failing = profiles.failed(before.rows)
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+        if not fixes:  # cumple: no se toca
+            out_path = out_dir / Path(path).name
+            if Path(path).resolve() != out_path.resolve():
+                import shutil
+
+                shutil.copyfile(path, out_path)
+            res.out_path, res.after = str(out_path), before
+            notes.append("Cumplía todo: no se ha tocado")
+            return res
+
+        notes.append(f"No cumplía: {', '.join(failing)} → se corrige solo eso" if failing
+                     else "Cumplía todo; solo se aplica lo que has pedido en las opciones")
+
+        # Formato de escritura: el original salvo que falle el formato o la codificación.
+        salida = (prof.get("procesado") or {}).get("salida") or {}
+        if "formato" in fixes:
+            container, subtype, ext = output_format(meta, salida.get("contenedor"), salida.get("subtipo"))
+        else:
+            container, subtype, ext = output_format(meta, None, None)
+
+        # Escalones de reducción de ruido (solo se usan si hace falta quitar ruido).
         start = settings.reduccion_db
-        if settings.escalar_reduccion and start is not None:
+        if settings.escalar_reduccion and start is not None and "ruido" in fixes:
             need = _needed_reduction(before.m, prof)
             if need > start:
                 start = start + 12 if need <= start + 12 else None
-                notes.append("El audio tenía bastante ruido: se ha empezado con una reducción "
-                             f"{'máxima' if start is None else f'de {start:.0f} dB'}")
-        steps = [(start, False)]
+        ladder = [(start, False)]
         if settings.escalar_reduccion:
             if start is not None:
-                steps += [(lv, False) for lv in (start + 12, None) if lv != start]
-            steps.append((None, True))
-        sil = prof.get("silencios") or None
-        cache: dict = {}
-
-        for i, (att, expander) in enumerate(steps):
-            def prog(f, i=i):
-                if progress:
-                    progress(f, f"Reduciendo ruido ({'sin límite' if att is None else f'{att:.0f} dB'})")
+                ladder += [(lv, False) for lv in (start + 12, None) if lv != start]
+            ladder.append((None, True))
 
-            if att not in cache:
-                cache[att] = dsp.denoise(x, sr, att, keep_ultrasonic=settings.conservar_ultrasonidos,
-                                         use_gpu=settings.usar_gpu, progress=prog)
-            y, info = cache[att]
-            step_notes = [f"Ruido de fondo reducido ({'al máximo' if att is None else f'hasta {att:.0f} dB'})"
-                          f" · procesado en {info['dispositivo']}"] + info["avisos"]
-            if expander:
-                y, ex = dsp.pause_expander(y, sr)
-                step_notes.append(f"Ruido que quedaba en las pausas bajado 15 dB más ({ex['pausas_pct']:.0f} % del audio son pausas)")
-            if sil:
-                region = dsp.detect_voice(dsp.to_mono(y)[:, 0], sr)
-                if region.found:
-                    y, sn = dsp.set_edge_silences(y, sr, region, sil.get("objetivo_s", 0.6), sil.get("relleno", "tono_sala"))
-                    step_notes += sn
-                else:
-                    step_notes.append("No se detecta voz: no se ajustan los silencios")
-            y = _level(y, sr, prof, step_notes)
-            m = metrics.measure(y, sr, with_lufs=False)
-            rows = profiles.check(AudioMeta(meta.name, "WAV", "FLOAT", sr, y.shape[1], y.shape[0]), m, prof)
-            noise_fail = [r.parametro for r in rows if r.ok is False and r.parametro in NOISE_CHECKS]
-            if not noise_fail or i == len(steps) - 1:
-                notes += step_notes
-                break
-            notes.append(f"Con la reducción {'máxima' if att is None else f'de {att:.0f} dB'} seguía sin cumplir "
-                         f"«{', '.join(noise_fail)}»: se ha insistido con más reducción")
+        cache: dict = {}
+        step = 0
+        for _ in range(8):
+            att, expander = ladder[step]
+            y, out_sr, step_notes = _apply(data, sr, meta, prof, settings, fixes, att, expander, cache, progress)
+            m = metrics.measure(y, out_sr, with_lufs=False, detector=prof.get("deteccion_voz"))
+            rows = profiles.check(AudioMeta(meta.name, container, subtype, out_sr, y.shape[1], y.shape[0]), m, prof)
+            new = _fixes_for(rows) - fixes
+            noise_left = [r.parametro for r in rows if r.ok is False and r.parametro in NOISE_CHECKS]
+            if new:
+                notes.append("Al corregir aparecieron fallos nuevos ("
+                             + ", ".join(r.parametro for r in rows if r.ok is False and FIX_FOR.get(r.parametro) in new)
+                             + "): se corrigen también")
+                fixes |= new
+                continue
+            if noise_left and "ruido" in fixes and step < len(ladder) - 1:
+                step += 1
+                notes.append(f"Seguía sin cumplir «{', '.join(noise_left)}»: se insiste con más reducción de ruido")
+                continue
+            break
+        notes += step_notes
 
-        container, subtype, ext = output_format(meta, (prof.get("procesado") or {}).get("salida", {}).get("contenedor"),
-                                                (prof.get("procesado") or {}).get("salida", {}).get("subtipo"))
-        out_dir.mkdir(parents=True, exist_ok=True)
         out_path = out_dir / (Path(meta.name).stem + ext)
-        write_audio(out_path, y, sr, container, subtype)
+        write_audio(out_path, y, out_sr, container, subtype)
         res.out_path = str(out_path)
         res.after = analyze(str(out_path), prof, with_dnsmos=settings.dnsmos)
         if res.after.meta:

profiles.py

@@ -26,6 +26,12 @@ class Check:
     requisito: str
     ok: bool | None
 
+    def __post_init__(self):
+        # Las medidas son floats de numpy y sus comparaciones dan numpy.bool_, que no es True/False:
+        # `numpy.False_ is False` es falso. Se normaliza aquí para que «cumple / no cumple» sea fiable.
+        if self.ok is not None:
+            self.ok = bool(self.ok)
+
 
 def load_profiles(directory: Path = PROFILES_DIR) -> dict[str, dict]:
     profiles = {}
@@ -101,6 +107,12 @@ def check(meta: AudioMeta, m: dict, prof: dict) -> list[Check]:
                           m["muestras_saturadas"] <= prof["saturacion_max_muestras"]))
 
     # Informativo
+    if "pausas_s" in m:
+        max_p = pause_max(prof)
+        largas = [p for p in m["pausas_s"] if p > max_p + 0.05]
+        rows.append(Check(f"Pausas largas (> {max_p:.1f} s)",
+                          f"{len(largas)} · la más larga {max(largas):.1f} s" if largas else "ninguna",
+                          "informativo (se pueden acortar)", None))
     rows.append(Check("Ruido de fondo", fdb(m["ruido_fondo_dbfs"]), "informativo", None))
     if not nz.get("snr_min_db"):
         rows.append(Check("SNR", fdb(m["snr_db"], "dB"), "informativo", None))
@@ -116,6 +128,15 @@ def check(meta: AudioMeta, m: dict, prof: dict) -> list[Check]:
     return rows
 
 
+def pause_max(prof: dict) -> float:
+    """Pausa interna máxima para informar y acortar: la elegida en la app o la del perfil (2 s por defecto)."""
+    return float(prof.get("_pausa_max_s") or (prof.get("pausas") or {}).get("max_s") or 2.0)
+
+
+def long_pauses(m: dict, prof: dict) -> list[float]:
+    return [p for p in m.get("pausas_s", []) if p > pause_max(prof) + 0.05]
+
+
 def passes(rows: list[Check]) -> bool:
     return all(r.ok is not False for r in rows)