1 Commits

Author SHA1 Message Date
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
5 changed files with 302 additions and 14 deletions

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

@@ -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:

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() == "번역을 시작하면 움직입니다"