3 Commits

Author SHA1 Message Date
EJClaw
1f59ed0679 fix: exe 에서 자막이 하나도 안 나오던 것 (Silero VAD 모델 누락)
Some checks failed
Windows / verify (push) Has been cancelled
포터블 exe 에 faster_whisper/assets/silero_vad_v6.onnx 가 빠져 있었다.
확정 문장 인식은 vad_filter=True 라서 매번 NoSuchFile 로 실패했고,
엔진이 경고 로그만 남기고 넘어가 어떤 목소리도 자막이 되지 않았다.
소스 점검(--pipeline)은 파일이 있는 venv 에서 돌아 통과했다.

- livesub.spec: collect_data_files("faster_whisper") 로 assets 를 넣는다.
- windows_smoke --exe: exe 안에 VAD 모델·용어집이 들어 있는지 확인한다.
  test7 exe 에 돌리면 silero_vad_v6.onnx 가 빠졌다고 실패한다.

함께, 효과가 걸린 게임 목소리를 Silero 가 통째로 버리던 것도 고친다.
사용자 녹음의 "Get up! Over here!" 는 Silero 확률이 0.14 라 사라졌다.
Silero 가 구간 전체를 버렸을 때만 VAD 없이 한 번 더 받고, 잡음 환각은
창 끝까지 이어진 구간(Thank you. 29.98s), 낮은 log 확률(< -1.0),
높은 압축률로 거른다. 실제 모델(turbo·small)로 사용자 녹음 대사 3개를
모두 받고 잡음 구간 5곳은 모두 빈 결과임을 확인했다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 17:29:00 +09:00
EJClaw
d9b23dd20b feat: 홈 화면 입력 소리 게이지가 번역 중 실제로 움직이게
Some checks failed
Windows / verify (push) Has been cancelled
게이지 위젯은 있었지만 엔진 상태 이벤트(시작·정지 때만 나감)로만 값을
받아서 번역 중에는 바닥에 멈춰 있었다. 소리가 들어오는지 확인할 방법이
없었다.

- 엔진이 최근 입력 RMS를 level 로 내주고, 메인 창이 번역 중에만 약 30Hz로 읽어 그린다
- 프레임이 끊기면(프로그램이 소리를 안 냄) 레벨을 0으로 내린다
- 게이지를 dB 눈금(-60~0 dBFS)으로 그린다. 평범한 대사(-30 dBFS)가 절반을 채운다
- 빠르게 오르고 천천히 내려가며, 최근 최고점을 세로선으로 잠깐 남긴다
- '입력 소리' 라벨과 '소리 받는 중 / 소리 없음' 문구를 옆에 붙였다

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:44:33 +09:00
EJClaw
53ccbcf677 fix: 한국인 억양 영어를 한국어로 감지해 한글 음차로 적던 것
Some checks failed
Windows / verify (push) Has been cancelled
원본 언어가 '자동 감지'일 때 Whisper 는 말의 언어보다 억양을 보고 언어를
고른다. 한국어 화자가 말한 영어는 한국어로 감지되고 "스나이퍼 온 더
루프탑" 처럼 소리 나는 대로 적혀, 원문=번역 언어가 되어 번역도 건너뛰었다.
실측(한국어 TTS 가 영어를 읽은 10문장): small·turbo 모두 10/10 한국어 감지.

번역 대상 언어(또는 지원 밖 언어)로 감지된 확정 문장만 한 번 더 받아 적는다.
- 대안 언어는 영어 우선. 확률 순으로 고르면 일본어가 뽑혀 가타카나 음차가
  되고 확률도 높아 거를 수 없었다.
- 평균 log 확률이 크게 떨어지면(진짜 한국어를 영작한 경우) 버린다.
- 대안에 한글이 섞이면(small 이 언어를 못 바꾼 경우) 버린다.
- 압축률 2.4 초과(반복 환각)면 버린다.

결과: small·turbo(beam 1/2) 모두 억양 영어 10/10 영어로, 한국어 6/6 유지,
원어민 영어·무전 가공 음성은 그대로.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 02:27:41 +09:00
11 changed files with 685 additions and 29 deletions

View File

@@ -27,7 +27,7 @@
from pathlib import Path
from PyInstaller.utils.hooks import collect_dynamic_libs
from PyInstaller.utils.hooks import collect_data_files, collect_dynamic_libs
BLOCK_CIPHER = None
ROOT = Path(SPECPATH).parent # noqa: F821 - PyInstaller 가 주입
@@ -39,6 +39,11 @@ capture_exe = SRC / "livesub" / "resources" / "bin" / "livesub_capture.exe"
if capture_exe.is_file():
datas.append((str(capture_exe), "livesub/resources/bin"))
# faster-whisper 는 문장을 확정할 때 Silero VAD 모델(assets/silero_vad_v6.onnx)을
# 패키지 폴더에서 읽는다. .py 가 아닌 파일이라 PyInstaller 가 자동으로 넣지 않고,
# 빠지면 확정 문장 인식이 매번 실패해 자막이 하나도 안 나온다 (v0.3.0-test7 까지).
datas += collect_data_files("faster_whisper")
# CTranslate2 는 CUDA/cuDNN DLL 을 곁에 두고 로드한다. 자동 수집에서 빠지기 쉽다.
binaries = collect_dynamic_libs("ctranslate2")

