More live opt

bench.py

@@ -1,260 +0,0 @@
-import argparse
-import json
-import os
-import statistics
-import time
-from pathlib import Path
-
-import numpy as np
-import onnxruntime as ort
-
-ort.set_default_logger_severity(3)
-
-NP = {
-    "tensor(float)": np.float32, "tensor(float16)": np.float16, "tensor(double)": np.float64,
-    "tensor(int64)": np.int64, "tensor(int32)": np.int32, "tensor(int8)": np.int8,
-    "tensor(uint8)": np.uint8, "tensor(bool)": np.bool_,
-}
-TAG = {"tensor(float)": "f32", "tensor(float16)": "f16", "tensor(double)": "f64",
-       "tensor(int64)": "i64", "tensor(int32)": "i32", "tensor(int8)": "i8",
-       "tensor(uint8)": "u8", "tensor(bool)": "b"}
-GRAPHS = ["ssl", "encode", "decode", "global"]
-
-
-def cpu_info():
-    info = {"cpu": platform_cpu(), "logical": os.cpu_count(), "phys": "?", "isa": {}}
-    try:
-        txt = Path("/proc/cpuinfo").read_text()
-        for l in txt.splitlines():
-            if l.startswith("model name"):
-                info["cpu"] = l.split(":", 1)[1].strip(); break
-        flags = next((l for l in txt.splitlines() if l.startswith("flags")), "")
-        cc = next((l for l in txt.splitlines() if l.startswith("cpu cores")), "")
-        if cc:
-            info["phys"] = cc.split(":")[1].strip()
-        info["isa"] = {k: int(k in flags) for k in
-                       ["avx2", "avx512f", "avx_vnni", "avx512_vnni", "amx_int8"]}
-    except Exception:
-        pass
-    return info
-
-
-def platform_cpu():
-    import platform
-    return platform.processor() or platform.machine()
-
-
-def make_session(path, provider, intra, inter, profile=False):
-    so = ort.SessionOptions()
-    so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-    if intra:
-        so.intra_op_num_threads = intra
-    if inter:
-        so.inter_op_num_threads = inter
-    so.enable_profiling = profile
-    if provider == "openvino":
-        providers = [("OpenVINOExecutionProvider", {"device_type": "CPU"}), "CPUExecutionProvider"]
-    else:
-        providers = ["CPUExecutionProvider"]
-    return ort.InferenceSession(str(path), sess_options=so, providers=providers)
-
-
-def dim_value(name, axis, ndim, meta, seq):
-    n = name.lower()
-    if axis == 0 and ndim >= 2:
-        return 1
-    if "audio" in n:
-        return int(meta.get("ssl_in_16k", seq))
-    if "local" in n or ("ssl_features" in n and "global" not in n):
-        return int(meta.get("enc_tokens", 1) * meta.get("downsample_factor", 1)) or seq
-    if "token" in n or "indices" in n:
-        return int(meta.get("dec_tokens", seq))
-    return seq
-
-
-def resolve_inputs(sess, meta, seq, rng):
-    feeds, shapes = {}, {}
-    for inp in sess.get_inputs():
-        dt = NP.get(inp.type, np.float32)
-        shape = [d if isinstance(d, int) and d > 0
-                 else dim_value(inp.name, ax, len(inp.shape), meta, seq)
-                 for ax, d in enumerate(inp.shape)]
-        shapes[inp.name] = (shape, TAG.get(inp.type, "?"))
-        n = inp.name.lower()
-        if np.issubdtype(dt, np.integer):
-            feeds[inp.name] = np.zeros(shape, dtype=dt)
-        elif dt == np.bool_:
-            feeds[inp.name] = np.ones(shape, dtype=dt)
-        else:
-            a = rng.standard_normal(shape).astype(dt)
-            if "std" in n:
-                a = np.abs(a) + 1.0
-            elif "mean" in n:
-                a *= 0.0
-            elif "audio" in n:
-                a *= 0.1
-            feeds[inp.name] = a
-    return feeds, shapes
-
-
-def bench(sess, feeds, runs, warmup):
-    out = [o.name for o in sess.get_outputs()]
-    for _ in range(warmup):
-        sess.run(out, feeds)
-    ts = []
-    for _ in range(runs):
-        t = time.perf_counter()
-        sess.run(out, feeds)
-        ts.append((time.perf_counter() - t) * 1e3)
-    return ts, out
-
-
-def profile_ops(path, provider, intra, inter, feeds, out, runs):
-    sess = make_session(path, provider, intra, inter, profile=True)
-    for _ in range(runs):
-        sess.run(out, feeds)
-    prof = Path(sess.end_profiling())
-    events = json.loads(prof.read_text())
-    prof.unlink(missing_ok=True)
-    agg, prov = {}, {}
-    for e in events:
-        if e.get("cat") == "Node" and e.get("name", "").endswith("kernel_time"):
-            op = e.get("args", {}).get("op_name", "?")
-            agg[op] = agg.get(op, 0.0) + e.get("dur", 0)
-            p = e.get("args", {}).get("provider", "")
-            if p:
-                prov.setdefault(op, set()).add(p)
-    rows = sorted(agg.items(), key=lambda kv: kv[1], reverse=True)
-    return rows, (sum(agg.values()) or 1.0), prov
-
-
-def static_ops(path):
-    try:
-        import onnx
-    except Exception:
-        return None
-    m = onnx.load(str(path), load_external_data=False)
-    c = {}
-    for node in m.graph.node:
-        c[node.op_type] = c.get(node.op_type, 0) + 1
-    return dict(sorted(c.items(), key=lambda kv: kv[1], reverse=True))
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--dir", default="outputs")
-    ap.add_argument("--meta")
-    ap.add_argument("--provider", choices=["cpu", "openvino"], default="cpu")
-    ap.add_argument("--intra", type=int, default=0)
-    ap.add_argument("--inter", type=int, default=0)
-    ap.add_argument("--runs", type=int, default=50)
-    ap.add_argument("--warmup", type=int, default=5)
-    ap.add_argument("--seq", type=int, default=100)
-    ap.add_argument("--extra", nargs="*", default=[])
-    ap.add_argument("--quant", action="store_true")
-    args = ap.parse_args()
-
-    d = Path(args.dir)
-    meta = json.loads(Path(args.meta or d / "meta.json").read_text())
-    rng = np.random.default_rng(0)
-    avail = ort.get_available_providers()
-    prov = args.provider
-    if prov == "openvino" and "OpenVINOExecutionProvider" not in avail:
-        prov = "cpu"
-        ov_note = "requested but NOT installed -> fell back to cpu"
-    else:
-        ov_note = "available" if "OpenVINOExecutionProvider" in avail else "not installed"
-
-    models = {g: d / f"{g}.onnx" for g in GRAPHS if (d / f"{g}.onnx").exists()}
-    if args.quant:
-        for g in GRAPHS:
-            q = d / f"{g}_quant.onnx"
-            if q.exists():
-                models[f"{g}_q"] = q
-    for kv in args.extra:
-        name, _, path = kv.partition("=")
-        models[name] = Path(path)
-
-    ci = cpu_info()
-    isa = " ".join(f"{k}={v}" for k, v in ci["isa"].items())
-    print("=== ENV ===")
-    print(f"cpu: {ci['cpu']}")
-    print(f"cores: {ci['phys']} phys / {ci['logical']} logical")
-    print(f"isa: {isa}")
-    print(f"onnxruntime: {ort.__version__}")
-    print(f"providers avail: {avail}")
-    print(f"openvino EP: {ov_note}")
-    print(f"config: provider={prov} intra={args.intra or 'default'} "
-          f"inter={args.inter or 'default'} runs={args.runs}")
-
-    med = {}
-    csv_rows = [("graph", "med_ms", "mean_ms", "p90_ms", "min_ms", "runs")]
-    op_rows = [("graph", "op", "ms_per_run", "pct", "provider")]
-    for name, path in models.items():
-        print(f"\n=== {name.upper()} ===")
-        print(f"path: {path}  size: {path.stat().st_size / 1e6:.3g} MB")
-        try:
-            sess = make_session(path, prov, args.intra, args.inter)
-            feeds, shapes = resolve_inputs(sess, meta, args.seq, rng)
-            print("inputs: " + "  ".join(
-                f"{k}[{','.join(map(str, s))}]{t}" for k, (s, t) in shapes.items()))
-            ts, out = bench(sess, feeds, args.runs, args.warmup)
-            m = statistics.median(ts)
-            med[name] = m
-            p90 = sorted(ts)[int(0.9 * len(ts)) - 1]
-            print(f"latency ms: med {m:.3g}  mean {statistics.fmean(ts):.3g}  "
-                  f"p90 {p90:.3g}  min {min(ts):.3g}")
-            csv_rows.append((name, f"{m:.3g}", f"{statistics.fmean(ts):.3g}",
-                             f"{p90:.3g}", f"{min(ts):.3g}", args.runs))
-
-            so = static_ops(path)
-            if so:
-                print("ops static: " + "  ".join(f"{k}:{v}" for k, v in list(so.items())[:10]))
-
-            rows, total, pmap = profile_ops(path, prov, args.intra, args.inter, feeds, out, args.warmup or 5)
-            multi = len({p for ps in pmap.values() for p in ps}) > 1
-            parts = []
-            for op, dur in rows[:6]:
-                pr = "/".join(sorted(x.replace("ExecutionProvider", "") for x in pmap.get(op, [])))
-                tag = f"({pr})" if multi else ""
-                parts.append(f"{op}{tag} {dur / (args.warmup or 5) / 1e3:.3g}ms {100 * dur / total:.0f}%")
-                op_rows.append((name, op, f"{dur / (args.warmup or 5) / 1e3:.3g}",
-                                f"{100 * dur / total:.0f}", pr or "CPU"))
-            print("ops time: " + " | ".join(parts))
-        except Exception as e:
-            print(f"FAILED: {e}")
-
-    print("\n=== ROLLUP ===")
-    ds = meta.get("downsample_factor", 1)
-    tok16 = ds * meta.get("wavlm_hop", 1)
-    sr16 = meta.get("ssl_sample_rate", 16000)
-    chunk = meta.get("chunk", 1)
-    audio_s = chunk * tok16 / sr16
-    per_win = sum(med.get(g, 0.0) for g in ("ssl", "encode", "decode"))
-    print(f"chunk={chunk} tok16={tok16} audio/window={audio_s * 1e3:.3g}ms")
-    print(f"per-window compute (ssl+encode+decode): {per_win:.3g}ms")
-    if audio_s > 0:
-        print(f"est streaming RTF: {(per_win / 1e3) / audio_s:.3g}  (global enc one-shot, excluded)")
-
-    if args.quant:
-        print("fp32 -> quant:")
-        for g in ("ssl", "encode", "decode", "global"):
-            if g in med and f"{g}_q" in med:
-                f0, f1 = med[g], med[f"{g}_q"]
-                print(f"  {g}: {f0:.3g} -> {f1:.3g}ms  ({100 * (1 - f1 / f0):+.0f}%)")
-        per_q = sum(med.get(f"{g}_q", med.get(g, 0.0)) for g in ("ssl", "encode", "decode"))
-        if audio_s > 0:
-            print(f"per-window quant: {per_q:.3g}ms  RTF {(per_q / 1e3) / audio_s:.3g}")
-
-    od = Path("outputs")
-    od.mkdir(exist_ok=True)
-    import csv
-    with open(od / "bench.csv", "w", newline="") as f:
-        csv.writer(f).writerows(csv_rows)
-    with open(od / "ops.csv", "w", newline="") as f:
-        csv.writer(f).writerows(op_rows)
-    print(f"\nwrote {od/'bench.csv'}  {od/'ops.csv'}")
-
-
-if __name__ == "__main__":
-    main()

