2 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
9 changed files with 434 additions and 30 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

View File

@@ -9,7 +9,7 @@ from dataclasses import dataclass, field
import numpy as np
from ..constants import LANGUAGE_CODES, models_dir
from ..constants import LANGUAGE_CODES, SAMPLE_RATE, models_dir
from .tiers import AsrSpec
log = logging.getLogger(__name__)
@@ -27,6 +27,15 @@ ALT_LANGUAGE_MAX_LOGPROB_DROP = -0.45
#: 반복 루프는 확률이 높게 나와서 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 = {
@@ -131,20 +140,15 @@ class SpeechRecognizer:
def _run(
self, audio: np.ndarray, language: str | None, fast: bool, prompt: str
) -> Transcript:
assert self._model is not None
with self._lock:
segments, info = self._model.transcribe(
audio.astype(np.float32, copy=False),
language=language,
beam_size=1 if fast else self.spec.beam_size,
temperature=0.0,
condition_on_previous_text=False,
initial_prompt=prompt or None,
vad_filter=not fast,
vad_parameters={"min_silence_duration_ms": 300},
word_timestamps=False,
)
segments = list(segments)
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)
@@ -167,6 +171,24 @@ class SpeechRecognizer:
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),
language=language,
beam_size=1 if fast else self.spec.beam_size,
temperature=0.0,
condition_on_previous_text=False,
initial_prompt=prompt or None,
vad_filter=vad,
vad_parameters={"min_silence_duration_ms": 300} if vad else None,
word_timestamps=False,
)
return list(segments), info
def _alternative_language(
probs: dict[str, float], detected: str, supported: bool
@@ -191,6 +213,15 @@ def _most_likely(candidates: list[str], probs: dict[str, float]) -> str | None:
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

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:

View File

@@ -144,3 +144,61 @@ def test_unsupported_language_falls_back_to_best_supported():
)
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() == "번역을 시작하면 움직입니다"