View File

@@ -526,6 +526,21 @@ def _scratch_appdata():
shutil.rmtree(tmp, ignore_errors=True)
#: exe 안에 반드시 있어야 하는 .py 아닌 파일. 빠져도 창은 잘 뜨고 소스 점검도
#: 통과하므로, 실제로 말소리가 들어올 때가 돼서야 터진다.
EXE_REQUIRED_FILES = (
"faster_whisper/assets/silero_vad_v6.onnx", # 확정 문장 인식의 VAD
"livesub/resources/glossaries/fps-common.json",
)
def missing_bundle_files(exe: Path) -> list[str]:
from PyInstaller.archive.readers import CArchiveReader
names = {name.replace("\\", "/") for name in CArchiveReader(str(exe)).toc}
return [f for f in EXE_REQUIRED_FILES if f not in names]
def run_exe_check(exe: Path) -> None:
print(f"\n=== 빌드된 exe 점검: {exe} ===")
@@ -538,6 +553,13 @@ def run_exe_check(exe: Path) -> None:
raise RuntimeError(f"{mb:.0f}MB — 너무 큼. torch 가 섞여 들어갔는지 확인")
return f"{mb:.1f} MB"
@check("exe 에 실행 중 읽는 파일이 들어 있는지")
def _bundled_files():
missing = missing_bundle_files(exe)
if missing:
raise RuntimeError(f"빠짐: {', '.join(missing)}")
return f"{len(EXE_REQUIRED_FILES)}개 확인"
@check("exe 첫 실행 — 저장 위치 화면")
def _first_run():
# APPDATA 를 빈 폴더로 돌려 "처음 켜는 사람" 을 그대로 재현한다.

View File

@@ -73,6 +73,15 @@ class TranslationEngine:
def status(self) -> EngineStatus:
return self._status
@property
def level(self) -> float:
"""가장 최근 입력 오디오의 RMS(0~1). UI가 게이지용으로 주기적으로 읽는다.
상태 이벤트는 시작·정지 같은 때만 나가므로 게이지를 거기에 실으면
번역 중에 전혀 움직이지 않는다. 그래서 따로 읽어 가게 한다.
"""
return self._level
@property
def running(self) -> bool:
return self._status.state in (EngineState.RUNNING, EngineState.LOADING)
@@ -100,6 +109,7 @@ class TranslationEngine:
t.join(timeout=3)
self._threads = []
self._drain_segments()
self._level = 0.0
self._emit_status(EngineState.IDLE, "대기 중")
def shutdown(self) -> None:
@@ -183,6 +193,9 @@ class TranslationEngine:
break
chunk = capture.read(timeout=0.3)
if chunk is None:
# 프로그램이 소리를 안 내면 프레임 자체가 안 올 수 있다.
# 마지막 값을 들고 있으면 조용한데도 게이지가 떠 있게 된다.
self._level = 0.0
if capture.error is not None:
self._emit_status(EngineState.ERROR, str(capture.error))
return
@@ -272,6 +285,7 @@ class TranslationEngine:
language=source_lang,
fast=not segment.is_final,
prompt=self._last_final_text if segment.is_final else "",
target_lang=mcfg.target_lang,
)
asr_ms = int((time.perf_counter() - t0) * 1000)
if not transcript.text:

View File

