openaudiofix 0.1.0__tar.gz

openaudiofix-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenAudioFix contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openaudiofix-0.1.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: openaudiofix
+Version: 0.1.0
+Summary: Self-hosted audio repair studio: buffer-dropout glitches, clipping, background noise.
+License: MIT
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy==1.26.4
+Requires-Dist: scipy==1.15.3
+Requires-Dist: soundfile==0.13.1
+Requires-Dist: onnxruntime==1.20.1
+Provides-Extra: server
+Requires-Dist: fastapi==0.115.6; extra == "server"
+Requires-Dist: uvicorn==0.34.0; extra == "server"
+Requires-Dist: python-multipart==0.0.20; extra == "server"
+Provides-Extra: dev
+Requires-Dist: pytest==8.3.4; extra == "dev"
+Requires-Dist: httpx==0.28.1; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+  <img src="docs/assets/logo.svg" width="84" alt="">
+  <h1>OpenAudioFix</h1>
+  <p><strong>Repair ruined recordings on your own computer.</strong><br>
+  Rebuild clipped peaks, fix dropouts, remove noise and keep only the speech, without touching the rest of your audio.</p>
+  <p>
+    <a href="https://romanticamaj.github.io/openaudiofix/"><strong>Hear the demo</strong></a> ·
+    <a href="#quick-start">Quick start</a> ·
+    <a href="docs/how-it-works.md">How it works</a> ·
+    <a href="README.zh-TW.md">繁體中文</a>
+  </p>
+  <p>
+    <a href="https://github.com/romanticamaj/openaudiofix/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/romanticamaj/openaudiofix/actions/workflows/ci.yml/badge.svg"></a>
+    <a href="LICENSE"><img alt="MIT licence" src="https://img.shields.io/badge/license-MIT-8b7cf6"></a>
+    <a href="https://github.com/romanticamaj/openaudiofix/releases"><img alt="Latest release" src="https://img.shields.io/github/v/release/romanticamaj/openaudiofix?color=8b7cf6"></a>
+  </p>
+</div>
+
+<a href="https://romanticamaj.github.io/openaudiofix/"><img src="docs/screenshots/results.png" alt="The OpenAudioFix results workspace: a waveform with every fix marked, a spectrogram, and the list of repairs"></a>
+
+## Why OpenAudioFix
+
+You recorded the perfect take, then found the clipping. Or the ticks from an interface that dropped samples. Most
+tools answer by regenerating the whole file. OpenAudioFix fixes the broken samples and leaves the rest alone.
+
+- **Only what is broken changes.** In the demo clip, 94.5% of the samples are exactly as recorded.
+- **You can check every fix.** Each repair is listed and marked on the waveform. Switch between the original, each
+  step and the difference on the same word.
+- **Your audio stays with you.** No account, no upload. It runs on your own machine.
+
+<img src="docs/assets/peaks.svg" alt="18 milliseconds of a real recording. Before: peaks cut flat at full scale. After: the peaks rebuilt.">
+
+**[Listen to it →](https://romanticamaj.github.io/openaudiofix/)** Ten seconds of a real recording with 228 clipped
+peaks and 3 dropouts. Switch between before, after and difference while it plays.
+
+## What it repairs
+
+| Module | Fixes | Needs |
+|---|---|---|
+| **Declip** | Peaks flattened by too much input gain | CPU |
+| **Glitch repair** | Ticks and skips from audio-interface buffer dropouts | CPU |
+| **Keep speech only** | Removes knocks, music and silence from a podcast track, and keeps what it removed on a second track | CPU |
+| **Background repair** | Noise and room sound, with MossFormer2 | NVIDIA GPU, optional |
+
+## Quick start
+
+Start it with Docker, then open <http://127.0.0.1:8765/>:
+
+```bash
+docker run -p 127.0.0.1:8765:8765 -v openaudiofix-data:/data ghcr.io/romanticamaj/openaudiofix:0.1.0
+```
+
+Drop in a file, choose the repairs, listen, export. Any format ffmpeg reads is accepted, and export gives you a WAV.
+
+<details>
+<summary><strong>With an NVIDIA GPU (adds Background repair)</strong></summary>
+
+You need the NVIDIA driver and the NVIDIA Container Toolkit. The image is about 9 GB because it carries PyTorch and
+the model.
+
+```bash
+docker run --gpus all -p 127.0.0.1:8765:8765 -v openaudiofix-data:/data ghcr.io/romanticamaj/openaudiofix-gpu:0.1.0
+```
+
+Both images use the same data volume, so switching keeps your projects.
+</details>
+
+<details>
+<summary><strong>Without Docker</strong></summary>
+
+You need Python 3.10 to 3.12, Node.js and ffmpeg on `PATH`.
+
+```bash
+git clone https://github.com/romanticamaj/openaudiofix && cd openaudiofix
+python -m venv .venv && . .venv/bin/activate      # Windows: .venv\Scripts\activate
+pip install -e ".[server]"
+cd web && npm ci && npm run build && cd ..
+AFIX_WEB_DIST=web/dist python -m server.launcher  # Windows: set AFIX_WEB_DIST=web\dist first
+```
+
+Open **Modules & models → Background repair** to install the GPU module from the app (about 6 GB).
+</details>
+
+<details>
+<summary><strong>Build the images yourself</strong></summary>
+
+```bash
+git clone https://github.com/romanticamaj/openaudiofix && cd openaudiofix
+docker compose up -d --build
+docker compose -f docker-compose.yml -f docker-compose.gpu.yml up -d --build   # GPU version
+```
+</details>
+
+## Command line
+
+```bash
+pip install openaudiofix
+afix scan interview.wav                       # report what was found, change nothing
+afix repair interview.wav -m glitch,declip    # repaired file, difference file and a CSV of every fix
+afix repair interview.wav -m declip --float   # 32-bit float, no gain reduction
+afix speech episode.wav                       # episode_speech.wav, episode_removed.wav, episode_removed.txt
+afix speech host.wav guest.wav --out-dir edit # tracks of one session are split together
+```
+
+You need ffmpeg on `PATH`. `afix --help` lists every option. The web app runs from Docker or a clone.
+
+## Screenshots
+
+<table>
+  <tr>
+    <td><img src="docs/screenshots/modules.png" alt="Detection results and module choice"></td>
+    <td><img src="docs/screenshots/export.png" alt="The export dialog"></td>
+  </tr>
+  <tr>
+    <td align="center">Scan first, then choose what to repair</td>
+    <td align="center">Export without overwriting anything</td>
+  </tr>
+</table>
+
+## How it compares
+
+| | OpenAudioFix | Audacity | iZotope RX | Adobe Podcast |
+|---|---|---|---|---|
+| Open source | Yes (MIT) | Yes (GPL) | No | No |
+| Price | Free | Free | Paid | Free tier, paid plans |
+| Audio stays on your computer | Yes | Yes | Yes | No, it is uploaded |
+| Lists every change | Yes | No | Partly | No |
+
+RX has far more tools and years of refinement. OpenAudioFix does a few repairs, in the open, and shows its work.
+
+## Good to know
+
+- **Peaks above 0 dBFS are expected.** Rebuilt peaks were above it before the clipping. Export offers a 32-bit float
+  file that keeps them, or your original bit depth lowered just enough to fit.
+- **Lossy files work**, but repairs are better from WAV or FLAC.
+- **It listens on `127.0.0.1` only.** To use your own hostname, set `AFIX_ALLOWED_HOSTS`. See
+  [configuration](docs/configuration.md), which also covers folders and environment variables.
+- **Unrelated names.** This project has no connection to the iOS and macOS app "AudioFix" or to the npm package `afix`.
+
+## Contributing
+
+Bug reports with a short sample of the audio help most. New repair modules and UI languages are welcome: see
+[CONTRIBUTING.md](CONTRIBUTING.md). Every bug that gets fixed gets a test.
+
+## License
+
+[MIT](LICENSE). Third-party components are listed in [THIRD_PARTY.md](THIRD_PARTY.md).

openaudiofix-0.1.0/README.md

@@ -0,0 +1,147 @@
+<div align="center">
+  <img src="docs/assets/logo.svg" width="84" alt="">
+  <h1>OpenAudioFix</h1>
+  <p><strong>Repair ruined recordings on your own computer.</strong><br>
+  Rebuild clipped peaks, fix dropouts, remove noise and keep only the speech, without touching the rest of your audio.</p>
+  <p>
+    <a href="https://romanticamaj.github.io/openaudiofix/"><strong>Hear the demo</strong></a> ·
+    <a href="#quick-start">Quick start</a> ·
+    <a href="docs/how-it-works.md">How it works</a> ·
+    <a href="README.zh-TW.md">繁體中文</a>
+  </p>
+  <p>
+    <a href="https://github.com/romanticamaj/openaudiofix/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/romanticamaj/openaudiofix/actions/workflows/ci.yml/badge.svg"></a>
+    <a href="LICENSE"><img alt="MIT licence" src="https://img.shields.io/badge/license-MIT-8b7cf6"></a>
+    <a href="https://github.com/romanticamaj/openaudiofix/releases"><img alt="Latest release" src="https://img.shields.io/github/v/release/romanticamaj/openaudiofix?color=8b7cf6"></a>
+  </p>
+</div>
+
+<a href="https://romanticamaj.github.io/openaudiofix/"><img src="docs/screenshots/results.png" alt="The OpenAudioFix results workspace: a waveform with every fix marked, a spectrogram, and the list of repairs"></a>
+
+## Why OpenAudioFix
+
+You recorded the perfect take, then found the clipping. Or the ticks from an interface that dropped samples. Most
+tools answer by regenerating the whole file. OpenAudioFix fixes the broken samples and leaves the rest alone.
+
+- **Only what is broken changes.** In the demo clip, 94.5% of the samples are exactly as recorded.
+- **You can check every fix.** Each repair is listed and marked on the waveform. Switch between the original, each
+  step and the difference on the same word.
+- **Your audio stays with you.** No account, no upload. It runs on your own machine.
+
+<img src="docs/assets/peaks.svg" alt="18 milliseconds of a real recording. Before: peaks cut flat at full scale. After: the peaks rebuilt.">
+
+**[Listen to it →](https://romanticamaj.github.io/openaudiofix/)** Ten seconds of a real recording with 228 clipped
+peaks and 3 dropouts. Switch between before, after and difference while it plays.
+
+## What it repairs
+
+| Module | Fixes | Needs |
+|---|---|---|
+| **Declip** | Peaks flattened by too much input gain | CPU |
+| **Glitch repair** | Ticks and skips from audio-interface buffer dropouts | CPU |
+| **Keep speech only** | Removes knocks, music and silence from a podcast track, and keeps what it removed on a second track | CPU |
+| **Background repair** | Noise and room sound, with MossFormer2 | NVIDIA GPU, optional |
+
+## Quick start
+
+Start it with Docker, then open <http://127.0.0.1:8765/>:
+
+```bash
+docker run -p 127.0.0.1:8765:8765 -v openaudiofix-data:/data ghcr.io/romanticamaj/openaudiofix:0.1.0
+```
+
+Drop in a file, choose the repairs, listen, export. Any format ffmpeg reads is accepted, and export gives you a WAV.
+
+<details>
+<summary><strong>With an NVIDIA GPU (adds Background repair)</strong></summary>
+
+You need the NVIDIA driver and the NVIDIA Container Toolkit. The image is about 9 GB because it carries PyTorch and
+the model.
+
+```bash
+docker run --gpus all -p 127.0.0.1:8765:8765 -v openaudiofix-data:/data ghcr.io/romanticamaj/openaudiofix-gpu:0.1.0
+```
+
+Both images use the same data volume, so switching keeps your projects.
+</details>
+
+<details>
+<summary><strong>Without Docker</strong></summary>
+
+You need Python 3.10 to 3.12, Node.js and ffmpeg on `PATH`.
+
+```bash
+git clone https://github.com/romanticamaj/openaudiofix && cd openaudiofix
+python -m venv .venv && . .venv/bin/activate      # Windows: .venv\Scripts\activate
+pip install -e ".[server]"
+cd web && npm ci && npm run build && cd ..
+AFIX_WEB_DIST=web/dist python -m server.launcher  # Windows: set AFIX_WEB_DIST=web\dist first
+```
+
+Open **Modules & models → Background repair** to install the GPU module from the app (about 6 GB).
+</details>
+
+<details>
+<summary><strong>Build the images yourself</strong></summary>
+
+```bash
+git clone https://github.com/romanticamaj/openaudiofix && cd openaudiofix
+docker compose up -d --build
+docker compose -f docker-compose.yml -f docker-compose.gpu.yml up -d --build   # GPU version
+```
+</details>
+
+## Command line
+
+```bash
+pip install openaudiofix
+afix scan interview.wav                       # report what was found, change nothing
+afix repair interview.wav -m glitch,declip    # repaired file, difference file and a CSV of every fix
+afix repair interview.wav -m declip --float   # 32-bit float, no gain reduction
+afix speech episode.wav                       # episode_speech.wav, episode_removed.wav, episode_removed.txt
+afix speech host.wav guest.wav --out-dir edit # tracks of one session are split together
+```
+
+You need ffmpeg on `PATH`. `afix --help` lists every option. The web app runs from Docker or a clone.
+
+## Screenshots
+
+<table>
+  <tr>
+    <td><img src="docs/screenshots/modules.png" alt="Detection results and module choice"></td>
+    <td><img src="docs/screenshots/export.png" alt="The export dialog"></td>
+  </tr>
+  <tr>
+    <td align="center">Scan first, then choose what to repair</td>
+    <td align="center">Export without overwriting anything</td>
+  </tr>
+</table>
+
+## How it compares
+
+| | OpenAudioFix | Audacity | iZotope RX | Adobe Podcast |
+|---|---|---|---|---|
+| Open source | Yes (MIT) | Yes (GPL) | No | No |
+| Price | Free | Free | Paid | Free tier, paid plans |
+| Audio stays on your computer | Yes | Yes | Yes | No, it is uploaded |
+| Lists every change | Yes | No | Partly | No |
+
+RX has far more tools and years of refinement. OpenAudioFix does a few repairs, in the open, and shows its work.
+
+## Good to know
+
+- **Peaks above 0 dBFS are expected.** Rebuilt peaks were above it before the clipping. Export offers a 32-bit float
+  file that keeps them, or your original bit depth lowered just enough to fit.
+- **Lossy files work**, but repairs are better from WAV or FLAC.
+- **It listens on `127.0.0.1` only.** To use your own hostname, set `AFIX_ALLOWED_HOSTS`. See
+  [configuration](docs/configuration.md), which also covers folders and environment variables.
+- **Unrelated names.** This project has no connection to the iOS and macOS app "AudioFix" or to the npm package `afix`.
+
+## Contributing
+
+Bug reports with a short sample of the audio help most. New repair modules and UI languages are welcome: see
+[CONTRIBUTING.md](CONTRIBUTING.md). Every bug that gets fixed gets a test.
+
+## License
+
+[MIT](LICENSE). Third-party components are listed in [THIRD_PARTY.md](THIRD_PARTY.md).

openaudiofix-0.1.0/openaudiofix/__init__.py

@@ -0,0 +1,2 @@
+"""OpenAudioFix: self-hosted audio repair (glitch, declip, background noise)."""
+__version__ = "0.1.0"

openaudiofix-0.1.0/openaudiofix/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

openaudiofix-0.1.0/openaudiofix/algorithms/align.py

@@ -0,0 +1,39 @@
+"""Resampling and fixed-latency alignment for model outputs (copied from separation/runners/_common.py)."""
+import numpy as np
+
+MAX_LAG = 4096          # alignment search range (+-samples); the model delay is usually within a few hundred samples
+
+
+def resample(x, sr_in, sr_out):
+    if sr_in == sr_out:
+        return x
+    from scipy.signal import resample_poly
+    from math import gcd
+    g = gcd(sr_in, sr_out)
+    return resample_poly(x, sr_out // g, sr_in // g).astype(np.float32)
+
+
+def align_to(ref, y):
+    """Align the model output y to the original ref: compensate a fixed delay and trim to equal length.
+    Returns (y_aligned, lag). lag>0 means y is lag samples later than ref. Found by cross-correlating the whole
+    signal; speech-enhancement models do not change the time axis, so there should be only one fixed delay, and a
+    peak that is not prominent enough is treated as 0 (no spurious shifting)."""
+    n = min(len(ref), len(y))
+    a = ref[:n].astype(np.float64); b = y[:n].astype(np.float64)
+    L = 1 << int(np.ceil(np.log2(2 * n)))
+    A = np.fft.rfft(a, L); B = np.fft.rfft(b, L)
+    c = np.fft.irfft(np.conj(A) * B, L)
+    cand = np.r_[c[:MAX_LAG + 1], c[-MAX_LAG:]]
+    lags = np.r_[np.arange(0, MAX_LAG + 1), np.arange(-MAX_LAG, 0)]
+    k = int(np.argmax(cand))
+    lag = int(lags[k])
+    if cand[k] < 3 * np.median(np.abs(cand)):
+        lag = 0
+    if lag > 0:
+        y = np.r_[y[lag:], np.zeros(lag, np.float32)]
+    elif lag < 0:
+        y = np.r_[np.zeros(-lag, np.float32), y[:lag]]
+    if len(y) < len(ref):
+        y = np.r_[y, np.zeros(len(ref) - len(y), np.float32)]
+    return y[:len(ref)].astype(np.float32), lag
+

openaudiofix-0.1.0/openaudiofix/algorithms/aspade.py

@@ -0,0 +1,114 @@
+"""A-SPADE (analysis sparse audio declipper), for a direct comparison with the whole-frame joint AR
+(declip.declip_joint).
+
+Algorithm: Kitić, Bertin, Gribonval 2015; ADMM form and parameters follow Záviška et al. 2019/2021.
+Each frame (after windowing) solves
+    min ||A x||_0   s.t.  x ∈ Γ
+A = 2x-redundant DFT (Parseval tight frame: A^H A = I), Γ = clipping-consistent set:
+    reliable samples x = y; positive clipping x ≥ y; negative clipping x ≤ y (y is the windowed observation).
+ADMM:
+    z = H_k(A x + u)            hard threshold, keep only the k largest coefficients
+    x = P_Γ(A^H (z − u))        project back onto the consistent set
+    stop if ||A x − z|| ≤ ε, otherwise u += A x − z, and every r iterations k += s
+The fundamental difference from the AR family: the prior is "time-frequency sparsity", not "linear predictability".
+For periodic speech, harmonics are already sparse in frequency, so in theory it suits dense clipping; the cost is many
+iterations.
+
+Frame synthesis: each frame is solved in the windowed domain (x_w ≈ g·x), multiplied by g again when overlap-adding,
+and finally divided by Σg², which is correct for any overlap ratio.
+Only frames containing clipping are processed; regions without clipping are unchanged sample by sample.
+"""
+import numpy as np
+
+# frame length (43 ms): speech is shorter than the music Záviška tested; start here, sweep later on the benchmark
+W = 2048
+HOP = 512         # 75% overlap
+REDUND = 2        # DFT redundancy factor
+S = 1             # sparsity relaxed at each step
+R = 1             # relax once every R iterations
+EPS = 0.1         # stopping criterion ||Ax − z|| (same as Záviška; relative to the scale of the windowed signal)
+MAX_IT = 1000
+
+
+def _A(x, n):
+    return np.fft.fft(x, n, norm="ortho")
+
+
+def _AH(z, w):
+    return np.real(np.fft.ifft(z, norm="ortho"))[:w]
+
+
+def _hard(z, k):
+    """Keep the k coefficients with the largest magnitude (conjugate pairs counted together: the threshold is decided
+    from the first half of the spectrum, which keeps the symmetry of a real signal)."""
+    a = np.abs(z)
+    if k >= len(a):
+        return z
+    thr = np.partition(a, len(a) - k)[len(a) - k]
+    return np.where(a >= thr, z, 0)
+
+
+def aspade_frame(y, rel, cp, cn, eps=EPS, s=S, r=R, max_it=MAX_IT):
+    """y: windowed frame; rel/cp/cn: reliable / positive-clip / negative-clip masks.
+    Returns the reconstructed frame (in the windowed domain)."""
+    w = len(y); n = REDUND * w
+    x = y.copy(); u = np.zeros(n, dtype=complex)
+    k = s
+    for it in range(1, max_it + 1):
+        Ax = _A(x, n)
+        z = _hard(Ax + u, k)
+        v = _AH(z - u, w)
+        x = v.copy()                      # projection onto Γ
+        x[rel] = y[rel]
+        x[cp] = np.maximum(v[cp], y[cp])
+        x[cn] = np.minimum(v[cn], y[cn])
+        Ax = _A(x, n)
+        res = np.linalg.norm(Ax - z)
+        if res <= eps:
+            break
+        u = u + Ax - z
+        if it % r == 0:
+            k += 2 * s                    # 2 = conjugate pair; makes the "true" sparsity grow by s each time
+    return x, it
+
+
+def declip_aspade(x, sr, thr_pos=None, thr_neg=None, w=W, hop=HOP, eps=EPS, max_it=MAX_IT, progress=None):
+    """Process the whole signal. If thr is not given, it is inferred with declip.estimate_threshold. Returns (y,
+    info)."""
+    x = np.asarray(x, dtype=np.float64)
+    if thr_pos is None:
+        from . import declip as _D
+        thr_pos, thr_neg, det = _D.estimate_threshold(x)
+        if not det:
+            return x.copy(), dict(detected=False)
+    cp_all = x >= thr_pos; cn_all = x <= thr_neg
+    clipped = cp_all | cn_all
+    g = np.hanning(w + 2)[1:-1]
+    num = np.zeros(len(x)); den = np.zeros(len(x))
+    its = []
+    starts = range(-w + hop, len(x), hop)
+    for st in starts:
+        a, b = st, st + w
+        a0, b0 = max(a, 0), min(b, len(x))
+        if not clipped[a0:b0].any():
+            continue
+        seg = np.zeros(w); seg[a0 - a:b0 - a] = x[a0:b0]
+        cp = np.zeros(w, bool); cn = np.zeros(w, bool)
+        cp[a0 - a:b0 - a] = cp_all[a0:b0]; cn[a0 - a:b0 - a] = cn_all[a0:b0]
+        rel = ~(cp | cn)
+        yw = seg * g
+        xr, it = aspade_frame(yw, rel, cp, cn, eps=eps, max_it=max_it)
+        its.append(it)
+        if progress is not None and len(its) % 25 == 0:
+            progress(max(st, 0), len(x))
+        num[a0:b0] += (xr * g)[a0 - a:b0 - a]
+        den[a0:b0] += (g * g)[a0 - a:b0 - a]
+    y = x.copy()
+    m = clipped & (den > 1e-9)
+    y[m] = num[m] / den[m]
+    # Consistency: reconstructed values must not fall back inside the threshold (numerical error at window edges can
+    # cause tiny violations)
+    y[cp_all] = np.maximum(y[cp_all], thr_pos)
+    y[cn_all] = np.minimum(y[cn_all], thr_neg)
+    return y, dict(detected=True, n_frames=len(its), iters_median=int(np.median(its)) if its else 0,
+                   peak=float(np.abs(y).max()))

openaudiofix-0.1.0/openaudiofix/algorithms/declick.py

@@ -0,0 +1,164 @@
+"""Repair of phase jumps from dropped samples (single file): detect, then phase-aligned micro-warp / per-hole
+interpolation, then verify the residue.
+
+"Track" here corresponds to "channel" (mono=1, stereo=2).
+Uses the same logic as the whole-file pipeline for a long real recording: adjacent/overlapping
+seams are first merged into one discard zone and solved at once; after repair the detector is rerun, residues first
+fall back to the safe path and, if that still fails, are widened, and every round reapplies all patches
+from the original file. The detector is the generic single-file version (`declick_detect.py`).
+"""
+import time
+import numpy as np
+
+from . import declick_detect as D, phase_warp
+
+MAX_PASS = 4
+CLUSTER_MARGIN = 330    # seams closer than this are merged into one discard zone and solved at once
+RESID_NEAR = 200         # residual events within ± this range of an existing group count as the same spot
+MAX_GAP = 960
+
+
+def merge_groups(seams, margin=CLUSTER_MARGIN):
+    """seams: {p: {gap, za, zb, ...}} → merge nearby / overlapping windows [za-gap/2, zb+gap/2) into groups.
+    Returns a list of dict(za, zb, subs=[(a,b),...], positions=[p,...], force=False), sorted by position."""
+    items = []
+    for p, s in sorted(seams.items()):
+        half = s["gap"] // 2
+        a = min(s["za"] - half, s["za"] - 1)
+        b = max(s["zb"] + half, s["zb"] + 1)
+        if b - a < s["gap"]:
+            b = a + s["gap"]
+        items.append(dict(p=p, za=s["za"], zb=s["zb"], a=a, b=b, gap=s["gap"]))
+    groups = []
+    for it in items:
+        if groups and it["a"] <= groups[-1]["zb"] + margin:
+            g = groups[-1]
+            g["zb"] = max(g["zb"], it["zb"]); g["b"] = max(g["b"], it["b"])
+            g["subs"].append((it["a"], it["b"])); g["positions"].append(it["p"])
+        else:
+            groups.append(dict(za=it["za"], zb=it["zb"], a=it["a"], b=it["b"],
+                                subs=[(it["a"], it["b"])], positions=[it["p"]]))
+    for g in groups:
+        g["force"] = any(seams[p].get("force", False) for p in g["positions"])
+    return groups
+
+
+def run_pass(X, groups, sr, on_group=None):
+    """Call phase_warp.repair_joint on each group in turn; returns (new channel arrays, per-group repair records).
+    on_group(done, total): optional; reports progress after each batch of groups is repaired (does not affect the
+    result)."""
+    Y = [x.copy() for x in X]
+    records = []
+    prev_end = -10 ** 9
+    for gi, g in enumerate(groups):
+        if on_group and gi % 25 == 0:
+            on_group(gi, len(groups))
+        roomL = g["za"] - max(prev_end, groups[gi - 1]["zb"] if gi else -10 ** 9)
+        roomR = (groups[gi + 1]["za"] if gi + 1 < len(groups) else 10 ** 12) - g["zb"]
+        WL_av = roomL - 32
+        WR_av = roomR // 2 - 32
+        # Zero everything when there is not enough room (rather than passing a small non-zero value): a warp window
+        # shorter
+        # than the pitch period makes phase_warp's internal "extension start continuity correction" read out of bounds.
+        # The whole-file pipeline always had this safety margin (its `tight` check); the single-file pipeline initially
+        # missed
+        # this step, and an end-to-end test on a real clip with dense defects caught it (the stereo test clip triggered
+        # a
+        # broadcast error in render()), so it was added here too.
+        tight = 2 * (phase_warp.W_AVAIL_MIN + 32) + 64
+        if roomR < tight:
+            WR_av = 0
+        if roomL < tight:
+            WL_av = 0
+        if g["za"] - phase_warp.NEED - phase_warp.W_MAX < 0 or g["zb"] + phase_warp.NEED + phase_warp.W_MAX > len(Y[0]):
+            res = None
+        else:
+            res = phase_warp.repair_joint(Y, g["za"], g["zb"], g["subs"], sr, WL_av=max(WL_av, 0),
+                                           WR_av=max(WR_av, 0), roomL=max(roomL, 0), roomR=max(roomR, 0),
+                                           force_fallback=g["force"])
+        if res is None:
+            lo0, hi0 = g["a"], g["b"]
+            for t in range(len(Y)):
+                o = max(lo0 - 16384, 0)
+                ctx = Y[t][o:hi0 + 16384].copy(); ctx[lo0 - o:hi0 - o] = np.nan
+                from .v3methods import ensemble_select
+                yv = ensemble_select.fill(ctx, lo0 - o, hi0 - o, sr)
+                Y[t][lo0:hi0] = yv
+            info = dict(mode="fallback-edge", lo=lo0, hi=hi0)
+            end = hi0
+        else:
+            end = g["b"]
+            for t, (lo, y, info_t) in enumerate(res):
+                Y[t][lo:lo + len(y)] = y
+                end = max(end, lo + len(y))
+            info = res[0][2]
+        records.append(dict(group=g, info=info))
+        prev_end = end
+    return Y, records
+
+
+def repair_file(channels, sr, job_dir, progress=None, detected=None):
+    """channels: list of 1D float64 np.array (equal length). Returns (Y, seams_final, grid_info, history).
+    detected: optional (seams, grid), e.g. the result of detecting on another signal (the original, before declip
+    repair);
+    if given, detection is not rerun on channels."""
+    X0 = [x.copy() for x in channels]
+    if detected is None:
+        seams, grid = D.detect_seams(X0, sr)
+    else:
+        seams, grid = {p: dict(s) for p, s in detected[0].items()}, detected[1]
+    if progress:
+        progress(state="repairing", grid=grid, n_seams_initial=len(seams))
+    history = []
+    Y = X0
+    for it in range(1, MAX_PASS + 1):
+        groups = merge_groups(seams)
+        t0 = time.time()
+        Y, records = run_pass(X0, groups, sr, on_group=(lambda i, n, _it=it: progress(
+            state="repairing", pass_=_it, done=i, total=n)) if progress else None)
+        if progress:
+            progress(state="repairing", pass_=it, n_groups=len(groups),
+                     n_seams=len(seams), pass_seconds=round(time.time() - t0, 1))
+        evs, sts = [], []
+        for x in Y:
+            e, s = D.detect(x)
+            evs.append(e); sts.append(s)
+        tri = D.coincident_all(evs) if len(Y) > 1 else evs[0]
+        grid_tuple = (grid["L"], set(grid["residues"]), grid["coverage"], grid["confidence"])
+        resid = tri if len(Y) > 1 else np.array(
+            sorted(p for p, ntr, ongrid, strength in D.build_seam_list(evs, sts, grid_tuple) if ongrid or ntr >= 1))
+        widened = forced = added = 0
+        for t in resid.astype(int):
+            hit = [g for g in groups if g["za"] - RESID_NEAR <= t <= g["zb"] + RESID_NEAR]
+            if hit:
+                g = min(hit, key=lambda g: min(abs(g["za"] - t), abs(g["zb"] - t)))
+                if not g["force"]:
+                    # this group used phase warping in the previous round and the residue is still there -> this round
+                    # falls back to the safe path (more reliable than widening)
+                    for p in g["positions"]:
+                        seams[p]["force"] = True
+                    forced += 1
+                else:
+                    # already on the safe path and still residual -> widen the window and repair again
+                    key_p = min(g["positions"], key=lambda p: abs(p - t))
+                    s = seams[key_p]
+                    if s["gap"] < MAX_GAP:
+                        ext = min(s["gap"] // 2, (MAX_GAP - s["gap"]) // 2)
+                        s["gap"] += 2 * ext; s["za"] -= ext; s["zb"] += ext
+                        widened += 1
+            else:
+                Lg, residues, conf = grid["L"], set(grid["residues"]), grid["confidence"]
+                ongrid = (t % Lg) in residues if residues else False
+                if ongrid and conf >= D.GRID_CONFIDENCE_MIN:
+                    seams[t] = dict(gap=D.GAP0, za=t, zb=t, ntracks=1, ongrid=True, strength=0.0, force=False)
+                    added += 1
+        history.append(dict(pass_=it, residual=int(len(resid)), forced_fallback=forced, widened=widened, added=added))
+        if progress:
+            progress(state="repairing", history=history)
+        if forced == 0 and widened == 0 and added == 0:
+            break
+    mode_by_pos = {}
+    for rec in records:
+        for p in rec["group"]["positions"]:
+            mode_by_pos[p] = rec["info"].get("mode", "?")
+    return Y, seams, grid, history, mode_by_pos