live.py

@@ -222,9 +222,9 @@ def main():
     parser.add_argument("--seed-audio", type=Path, help="Seed speaker calibration WAV (optional)")
     parser.add_argument("--chunk", type=int, default=6)
     parser.add_argument("--enc-left", type=int, default=48)
-    parser.add_argument("--enc-right", type=int, default=2)
+    parser.add_argument("--enc-right", type=int, default=4)
     parser.add_argument("--dec-left", type=int, default=32)
-    parser.add_argument("--dec-right", type=int, default=3)
+    parser.add_argument("--dec-right", type=int, default=4)
     parser.add_argument("--ema-alpha", type=float, default=0.9,
                         help="EMA smoothing on local SSL features (0=full smoothing, 1=no smoothing)")
     parser.add_argument("--rms-floor", type=float, default=0.0035,

live_onnx.py

@@ -53,7 +53,20 @@ class StreamingISTFT:
         self.win_sq = self.window ** 2
         self.tail_y = np.zeros(0, dtype=np.float32)
         self.tail_e = np.zeros(0, dtype=np.float32)
-        self.started = False
+        self.started = False\
+    
+    def block(self, real, imag):
+        spec = real + 1j * imag
+        T = spec.shape[1]
+        ifft = (np.fft.irfft(spec, self.n_fft, axis=0) * self.window[:, None]).astype(np.float32)
+        region = (T - 1) * self.hop + self.win
+        y = np.zeros(region, dtype=np.float32)
+        e = np.zeros(region, dtype=np.float32)
+        for t in range(T):
+            s = t * self.hop
+            y[s : s + self.win] += ifft[:, t]
+            e[s : s + self.win] += self.win_sq
+        return (y / np.maximum(e, 1e-8)).astype(np.float32)
 
     def process(self, real, imag):
         spec = real + 1j * imag
@@ -110,13 +123,16 @@ class StreamingVCONNX:
             prov = ["CUDAExecutionProvider", "CPUExecutionProvider"]
         else:
             prov = ["CPUExecutionProvider"]
-        
+
         self.ssl = ort.InferenceSession(args.ssl, sess_options=opts, providers=prov)
         self.enc = ort.InferenceSession(args.encode, sess_options=opts, providers=prov)
         self.dec = ort.InferenceSession(args.decode, sess_options=opts, providers=prov)
         self.glb = ort.InferenceSession(args.global_path, sess_options=opts, providers=prov)
 
         self.istft = StreamingISTFT(meta["n_fft"], meta["hop_length"])
+        self.xfade_frames = 9
+        self.istft_margin = int(np.ceil(meta["n_fft"] / meta["hop_length"]))
+        self.xfade_tail = None
         self.global_emb = None
         self.src_mean = None
         self.src_std = None
@@ -159,33 +175,46 @@ class StreamingVCONNX:
         frames = np.concatenate([l[c : c + keep * self.ds] for keep, l in locals_], axis=0)
         self.src_mean = frames.mean(axis=0).astype(np.float32)
         self.src_std = frames.std(axis=0, ddof=1).astype(np.float32)
-        
+
         seed_tokens = np.concatenate(
             [self._encode(l, self.src_mean, self.src_std)[self.enc_left : self.enc_left + keep] for keep, l in locals_]
         ) if locals_ else np.zeros(0, dtype=np.int64)
-        
+
         self.tokens = seed_tokens.astype(np.int64)
         self.decoded = len(self.tokens)
 
     def reset(self):
         self.istft = StreamingISTFT(self.meta["n_fft"], self.meta["hop_length"])
+        self.xfade_tail = None
         self.tokens = None
         self.decoded = 0
 
     def apply_ema(self, local_feats):
-        if self.prev_local_feats is not None and local_feats.shape == self.prev_local_feats.shape:
+        shift = self.chunk * self.ds
-            local_feats = self.ema_alpha * local_feats + (1.0 - self.ema_alpha) * self.prev_local_feats
+        if self.prev_local_feats is not None:
+            n = local_feats.shape[0] - shift
+            if n > 0:
+                local_feats[:n] = (self.ema_alpha * local_feats[:n]
+                                + (1 - self.ema_alpha) * self.prev_local_feats[shift:shift + n])
         self.prev_local_feats = local_feats.copy()
         return local_feats
 
-    def _decode(self, win_tokens, keep_left, keep_n):
+    def _decode(self, win_tokens, keep_left, keep_n, right_tokens):
         real, imag = self.dec.run(
             ["spec_real", "spec_imag"],
-            {"content_token_indices": win_tokens, "global_embedding": self.global_emb}
+            {"content_token_indices": win_tokens, "global_embedding": self.global_emb},
         )
-        f0 = keep_left * self.fpt
+        fpt, hop = self.fpt, self.istft.hop
-        f1 = (keep_left + keep_n) * self.fpt
+        a = keep_left * fpt
-        return self.istft.process(real[:, f0:f1], imag[:, f0:f1])
+        b = (keep_left + keep_n) * fpt
+        right_frames = right_tokens * fpt
+        ov = min(self.xfade_frames, max(0, right_frames))
+        m = min(self.istft_margin, a, max(0, right_frames - ov))
+        F0, F1 = a - m, b + ov + m
+        audio = self.istft.block(real[:, F0:F1], imag[:, F0:F1])
+        start = (a - F0) * hop
+        seg = audio[start : start + (keep_n * fpt + ov) * hop]
+        return seg, ov * hop
 
     def _commit_tokens(self, new_idx):
         if self.tokens is None:
@@ -195,6 +224,7 @@ class StreamingVCONNX:
 
     def _drain(self, final=False):
         out = []
+        hop = self.istft.hop
         committed = len(self.tokens) if self.tokens is not None else 0
         while True:
             d0 = self.decoded
@@ -204,13 +234,23 @@ class StreamingVCONNX:
             keep_n = min(self.chunk, avail) if final else self.chunk
             left = min(self.dec_left, d0)
             right = min(self.dec_right, committed - (d0 + keep_n))
-            
+            lo, hi = d0 - left, d0 + keep_n + right
-            lo = d0 - left
+            win = self.tokens[np.clip(np.arange(lo, hi), 0, committed - 1)].astype(np.int64)
-            hi = d0 + keep_n + right
+
-            win_idx = np.clip(np.arange(lo, hi), 0, committed - 1)
+            seg, h = self._decode(win, left, keep_n, right)
-            win = self.tokens[win_idx].astype(np.int64)
+            body_end = keep_n * self.fpt * hop
-            
+            head, body, tail = seg[:h], seg[h:body_end], seg[body_end:]
-            out.append(self._decode(win, left, keep_n))
+
+            if self.xfade_tail is not None and len(self.xfade_tail) == h and h > 0:
+                t = np.linspace(0.0, 1.0, h, dtype=np.float32)
+                out.append((1.0 - t) * self.xfade_tail + t * head)
+            else:
+                out.append(head)
+            out.append(body)
+
+            self.xfade_tail = None if final else tail
+            if final and tail.size:
+                out.append(tail)
             self.decoded += keep_n
         return np.concatenate(out) if out else np.zeros(0, dtype=np.float32)
 
@@ -264,7 +304,7 @@ def main():
 
     sr = vc.sr
     sr16 = vc.sr16
-    
+
     token_hz = meta["token_hz"]
     tok_samples = sr // token_hz
     chunk_samples = vc.chunk * tok_samples
@@ -274,6 +314,10 @@ def main():
     chunk_samples_16k = vc.chunk * tok16
     left_pad_16k = vc.enc_left * tok16
     right_pad_16k = vc.enc_right * tok16
+    required_samples_16k = left_pad_16k + chunk_samples_16k + right_pad_16k
+
+    fade_len = int(0.01 * sr16)
+    ramp_down = np.linspace(1.0, 0.0, fade_len, dtype=np.float32)
 
     print(f"Sample Rate: {sr} Hz (target) | 16000 Hz (SSL internal)")
     print(f"Chunk Size: {vc.chunk} tokens ({budget_ms:.1f}ms budget)")
@@ -295,12 +339,11 @@ def main():
     vc.seed(seed_audio)
 
     if len(seed_audio) >= left_pad_16k:
-        raw_input_accum_16k = seed_audio[-left_pad_16k:]
+        accum_16k = seed_audio[-left_pad_16k:]
     else:
-        raw_input_accum_16k = np.pad(seed_audio, (left_pad_16k - len(seed_audio), 0))
+        accum_16k = np.pad(seed_audio, (left_pad_16k - len(seed_audio), 0))
 
     in_q = queue.Queue(maxsize=8)
-    ssl_q = queue.Queue(maxsize=8)
     out_q = queue.Queue(maxsize=2)
     stop_event = threading.Event()
 
@@ -318,58 +361,12 @@ def main():
             except queue.Empty:
                 continue
 
-    def ssl_thread_func(accum_16k):
+    print(f"\n{'chunk':>6}  {'q_in':>4}  {'q_out':>5}  {'ssl':>7}  {'enc':>7}  {'dec':>7}  {'total':>7}  {'budget':>7}  {'gap':>7}")
-        hangover_counter = 0
+    print("-" * 80)
-        t_last = None
-        while not stop_event.is_set():
-            try:
-                raw = in_q.get(timeout=0.5)
-            except queue.Empty:
-                continue
-
-            t_now = time.perf_counter()
-            gap_ms = (t_now - t_last) * 1000 if t_last else 0.0
-            t_last = t_now
-
-            rms = float(np.sqrt(np.mean(raw ** 2)))
-
-            if rms >= args.rms_floor:
-                hangover_counter = args.hangover_chunks
-                is_silence = False
-            else:
-                if hangover_counter > 0:
-                    hangover_counter -= 1
-                    is_silence = False  
-                else:
-                    is_silence = True   
-
-            raw_16k = resample(raw, sr, sr16)
-            accum_16k = np.concatenate([accum_16k, raw_16k])
-            required_samples_16k = left_pad_16k + chunk_samples_16k + right_pad_16k
-
-            if len(accum_16k) >= required_samples_16k:
-                window_16k = accum_16k[:required_samples_16k]
-                accum_16k = accum_16k[chunk_samples_16k:]
-
-                fade_len = int(0.01 * sr16)
-                ramp_down = np.linspace(1.0, 0.0, fade_len, dtype=np.float32)
-
-                if is_silence:
-                    window_16k = window_16k.copy()
-                    active_start = left_pad_16k
-                    active_end = left_pad_16k + chunk_samples_16k
-                    window_16k[active_start : active_start + fade_len] *= ramp_down
-                    window_16k[active_start + fade_len : active_end] = 0.0
-
-                local_feats, t_ssl = sync_time(lambda: vc._ssl(window_16k)[0])
-                ssl_q.put((local_feats, is_silence, t_ssl, gap_ms, rms))
-            else:
-                ssl_q.put((None, is_silence, 0.0, gap_ms, rms))
-
-    print(f"\n{'chunk':>6}  {'q_in':>4}  {'q_ss':>4}  {'q_out':>5}  {'ssl':>7}  {'enc':>7}  {'dec':>7}  {'total':>7}  {'budget':>7}  {'gap':>7}")
-    print("-" * 88)
 
     chunk_n = 0
+    t_last = None
+    hangover_counter = 0
 
     with sd.InputStream(device=args.input, channels=n_in_ch, samplerate=sr,
                         blocksize=chunk_samples, dtype="float32",
@@ -378,21 +375,40 @@ def main():
                              dtype="float32", latency="low") as out_stream:
 
             writer = threading.Thread(target=write_thread, args=(out_stream,), daemon=True)
-            ssl_worker = threading.Thread(target=ssl_thread_func, args=(raw_input_accum_16k,), daemon=True)
-            
             writer.start()
-            ssl_worker.start()
 
             try:
                 while True:
-                    try:
+                    raw = in_q.get()
-                        item = ssl_q.get(timeout=0.5)
+                    t_now = time.perf_counter()
-                    except queue.Empty:
+                    gap_ms = (t_now - t_last) * 1000 if t_last else 0.0
-                        continue
+                    t_last = t_now
 
-                    local_feats, is_silence, t_ssl, gap_ms, rms = item
+                    rms = float(np.sqrt(np.mean(raw ** 2)))
+                    if rms >= args.rms_floor:
+                        hangover_counter = args.hangover_chunks
+                        is_silence = False
+                    elif hangover_counter > 0:
+                        hangover_counter -= 1
+                        is_silence = False
+                    else:
+                        is_silence = True
 
-                    if local_feats is not None:
+                    raw_16k = resample(raw, sr, sr16)
+                    accum_16k = np.concatenate([accum_16k, raw_16k])
+
+                    if len(accum_16k) >= required_samples_16k:
+                        window_16k = accum_16k[:required_samples_16k]
+                        accum_16k = accum_16k[chunk_samples_16k:]
+
+                        if is_silence:
+                            window_16k = window_16k.copy()
+                            active_start = left_pad_16k
+                            active_end = left_pad_16k + chunk_samples_16k
+                            window_16k[active_start : active_start + fade_len] *= ramp_down
+                            window_16k[active_start + fade_len : active_end] = 0.0
+
+                        local_feats, t_ssl = sync_time(lambda: vc._ssl(window_16k)[0])
                         local_feats = vc.apply_ema(local_feats)
                         idx, t_enc = sync_time(lambda: vc._encode(local_feats, vc.src_mean, vc.src_std))
                         chunk_tokens = idx[vc.enc_left : vc.enc_left + vc.chunk]
@@ -406,22 +422,22 @@ def main():
                             pcm_out = np.stack([pcm, pcm], axis=1)
                     else:
                         pcm_out = np.zeros((chunk_samples, 2), dtype=np.float32)
-                        t_enc, t_dec = 0.0, 0.0
+                        t_ssl, t_enc, t_dec = 0.0, 0.0, 0.0
 
                     out_q.put(pcm_out)
 
                     total = t_ssl + t_enc + t_dec
                     chunk_n += 1
-                    
+
                     if is_silence:
                         print(
-                            f"{chunk_n:>6}  {in_q.qsize():>4}  {ssl_q.qsize():>4}  {out_q.qsize():>5}  "
+                            f"{chunk_n:>6}  {in_q.qsize():>4}  {out_q.qsize():>5}  "
-                            f"{'--silence--':>54}  rms={rms:.4f}",
+                            f"{'--silence--':>41}  rms={rms:.4f}",
                             flush=True,
                         )
                     else:
                         print(
-                            f"{chunk_n:>6}  {in_q.qsize():>4}  {ssl_q.qsize():>4}  {out_q.qsize():>5}  "
+                            f"{chunk_n:>6}  {in_q.qsize():>4}  {out_q.qsize():>5}  "
                             f"{t_ssl:>6.1f}ms  {t_enc:>6.1f}ms  {t_dec:>6.1f}ms  "
                             f"{total:>6.1f}ms  {budget_ms:>6.0f}ms  {gap_ms:>6.1f}ms",
                             flush=True,
@@ -432,7 +448,6 @@ def main():
             finally:
                 stop_event.set()
                 writer.join()
-                ssl_worker.join()
 
     print("stopped")
 

pyproject.toml

@@ -7,8 +7,6 @@ requires-python = ">=3.12"
 dependencies = [
     "miocodec",
     "numpy>=2.4.6",
-    "onnxruntime>=1.26.0",
-    "onnxruntime-gpu>=1.26.0",
     "onnxruntime-openvino>=1.24.1",
     "onnxscript>=0.7.0",
     "sounddevice>=0.5.5",

uv.lock

@@ -208,8 +208,6 @@ source = { virtual = "." }
 dependencies = [
     { name = "miocodec" },
     { name = "numpy" },
-    { name = "onnxruntime" },
-    { name = "onnxruntime-gpu" },
     { name = "onnxruntime-openvino" },
     { name = "onnxscript" },
     { name = "sounddevice" },
@@ -221,8 +219,6 @@ dependencies = [
 requires-dist = [
     { name = "miocodec", git = "https://github.com/Aratako/MioCodec" },
     { name = "numpy", specifier = ">=2.4.6" },
-    { name = "onnxruntime", specifier = ">=1.26.0" },
-    { name = "onnxruntime-gpu", specifier = ">=1.26.0" },
     { name = "onnxruntime-openvino", specifier = ">=1.24.1" },
     { name = "onnxscript", specifier = ">=0.7.0" },
     { name = "sounddevice", specifier = ">=0.5.5" },
@@ -835,59 +831,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8c/aa/f7a53321c60b9ad9ee184b6018292ed6b5389947592a2c8c09c736bb7f9e/onnx_ir-0.2.1-py3-none-any.whl", hash = "sha256:c7285da889312f91882de2092e298a9eeeefbfc1d1951c49d983992967eb09a7", size = 166792, upload-time = "2026-04-20T20:21:46.357Z" },
 ]
 
-[[package]]
-name = "onnxruntime"
-version = "1.26.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "flatbuffers" },
-    { name = "numpy" },
-    { name = "packaging" },
-    { name = "protobuf" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/b1/d111b1df656761f980d9e298a60039a9cb66036b1d039e777537743d0ac3/onnxruntime-1.26.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05b028781b322ad74b57ce5b50aa5280bb1fe96ceec334628ade681e0b24c1ac", size = 18016624, upload-time = "2026-05-12T00:41:01.735Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/a0/3f9d896a0385a36bd04345d6d0b802821a5782adde562e7e135f6bb71c73/onnxruntime-1.26.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91f2bb870a4b9224eba0a6728c1fa7a9e552b8e59e1083c51fbbc3d013f2b5c0", size = 16052692, upload-time = "2026-05-08T19:07:13.829Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/43/2a4e04f8dbeffad19bbcced4bcd4289bf478921518437404d6b92bdf213b/onnxruntime-1.26.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b6dd70599005bd1bf29779f04a91978b92b5e719c11a20068a8f8e535f725b6", size = 18185439, upload-time = "2026-05-08T19:07:36.299Z" },
-    { url = "https://files.pythonhosted.org/packages/44/fc/026d0a7162b9c2153dac292baea9e027c42304dc1d9dc6f8ff5b4cfbaedd/onnxruntime-1.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:a26374dc7fbcaae593601086b242120e13f2310558df0991da6dd8b8fac00414", size = 13026427, upload-time = "2026-05-08T19:08:03.503Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/27/1dcf88e45e4c69db5f7b106f2dacc3801ba98994e082ca03e1dfdf7bfe57/onnxruntime-1.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:54a8053410fd31fd66469bd754fcfe8a4df9f7eb44756b4b5479bf50c842d948", size = 12796647, upload-time = "2026-05-08T19:07:52.108Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/a2/c801242685e0ce48a4ca51dfafbb588765e0446397e123be53ba5598f3f5/onnxruntime-1.26.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccce19c5f771b8268902f77d9fed9e88f9499465d6780808faa6611a789d33f0", size = 18016563, upload-time = "2026-05-08T19:07:28.081Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/64/0492c0b1db04e29b2630c87cfa36f9d6872b1ca8614b90c5cad58fac7d76/onnxruntime-1.26.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bdbed8cf3b672b66acb032f33a253bc27f42bce6ece48ae3fab4fa483a5e96e0", size = 16052634, upload-time = "2026-05-08T19:07:16.885Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/26/4d09ddc755a84fc8d5e192991626b0e0680e8f6c5d58f4f1d05c42bc48cf/onnxruntime-1.26.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c07af6fc6d5557835f2b6ee7a96d8b3235d0c57a8e230efdedaee106a8a3cbc6", size = 18185632, upload-time = "2026-05-08T19:07:38.756Z" },
-    { url = "https://files.pythonhosted.org/packages/77/89/3e52249aa08fa301e217ecba07b5246a8338fa2b401e109326e3fc5be0f9/onnxruntime-1.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:61bec80655efa460591c2bc655392d57d2650ce85533a6b9b3b7a790d7ea7916", size = 13026751, upload-time = "2026-05-08T19:08:06.2Z" },
-    { url = "https://files.pythonhosted.org/packages/06/b3/c1c8782b14af6797c303de132d6eef26a9fb80dfacd3750ce57911d11c6b/onnxruntime-1.26.0-cp313-cp313-win_arm64.whl", hash = "sha256:a6677545ff451e3539a02746d2f207d8c5baa4a0a818886bb9d6a6eb9511ee89", size = 12796807, upload-time = "2026-05-08T19:07:54.879Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/f5/47b0676408abec652c14b84d7173e389837832d850c24f87184277313e8d/onnxruntime-1.26.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e016edc15d3c19f36807e1c6b10be5b27807688c32720f91b5ae480a95215d0", size = 16057265, upload-time = "2026-05-08T19:07:19.603Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/45/33ab6deeef010ca844c877dd618cebc079590bbe52d2a3678e7223b1b908/onnxruntime-1.26.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5fc48a91a046a6a5c9b147f83fb41d65d24d24923373b222cdd248f0f4f4aac", size = 18197590, upload-time = "2026-05-08T19:07:41.422Z" },
-    { url = "https://files.pythonhosted.org/packages/40/89/17546c1c20f6bfc3ae41c22152378a26edfea918af3129e2139dcd7c99f3/onnxruntime-1.26.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:33a791f31432a3af1a96db5e54818b37aba5e5eefc2e6af5794c10a9118a9993", size = 18019724, upload-time = "2026-05-08T19:07:30.723Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/24/89457a35f6af29538a76647f2c18c3a28277e6c19234c847e7b4b7c19860/onnxruntime-1.26.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e90c00732c4553618103149d93f688e8c3063017938f8983e21a71d9f3b6d22e", size = 16054821, upload-time = "2026-05-08T19:07:22.348Z" },
-    { url = "https://files.pythonhosted.org/packages/12/f9/15b2e1815cf570d238e0135529f80d2dce64e8e8818a1489cae83823c5c6/onnxruntime-1.26.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01498e80ba8988428d08c2d51b1338f89e3de2a93e6ffe555f79c68f26a5c06b", size = 18185815, upload-time = "2026-05-08T19:07:44.179Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/65/2e11055faf015e4b07f45b513fa49b391baf2e19d92d77d73ebee13c1004/onnxruntime-1.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:7ead61450d8405167c87dd3a31d8da1d576b490a57dab1aa8b82a7da6825f5aa", size = 13349887, upload-time = "2026-05-08T19:08:08.671Z" },
-    { url = "https://files.pythonhosted.org/packages/19/e4/0f9d1a5718b1781c610c1e354765a3820597081754277a6a9a2b50705702/onnxruntime-1.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:31d71a53490e46910877d0902b5ad99c69a5955e5c7ea6c82863519410e1ba7c", size = 13140121, upload-time = "2026-05-08T19:07:57.804Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/42/3b8e635f067d06d9f45bede470b8d539d101a4166c272213158dfd08b6ce/onnxruntime-1.26.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7b6d258fb78fdfcf049795bcfaa74dcb90ae7baa277afd21e6fd28b83f2c496", size = 16057240, upload-time = "2026-05-08T19:07:25.163Z" },
-    { url = "https://files.pythonhosted.org/packages/93/99/f2be40a31b908d96b861ae0ce98582fa376c18a7f816b9d5eb4cd6aa0a4c/onnxruntime-1.26.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4eefd386a45202aefb7a5132b94f32df9d506c9edcc7faf2fc60d65183f4b183", size = 18197382, upload-time = "2026-05-08T19:07:46.965Z" },
-]
-
-[[package]]
-name = "onnxruntime-gpu"
-version = "1.26.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "flatbuffers" },
-    { name = "numpy" },
-    { name = "packaging" },
-    { name = "protobuf" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/94/fd/59bee7cffaa435da44fefdeb63e29c61de4dbfa4b279852f59cd02c042ae/onnxruntime_gpu-1.26.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c01119ed4d9449d60367fa8ccffcd02bd3fe736754284e4b198d131f54edad6", size = 276971796, upload-time = "2026-05-08T19:15:46.192Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/e4/9b378a5466ea0bed65e5beb8e09254973c580a6522810a38afbcc45e5105/onnxruntime_gpu-1.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:5f49c44689894650990e4c8a857d2edafc276fbd79bba57ceb224bd18d25d491", size = 226548963, upload-time = "2026-05-08T19:09:34.925Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/97/fe8979f44b9275654b42f7bb556e30789b71a1b22998c83b540df2b1b774/onnxruntime_gpu-1.26.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfda2fad535595bfc3e570eb588092717711dcb2957656d814695e0c9ceb1508", size = 276974871, upload-time = "2026-05-08T19:15:58.052Z" },
-    { url = "https://files.pythonhosted.org/packages/67/3f/59f1777a394625ecc9a85636de57dc47c25dbb5f888da050f1463955a0ce/onnxruntime_gpu-1.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:6ab9f9c741d2e239b2e321ab0d389c04329d4ab7f11e3b92dd3aa7db1c59dee4", size = 226548083, upload-time = "2026-05-08T19:09:44.408Z" },
-    { url = "https://files.pythonhosted.org/packages/89/96/360328e3c463f7ea08e853c4239c397e83363dd0204de71a710dc1a544bd/onnxruntime_gpu-1.26.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bcf6f347cad9f88a9a625c2b352cf9de927528aedb627ebbc089a201f1990b94", size = 276992052, upload-time = "2026-05-08T19:16:09.892Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/c8/aa2dc0e79bba577f37d5448bcb32fea79977e07506684d8138c19a0f1077/onnxruntime_gpu-1.26.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e6e4fb1ec9ae1cf456534d9115f106ab2a1ae96fa513b4ed0f4795302b4a2c6", size = 276978254, upload-time = "2026-05-08T19:16:22.096Z" },
-    { url = "https://files.pythonhosted.org/packages/41/e7/923298431e669567d7ccc2a4c898b6534a47641a051569fd97165fe6d9b8/onnxruntime_gpu-1.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e592439b0183d303c2374517b5b392599a3d50b2dc9de949b9b15731ac921c9", size = 229142768, upload-time = "2026-05-08T19:09:54.589Z" },
-    { url = "https://files.pythonhosted.org/packages/97/91/93ffe5431d154989f5e04864a25a97eea480997d771232bcbbc538188241/onnxruntime_gpu-1.26.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56dc7b73954ff4bdc71f5b8ab306b6f61be5d007881b6ef423a609e2b9cd088b", size = 276991545, upload-time = "2026-05-08T19:16:33.347Z" },
-]
-
 [[package]]
 name = "onnxruntime-openvino"
 version = "1.24.1"