@@ -3,16 +3,46 @@
from __future__ import annotations
import logging
import re
import threading
from dataclasses import dataclass
from dataclasses import dataclass, field
import numpy as np
from ..constants import models_dir
from ..constants import LANGUAGE_CODES, SAMPLE_RATE, models_dir
from .tiers import AsrSpec
log = logging.getLogger(__name__)
#: 번역 대상 언어로 감지됐을 때, 다른 언어로 다시 받아 적은 결과를 채택하는 기준.
#: 두 결과의 토큰당 평균 log 확률 차이(다시 받은 쪽 - 처음 쪽)가 이 값보다 커야 한다.
#:
#: 한국인 억양 영어는 Whisper 가 한국어로 감지해 "스나이퍼 온 더 루프탑" 처럼
#: 소리 나는 대로 적는다. 영어로 다시 받으면 확률이 비슷하거나 더 높게 나온다
#: (실측 차이 -0.35 ~ +0.32). 진짜 한국어를 영어로 받으면 엉뚱한 영작이 되며
#: 확률이 크게 떨어진다 (turbo 실측 -0.79 이하). 그 사이에 둔다.
ALT_LANGUAGE_MAX_LOGPROB_DROP = -0.45
#: Whisper 가 반복 환각("お客様にお客様に…")을 판정할 때 쓰는 압축률 기준과 같다.
#: 반복 루프는 확률이 높게 나와서 log 확률만으로는 걸러지지 않는다.
MAX_COMPRESSION_RATIO = 2.4
#: Silero 없이 다시 받은 결과를 믿는 최저 토큰당 평균 log 확률. Whisper 원본의
#: logprob_threshold 와 같은 값이다. 게임 잡음에서 나오는 "Oh." "you" 같은 환각은
#: -1.1 대로 나오고, 효과 걸린 실제 대사는 -0.3 ~ -0.8 로 나온다 (실측).
FALLBACK_MIN_LOGPROB = -1.0
#: 구간이 실제 오디오보다 이만큼(초) 넘게 끝나면 환각이다. 말소리가 없으면 Whisper 는
#: 타임스탬프를 못 찍고 30초 창 끝까지 이어진 "Thank you." 를 내놓는다.
FALLBACK_MAX_OVERRUN_S = 1.0
#: 다시 받은 결과에 이 글자가 섞여 있으면 모델이 언어를 바꾸지 못한 것이다.
#: (진짜 한국어를 small 모델로 '영어로' 받으면 한글을 그대로 적는다.)
_SCRIPT = {
"ko": re.compile(r"[\uac00-\ud7a3\u3131-\u318e]"),
"ja": re.compile(r"[\u3040-\u30ff]"),
}
@dataclass
class Transcript:
@@ -20,6 +50,12 @@ class Transcript:
language: str
confidence: float = 0.0
duration_s: float = 0.0
#: 토큰당 평균 log 확률. 언어 재판정에 쓴다.
avg_logprob: float = 0.0
#: 구간 중 가장 높은 압축률. 높으면 같은 말을 반복하는 환각이다.
compression_ratio: float = 0.0
#: 언어 감지를 했을 때의 언어별 확률 (지정했으면 비어 있다)
language_probs: dict[str, float] = field(default_factory=dict)
class SpeechRecognizer:
@@ -63,15 +99,82 @@ class SpeechRecognizer:
language: str | None = None,
fast: bool = False,
prompt: str = "",
target_lang: str | None = None,
) -> Transcript:
"""오디오 한 덩어리를 텍스트로.
`fast=True` 는 중간 결과용으로 beam search를 끄고 빠르게 돌린다.
`language` 가 None(자동 감지)이고 `target_lang` 을 주면 감지 결과를 한 번
더 따진다. Whisper 는 말의 언어보다 **억양**을 보고 언어를 고르는 경향이
있어서, 한국인이 말한 영어를 한국어로 감지하고 소리 나는 대로 한글로 적는다.
그러면 원문과 번역 언어가 같아져 번역도 건너뛰고, 자막에는 "에너미 커밍
프롬더 레프트" 가 뜬다. 그래서 지원 언어 밖이거나 번역 대상 언어로 감지되면
다른 지원 언어로 한 번 더 받아 적고, 그쪽이 자연스러우면 채택한다.
"""
if self._model is None:
self.load()
assert self._model is not None
first = self._run(audio, language, fast, prompt)
if language is not None or fast or not first.text:
return first
supported = first.language in LANGUAGE_CODES
if supported and first.language != target_lang:
return first
alt_lang = _alternative_language(first.language_probs, first.language, supported)
if alt_lang is None:
return first
alt = self._run(audio, alt_lang, fast, prompt)
if not alt.text or alt.compression_ratio > MAX_COMPRESSION_RATIO:
return first
# 지원하지 않는 언어로는 어차피 번역할 수 없으므로 그때는 더 따지지 않는다.
if supported and not _accept_alternative(first, alt, first.language):
return first
log.debug("언어 재판정: %s -> %s (%r)", first.language, alt.language, alt.text)
alt.language_probs = first.language_probs
return alt
def _run(
self, audio: np.ndarray, language: str | None, fast: bool, prompt: str
) -> Transcript:
segments, info = self._decode(audio, language, fast, prompt, vad=not fast)
if not fast and not any(s.text.strip() for s in segments):
# Silero VAD 가 구간을 통째로 버렸다. 효과가 걸린 게임 목소리("Get up!
# Over here!")는 Silero 확률이 0.1 대로 나와서 여기서 사라진다. 이 구간은
# 이미 우리 분할기가 말소리로 본 것이므로 VAD 없이 한 번 더 받되, 잡음에서
# 나오는 환각("Thank you.")은 `_plausible` 로 거른다.
segments, info = self._decode(audio, language, fast, prompt, vad=False)
duration = audio.size / SAMPLE_RATE
segments = [s for s in segments if _plausible(s, duration)]
text = " ".join(s.text.strip() for s in segments if s.text.strip()).strip()
tokens = sum(len(getattr(s, "tokens", ()) or ()) for s in segments)
logprob = (
sum(s.avg_logprob * len(getattr(s, "tokens", ()) or ()) for s in segments) / tokens
if tokens
else 0.0
)
probs = getattr(info, "all_language_probs", None) or []
return Transcript(
text=text,
language=getattr(info, "language", language or "") or "",
confidence=float(getattr(info, "language_probability", 0.0) or 0.0),
duration_s=float(getattr(info, "duration", 0.0) or 0.0),
avg_logprob=float(logprob),
compression_ratio=max(
(float(getattr(s, "compression_ratio", 0.0) or 0.0) for s in segments),
default=0.0,
),
language_probs={str(k): float(v) for k, v in probs},
)
def _decode(
self, audio: np.ndarray, language: str | None, fast: bool, prompt: str, vad: bool
) -> tuple[list, object]:
assert self._model is not None
with self._lock:
segments, info = self._model.transcribe(
audio.astype(np.float32, copy=False),
@@ -80,16 +183,49 @@ class SpeechRecognizer:
temperature=0.0,
condition_on_previous_text=False,
initial_prompt=prompt or None,
vad_filter=not fast,
vad_parameters={"min_silence_duration_ms": 300},
vad_filter=vad,
vad_parameters={"min_silence_duration_ms": 300} if vad else None,
word_timestamps=False,
)
parts = [s.text for s in segments]
return list(segments), info
text = " ".join(p.strip() for p in parts if p.strip()).strip()
return Transcript(
text=text,
language=getattr(info, "language", language or "") or "",
confidence=float(getattr(info, "language_probability", 0.0) or 0.0),
duration_s=float(getattr(info, "duration", 0.0) or 0.0),
)
def _alternative_language(
probs: dict[str, float], detected: str, supported: bool
) -> str | None:
"""다시 받아 적을 언어 하나.
번역 대상 언어로 잘못 감지된 경우는 거의 다 억양 섞인 영어라서 영어를 먼저
본다. 감지 확률 순으로 고르면 안 된다 — 한국인 억양 영어에 Whisper 는 영어보다
일본어를 높게 치기도 하는데, 일본어로 받으면 "スナイパーオン・ド・ループトップ"
처럼 가타카나로 소리를 적고 확률도 높게 나와 걸러낼 방법이 없다.
지원하지 않는 언어로 감지됐을 때(광둥어 등)는 지원 언어 중 확률이 가장 높은 쪽.
"""
candidates = [c for c in LANGUAGE_CODES if c != detected]
if supported:
return "en" if "en" in candidates else _most_likely(candidates, probs)
return _most_likely(candidates, probs)
def _most_likely(candidates: list[str], probs: dict[str, float]) -> str | None:
known = [c for c in candidates if c in probs]
return max(known, key=lambda c: probs[c]) if known else None
def _plausible(segment, duration_s: float) -> bool:
"""Silero 없이 받은 구간이 실제 말소리를 받아 적은 것으로 보이는가."""
if float(getattr(segment, "end", 0.0) or 0.0) > duration_s + FALLBACK_MAX_OVERRUN_S:
return False
if float(getattr(segment, "compression_ratio", 0.0) or 0.0) > MAX_COMPRESSION_RATIO:
return False
return float(getattr(segment, "avg_logprob", 0.0)) >= FALLBACK_MIN_LOGPROB
def _accept_alternative(first: Transcript, alt: Transcript, avoided: str) -> bool:
if not alt.text:
return False
script = _SCRIPT.get(avoided)
if script is not None and script.search(alt.text):
return False
return alt.avg_logprob - first.avg_logprob > ALT_LANGUAGE_MAX_LOGPROB_DROP

View File

@@ -73,6 +73,14 @@ class MainWindow(QMainWindow):
self._save_timer.setInterval(800) # 입력 중 계속 쓰지 않도록 묶어서 저장
self._save_timer.timeout.connect(lambda: self.config.save())
# 입력 게이지는 상태 이벤트가 아니라 타이머로 엔진 값을 읽어 그린다.
# 상태 이벤트는 시작·정지 때만 나가서 번역 중에는 게이지가 멈춰 있었다.
self._level_timer = QTimer(self)
self._level_timer.setInterval(33) # 약 30Hz
self._level_timer.timeout.connect(
lambda: self.home_page.set_input_level(self.engine.level)
)
# --- UI -------------------------------------------------------------
def _build_ui(self) -> None:
self.setStyleSheet(stylesheet(self.config.theme))
@@ -257,6 +265,10 @@ class MainWindow(QMainWindow):
def _on_status(self, status: EngineStatus) -> None:
self.home_page.on_status(status)
if status.state is EngineState.RUNNING:
self._level_timer.start()
else:
self._level_timer.stop()
if status.state is EngineState.ERROR:
QMessageBox.warning(self, "오류", status.message)

View File

@@ -25,6 +25,7 @@ from ...constants import LANGUAGES
from ...core.events import EngineState, EngineStatus, TranslationLine
from ..theme import SPACING, palette
from ..widgets import Card, LevelMeter, PageHeader, StatusPill
from ..widgets.common import METER_AUDIBLE_DB, level_to_db
MAX_LOG_ROWS = 300
@@ -157,10 +158,49 @@ class HomePage(QWidget):
layout.addWidget(self.toggle_button)
card.add(row)
self.level_meter = LevelMeter()
card.add(self.level_meter)
card.add(self._build_level_row())
return card
def _build_level_row(self) -> QWidget:
"""소리를 제대로 받고 있는지 보여주는 입력 게이지."""
row = QWidget()
layout = QHBoxLayout(row)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(12)
layout.addWidget(QLabel("입력 소리"))
self.level_meter = LevelMeter()
self.level_meter.setToolTip(
"선택한 프로그램(또는 마이크)에서 받고 있는 소리 크기입니다.\n"
"말소리가 나는데 게이지가 안 움직이면 '소리 받아올 곳'을 다시 고르세요."
)
layout.addWidget(self.level_meter, 1)
self.level_label = QLabel()
self.level_label.setObjectName("Hint")
self.level_label.setMinimumWidth(150)
layout.addWidget(self.level_label)
self._quiet_ticks = 0
self._set_level_text("번역을 시작하면 움직입니다")
return row
def _set_level_text(self, text: str) -> None:
if self.level_label.text() != text:
self.level_label.setText(text)
#: '소리 없음'으로 바꾸기 전에 기다리는 갱신 횟수 (약 30Hz 기준 1.5초).
#: 말 사이 짧은 숨까지 '소리 없음'으로 깜빡이지 않게 한다.
QUIET_TICKS = 45
def set_input_level(self, rms: float) -> None:
"""번역 중 주기적으로 불린다. 게이지와 옆 문구를 갱신한다."""
self.level_meter.set_level(rms)
if level_to_db(rms) >= METER_AUDIBLE_DB:
self._quiet_ticks = 0
self._set_level_text("소리 받는 중")
return
self._quiet_ticks += 1
if self._quiet_ticks >= self.QUIET_TICKS:
self._set_level_text("소리 없음")
def _build_log_card(self) -> Card:
card = Card("최근 자막", "확정된 문장이 위로 쌓입니다. 지연 시간도 함께 보여줍니다.")
self.log_list = QListWidget()
@@ -275,7 +315,14 @@ class HomePage(QWidget):
EngineState.ERROR: "error",
}.get(status.state, "idle")
self.status_pill.set_status(status.message or status.state.value, kind)
self.level_meter.set_level(status.level)
if status.state is not EngineState.RUNNING:
self.level_meter.reset()
self._quiet_ticks = 0
self._set_level_text(
"모델 준비 중…"
if status.state is EngineState.LOADING
else "번역을 시작하면 움직입니다"
)
for widget in (
self.source_combo,

View File

@@ -2,6 +2,8 @@
from __future__ import annotations
import math
from PySide6.QtCore import Qt
from PySide6.QtGui import QColor, QPainter
from PySide6.QtWidgets import (
@@ -98,20 +100,68 @@ class StatusPill(QLabel):
)
#: 게이지 왼쪽 끝(dBFS). 이보다 작은 소리는 바닥으로 본다.
METER_FLOOR_DB = -60.0
#: 이 이상이면 '소리 들림'. 게임 배경음·대사는 보통 -40 ~ -15 dBFS 사이다.
METER_AUDIBLE_DB = -50.0
def level_to_db(rms: float) -> float:
"""RMS(0~1)를 dBFS로. 0이면 바닥값."""
if rms <= 0.0:
return METER_FLOOR_DB
return max(METER_FLOOR_DB, min(0.0, 20.0 * math.log10(rms)))
def level_to_fraction(rms: float) -> float:
"""RMS를 게이지 채움 비율(0~1)로.
소리 크기는 로그로 느끼므로 dB로 펴서 그린다. RMS를 그대로 그리면
평범한 게임 대사(-30 dBFS ≈ 0.03)가 게이지의 3%밖에 안 차서 멈춘 것처럼 보인다.
"""
return (level_to_db(rms) - METER_FLOOR_DB) / -METER_FLOOR_DB
class LevelMeter(QWidget):
"""입력 오디오 레벨 바. 소리가 잡히는지 한눈에 확인하는 용도."""
"""입력 오디오 레벨 바. 소리가 잡히는지 한눈에 확인하는 용도.
올라갈 때는 바로, 내려갈 때는 천천히 따라가서 말소리에 맞춰 출렁인다.
최근 최고점은 얇은 세로선으로 잠깐 남겨 둔다.
"""
#: set_level 한 번마다 내려가는 양 (약 30Hz 갱신 기준 0.5초에 바닥)
RELEASE_STEP = 0.06
#: 최고점 표시를 붙잡아 두는 갱신 횟수
PEAK_HOLD_TICKS = 25
def __init__(self, parent: QWidget | None = None):
super().__init__(parent)
self._level = 0.0
self._peak = 0.0
self.setFixedHeight(8)
self._peak_ticks = 0
self.setFixedHeight(12)
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
def set_level(self, value: float) -> None:
# RMS를 그대로 그리면 거의 안 움직여서 제곱근으로 펴준다.
self._level = min(1.0, max(0.0, value) ** 0.5 * 2.2)
self._peak = max(self._level, self._peak * 0.92)
@property
def level(self) -> float:
"""지금 그려진 채움 비율(0~1)."""
return self._level
def set_level(self, rms: float) -> None:
target = level_to_fraction(rms)
self._level = max(target, self._level - self.RELEASE_STEP)
if self._level >= self._peak:
self._peak = self._level
self._peak_ticks = self.PEAK_HOLD_TICKS
elif self._peak_ticks > 0:
self._peak_ticks -= 1
else:
self._peak = max(self._level, self._peak - self.RELEASE_STEP / 2)
self.update()
def reset(self) -> None:
self._level = self._peak = 0.0
self._peak_ticks = 0
self.update()
def paintEvent(self, event) -> None: # noqa: N802
@@ -120,12 +170,22 @@ class LevelMeter(QWidget):
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.setPen(Qt.PenStyle.NoPen)
painter.setBrush(QColor(p.surface_alt))
painter.drawRoundedRect(self.rect(), 4, 4)
painter.drawRoundedRect(self.rect(), 5, 5)
width = self.width()
if self._level > 0.01:
color = QColor(p.danger if self._level > 0.92 else p.success)
rect = self.rect().adjusted(0, 0, -int(self.width() * (1 - self._level)), 0)
painter.setBrush(color)
painter.drawRoundedRect(rect, 4, 4)
# 0 dBFS 근처면 소리가 찌그러질 만큼 크다는 뜻이라 색으로 알려준다.
if self._level > 0.95:
color = p.danger
elif self._level > 0.85:
color = p.warning
else:
color = p.success
painter.setBrush(QColor(color))
painter.drawRoundedRect(0, 0, max(6, int(width * self._level)), self.height(), 5, 5)
if self._peak > 0.02:
x = min(width - 2, int(width * self._peak))
painter.setBrush(QColor(p.text))
painter.drawRect(x, 1, 2, self.height() - 2)
def labelled_row(label: str, widget: QWidget) -> QWidget:

204
tests/test_asr_language.py Normal file
View File

@@ -0,0 +1,204 @@
"""억양 때문에 언어를 잘못 감지했을 때 다시 받아 적는지 (모델 없이 가짜로)."""
from __future__ import annotations
from types import SimpleNamespace
import numpy as np
from livesub.models.asr import SpeechRecognizer
from livesub.models.tiers import AsrSpec
AUDIO = np.zeros(16_000, dtype=np.float32)
def seg(text: str, logprob: float, tokens: int = 10):
return SimpleNamespace(text=text, avg_logprob=logprob, tokens=list(range(tokens)))
class FakeWhisper:
"""언어별로 정해 둔 결과를 돌려준다. language=None 이면 `detected` 로 감지한 척."""
def __init__(
self,
detected: str,
probs: dict[str, float],
results: dict[str, tuple],
ratios: dict[str, float] | None = None,
):
self.ratios = ratios or {}
self.detected = detected
self.probs = probs
self.results = results
self.calls: list[str | None] = []
def transcribe(self, audio, language=None, **_):
self.calls.append(language)
lang = language or self.detected
text, logprob = self.results.get(lang, ("", 0.0))
info = SimpleNamespace(
language=lang,
language_probability=self.probs.get(lang, 1.0),
duration=1.0,
all_language_probs=list(self.probs.items()) if language is None else None,
)
segment = seg(text, logprob)
segment.compression_ratio = self.ratios.get(lang, 1.2)
return iter([segment]), info
def recognizer(fake: FakeWhisper) -> SpeechRecognizer:
rec = SpeechRecognizer(AsrSpec("fake", "int8", 1, 0), device="cpu")
rec._model = fake
return rec
# 실제 측정값을 그대로 옮겼다 (large-v3-turbo, 한국어 TTS 음성이 영어를 읽음).
ACCENTED = FakeWhisper(
"ko",
{"ko": 0.97, "en": 0.02, "ja": 0.005},
{"ko": ("스나이퍼 온 더 루프타프, 노스 사이드.", -0.252),
"en": ("Sniper on the rooftop North side.", -0.487)},
)
def test_korean_accented_english_is_rewritten_in_english():
t = recognizer(ACCENTED).transcribe(AUDIO, target_lang="ko")
assert t.language == "en"
assert t.text == "Sniper on the rooftop North side."
def test_english_is_tried_even_when_japanese_scores_higher():
"""small 모델 실측: 일본어 확률이 영어보다 높지만 일본어로 받으면 가타카나 음차가 된다."""
fake = FakeWhisper(
"ko",
{"ko": 0.77, "ja": 0.13, "en": 0.07, "zh": 0.01},
{"ko": ("스나이퍼 온 더 루프탑, 노스 사이드.", -0.505),
"ja": ("スナイフォンとループタップ、ノスサイド。", -0.509),
"en": ("Sniper on the rooftop, Northside.", -0.363)},
)
t = recognizer(fake).transcribe(AUDIO, target_lang="ko")
assert (t.language, t.text) == ("en", "Sniper on the rooftop, Northside.")
assert fake.calls == [None, "en"] # 다시 받는 건 한 번뿐
def test_repetition_loop_is_rejected():
"""반복 환각은 확률이 높게 나와서 압축률로 거른다."""
fake = FakeWhisper(
"nn",
{"nn": 0.6, "en": 0.3},
{"nn": ("hmm", -0.9), "en": ("the the the the the the the the the the the the", -0.1)},
ratios={"en": 9.0},
)
t = recognizer(fake).transcribe(AUDIO, target_lang="ko")
assert t.text == "hmm"
def test_real_korean_stays_korean():
"""진짜 한국어를 영어로 받으면 엉뚱한 영작이 되고 확률이 크게 떨어진다."""
fake = FakeWhisper(
"ko",
{"ko": 1.0, "en": 0.0},
{"ko": ("잘했어 다음 판도 가자.", -0.284), "en": ("Well done, next time.", -1.074)},
)
t = recognizer(fake).transcribe(AUDIO, target_lang="ko")
assert (t.language, t.text) == ("ko", "잘했어 다음 판도 가자.")
def test_alternative_still_in_hangul_is_rejected():
"""작은 모델은 '영어로' 받으라 해도 진짜 한국어를 한글로 그대로 적는다."""
fake = FakeWhisper(
"ko",
{"ko": 0.99, "en": 0.0},
{"ko": ("잘했어 다음 판도 가자", -0.40), "en": ("잘했어 다음 판도 가자", -0.44)},
)
t = recognizer(fake).transcribe(AUDIO, target_lang="ko")
assert t.language == "ko"
def test_no_second_pass_when_language_differs_from_target():
fake = FakeWhisper("en", {"en": 0.99, "ko": 0.01}, {"en": ("Fall back now.", -0.2)})
t = recognizer(fake).transcribe(AUDIO, target_lang="ko")
assert t.language == "en"
assert fake.calls == [None]
def test_fixed_source_language_is_never_second_guessed():
fake = FakeWhisper("ko", {}, {"ko": ("안녕", -0.1)})
recognizer(fake).transcribe(AUDIO, language="ko", target_lang="ko")
assert fake.calls == ["ko"]
def test_partial_results_skip_the_second_pass():
"""중간 결과는 빨라야 한다. 확정 문장에서만 다시 따진다."""
recognizer(ACCENTED).transcribe(AUDIO, fast=True, target_lang="ko")
assert ACCENTED.calls[-1] is None
def test_unsupported_language_falls_back_to_best_supported():
"""지원 언어가 아니면 번역을 못 하므로 지원 언어 중 가장 그럴듯한 쪽으로."""
fake = FakeWhisper(
"nn",
{"nn": 0.5, "en": 0.3, "ko": 0.1},
{"nn": ("Nice skot", -0.9), "en": ("Nice shot", -0.5)},
)
t = recognizer(fake).transcribe(AUDIO, target_lang="ko")
assert (t.language, t.text) == ("en", "Nice shot")
class SileroDropsWhisper:
"""Silero VAD 를 켜면 아무것도 못 받고, 끄면 정해 둔 구간을 돌려준다."""
def __init__(self, segments):
self.segments = segments
self.vad_calls: list[bool] = []
def transcribe(self, audio, language=None, vad_filter=False, **_):
self.vad_calls.append(vad_filter)
info = SimpleNamespace(
language="en", language_probability=0.9, duration=audio.size / 16_000,
all_language_probs=[("en", 0.9)],
)
return iter([] if vad_filter else self.segments), info
def raw(text: str, end: float, logprob: float, ratio: float = 1.0):
s = seg(text, logprob)
s.end = end
s.compression_ratio = ratio
return s
# 실측값 (large-v3-turbo, 사용자 게임 녹음 5.2초 구간). Silero 확률이 0.14 라 통째로 버려졌다.
EFFECT_VOICE = [raw(" Get up!", 2.0, -0.73), raw(" Over here!", 4.0, -0.73)]
FIVE_SECONDS = np.zeros(5 * 16_000, dtype=np.float32)
def test_voice_dropped_by_silero_is_recovered_without_vad():
fake = SileroDropsWhisper(EFFECT_VOICE)
t = recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko")
assert t.text == "Get up! Over here!"
assert fake.vad_calls == [True, False]
def test_noise_hallucination_running_to_window_end_is_dropped():
"""말소리가 없으면 30초 창 끝까지 이어진 'Thank you.' 가 나온다 (turbo 실측)."""
fake = SileroDropsWhisper([raw(" Thank you.", 29.98, -0.77)])
assert recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko").text == ""
def test_low_confidence_noise_word_is_dropped():
fake = SileroDropsWhisper([raw(" Oh.", 0.5, -1.12)])
assert recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko").text == ""
def test_repetition_without_vad_is_dropped():
fake = SileroDropsWhisper([raw(" විවිවිවිවිවිවිවි", 3.8, -0.26, ratio=6.0)])
assert recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko").text == ""
def test_partial_results_never_retry():
"""중간 결과는 원래 VAD 없이 한 번만 받는다."""
fake = SileroDropsWhisper(EFFECT_VOICE)
recognizer(fake).transcribe(FIVE_SECONDS, fast=True, target_lang="ko")
assert fake.vad_calls == [False]

156
tests/test_level_meter.py Normal file
View File

@@ -0,0 +1,156 @@
"""홈 화면 입력 소리 게이지 — 엔진이 레벨을 내주고, UI가 번역 중 계속 그리는지."""
from __future__ import annotations
import os
import time
import numpy as np
import pytest
from livesub.audio.base import CaptureBackend
from livesub.config import AppConfig
from livesub.constants import SAMPLE_RATE
from livesub.core.engine import TranslationEngine
pytest.importorskip("PySide6")
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6.QtWidgets import QApplication # noqa: E402
from livesub.core.events import EngineState, EngineStatus # noqa: E402
from livesub.ui.main_window import MainWindow # noqa: E402
from livesub.ui.widgets.common import LevelMeter, level_to_fraction # noqa: E402
class BurstCapture(CaptureBackend):
"""0.6초 동안 소리를 내고 그 뒤로는 프레임을 아예 보내지 않는다.
프로그램이 소리를 멈추면 프로그램별 캡처는 프레임이 끊길 수 있다.
"""
name = "burst"
@staticmethod
def available() -> bool:
return True
@staticmethod
def list_sources():
return []
def _run(self) -> None:
n = SAMPLE_RATE // 50 # 20ms
t = np.arange(n, dtype=np.float32) / SAMPLE_RATE
frame = (np.sin(2 * np.pi * 300 * t) * 0.3).astype(np.float32)
for _ in range(30):
if self._stop.is_set():
return
self._emit(frame.copy())
time.sleep(0.02)
self._stop.wait()
@pytest.fixture
def engine(tmp_path, monkeypatch):
config = AppConfig()
config.models.preload_on_start = False
config.glossary.path = str(tmp_path / "glossary.json")
eng = TranslationEngine(config)
monkeypatch.setattr("livesub.core.engine.create_capture", lambda cfg: BurstCapture())
yield eng
eng.shutdown()
def _wait_for(cond, timeout=3.0) -> bool:
deadline = time.time() + timeout
while time.time() < deadline:
if cond():
return True
time.sleep(0.02)
return False
def test_engine_level_follows_audio_and_drops_when_frames_stop(engine):
assert engine.level == 0.0
engine.start()
# 진폭 0.3 사인파의 RMS ≈ 0.21
assert _wait_for(lambda: engine.level > 0.15), "소리가 나는데 레벨이 오르지 않았습니다"
assert _wait_for(lambda: engine.level == 0.0), "프레임이 끊겼는데 레벨이 남아 있습니다"
engine.stop()
assert engine.level == 0.0
def test_engine_level_resets_on_stop(engine):
engine.start()
assert _wait_for(lambda: engine.level > 0.15)
engine.stop()
assert engine.level == 0.0
def test_level_to_fraction_uses_db_scale():
assert level_to_fraction(0.0) == 0.0
assert level_to_fraction(1.0) == pytest.approx(1.0)
# 평범한 게임 대사 크기(-30 dBFS)가 게이지 절반을 채워야 눈에 띈다.
assert level_to_fraction(10 ** (-30 / 20)) == pytest.approx(0.5)
assert level_to_fraction(1e-6) == 0.0 # 바닥 아래는 0
@pytest.fixture(scope="module")
def qapp():
return QApplication.instance() or QApplication([])
def test_meter_jumps_up_and_falls_back_slowly(qapp):
meter = LevelMeter()
meter.set_level(0.1)
high = meter.level
assert high == pytest.approx(level_to_fraction(0.1))
meter.set_level(0.0)
assert 0.0 < meter.level < high # 바로 떨어지지 않고 서서히
for _ in range(40):
meter.set_level(0.0)
assert meter.level == 0.0
@pytest.fixture
def window(qapp, tmp_path, monkeypatch):
monkeypatch.setattr("livesub.constants.user_data_dir", lambda: tmp_path)
config = AppConfig()
config.models.preload_on_start = False
config.glossary.path = str(tmp_path / "glossary.json")
win = MainWindow(config)
yield win
win.engine.shutdown()
win.overlay.close()
win.close()
def test_gauge_is_polled_only_while_running(window):
assert not window._level_timer.isActive()
window._on_status(EngineStatus(EngineState.RUNNING, "듣는 중"))
assert window._level_timer.isActive()
window._on_status(EngineStatus(EngineState.IDLE, "대기 중"))
assert not window._level_timer.isActive()
def test_timer_tick_moves_gauge_and_label(window, monkeypatch):
home = window.home_page
window._on_status(EngineStatus(EngineState.RUNNING, "듣는 중"))
monkeypatch.setattr(window.engine, "_level", 0.05)
window._level_timer.timeout.emit()
assert home.level_meter.level > 0.5
assert home.level_label.text() == "소리 받는 중"
# 말 사이 짧은 숨에는 문구가 바뀌지 않는다.
monkeypatch.setattr(window.engine, "_level", 0.0)
for _ in range(5):
window._level_timer.timeout.emit()
assert home.level_label.text() == "소리 받는 중"
for _ in range(home.QUIET_TICKS):
window._level_timer.timeout.emit()
assert home.level_label.text() == "소리 없음"
window._on_status(EngineStatus(EngineState.IDLE, "대기 중"))
assert home.level_meter.level == 0.0
assert home.level_label.text() == "번역을 시작하면 움직입니다"

View File

@@ -55,7 +55,7 @@ class FakeRecognizer:
def unload(self):
pass
def transcribe(self, audio, language=None, fast=False, prompt=""):
def transcribe(self, audio, language=None, fast=False, prompt="", target_lang=None):
return Transcript(text="hello world", language="en", confidence=0.99)

View File

@@ -194,7 +194,7 @@ def _run(monkeypatch, tmp_path, level: str, source_text: str, source_lang: str)
translator = _PoliteTranslator()
class Recognizer:
def transcribe(self, audio, language=None, fast=False, prompt=""):
def transcribe(self, audio, language=None, fast=False, prompt="", target_lang=None):
return Transcript(text=source_text, language=source_lang)
lines = []