Compare commits
9 Commits
v0.3.0-tes
...
v0.3.0-tes
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
42a38eb938 | ||
|
|
c2e600fa3d | ||
|
|
176e06c4bd | ||
|
|
bd24063c15 | ||
|
|
1f59ed0679 | ||
|
|
d9b23dd20b | ||
|
|
53ccbcf677 | ||
|
|
1dde1b2aaa | ||
|
|
0201c7b913 |
@@ -25,12 +25,14 @@
|
||||
## 주요 기능
|
||||
|
||||
- **프로그램 단위 소리 캡처** — 게임 소리만 받고 디스코드 음성은 안 받습니다
|
||||
- **마이크 입력도 가능** — 홈 화면에서 목록을 입력 장치로 바꾸면 통화 상대나 내 목소리를 번역합니다
|
||||
- **게임과 같이 써도 안 무겁게** — GPU를 얼마나 양보할지 직접 정합니다 (아래 참고)
|
||||
- **디스코드식 자막 배치** — 모니터를 고르고 9칸 중 하나를 누르면 그 자리에 붙습니다
|
||||
- **평소엔 잠겨 있는 자막** — 게임 중에 실수로 끌려가지 않습니다. `자막 위치 조정`을 켜면 옮기고 모서리로 크기를 바꿀 수 있고, 크기에 맞춰 글자도 같이 커집니다
|
||||
- **전역 단축키** — 게임 중에 `Ctrl+Alt+S` 로 자막을 껐다 켭니다
|
||||
- **게임별 기본 용어집 내장** — 옵치2·워독스·배그·R6·롤·발로란트·에이펙스 등 **540개** (필수 게임은 기본 켜짐)
|
||||
- **5단계 품질 선택** — 속도 우선(0.6초)부터 품질 우선까지
|
||||
- **자막 자유 설정** — 글꼴·크기·색·외곽선·투명도·줄 수
|
||||
- **5단계 품질 선택** — 속도 우선(0.6초)부터 품질 우선까지. GPU가 없으면 CPU에서 실제로 돌아가는 티어를 추천합니다
|
||||
- **자막 자유 설정** — 글꼴·크기·색·외곽선·투명도·줄 수·배경 여백 (배경은 글자를 감싸는 크기로 그려집니다)
|
||||
- **추가학습** — 게임/방송 말투로 번역 모델을 LoRA 학습시킬 수 있습니다
|
||||
- **존댓말 / 반말 선택** — 기본은 존댓말. 원문이 실제로 존댓말이면 반말 모드여도 존댓말을 지킵니다
|
||||
- **포터블 exe** — 설치 없이 파일 하나로 실행 (아래 참고)
|
||||
|
||||
@@ -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")
|
||||
|
||||
|
||||
@@ -130,6 +130,23 @@ def run_source_checks() -> None:
|
||||
raise RuntimeError(gpu.reason)
|
||||
return f"{gpu.name} · {gpu.total_vram_mb / 1024:.1f}GB"
|
||||
|
||||
# CTranslate2 는 GPU 계산 때 cublas64_12.dll 을 이름으로 불러오는데, 포터블
|
||||
# 빌드에는 이 파일이 없다 (v0.3.0-test8 까지 GPU 에서 자막이 안 나온 원인).
|
||||
# 앱이 처음 GPU 를 쓸 때 받아 두는 경로가 실제로 받고 불러오는지 본다.
|
||||
# GPU 가 없어도 DLL 은 올라간다. 한 번 받으면 다음부터는 캐시를 쓴다.
|
||||
@check("GPU 계산 파일(cuBLAS) 받기·불러오기")
|
||||
def _cublas():
|
||||
import ctypes
|
||||
|
||||
from livesub.models import cuda_runtime
|
||||
|
||||
if not cuda_runtime.ensure(device="cuda"):
|
||||
raise RuntimeError("Windows 인데 준비를 건너뛰었습니다")
|
||||
ctypes.WinDLL("cublas64_12.dll") # CTranslate2 처럼 이름만으로 찾아지는지
|
||||
import ctranslate2 # noqa: F401 - 미리 올린 DLL 과 같이 올라가는지
|
||||
|
||||
return str(cuda_runtime.runtime_dir())
|
||||
|
||||
@check("사용 가능한 모델 티어")
|
||||
def _tiers():
|
||||
from livesub.models.manager import has_torch, tier_availability
|
||||
@@ -526,6 +543,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 +570,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 를 빈 폴더로 돌려 "처음 켜는 사람" 을 그대로 재현한다.
|
||||
|
||||
@@ -9,6 +9,7 @@ from pathlib import Path
|
||||
|
||||
from .config import AppConfig
|
||||
from .constants import APP_NAME, ORG_NAME, user_data_dir
|
||||
from .log_buffer import BUFFER, BufferHandler
|
||||
|
||||
|
||||
def setup_logging(verbose: bool = False, to_file: bool = True) -> None:
|
||||
@@ -18,7 +19,12 @@ def setup_logging(verbose: bool = False, to_file: bool = True) -> None:
|
||||
핸들러를 열면 사용자가 고르지도 않은 기본 폴더가 만들어지고 로그가
|
||||
거기에 남는다.
|
||||
"""
|
||||
handlers: list[logging.Handler] = [logging.StreamHandler(sys.stderr)]
|
||||
# 버퍼는 저장 위치와 상관없이 처음부터 붙인다. 저장 위치를 고르기 전의
|
||||
# 로그도 '로그' 화면에서 보여야 한다. 다시 불려도 같은 버퍼에 이어 쌓인다.
|
||||
handlers: list[logging.Handler] = [
|
||||
logging.StreamHandler(sys.stderr),
|
||||
BufferHandler(BUFFER),
|
||||
]
|
||||
if to_file:
|
||||
with contextlib.suppress(OSError):
|
||||
handlers.append(
|
||||
|
||||
@@ -7,17 +7,25 @@ import logging
|
||||
from ..config import AudioConfig
|
||||
from .base import AudioSource, CaptureBackend, CaptureError
|
||||
from .file_source import FileCapture
|
||||
from .input_device import InputDeviceCapture
|
||||
from .process_loopback import ProcessLoopbackCapture
|
||||
from .segmenter import Segment, Segmenter, SegmenterConfig
|
||||
from .wasapi_loopback import WasapiLoopbackCapture
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
#: 홈 화면 목록이 무엇을 보여줄지.
|
||||
SOURCE_MODE_OUTPUT = "output" # 게임 등 프로그램 소리 + 출력 장치
|
||||
SOURCE_MODE_INPUT = "input" # 마이크 등 입력 장치
|
||||
|
||||
__all__ = [
|
||||
"SOURCE_MODE_INPUT",
|
||||
"SOURCE_MODE_OUTPUT",
|
||||
"AudioSource",
|
||||
"CaptureBackend",
|
||||
"CaptureError",
|
||||
"FileCapture",
|
||||
"InputDeviceCapture",
|
||||
"ProcessLoopbackCapture",
|
||||
"Segment",
|
||||
"Segmenter",
|
||||
@@ -34,12 +42,20 @@ def capture_capabilities() -> dict[str, bool]:
|
||||
return {
|
||||
"process": ProcessLoopbackCapture.available(),
|
||||
"device": WasapiLoopbackCapture.available(),
|
||||
"input": InputDeviceCapture.available(),
|
||||
"file": True,
|
||||
}
|
||||
|
||||
|
||||
def list_sources() -> list[AudioSource]:
|
||||
"""프로그램 + 출력 장치를 한 목록으로."""
|
||||
def list_sources(mode: str = SOURCE_MODE_OUTPUT) -> list[AudioSource]:
|
||||
"""고른 쪽의 캡처 대상 목록.
|
||||
|
||||
출력(게임 소리)과 입력(마이크)을 한 목록에 섞으면 수십 줄이 되고, 정작
|
||||
찾으려던 게임이 마이크·라인입력 사이에 파묻힌다. 그래서 한 번에 한 쪽만
|
||||
보여주고 홈 화면에서 전환한다.
|
||||
"""
|
||||
if mode == SOURCE_MODE_INPUT:
|
||||
return InputDeviceCapture.list_sources()
|
||||
sources: list[AudioSource] = []
|
||||
if ProcessLoopbackCapture.available():
|
||||
sources.extend(ProcessLoopbackCapture.list_sources())
|
||||
@@ -53,6 +69,13 @@ def create_capture(config: AudioConfig) -> CaptureBackend:
|
||||
if backend == "file":
|
||||
return FileCapture(config.target_process_name)
|
||||
|
||||
if backend == "input":
|
||||
if not InputDeviceCapture.available():
|
||||
raise CaptureError(
|
||||
"입력 장치를 열 수 없습니다. Windows에서 PyAudioWPatch 설치 여부를 확인하세요."
|
||||
)
|
||||
return InputDeviceCapture(config.device_index)
|
||||
|
||||
want_process = backend in ("process", "auto") and config.target_pid > 0
|
||||
if want_process:
|
||||
if ProcessLoopbackCapture.available():
|
||||
|
||||
@@ -20,7 +20,8 @@ from ..constants import SAMPLE_RATE
|
||||
class AudioSource:
|
||||
"""UI에 노출되는 캡처 대상 한 줄."""
|
||||
|
||||
kind: str # "process" | "device"
|
||||
#: "process"=특정 프로그램 소리 · "device"=출력 장치 루프백 · "input"=마이크 등 입력 장치
|
||||
kind: str
|
||||
identifier: str # pid 문자열 또는 장치 인덱스
|
||||
label: str
|
||||
detail: str = ""
|
||||
@@ -32,7 +33,7 @@ class AudioSource:
|
||||
|
||||
@property
|
||||
def device_index(self) -> int:
|
||||
return int(self.identifier) if self.kind == "device" else -1
|
||||
return int(self.identifier) if self.kind in ("device", "input") else -1
|
||||
|
||||
|
||||
class CaptureError(RuntimeError):
|
||||
|
||||
106
src/livesub/audio/input_device.py
Normal file
106
src/livesub/audio/input_device.py
Normal file
@@ -0,0 +1,106 @@
|
||||
"""마이크 등 입력 장치 캡처 (Windows).
|
||||
|
||||
루프백(=스피커로 나가는 소리)이 아니라 **들어오는 소리**를 받는다. 통화나
|
||||
합주처럼 상대 목소리가 내 스피커로 나오지 않는 상황, 또는 내가 말하는 것을
|
||||
그대로 번역해 보고 싶을 때 쓴다.
|
||||
|
||||
WasapiLoopbackCapture 와 스트림을 여는 모양이 비슷하지만 합치지 않았다.
|
||||
장치 목록을 만드는 방법(루프백 전용 열거 vs 일반 입력 장치)과 기본 장치를
|
||||
고르는 방법이 서로 달라서, 한 클래스에 넣으면 분기가 코드의 절반이 된다.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import contextlib
|
||||
import logging
|
||||
|
||||
import numpy as np
|
||||
|
||||
from ..constants import FRAME_SAMPLES
|
||||
from .base import AudioSource, CaptureBackend, CaptureError, to_mono_16k
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
try: # pragma: no cover - 플랫폼 의존
|
||||
import pyaudiowpatch as pyaudio
|
||||
except ImportError: # pragma: no cover
|
||||
pyaudio = None # type: ignore[assignment]
|
||||
|
||||
|
||||
class InputDeviceCapture(CaptureBackend):
|
||||
name = "input"
|
||||
per_process = False
|
||||
|
||||
def __init__(self, device_index: int = -1) -> None:
|
||||
super().__init__()
|
||||
self.device_index = device_index
|
||||
|
||||
@staticmethod
|
||||
def available() -> bool:
|
||||
return pyaudio is not None
|
||||
|
||||
@staticmethod
|
||||
def list_sources() -> list[AudioSource]:
|
||||
if pyaudio is None:
|
||||
return []
|
||||
sources: list[AudioSource] = []
|
||||
pa = pyaudio.PyAudio()
|
||||
try:
|
||||
default_index = -1
|
||||
with contextlib.suppress(OSError, LookupError):
|
||||
default_index = int(pa.get_default_input_device_info()["index"])
|
||||
for i in range(pa.get_device_count()):
|
||||
info = pa.get_device_info_by_index(i)
|
||||
if int(info.get("maxInputChannels", 0)) <= 0:
|
||||
continue
|
||||
# 루프백 장치는 '출력 장치' 목록에서 이미 보여주고 있다.
|
||||
# 여기서 또 내보내면 같은 것이 두 목록에 걸쳐 나온다.
|
||||
if info.get("isLoopbackDevice"):
|
||||
continue
|
||||
sources.append(
|
||||
AudioSource(
|
||||
kind="input",
|
||||
identifier=str(i),
|
||||
label=str(info["name"]),
|
||||
detail="기본 입력 장치" if i == default_index else "입력 장치",
|
||||
)
|
||||
)
|
||||
finally:
|
||||
pa.terminate()
|
||||
return sources
|
||||
|
||||
def _resolve_device(self, pa) -> dict:
|
||||
if self.device_index >= 0:
|
||||
return pa.get_device_info_by_index(self.device_index)
|
||||
return pa.get_default_input_device_info()
|
||||
|
||||
def _run(self) -> None: # pragma: no cover - 실제 오디오 장치 필요
|
||||
if pyaudio is None:
|
||||
raise CaptureError("PyAudioWPatch가 설치되지 않았습니다.")
|
||||
pa = pyaudio.PyAudio()
|
||||
stream = None
|
||||
try:
|
||||
info = self._resolve_device(pa)
|
||||
if info is None:
|
||||
raise CaptureError("입력 장치를 찾지 못했습니다.")
|
||||
rate = int(info["defaultSampleRate"])
|
||||
channels = max(1, int(info["maxInputChannels"]))
|
||||
chunk = max(FRAME_SAMPLES, int(rate * 0.02))
|
||||
stream = pa.open(
|
||||
format=pyaudio.paFloat32,
|
||||
channels=channels,
|
||||
rate=rate,
|
||||
input=True,
|
||||
input_device_index=int(info["index"]),
|
||||
frames_per_buffer=chunk,
|
||||
)
|
||||
log.info("입력 장치 캡처 시작: %s (%dHz, %dch)", info["name"], rate, channels)
|
||||
while not self._stop.is_set():
|
||||
raw = stream.read(chunk, exception_on_overflow=False)
|
||||
data = np.frombuffer(raw, dtype=np.float32)
|
||||
self._emit(to_mono_16k(data, channels, rate))
|
||||
finally:
|
||||
if stream is not None:
|
||||
stream.stop_stream()
|
||||
stream.close()
|
||||
pa.terminate()
|
||||
@@ -35,6 +35,9 @@ class SubtitleStyle:
|
||||
outline_width: int = 3
|
||||
background_color: str = "#000000"
|
||||
background_opacity: int = 55 # 0-100
|
||||
#: 글자와 배경 상자 가장자리 사이 여백. 배경 상자는 글자를 감싸는 크기로
|
||||
#: 그려지므로 이 값이 곧 배경 크기를 정한다.
|
||||
padding: int = 18
|
||||
line_spacing: int = 6
|
||||
max_lines: int = 2
|
||||
show_source: bool = False # 원문 동시 표시
|
||||
@@ -53,7 +56,9 @@ class OverlayConfig:
|
||||
always_on_top: bool = True
|
||||
#: 자막 위로 마우스가 통과하게 한다. 게임 중에는 켜두는 게 편하다.
|
||||
click_through: bool = True
|
||||
locked: bool = False
|
||||
#: 기본은 잠금이다. 게임 중에 자막을 실수로 끌고 다니는 사고를 막는다.
|
||||
#: 옮기거나 크기를 바꿀 때는 자막 화면의 '자막 위치 조정'을 켠다.
|
||||
locked: bool = True
|
||||
#: 자막 표시 on/off (단축키로 토글)
|
||||
visible: bool = True
|
||||
#: 자막을 띄울 모니터 인덱스 (0부터)
|
||||
@@ -66,7 +71,10 @@ class OverlayConfig:
|
||||
|
||||
@dataclass
|
||||
class AudioConfig:
|
||||
backend: str = "auto" # auto | process | device | file
|
||||
backend: str = "auto" # auto | process | device | input | file
|
||||
#: 홈 화면 목록이 무엇을 보여줄지. "output"=프로그램과 출력 장치(게임 소리),
|
||||
#: "input"=마이크 같은 입력 장치. 고른 쪽을 기억한다.
|
||||
source_mode: str = "output"
|
||||
target_pid: int = 0
|
||||
target_process_name: str = ""
|
||||
device_index: int = -1 # -1 = 기본 출력 장치 루프백
|
||||
|
||||
@@ -9,6 +9,7 @@ from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import queue
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
from collections.abc import Callable
|
||||
@@ -25,7 +26,8 @@ from ..audio import (
|
||||
)
|
||||
from ..config import AppConfig
|
||||
from ..constants import LANGUAGE_CODES, user_data_dir
|
||||
from ..models import Glossary, ModelManager
|
||||
from ..models import Glossary, ModelManager, cuda_runtime
|
||||
from ..models.cuda_runtime import DownloadCancelled
|
||||
from ..models.manager import apply_vram_limit
|
||||
from ..models.packs import build_glossary
|
||||
from ..models.speech_level import (
|
||||
@@ -38,6 +40,10 @@ from .events import EngineState, EngineStatus, TranslationLine
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
#: GPU 쪽 문제로 보이는 예외 문구. 이런 실패는 CPU 로 바꾸면 자막이 나온다.
|
||||
_GPU_ERROR = re.compile(r"cuda|cublas|cudnn|gpu", re.IGNORECASE)
|
||||
_FAILED_PREFIX = "듣는 중 · 문장 처리 실패: "
|
||||
|
||||
StatusCallback = Callable[[EngineStatus], None]
|
||||
LineCallback = Callable[[TranslationLine], None]
|
||||
|
||||
@@ -67,12 +73,23 @@ class TranslationEngine:
|
||||
#: 마지막으로 실제 발화를 처리한 시각. 유휴 언로드 판단에 쓴다.
|
||||
self._last_activity = time.monotonic()
|
||||
self._models_unloaded = False
|
||||
#: GPU 를 못 써서 CPU 로 돌고 있으면 그 사유. 홈 화면 상태에 보인다.
|
||||
self._cpu_notice = ""
|
||||
|
||||
# --- 수명주기 -------------------------------------------------------
|
||||
@property
|
||||
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)
|
||||
@@ -80,10 +97,15 @@ class TranslationEngine:
|
||||
def start(self) -> None:
|
||||
if self.running:
|
||||
return
|
||||
self._stop.clear()
|
||||
# clear() 가 아니라 새로 만든다. 정지된 이전 시작 작업(예: cuBLAS 받는 중)이
|
||||
# 아직 끝나지 않았을 수 있는데, 같은 이벤트를 다시 끄면 그 작업이 정지된
|
||||
# 줄 모르고 캡처를 켜 버린다.
|
||||
self._stop = threading.Event()
|
||||
self._emit_status(EngineState.LOADING, "모델을 준비하고 있습니다…", 0.0)
|
||||
|
||||
thread = threading.Thread(target=self._bootstrap, name="engine-boot", daemon=True)
|
||||
thread = threading.Thread(
|
||||
target=self._bootstrap, args=(self._stop,), name="engine-boot", daemon=True
|
||||
)
|
||||
thread.start()
|
||||
self._threads = [thread]
|
||||
|
||||
@@ -100,6 +122,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:
|
||||
@@ -134,20 +157,40 @@ class TranslationEngine:
|
||||
return True
|
||||
|
||||
# --- 내부 스레드 ----------------------------------------------------
|
||||
def _bootstrap(self) -> None:
|
||||
def _bootstrap(self, stop: threading.Event) -> None:
|
||||
"""모델·캡처를 준비한다. `stop` 은 이 시작 작업 전용 정지 신호다.
|
||||
|
||||
준비 도중(cuBLAS 받기, 모델 올리기)에 정지를 누를 수 있다. 그때는
|
||||
캡처를 켜지도 상태를 바꾸지도 않고 조용히 끝낸다.
|
||||
"""
|
||||
def report(msg: str, pct: float) -> None:
|
||||
if not stop.is_set():
|
||||
self._emit_status(EngineState.LOADING, msg, pct)
|
||||
|
||||
self._cpu_notice = ""
|
||||
try:
|
||||
# 설정이 바뀐 채로 재시작됐을 수 있으므로 매 시작마다 맞춘다.
|
||||
self.sync_performance()
|
||||
self.models.use_device(self.config.models.device)
|
||||
self._prepare_gpu(report, stop)
|
||||
if stop.is_set():
|
||||
return
|
||||
perf = self.config.performance
|
||||
if perf.game_mode and self.config.models.device == "cuda":
|
||||
if perf.game_mode and self.models.device == "cuda":
|
||||
# 모델을 올리기 *전에* 걸어야 상한이 실제로 먹는다.
|
||||
apply_vram_limit(perf.vram_limit_ratio, self.config.models.device_index)
|
||||
if self.config.models.preload_on_start:
|
||||
self.models.preload(
|
||||
lambda msg, pct: self._emit_status(EngineState.LOADING, msg, pct)
|
||||
)
|
||||
self._capture = create_capture(self.config.audio)
|
||||
self._capture.start()
|
||||
self._preload(report)
|
||||
if stop.is_set():
|
||||
return
|
||||
capture = create_capture(self.config.audio)
|
||||
capture.start()
|
||||
self._capture = capture
|
||||
if stop.is_set():
|
||||
# stop() 이 캡처를 확인한 뒤에 여기 왔을 수 있다. 직접 닫는다.
|
||||
capture.stop()
|
||||
self._capture = None
|
||||
return
|
||||
|
||||
workers = [
|
||||
threading.Thread(target=self._segment_loop, name="engine-segment", daemon=True),
|
||||
@@ -157,11 +200,41 @@ class TranslationEngine:
|
||||
w.start()
|
||||
self._threads.extend(workers)
|
||||
|
||||
kind = "프로그램별 캡처" if self._capture.per_process else "출력 장치 전체"
|
||||
self._emit_status(EngineState.RUNNING, f"듣는 중 · {kind}", 1.0)
|
||||
kind = "프로그램별 캡처" if capture.per_process else "출력 장치 전체"
|
||||
message = self._cpu_notice or f"듣는 중 · {kind}"
|
||||
self._emit_status(EngineState.RUNNING, message, 1.0)
|
||||
except (CaptureError, OSError, RuntimeError, ImportError) as exc:
|
||||
log.exception("엔진 시작 실패")
|
||||
self._emit_status(EngineState.ERROR, str(exc))
|
||||
if not stop.is_set():
|
||||
self._emit_status(EngineState.ERROR, str(exc))
|
||||
|
||||
def _preload(self, report) -> None:
|
||||
"""모델을 미리 올린다. GPU 로 안 올라가면 CPU 로 바꿔 다시 올린다."""
|
||||
try:
|
||||
self.models.preload(report)
|
||||
except Exception as exc:
|
||||
if self.models.device != "cuda" or not _GPU_ERROR.search(str(exc)):
|
||||
raise
|
||||
log.warning("GPU 로 모델을 올리지 못했습니다: %s", exc, exc_info=True)
|
||||
self._fall_back_to_cpu(f"GPU 오류: {_short(exc)}")
|
||||
self.models.preload(report)
|
||||
|
||||
def _prepare_gpu(self, report, stop: threading.Event) -> None:
|
||||
"""GPU 계산에 필요한 파일을 준비한다. 안 되면 CPU 로 돌린다."""
|
||||
if self.models.device != "cuda":
|
||||
return
|
||||
try:
|
||||
cuda_runtime.ensure(report, cancel=stop)
|
||||
except DownloadCancelled:
|
||||
log.info("cuBLAS 받기를 멈췄습니다 (번역 정지)")
|
||||
except Exception as exc: # noqa: BLE001 - 받기 실패여도 자막은 나와야 한다
|
||||
log.warning("GPU 계산 파일을 준비하지 못했습니다: %s", exc, exc_info=True)
|
||||
self._fall_back_to_cpu(f"GPU 계산 파일을 받지 못했습니다 ({_short(exc)})")
|
||||
|
||||
def _fall_back_to_cpu(self, reason: str) -> None:
|
||||
self.models.use_device("cpu")
|
||||
self._cpu_notice = f"CPU로 받아 적는 중 · {reason}"
|
||||
log.warning("CPU 로 전환합니다: %s", reason)
|
||||
|
||||
def _segment_loop(self) -> None:
|
||||
cfg = self.config.audio
|
||||
@@ -183,6 +256,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
|
||||
@@ -227,21 +303,40 @@ class TranslationEngine:
|
||||
if not segment.is_final and not self._segments.empty():
|
||||
continue
|
||||
|
||||
self._process_safely(segment, mcfg)
|
||||
|
||||
# 게임에 GPU를 잠깐 돌려준다. 연속 발화 때 우리가 GPU를 독점하면
|
||||
# 프레임이 눈에 띄게 끊긴다.
|
||||
if perf.game_mode and perf.yield_ms > 0:
|
||||
self._stop.wait(perf.yield_ms / 1000)
|
||||
|
||||
def _process_safely(self, segment: Segment, mcfg) -> None:
|
||||
"""한 구간을 처리한다. 실패해도 엔진은 계속 돌고, 사용자에게 보인다.
|
||||
|
||||
예전에는 실패를 로그에만 남겨서, 매 문장이 실패해도 화면은 '듣는 중'
|
||||
그대로였다. 사용자는 게이지만 움직이고 자막이 안 나오는 이유를 알 수 없었다.
|
||||
"""
|
||||
for attempt in range(2):
|
||||
# 모델 참조를 캐시하지 않는다. 유휴 언로드 뒤에는 새로 올려야 하고,
|
||||
# 캐시된 참조를 쓰면 이미 내려간 모델을 붙잡고 있게 된다.
|
||||
try:
|
||||
self._process(
|
||||
segment, self.models.recognizer(), self.models.translator(), mcfg
|
||||
)
|
||||
self._last_activity = time.monotonic()
|
||||
self._models_unloaded = False
|
||||
except Exception as exc: # noqa: BLE001 - 한 문장 실패로 엔진이 죽으면 안 된다
|
||||
log.warning("구간 처리 실패: %s", exc, exc_info=log.isEnabledFor(logging.DEBUG))
|
||||
|
||||
# 게임에 GPU를 잠깐 돌려준다. 연속 발화 때 우리가 GPU를 독점하면
|
||||
# 프레임이 눈에 띄게 끊긴다.
|
||||
if perf.game_mode and perf.yield_ms > 0:
|
||||
self._stop.wait(perf.yield_ms / 1000)
|
||||
log.warning("구간 처리 실패: %s", exc, exc_info=True)
|
||||
if attempt == 0 and self.models.device == "cuda" and _GPU_ERROR.search(str(exc)):
|
||||
# GPU 로는 안 되는 환경이다. 같은 구간을 CPU 로 다시 받아 적는다.
|
||||
self._fall_back_to_cpu(f"GPU 오류: {_short(exc)}")
|
||||
self._emit_status(EngineState.RUNNING, self._cpu_notice)
|
||||
continue
|
||||
self._emit_status(EngineState.RUNNING, f"{_FAILED_PREFIX}{_short(exc)}")
|
||||
return
|
||||
self._last_activity = time.monotonic()
|
||||
self._models_unloaded = False
|
||||
if self._status.message.startswith(_FAILED_PREFIX):
|
||||
self._emit_status(EngineState.RUNNING, self._cpu_notice or "듣는 중")
|
||||
return
|
||||
|
||||
def _maybe_unload_idle(self) -> None:
|
||||
"""한동안 말소리가 없으면 모델을 내려 VRAM을 통째로 돌려준다.
|
||||
@@ -272,6 +367,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:
|
||||
@@ -303,6 +399,12 @@ class TranslationEngine:
|
||||
translated = fix_particles(translated)
|
||||
mt_ms = int((time.perf_counter() - t1) * 1000)
|
||||
self._last_final_text = transcript.text
|
||||
# '로그' 화면으로 받아 보는 진단용. 엉뚱한 자막이 뜨면 이 줄로 원인을 본다.
|
||||
log.info(
|
||||
"자막 %.1f초 %s %r → %r (인식 %dms · 번역 %dms · 확률 %.2f)",
|
||||
transcript.duration_s, detected, transcript.text, translated,
|
||||
asr_ms, mt_ms, transcript.avg_logprob,
|
||||
)
|
||||
|
||||
line = TranslationLine(
|
||||
source_text=transcript.text,
|
||||
@@ -349,3 +451,9 @@ class TranslationEngine:
|
||||
)
|
||||
if self._on_status:
|
||||
self._on_status(self._status)
|
||||
|
||||
|
||||
def _short(exc: Exception, limit: int = 120) -> str:
|
||||
"""상태 줄에 넣을 만큼 짧은 오류 문구."""
|
||||
text = " ".join(str(exc).split()) or type(exc).__name__
|
||||
return text if len(text) <= limit else text[: limit - 1] + "…"
|
||||
|
||||
71
src/livesub/log_buffer.py
Normal file
71
src/livesub/log_buffer.py
Normal file
@@ -0,0 +1,71 @@
|
||||
"""실행 중 로그를 메모리에 모아 두는 곳. '로그' 화면이 여기서 읽는다.
|
||||
|
||||
`livesub.log` 파일만으로는 사용자가 찾아서 보내기 어렵다. 저장 위치를 직접
|
||||
열어야 하고, 실행 중에는 파일이 잠겨 있을 때도 있다. 그래서 같은 내용을
|
||||
메모리에도 쌓아 두고 화면에서 바로 복사·저장하게 한다.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import threading
|
||||
from collections import deque
|
||||
from collections.abc import Callable
|
||||
|
||||
#: 화면에 들고 있을 최대 줄 수. 한 줄 200바이트로 잡아도 1MB 남짓이다.
|
||||
MAX_RECORDS = 5000
|
||||
|
||||
Listener = Callable[[str], None]
|
||||
|
||||
|
||||
class LogBuffer:
|
||||
"""서식을 입힌 로그 줄을 최근 것부터 `MAX_RECORDS` 개까지 들고 있는다. 스레드 안전."""
|
||||
|
||||
def __init__(self, limit: int = MAX_RECORDS) -> None:
|
||||
self._lines: deque[str] = deque(maxlen=limit)
|
||||
self._listeners: list[Listener] = []
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def append(self, line: str) -> None:
|
||||
with self._lock:
|
||||
self._lines.append(line)
|
||||
listeners = list(self._listeners)
|
||||
for listener in listeners:
|
||||
listener(line)
|
||||
|
||||
def lines(self) -> list[str]:
|
||||
with self._lock:
|
||||
return list(self._lines)
|
||||
|
||||
def text(self) -> str:
|
||||
return "\n".join(self.lines())
|
||||
|
||||
def clear(self) -> None:
|
||||
with self._lock:
|
||||
self._lines.clear()
|
||||
|
||||
def subscribe(self, listener: Listener) -> None:
|
||||
"""새 줄이 들어올 때마다 불린다. 로그를 남긴 스레드에서 불리는 점에 주의."""
|
||||
with self._lock:
|
||||
self._listeners.append(listener)
|
||||
|
||||
def unsubscribe(self, listener: Listener) -> None:
|
||||
with self._lock:
|
||||
if listener in self._listeners:
|
||||
self._listeners.remove(listener)
|
||||
|
||||
|
||||
class BufferHandler(logging.Handler):
|
||||
def __init__(self, buffer: LogBuffer) -> None:
|
||||
super().__init__()
|
||||
self.buffer = buffer
|
||||
|
||||
def emit(self, record: logging.LogRecord) -> None:
|
||||
try:
|
||||
self.buffer.append(self.format(record))
|
||||
except Exception: # noqa: BLE001 - 로그 때문에 프로그램이 죽으면 안 된다
|
||||
self.handleError(record)
|
||||
|
||||
|
||||
#: 프로그램 전체가 쓰는 하나뿐인 버퍼. `setup_logging` 이 여기에 붙인다.
|
||||
BUFFER = LogBuffer()
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
from .asr import SpeechRecognizer, Transcript
|
||||
from .glossary import Glossary, GlossaryEntry
|
||||
from .manager import GpuInfo, ModelManager, detect_gpu
|
||||
from .manager import GpuInfo, ModelManager, detect_gpu, recommended_tier
|
||||
from .speech_level import (
|
||||
Politeness,
|
||||
SpeechLevel,
|
||||
@@ -43,5 +43,6 @@ __all__ = [
|
||||
"detect_gpu",
|
||||
"get_tier",
|
||||
"ordered_tiers",
|
||||
"recommended_tier",
|
||||
"to_casual",
|
||||
]
|
||||
|
||||
@@ -3,16 +3,66 @@
|
||||
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
|
||||
|
||||
#: Silero 없이 다시 받을 때 말소리가 없으면 Whisper 가 지어내는 문장들. 게임 잡음·
|
||||
#: 숨소리·웅웅거림을 넣으면 이 말이 나온다 (turbo 실측). 진짜 대사라면 Silero 가
|
||||
#: 먼저 받아 주므로, 다시 받은 쪽에서만 버린다. 비교는 `_normalized` 로 한다.
|
||||
FALLBACK_HALLUCINATIONS = frozenset(
|
||||
{
|
||||
"",
|
||||
"you",
|
||||
"okay",
|
||||
"ok",
|
||||
"oh",
|
||||
"bye",
|
||||
"thank you",
|
||||
"thanks",
|
||||
"thank you for watching",
|
||||
"thanks for watching",
|
||||
"obrigado",
|
||||
"e aí",
|
||||
}
|
||||
)
|
||||
|
||||
#: 다시 받은 결과에 이 글자가 섞여 있으면 모델이 언어를 바꾸지 못한 것이다.
|
||||
#: (진짜 한국어를 small 모델로 '영어로' 받으면 한글을 그대로 적는다.)
|
||||
_SCRIPT = {
|
||||
"ko": re.compile(r"[\uac00-\ud7a3\u3131-\u318e]"),
|
||||
"ja": re.compile(r"[\u3040-\u30ff]"),
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Transcript:
|
||||
@@ -20,6 +70,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 +119,94 @@ 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` 로 거른다.
|
||||
#
|
||||
# 직전 문장(prompt)은 넘기지 않는다. 말소리가 없으면 Whisper 는 prompt 를
|
||||
# 그대로 따라 적는다. 한 번 "Okay." 가 나오면 그 뒤 잡음마다 "Okay." 가
|
||||
# 나와 아무 말도 없는데 자막이 계속 떴다 (잡음 8종 모두, turbo 실측).
|
||||
segments, info = self._decode(audio, language, fast, "", vad=False)
|
||||
duration = audio.size / SAMPLE_RATE
|
||||
kept = [s for s in segments if _plausible(s, duration)]
|
||||
if segments:
|
||||
log.info(
|
||||
"Silero 가 버린 구간을 VAD 없이 다시 받음 (%.1f초): 채택 %r · 버림 %r",
|
||||
duration,
|
||||
[s.text.strip() for s in kept],
|
||||
[s.text.strip() for s in segments if s not in kept],
|
||||
)
|
||||
segments = kept
|
||||
|
||||
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 +215,56 @@ 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
|
||||
if _normalized(segment.text) in FALLBACK_HALLUCINATIONS:
|
||||
return False
|
||||
return float(getattr(segment, "avg_logprob", 0.0)) >= FALLBACK_MIN_LOGPROB
|
||||
|
||||
|
||||
def _normalized(text: str) -> str:
|
||||
"""비교용으로 문장부호·대소문자·여분 공백을 없앤다. "Okay." == "okay"""
|
||||
return " ".join(re.sub(r"[^\w\s]", " ", text.lower()).split())
|
||||
|
||||
|
||||
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
|
||||
|
||||
156
src/livesub/models/cuda_runtime.py
Normal file
156
src/livesub/models/cuda_runtime.py
Normal file
@@ -0,0 +1,156 @@
|
||||
"""GPU 로 받아 적고 번역할 때 필요한 cuBLAS DLL 을 준비한다 (Windows).
|
||||
|
||||
CTranslate2 의 Windows 패키지는 GPU 계산 때 `cublas64_12.dll` 을 이름으로 찾아
|
||||
불러온다. 그런데 이 DLL 은 패키지에 들어 있지 않다. 리눅스 개발 환경에서는
|
||||
torch 가 같이 깔아 둔 cuBLAS 를 쓰기 때문에 문제가 드러나지 않았고, torch 를 뺀
|
||||
포터블 exe 에서는 모델은 GPU 에 잘 올라가는데 첫 문장을 받아 적는 순간부터
|
||||
매번 실패했다. 소리 게이지는 움직이는데 자막이 하나도 안 나오던 원인이다.
|
||||
|
||||
두 DLL 이 790MB 라 exe 에 넣으면 실행할 때마다 그만큼 임시폴더에 풀어야 한다.
|
||||
그래서 처음 GPU 를 쓸 때 NVIDIA 가 PyPI 에 올린 공식 패키지를 한 번 받아 모델
|
||||
폴더에 둔다. CUDA Toolkit 이 깔려 있어 이미 불러올 수 있으면 받지 않는다.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import ctypes
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import urllib.request
|
||||
import zipfile
|
||||
from collections.abc import Callable
|
||||
from pathlib import Path
|
||||
|
||||
from ..constants import models_dir
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
#: cuBLAS 12.8 부터 RTX 50 계열(Blackwell)을 지원한다.
|
||||
WHEEL_VERSION = "12.8.4.1"
|
||||
WHEEL_URL = (
|
||||
"https://files.pythonhosted.org/packages/70/61/"
|
||||
"7d7b3c70186fb651d0fbd35b01dbfc8e755f69fd58f817f3d0f642df20c3/"
|
||||
"nvidia_cublas_cu12-12.8.4.1-py3-none-win_amd64.whl"
|
||||
)
|
||||
WHEEL_SHA256 = "47e9b82132fa8d2b4944e708049229601448aaad7e6f296f630f2d1a32de35af"
|
||||
WHEEL_SIZE = 567_544_208
|
||||
|
||||
#: 불러오는 순서대로. cublas64_12 가 cublasLt64_12 를 import 하므로 Lt 가 먼저다.
|
||||
DLLS = ("cublasLt64_12.dll", "cublas64_12.dll")
|
||||
_WHEEL_DIR = "nvidia/cublas/bin/"
|
||||
|
||||
ProgressCallback = Callable[[str, float], None]
|
||||
|
||||
|
||||
class DownloadCancelled(Exception):
|
||||
"""사용자가 받는 도중에 번역을 정지했다."""
|
||||
|
||||
#: os.add_dll_directory 가 돌려준 핸들. 닫히면 검색 경로에서 빠지므로 붙잡아 둔다.
|
||||
_dll_dir_handle = None
|
||||
#: 불러온 DLL 핸들. 참조가 사라지면 내려갈 수 있으므로 들고 있는다.
|
||||
_loaded: list = []
|
||||
_ready = False
|
||||
|
||||
|
||||
def runtime_dir() -> Path:
|
||||
"""모델 폴더 안에 둔다. 저장 위치를 옮길 때 모델과 같이 따라간다."""
|
||||
return models_dir() / f"cuda-runtime-cublas-{WHEEL_VERSION}"
|
||||
|
||||
|
||||
def installed(directory: Path | None = None) -> bool:
|
||||
directory = directory or runtime_dir()
|
||||
return all((directory / name).is_file() for name in DLLS)
|
||||
|
||||
|
||||
def _system_has_cublas() -> bool:
|
||||
"""CUDA Toolkit 등으로 이미 이름만으로 불러올 수 있는가."""
|
||||
try:
|
||||
_loaded.append(ctypes.WinDLL(DLLS[-1])) # type: ignore[attr-defined]
|
||||
except OSError:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def ensure(progress: ProgressCallback | None = None, device: str = "cuda",
|
||||
cancel: threading.Event | None = None) -> bool:
|
||||
"""GPU 를 쓸 수 있게 cuBLAS 를 준비한다. 새로 받았거나 불러왔으면 True.
|
||||
|
||||
Windows 가 아니거나 CPU 로 돌릴 때는 아무것도 하지 않는다. 받기·불러오기에
|
||||
실패하면 예외를 그대로 올린다. 호출한 쪽이 CPU 로 바꿀지 정한다.
|
||||
`cancel` 이 켜지면 받기를 멈추고 `DownloadCancelled` 를 올린다.
|
||||
"""
|
||||
global _ready
|
||||
if sys.platform != "win32" or device != "cuda":
|
||||
return False
|
||||
if _ready:
|
||||
return True
|
||||
directory = runtime_dir()
|
||||
if not installed(directory) and _system_has_cublas():
|
||||
log.info("시스템에 있는 cuBLAS 를 씁니다.")
|
||||
else:
|
||||
if not installed(directory):
|
||||
download(directory, progress, cancel=cancel)
|
||||
activate(directory)
|
||||
_ready = True
|
||||
return True
|
||||
|
||||
|
||||
def download(directory: Path, progress: ProgressCallback | None = None,
|
||||
url: str = WHEEL_URL, sha256: str = WHEEL_SHA256,
|
||||
size: int = WHEEL_SIZE, cancel: threading.Event | None = None) -> None:
|
||||
"""공식 패키지를 받아 DLL 두 개만 꺼낸다. 끝나면 패키지 파일은 지운다."""
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
part = directory / "cublas.whl.part"
|
||||
total_mb = size / 2**20
|
||||
log.info("GPU 계산 파일(cuBLAS %s) 내려받기: %s", WHEEL_VERSION, url)
|
||||
digest = hashlib.sha256()
|
||||
done = 0
|
||||
last_pct = -1
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=30) as resp, part.open("wb") as out:
|
||||
while chunk := resp.read(1 << 20):
|
||||
if cancel is not None and cancel.is_set():
|
||||
raise DownloadCancelled("GPU 계산 파일 받기를 멈췄습니다")
|
||||
out.write(chunk)
|
||||
digest.update(chunk)
|
||||
done += len(chunk)
|
||||
pct = int(done * 100 / size) if size else 0
|
||||
if progress and pct != last_pct:
|
||||
last_pct = pct
|
||||
progress(
|
||||
f"GPU 계산 파일 받는 중 (처음 한 번만) "
|
||||
f"{done / 2**20:.0f}/{total_mb:.0f}MB",
|
||||
min(done / size, 1.0) if size else 0.0,
|
||||
)
|
||||
if done != size or digest.hexdigest() != sha256:
|
||||
raise RuntimeError(
|
||||
f"GPU 계산 파일이 손상됐습니다 ({done}바이트, 다시 시도해 주세요)"
|
||||
)
|
||||
with zipfile.ZipFile(part) as wheel:
|
||||
for name in DLLS:
|
||||
tmp = directory / f"{name}.part"
|
||||
with wheel.open(_WHEEL_DIR + name) as src, tmp.open("wb") as dst:
|
||||
while block := src.read(1 << 20):
|
||||
dst.write(block)
|
||||
tmp.replace(directory / name)
|
||||
finally:
|
||||
part.unlink(missing_ok=True)
|
||||
log.info("GPU 계산 파일 준비 완료: %s", directory)
|
||||
|
||||
|
||||
def activate(directory: Path) -> None:
|
||||
"""DLL 을 전체 경로로 미리 불러 둔다.
|
||||
|
||||
CTranslate2 는 `cublas64_12.dll` 을 이름으로만 찾는다. 같은 이름의 모듈이 이미
|
||||
올라와 있으면 Windows 는 그것을 쓰므로, 검색 경로 규칙에 기대지 않아도 된다.
|
||||
"""
|
||||
global _dll_dir_handle
|
||||
if _dll_dir_handle is None and hasattr(os, "add_dll_directory"):
|
||||
_dll_dir_handle = os.add_dll_directory(str(directory))
|
||||
os.environ["PATH"] = f"{directory}{os.pathsep}{os.environ.get('PATH', '')}"
|
||||
for name in DLLS:
|
||||
_loaded.append(ctypes.WinDLL(str(directory / name))) # type: ignore[attr-defined]
|
||||
log.info("cuBLAS 불러옴: %s", directory)
|
||||
@@ -8,7 +8,7 @@ from dataclasses import dataclass, replace
|
||||
|
||||
from ..config import ModelConfig
|
||||
from .asr import SpeechRecognizer
|
||||
from .tiers import TIERS, MTBackend, Tier, get_tier
|
||||
from .tiers import DEFAULT_TIER, TIERS, MTBackend, Tier, get_tier
|
||||
from .translator import Translator, create_translator
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
@@ -57,7 +57,10 @@ def detect_gpu() -> GpuInfo:
|
||||
return GpuInfo(True, name, int(total), int(free),
|
||||
reason="PyTorch 미설치 — 정보만 조회했습니다.")
|
||||
except Exception as exc: # noqa: BLE001
|
||||
return GpuInfo(False, reason=f"GPU 조회 실패: {exc}")
|
||||
# 예외 문자열에는 실행한 명령줄이 통째로 들어 있다. 그대로 화면에
|
||||
# 띄우면 안내가 아니라 로그 덤프가 된다. 자세한 건 로그로 보낸다.
|
||||
log.warning("nvidia-smi 조회 실패: %s", exc)
|
||||
return GpuInfo(False, reason="nvidia-smi 로 GPU 정보를 읽지 못했습니다.")
|
||||
|
||||
|
||||
def apply_vram_limit(ratio: float, device_index: int = 0) -> bool:
|
||||
@@ -136,6 +139,32 @@ def tier_availability(tier: Tier, gpu: GpuInfo | None = None) -> tuple[bool, str
|
||||
return True, ""
|
||||
|
||||
|
||||
def recommended_tier(gpu: GpuInfo | None = None) -> str:
|
||||
"""이 환경에서 실제로 권할 만한 티어.
|
||||
|
||||
티어 표에 박아둔 `recommended` 는 "GPU 가 넉넉할 때" 를 전제로 한 값이라,
|
||||
그대로 쓰면 GPU 가 없는 사람에게 10GB 짜리를 추천하게 된다. 그래서 환경을
|
||||
보고 정한다.
|
||||
|
||||
GPU 가 없으면 CTranslate2 계열(1~3티어)만 후보에 둔다. LLM 계열은 CPU 에서
|
||||
한 문장에 수십 초가 걸려 실시간 자막으로 쓸 수 없다. 그중에서도 가장
|
||||
가벼운 쪽을 고른다 — CPU 에서는 연산량이 그대로 지연으로 돌아온다.
|
||||
"""
|
||||
info = detect_gpu() if gpu is None else gpu
|
||||
usable = [t for t in TIERS.values() if tier_availability(t, info)[0]]
|
||||
if not usable:
|
||||
return DEFAULT_TIER
|
||||
|
||||
if not info.available:
|
||||
light = [t for t in usable if t.mt.backend is MTBackend.CTRANSLATE2]
|
||||
return min(light or usable, key=lambda t: t.order).key
|
||||
|
||||
preferred = [t for t in usable if t.recommended]
|
||||
if preferred:
|
||||
return max(preferred, key=lambda t: t.order).key
|
||||
return max(usable, key=lambda t: t.order).key
|
||||
|
||||
|
||||
def first_available_tier(preferred: str) -> str:
|
||||
"""선호 티어가 불가능하면 쓸 수 있는 가장 좋은 티어로 내린다."""
|
||||
tier = get_tier(preferred)
|
||||
@@ -162,6 +191,9 @@ class ModelManager:
|
||||
self.config = config
|
||||
#: 저부하(게임) 모드. 연산 정밀도를 낮춰 VRAM과 GPU 점유를 줄인다.
|
||||
self.low_power = low_power
|
||||
#: 실제로 돌릴 장치. 설정값에서 시작하지만, GPU 가 안 되면 이번 실행만
|
||||
#: CPU 로 바꾼다. 설정 파일에는 남기지 않는다 — 다음엔 GPU 가 될 수 있다.
|
||||
self.device = config.device
|
||||
self._tier: Tier = get_tier(config.tier)
|
||||
self._asr: SpeechRecognizer | None = None
|
||||
self._mt: Translator | None = None
|
||||
@@ -195,7 +227,7 @@ class ModelManager:
|
||||
with self._lock:
|
||||
if self._asr is None:
|
||||
self._asr = SpeechRecognizer(
|
||||
self.effective_asr_spec(), self.config.device, self.config.device_index
|
||||
self.effective_asr_spec(), self.device, self.config.device_index
|
||||
)
|
||||
return self._asr
|
||||
|
||||
@@ -204,7 +236,7 @@ class ModelManager:
|
||||
if self._mt is None:
|
||||
self._mt = create_translator(
|
||||
self.effective_mt_spec(),
|
||||
self.config.device,
|
||||
self.device,
|
||||
self.config.device_index,
|
||||
self.config.lora_adapter_path,
|
||||
)
|
||||
@@ -222,6 +254,15 @@ class ModelManager:
|
||||
self.translator().load()
|
||||
report("준비 완료", 1.0)
|
||||
|
||||
def use_device(self, device: str) -> bool:
|
||||
"""돌릴 장치를 바꾼다. 바뀌었으면 올라가 있던 모델을 내리고 True."""
|
||||
if device == self.device:
|
||||
return False
|
||||
self.unload()
|
||||
self.device = device
|
||||
log.info("연산 장치 변경: %s", device)
|
||||
return True
|
||||
|
||||
def switch_tier(self, tier_key: str) -> Tier:
|
||||
"""티어 변경. 기존 모델은 내려서 VRAM을 즉시 돌려준다."""
|
||||
if tier_key == self._tier.key:
|
||||
|
||||
@@ -120,7 +120,7 @@ SWIFT = _register(
|
||||
order=2,
|
||||
name="신속",
|
||||
tagline="빠르면서 인식률은 최상급",
|
||||
asr=AsrSpec("Systran/faster-whisper-large-v3-turbo", "int8_float16", 1, 1600),
|
||||
asr=AsrSpec("dropbox-dash/faster-whisper-large-v3-turbo", "int8_float16", 1, 1600),
|
||||
mt=MTSpec(
|
||||
"entai2965/nllb-200-distilled-600M-ctranslate2",
|
||||
MTBackend.CTRANSLATE2,
|
||||
@@ -140,7 +140,7 @@ BALANCE = _register(
|
||||
order=3,
|
||||
name="균형",
|
||||
tagline="기본값 · 속도와 품질의 중간",
|
||||
asr=AsrSpec("Systran/faster-whisper-large-v3-turbo", "float16", 2, 2400),
|
||||
asr=AsrSpec("dropbox-dash/faster-whisper-large-v3-turbo", "float16", 2, 2400),
|
||||
mt=MTSpec(
|
||||
"entai2965/nllb-200-distilled-1.3B-ctranslate2",
|
||||
MTBackend.CTRANSLATE2,
|
||||
@@ -160,7 +160,7 @@ PRECISION = _register(
|
||||
order=4,
|
||||
name="정밀",
|
||||
tagline="추천 · 현 시점 최고 번역 품질",
|
||||
asr=AsrSpec("Systran/faster-whisper-large-v3-turbo", "float16", 2, 2400),
|
||||
asr=AsrSpec("dropbox-dash/faster-whisper-large-v3-turbo", "float16", 2, 2400),
|
||||
mt=MTSpec(
|
||||
"ByteDance-Seed/Seed-X-PPO-7B-AWQ-Int4",
|
||||
MTBackend.TRANSFORMERS,
|
||||
|
||||
@@ -30,7 +30,7 @@ from ..constants import APP_NAME, APP_SLOGAN, APP_VERSION, user_data_dir
|
||||
from ..core import EngineState, EngineStatus, TranslationEngine, TranslationLine
|
||||
from .hotkeys import GlobalHotkeys
|
||||
from .overlay import SubtitleOverlay
|
||||
from .pages import GlossaryPage, HomePage, ModelsPage, SettingsPage, SubtitlePage
|
||||
from .pages import GlossaryPage, HomePage, LogPage, ModelsPage, SettingsPage, SubtitlePage
|
||||
from .theme import SPACING, palette, stylesheet
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
@@ -41,6 +41,7 @@ NAV = [
|
||||
("자막", "표시 설정"),
|
||||
("용어집", "고유명사 고정"),
|
||||
("설정", "세부 조정"),
|
||||
("로그", "전체 기록 · 복사/저장"),
|
||||
]
|
||||
|
||||
|
||||
@@ -73,6 +74,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))
|
||||
@@ -89,12 +98,14 @@ class MainWindow(QMainWindow):
|
||||
self.subtitle_page = SubtitlePage(self.config)
|
||||
self.glossary_page = GlossaryPage(self.config)
|
||||
self.settings_page = SettingsPage(self.config)
|
||||
self.log_page = LogPage(self.config)
|
||||
for page in (
|
||||
self.home_page,
|
||||
self.models_page,
|
||||
self.subtitle_page,
|
||||
self.glossary_page,
|
||||
self.settings_page,
|
||||
self.log_page,
|
||||
):
|
||||
self.stack.addWidget(_scrollable(page))
|
||||
layout.addWidget(self.stack, 1)
|
||||
@@ -162,8 +173,12 @@ class MainWindow(QMainWindow):
|
||||
self.settings_page.restart_needed.connect(self._on_restart_needed)
|
||||
self.settings_page.hotkeys_changed.connect(self._install_hotkeys)
|
||||
|
||||
self.subtitle_page.edit_mode_requested.connect(self.overlay.set_edit_mode)
|
||||
|
||||
self.overlay.geometry_changed.connect(self._on_overlay_moved)
|
||||
self.overlay.visibility_changed.connect(self.subtitle_page.overlay_check.setChecked)
|
||||
self.overlay.edit_mode_changed.connect(self.subtitle_page.set_edit_mode)
|
||||
self.overlay.font_size_changed.connect(self._on_overlay_font_resized)
|
||||
self.overlay.closed.connect(
|
||||
lambda: self.subtitle_page.overlay_check.setChecked(False)
|
||||
)
|
||||
@@ -253,6 +268,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)
|
||||
|
||||
@@ -278,6 +297,11 @@ class MainWindow(QMainWindow):
|
||||
self.subtitle_page.sync_from_config()
|
||||
self._schedule_save()
|
||||
|
||||
def _on_overlay_font_resized(self, size: int) -> None:
|
||||
"""모서리를 잡아 크기를 바꾸면 글자 크기도 같이 바뀐다."""
|
||||
self.subtitle_page.set_font_size(size)
|
||||
self._schedule_save()
|
||||
|
||||
def _on_glossary_changed(self) -> None:
|
||||
self.engine.reload_glossary()
|
||||
self._schedule_save()
|
||||
|
||||
@@ -3,11 +3,14 @@
|
||||
게임/영상 위에 얹는 무테두리 반투명 창. 기본 동작은 유튜브 자막과 같은
|
||||
'외곽선 있는 큰 흰 글씨'로, 어떤 배경 위에서도 읽히는 것을 최우선으로 한다.
|
||||
|
||||
조작:
|
||||
* 드래그 — 위치 이동
|
||||
* 우하단 모서리 — 크기 조절
|
||||
* 휠 — 글자 크기 조절
|
||||
* 우클릭 — 잠금 / 클릭 통과 / 숨기기 메뉴
|
||||
평소에는 **잠겨 있다.** 게임 중에 자막을 실수로 끌고 다니는 일이 없어야 하기
|
||||
때문이다. 자막 화면의 '자막 위치 조정'을 켜야 아래 조작이 열린다.
|
||||
|
||||
위치 조정 모드에서:
|
||||
* 드래그 — 위치 이동
|
||||
* 네 모서리 — 크기 조절 (글자 크기도 같은 비율로 따라온다)
|
||||
* 휠 — 글자 크기 조절
|
||||
* 우클릭 — 잠금 / 클릭 통과 / 숨기기 메뉴
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -38,17 +41,16 @@ def paint_subtitle(
|
||||
source: str = "",
|
||||
partial: str = "",
|
||||
) -> None:
|
||||
"""자막 한 화면을 그린다. 오버레이와 설정 미리보기가 이 함수를 공유한다."""
|
||||
"""자막 한 화면을 그린다. 오버레이와 설정 미리보기가 이 함수를 공유한다.
|
||||
|
||||
배경 상자는 창 전체가 아니라 **글자를 감싸는 크기**로 그린다. 창 전체를
|
||||
칠하면 자막이 짧아도 커다란 띠가 남고, 그 상태에서는 여백을 키워도 글자만
|
||||
안쪽으로 밀릴 뿐 '배경 크기'는 그대로다. 감싸도록 그려야 여백이 곧 배경
|
||||
크기가 된다.
|
||||
"""
|
||||
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
|
||||
painter.setRenderHint(QPainter.RenderHint.TextAntialiasing, True)
|
||||
|
||||
if st.background_opacity > 0:
|
||||
bg = QColor(st.background_color)
|
||||
bg.setAlpha(int(255 * st.background_opacity / 100))
|
||||
painter.setBrush(bg)
|
||||
painter.setPen(Qt.PenStyle.NoPen)
|
||||
painter.drawRoundedRect(rect, 12, 12)
|
||||
|
||||
rows: list[tuple[str, QColor, int]] = []
|
||||
if st.show_source and source and translated:
|
||||
rows.append((source, QColor(st.source_text_color), int(st.font_size * 0.62)))
|
||||
@@ -61,33 +63,60 @@ def paint_subtitle(
|
||||
if not rows:
|
||||
return
|
||||
|
||||
margin = 18
|
||||
available = rect.width() - margin * 2
|
||||
pad = max(0, st.padding)
|
||||
available = rect.width() - pad * 2
|
||||
blocks: list[tuple[list[str], QColor, QFont]] = []
|
||||
total_h = 0
|
||||
text_w = 0
|
||||
for text, color, size in rows:
|
||||
font = QFont(st.font_family, size)
|
||||
font.setBold(st.bold)
|
||||
lines = _wrap(text, QFontMetrics(font), available, st.max_lines)
|
||||
fm = QFontMetrics(font)
|
||||
lines = _wrap(text, fm, available, st.max_lines)
|
||||
blocks.append((lines, color, font))
|
||||
total_h += len(lines) * (QFontMetrics(font).height() + st.line_spacing)
|
||||
total_h += len(lines) * (fm.height() + st.line_spacing)
|
||||
for line in lines:
|
||||
text_w = max(text_w, fm.horizontalAdvance(line))
|
||||
|
||||
y = rect.y() + max(margin, (rect.height() - total_h) // 2)
|
||||
box = _content_box(rect, text_w, total_h, pad, st.align)
|
||||
|
||||
if st.background_opacity > 0:
|
||||
bg = QColor(st.background_color)
|
||||
bg.setAlpha(int(255 * st.background_opacity / 100))
|
||||
painter.setBrush(bg)
|
||||
painter.setPen(Qt.PenStyle.NoPen)
|
||||
painter.drawRoundedRect(box, 12, 12)
|
||||
|
||||
y = box.y() + pad
|
||||
for lines, color, font in blocks:
|
||||
painter.setFont(font)
|
||||
fm = QFontMetrics(font)
|
||||
for line in lines:
|
||||
width = fm.horizontalAdvance(line)
|
||||
if st.align == "left":
|
||||
x = rect.x() + margin
|
||||
x = box.x() + pad
|
||||
elif st.align == "right":
|
||||
x = rect.right() - margin - width
|
||||
x = box.right() - pad - width
|
||||
else:
|
||||
x = rect.x() + (rect.width() - width) // 2
|
||||
x = box.x() + (box.width() - width) // 2
|
||||
_draw_outlined_text(painter, x, y + fm.ascent(), line, color, font, st)
|
||||
y += fm.height() + st.line_spacing
|
||||
|
||||
|
||||
def _content_box(rect: QRect, text_w: int, text_h: int, pad: int, align: str) -> QRect:
|
||||
"""글자를 감싸는 배경 상자. 창 밖으로는 넘지 않는다."""
|
||||
width = min(rect.width(), text_w + pad * 2)
|
||||
height = min(rect.height(), text_h + pad * 2)
|
||||
if align == "left":
|
||||
x = rect.x()
|
||||
elif align == "right":
|
||||
x = rect.right() - width + 1
|
||||
else:
|
||||
x = rect.x() + (rect.width() - width) // 2
|
||||
y = rect.y() + (rect.height() - height) // 2
|
||||
return QRect(x, y, width, height)
|
||||
|
||||
|
||||
def _draw_outlined_text(painter, x, y, text, color, font, st: SubtitleStyle) -> None:
|
||||
"""외곽선 있는 글자.
|
||||
|
||||
@@ -145,6 +174,10 @@ class SubtitleOverlay(QWidget):
|
||||
geometry_changed = Signal(int, int, int, int)
|
||||
#: 자막 on/off 가 바뀔 때 (단축키로도 바뀌므로 UI가 따라와야 한다)
|
||||
visibility_changed = Signal(bool)
|
||||
#: 크기 조정으로 글자 크기가 같이 바뀌었을 때 (설정 화면이 따라와야 한다)
|
||||
font_size_changed = Signal(int)
|
||||
#: 위치 조정 모드가 켜지고 꺼질 때
|
||||
edit_mode_changed = Signal(bool)
|
||||
closed = Signal()
|
||||
|
||||
def __init__(self, style: SubtitleStyle, overlay: OverlayConfig) -> None:
|
||||
@@ -156,7 +189,13 @@ class SubtitleOverlay(QWidget):
|
||||
self._partial_text = ""
|
||||
self._source_text = ""
|
||||
self._drag_from: QPoint | None = None
|
||||
self._resize_from: QRect | None = None
|
||||
#: 위치 조정 모드. 설정에 저장하지 않는다 — 다음 실행 때는 다시 잠긴
|
||||
#: 상태로 시작해야 게임 중에 자막을 실수로 끌고 다니지 않는다.
|
||||
self._edit_mode = False
|
||||
self._resize_corner = ""
|
||||
self._resize_geo = QRect()
|
||||
self._resize_mouse = QPoint()
|
||||
self._resize_font = 0
|
||||
|
||||
self._fade = QTimer(self)
|
||||
self._fade.setSingleShot(True)
|
||||
@@ -181,8 +220,11 @@ class SubtitleOverlay(QWidget):
|
||||
else flags & ~Qt.WindowType.WindowStaysOnTopHint
|
||||
)
|
||||
self.setWindowFlags(flags)
|
||||
# 위치 조정 중에는 클릭 통과를 반드시 꺼야 한다. 켜둔 채로는 마우스가
|
||||
# 창을 그냥 지나가서 잡을 수가 없다.
|
||||
self.setAttribute(
|
||||
Qt.WidgetAttribute.WA_TransparentForMouseEvents, cfg.click_through
|
||||
Qt.WidgetAttribute.WA_TransparentForMouseEvents,
|
||||
cfg.click_through and not self._edit_mode,
|
||||
)
|
||||
|
||||
# 앵커가 지정돼 있거나 아직 배치된 적이 없으면 다시 계산한다.
|
||||
@@ -192,6 +234,50 @@ class SubtitleOverlay(QWidget):
|
||||
self.setVisible(cfg.visible)
|
||||
self.update()
|
||||
|
||||
# --- 위치 조정 모드 --------------------------------------------------
|
||||
@property
|
||||
def edit_mode(self) -> bool:
|
||||
return self._edit_mode
|
||||
|
||||
def set_edit_mode(self, on: bool) -> None:
|
||||
"""자막을 옮기고 크기를 바꿀 수 있는 상태로 전환한다.
|
||||
|
||||
평소에는 잠겨 있다. 게임 중에 자막을 잘못 건드려 끌고 다니는 일이
|
||||
없어야 하기 때문이다. 이 모드에서만 드래그·모서리 크기 조절·휠이
|
||||
동작하고, 켜는 동안에는 자막이 안 보여도 잡을 수 있게 창을 띄운다.
|
||||
"""
|
||||
if on == self._edit_mode:
|
||||
return
|
||||
self._edit_mode = on
|
||||
if on and not self.isVisible():
|
||||
self.setVisible(True)
|
||||
self.setAttribute(
|
||||
Qt.WidgetAttribute.WA_TransparentForMouseEvents,
|
||||
self.overlay_cfg.click_through and not on,
|
||||
)
|
||||
self.setCursor(
|
||||
Qt.CursorShape.SizeAllCursor if on else Qt.CursorShape.ArrowCursor
|
||||
)
|
||||
if not on:
|
||||
self._drag_from = None
|
||||
self._resize_corner = ""
|
||||
self.update()
|
||||
self.edit_mode_changed.emit(on)
|
||||
|
||||
@property
|
||||
def _interactive(self) -> bool:
|
||||
return self._edit_mode or not self.overlay_cfg.locked
|
||||
|
||||
def _corner_at(self, pos: QPoint) -> str:
|
||||
"""모서리 손잡이를 집었는지. 집었으면 어느 모서리인지."""
|
||||
left = pos.x() <= GRIP
|
||||
right = pos.x() >= self.width() - GRIP
|
||||
top = pos.y() <= GRIP
|
||||
bottom = pos.y() >= self.height() - GRIP
|
||||
if (left or right) and (top or bottom):
|
||||
return ("top" if top else "bottom") + ("left" if left else "right")
|
||||
return ""
|
||||
|
||||
def snap_to_anchor(self, anchor: str | None = None, save_only: bool = False) -> None:
|
||||
"""선택한 모니터의 9분할 위치로 자막 창을 붙인다 (디스코드 오버레이 방식)."""
|
||||
cfg = self.overlay_cfg
|
||||
@@ -248,53 +334,94 @@ class SubtitleOverlay(QWidget):
|
||||
self._source_text,
|
||||
self._partial_text,
|
||||
)
|
||||
if not (self._final_text or self._partial_text) and not self.overlay_cfg.locked:
|
||||
self._draw_placeholder(painter)
|
||||
self._draw_grip(painter)
|
||||
if self._edit_mode:
|
||||
self._draw_edit_chrome(painter)
|
||||
|
||||
def _draw_placeholder(self, painter) -> None:
|
||||
painter.setPen(QColor(255, 255, 255, 90))
|
||||
font = QFont(self.style_cfg.font_family, 13)
|
||||
painter.setFont(font)
|
||||
painter.drawText(
|
||||
self.rect(),
|
||||
Qt.AlignmentFlag.AlignCenter,
|
||||
"자막이 여기에 표시됩니다\n드래그로 이동 · 휠로 크기 · 우클릭으로 메뉴",
|
||||
)
|
||||
def _draw_edit_chrome(self, painter) -> None:
|
||||
"""위치 조정 중이라는 것과 어디를 잡으면 되는지 보여준다."""
|
||||
painter.setBrush(Qt.BrushStyle.NoBrush)
|
||||
painter.setPen(QPen(QColor(90, 170, 255, 220), 2, Qt.PenStyle.DashLine))
|
||||
painter.drawRect(self.rect().adjusted(1, 1, -2, -2))
|
||||
|
||||
def _draw_grip(self, painter) -> None:
|
||||
if self.overlay_cfg.locked or self.overlay_cfg.click_through:
|
||||
return
|
||||
painter.setPen(QPen(QColor(255, 255, 255, 110), 2))
|
||||
painter.setPen(Qt.PenStyle.NoPen)
|
||||
painter.setBrush(QColor(90, 170, 255, 235))
|
||||
for rect in self._corner_handles():
|
||||
painter.drawRect(rect)
|
||||
|
||||
if not (self._final_text or self._partial_text):
|
||||
painter.setPen(QColor(255, 255, 255, 170))
|
||||
font = QFont(self.style_cfg.font_family, 13)
|
||||
painter.setFont(font)
|
||||
painter.drawText(
|
||||
self.rect(),
|
||||
Qt.AlignmentFlag.AlignCenter,
|
||||
"끌어서 이동 · 모서리를 잡아 크기 조절 (글자 크기도 같이 바뀝니다)",
|
||||
)
|
||||
|
||||
def _corner_handles(self) -> list[QRect]:
|
||||
w, h = self.width(), self.height()
|
||||
for offset in (5, 10, 15):
|
||||
painter.drawLine(w - offset, h - 4, w - 4, h - offset)
|
||||
return [
|
||||
QRect(0, 0, GRIP, GRIP),
|
||||
QRect(w - GRIP, 0, GRIP, GRIP),
|
||||
QRect(0, h - GRIP, GRIP, GRIP),
|
||||
QRect(w - GRIP, h - GRIP, GRIP, GRIP),
|
||||
]
|
||||
|
||||
# --- 마우스 ---------------------------------------------------------
|
||||
def mousePressEvent(self, event) -> None: # noqa: N802
|
||||
if self.overlay_cfg.locked or event.button() != Qt.MouseButton.LeftButton:
|
||||
if not self._interactive or event.button() != Qt.MouseButton.LeftButton:
|
||||
return
|
||||
pos = event.position().toPoint()
|
||||
if pos.x() > self.width() - GRIP and pos.y() > self.height() - GRIP:
|
||||
self._resize_from = QRect(event.globalPosition().toPoint(), self.size())
|
||||
corner = self._corner_at(event.position().toPoint())
|
||||
if corner:
|
||||
self._resize_corner = corner
|
||||
self._resize_geo = QRect(self.geometry())
|
||||
self._resize_mouse = event.globalPosition().toPoint()
|
||||
self._resize_font = self.style_cfg.font_size
|
||||
else:
|
||||
self._drag_from = event.globalPosition().toPoint() - self.pos()
|
||||
|
||||
def mouseMoveEvent(self, event) -> None: # noqa: N802
|
||||
if self._resize_from is not None:
|
||||
delta = event.globalPosition().toPoint() - self._resize_from.topLeft()
|
||||
self.resize(
|
||||
max(self.minimumWidth(), self._resize_from.width() + delta.x()),
|
||||
max(self.minimumHeight(), self._resize_from.height() + delta.y()),
|
||||
)
|
||||
if self._resize_corner:
|
||||
self._resize_to(event.globalPosition().toPoint())
|
||||
elif self._drag_from is not None:
|
||||
self.move(event.globalPosition().toPoint() - self._drag_from)
|
||||
|
||||
def _resize_to(self, mouse: QPoint) -> None:
|
||||
"""잡은 모서리만 움직이고 반대쪽 모서리는 제자리에 둔다.
|
||||
|
||||
글자 크기는 높이 비율을 그대로 따라간다. 상자만 커지고 글자는 그대로면
|
||||
여백만 늘어나므로, 크기 조절이 '자막을 키우는' 조작이 되지 않는다.
|
||||
"""
|
||||
start = self._resize_geo
|
||||
dx = mouse.x() - self._resize_mouse.x()
|
||||
dy = mouse.y() - self._resize_mouse.y()
|
||||
left, top = start.left(), start.top()
|
||||
right, bottom = start.right(), start.bottom()
|
||||
|
||||
if "left" in self._resize_corner:
|
||||
left = min(left + dx, right - self.minimumWidth())
|
||||
else:
|
||||
right = max(right + dx, left + self.minimumWidth())
|
||||
if "top" in self._resize_corner:
|
||||
top = min(top + dy, bottom - self.minimumHeight())
|
||||
else:
|
||||
bottom = max(bottom + dy, top + self.minimumHeight())
|
||||
|
||||
rect = QRect(QPoint(left, top), QPoint(right, bottom))
|
||||
self.setGeometry(rect)
|
||||
|
||||
scaled = round(self._resize_font * rect.height() / max(1, start.height()))
|
||||
size = max(12, min(120, scaled))
|
||||
if size != self.style_cfg.font_size:
|
||||
self.style_cfg.font_size = size
|
||||
self.font_size_changed.emit(size)
|
||||
self.update()
|
||||
|
||||
def mouseReleaseEvent(self, event) -> None: # noqa: N802
|
||||
if self._drag_from is None and self._resize_from is None:
|
||||
if self._drag_from is None and not self._resize_corner:
|
||||
return
|
||||
self._drag_from = None
|
||||
self._resize_from = None
|
||||
self._resize_corner = ""
|
||||
|
||||
cfg = self.overlay_cfg
|
||||
g = self.geometry()
|
||||
@@ -309,10 +436,13 @@ class SubtitleOverlay(QWidget):
|
||||
self.geometry_changed.emit(g.x(), g.y(), g.width(), g.height())
|
||||
|
||||
def wheelEvent(self, event) -> None: # noqa: N802
|
||||
if self.overlay_cfg.locked:
|
||||
if not self._interactive:
|
||||
return
|
||||
step = 2 if event.angleDelta().y() > 0 else -2
|
||||
self.style_cfg.font_size = max(12, min(120, self.style_cfg.font_size + step))
|
||||
size = max(12, min(120, self.style_cfg.font_size + step))
|
||||
if size != self.style_cfg.font_size:
|
||||
self.style_cfg.font_size = size
|
||||
self.font_size_changed.emit(size)
|
||||
self.update()
|
||||
|
||||
def contextMenuEvent(self, event) -> None: # noqa: N802
|
||||
@@ -343,7 +473,11 @@ class SubtitleOverlay(QWidget):
|
||||
|
||||
def _set_click_through(self, value: bool) -> None:
|
||||
self.overlay_cfg.click_through = value
|
||||
self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, value)
|
||||
# 위치 조정 중이면 통과를 켜지 않는다. 켜는 순간 창을 못 잡게 된다.
|
||||
self.setAttribute(
|
||||
Qt.WidgetAttribute.WA_TransparentForMouseEvents,
|
||||
value and not self._edit_mode,
|
||||
)
|
||||
self.update()
|
||||
|
||||
def _set_always_on_top(self, value: bool) -> None:
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
from .glossary_page import GlossaryPage
|
||||
from .home import HomePage
|
||||
from .log_page import LogPage
|
||||
from .models_page import ModelsPage
|
||||
from .settings_page import SettingsPage
|
||||
from .subtitle_page import SubtitlePage
|
||||
|
||||
__all__ = ["GlossaryPage", "HomePage", "ModelsPage", "SettingsPage", "SubtitlePage"]
|
||||
__all__ = ["GlossaryPage", "HomePage", "LogPage", "ModelsPage", "SettingsPage", "SubtitlePage"]
|
||||
|
||||
@@ -14,12 +14,18 @@ from PySide6.QtWidgets import (
|
||||
QWidget,
|
||||
)
|
||||
|
||||
from ...audio import capture_capabilities, list_sources
|
||||
from ...audio import (
|
||||
SOURCE_MODE_INPUT,
|
||||
SOURCE_MODE_OUTPUT,
|
||||
capture_capabilities,
|
||||
list_sources,
|
||||
)
|
||||
from ...config import AppConfig
|
||||
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
|
||||
|
||||
@@ -65,12 +71,34 @@ class HomePage(QWidget):
|
||||
self.source_combo.currentIndexChanged.connect(self._on_source_changed)
|
||||
layout.addWidget(self.source_combo, 1)
|
||||
|
||||
# 마이크 등 입력 장치는 같은 목록에 섞지 않고 전환해서 보여준다.
|
||||
# 한 목록에 다 넣으면 정작 찾으려던 게임이 라인입력들 사이에 파묻힌다.
|
||||
self.mode_button = QPushButton()
|
||||
self.mode_button.setMinimumWidth(170)
|
||||
self.mode_button.clicked.connect(self._toggle_source_mode)
|
||||
layout.addWidget(self.mode_button)
|
||||
|
||||
refresh = QPushButton("새로고침")
|
||||
refresh.clicked.connect(self.refresh_sources)
|
||||
layout.addWidget(refresh)
|
||||
card.add(row)
|
||||
return card
|
||||
|
||||
@property
|
||||
def _mode(self) -> str:
|
||||
return (
|
||||
SOURCE_MODE_INPUT
|
||||
if self.config.audio.source_mode == SOURCE_MODE_INPUT
|
||||
else SOURCE_MODE_OUTPUT
|
||||
)
|
||||
|
||||
def _toggle_source_mode(self) -> None:
|
||||
self.config.audio.source_mode = (
|
||||
SOURCE_MODE_OUTPUT if self._mode == SOURCE_MODE_INPUT else SOURCE_MODE_INPUT
|
||||
)
|
||||
self.refresh_sources()
|
||||
self.config_changed.emit()
|
||||
|
||||
def _build_control_card(self) -> Card:
|
||||
card = Card()
|
||||
row = QWidget()
|
||||
@@ -130,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()
|
||||
@@ -145,29 +212,49 @@ class HomePage(QWidget):
|
||||
# --- 동작 -----------------------------------------------------------
|
||||
def refresh_sources(self) -> None:
|
||||
caps = capture_capabilities()
|
||||
self._sources = list_sources()
|
||||
mode = self._mode
|
||||
self._sources = list_sources(mode)
|
||||
|
||||
icons = {"process": "🎮", "device": "🔊", "input": "🎤"}
|
||||
self.source_combo.blockSignals(True)
|
||||
self.source_combo.clear()
|
||||
for src in self._sources:
|
||||
prefix = "🎮" if src.kind == "process" else "🔊"
|
||||
prefix = icons.get(src.kind, "🔊")
|
||||
self.source_combo.addItem(f"{prefix} {src.label} — {src.detail}", src)
|
||||
if not self._sources:
|
||||
self.source_combo.addItem("사용 가능한 오디오 대상이 없습니다", None)
|
||||
self.source_combo.addItem(
|
||||
"마이크 등 입력 장치를 찾지 못했습니다"
|
||||
if mode == SOURCE_MODE_INPUT
|
||||
else "사용 가능한 오디오 대상이 없습니다",
|
||||
None,
|
||||
)
|
||||
self._select_saved_source()
|
||||
self.source_combo.blockSignals(False)
|
||||
self._on_source_changed()
|
||||
|
||||
if caps["process"]:
|
||||
msg = "프로그램별 캡처 사용 가능 — 선택한 프로그램의 소리만 정확히 받아옵니다."
|
||||
elif caps["device"]:
|
||||
# 버튼 글자는 '지금 상태'가 아니라 '누르면 가는 곳'을 적는다.
|
||||
if mode == SOURCE_MODE_INPUT:
|
||||
self.mode_button.setText("프로그램 소리에서 고르기")
|
||||
self.mode_button.setToolTip("게임 등 프로그램과 출력 장치 목록으로 돌아갑니다.")
|
||||
msg = (
|
||||
"프로그램별 캡처 보조 프로그램(livesub_capture.exe)이 없어 "
|
||||
"출력 장치 전체 소리를 받습니다. native/process_loopback/build.ps1 로 빌드하면 "
|
||||
"프로그램 단위로 분리됩니다."
|
||||
"마이크 등 입력 장치로 듣습니다. 통화 상대 목소리나 내가 말하는 것을 "
|
||||
"번역할 때 쓰세요."
|
||||
if caps["input"]
|
||||
else "이 환경에서는 입력 장치를 열 수 없습니다. Windows에서 실행하세요."
|
||||
)
|
||||
else:
|
||||
msg = "이 환경에서는 오디오 캡처를 할 수 없습니다. Windows에서 실행하세요."
|
||||
self.mode_button.setText("마이크 입력에서 고르기")
|
||||
self.mode_button.setToolTip("목록을 마이크 등 입력 장치로 바꿉니다.")
|
||||
if caps["process"]:
|
||||
msg = "프로그램별 캡처 사용 가능 — 선택한 프로그램의 소리만 정확히 받아옵니다."
|
||||
elif caps["device"]:
|
||||
msg = (
|
||||
"프로그램별 캡처 보조 프로그램(livesub_capture.exe)이 없어 "
|
||||
"출력 장치 전체 소리를 받습니다. native/process_loopback/build.ps1 로 빌드하면 "
|
||||
"프로그램 단위로 분리됩니다."
|
||||
)
|
||||
else:
|
||||
msg = "이 환경에서는 오디오 캡처를 할 수 없습니다. Windows에서 실행하세요."
|
||||
self.capability_label.setText(msg)
|
||||
|
||||
def _select_saved_source(self) -> None:
|
||||
@@ -176,7 +263,11 @@ class HomePage(QWidget):
|
||||
if cfg.backend == "process" and src.kind == "process" and src.pid == cfg.target_pid:
|
||||
self.source_combo.setCurrentIndex(i)
|
||||
return
|
||||
if cfg.backend == "device" and src.kind == "device" and src.device_index == cfg.device_index:
|
||||
if (
|
||||
cfg.backend in ("device", "input")
|
||||
and src.kind == cfg.backend
|
||||
and src.device_index == cfg.device_index
|
||||
):
|
||||
self.source_combo.setCurrentIndex(i)
|
||||
return
|
||||
|
||||
@@ -190,7 +281,7 @@ class HomePage(QWidget):
|
||||
cfg.target_pid = src.pid
|
||||
cfg.target_process_name = src.label
|
||||
else:
|
||||
cfg.backend = "device"
|
||||
cfg.backend = src.kind # "device" 또는 "input"
|
||||
cfg.device_index = src.device_index
|
||||
cfg.target_pid = 0
|
||||
self.config_changed.emit()
|
||||
@@ -224,9 +315,21 @@ 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, self.source_lang, self.target_lang):
|
||||
for widget in (
|
||||
self.source_combo,
|
||||
self.mode_button,
|
||||
self.source_lang,
|
||||
self.target_lang,
|
||||
):
|
||||
widget.setEnabled(not running)
|
||||
self.speech_combo.setEnabled(
|
||||
not running and self.config.models.target_lang == "ko"
|
||||
|
||||
145
src/livesub/ui/pages/log_page.py
Normal file
145
src/livesub/ui/pages/log_page.py
Normal file
@@ -0,0 +1,145 @@
|
||||
"""로그 — 프로그램을 켠 뒤 남은 기록 전체. 복사하거나 파일로 저장해 보낼 수 있다."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import platform
|
||||
from datetime import datetime
|
||||
|
||||
from PySide6.QtCore import Signal
|
||||
from PySide6.QtGui import QFontDatabase, QGuiApplication
|
||||
from PySide6.QtWidgets import (
|
||||
QFileDialog,
|
||||
QHBoxLayout,
|
||||
QLabel,
|
||||
QPlainTextEdit,
|
||||
QPushButton,
|
||||
QVBoxLayout,
|
||||
QWidget,
|
||||
)
|
||||
|
||||
from ...config import AppConfig
|
||||
from ...constants import APP_NAME, APP_VERSION, user_data_dir
|
||||
from ...log_buffer import BUFFER, MAX_RECORDS, LogBuffer
|
||||
from ..theme import SPACING
|
||||
from ..widgets import Card, PageHeader
|
||||
|
||||
|
||||
class LogPage(QWidget):
|
||||
#: 로그는 아무 스레드에서나 들어오므로 시그널로 GUI 스레드에 넘긴다.
|
||||
line_logged = Signal(str)
|
||||
|
||||
def __init__(
|
||||
self, config: AppConfig, buffer: LogBuffer = BUFFER, parent: QWidget | None = None
|
||||
):
|
||||
super().__init__(parent)
|
||||
self.config = config
|
||||
self.buffer = buffer
|
||||
|
||||
root = QVBoxLayout(self)
|
||||
root.setContentsMargins(0, 0, 0, 0)
|
||||
root.setSpacing(SPACING + 4)
|
||||
root.addWidget(
|
||||
PageHeader(
|
||||
"로그",
|
||||
"프로그램을 켠 뒤 남은 기록 전체입니다. 문제가 생기면 '복사'나 "
|
||||
"'파일로 저장'을 눌러 그대로 보내 주세요.",
|
||||
)
|
||||
)
|
||||
|
||||
card = Card()
|
||||
buttons = QWidget()
|
||||
row = QHBoxLayout(buttons)
|
||||
row.setContentsMargins(0, 0, 0, 0)
|
||||
row.setSpacing(10)
|
||||
self.copy_button = QPushButton("복사")
|
||||
self.copy_button.setObjectName("Primary")
|
||||
self.copy_button.clicked.connect(self.copy_to_clipboard)
|
||||
self.save_button = QPushButton("파일로 저장")
|
||||
self.save_button.clicked.connect(self._save_dialog)
|
||||
self.clear_button = QPushButton("화면 비우기")
|
||||
self.clear_button.setToolTip("이 화면만 비웁니다. livesub.log 파일은 그대로 둡니다.")
|
||||
self.clear_button.clicked.connect(self.clear)
|
||||
for button in (self.copy_button, self.save_button, self.clear_button):
|
||||
row.addWidget(button)
|
||||
row.addStretch(1)
|
||||
self.notice = QLabel()
|
||||
self.notice.setObjectName("Hint")
|
||||
row.addWidget(self.notice)
|
||||
card.add(buttons)
|
||||
|
||||
self.view = QPlainTextEdit()
|
||||
self.view.setReadOnly(True)
|
||||
self.view.setLineWrapMode(QPlainTextEdit.LineWrapMode.WidgetWidth)
|
||||
self.view.setMaximumBlockCount(MAX_RECORDS)
|
||||
self.view.setFont(QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont))
|
||||
self.view.setMinimumHeight(520)
|
||||
card.add(self.view)
|
||||
root.addWidget(card, 1)
|
||||
|
||||
self.view.setPlainText(buffer.text())
|
||||
self.line_logged.connect(self._append)
|
||||
signal = self.line_logged
|
||||
|
||||
def forward(line: str) -> None:
|
||||
try:
|
||||
signal.emit(line)
|
||||
except RuntimeError: # 창이 이미 사라졌다
|
||||
buffer.unsubscribe(forward)
|
||||
|
||||
self._forward = forward
|
||||
buffer.subscribe(forward)
|
||||
|
||||
# --- 동작 -----------------------------------------------------------
|
||||
def report(self) -> str:
|
||||
"""보낼 내용 전체. 맨 위에 실행 환경을 붙여서 로그만 봐도 상황을 알게 한다."""
|
||||
models = self.config.models
|
||||
audio = self.config.audio
|
||||
header = [
|
||||
f"{APP_NAME} v{APP_VERSION} · {platform.platform()} · Python {platform.python_version()}",
|
||||
f"티어 {models.tier} · 장치 {models.device} · 원본 {models.source_lang} → "
|
||||
f"번역 {models.target_lang} · 소리 {audio.backend}"
|
||||
f"{' ' + audio.target_process_name if audio.backend == 'process' else ''}",
|
||||
f"저장 위치 {user_data_dir()} · 기록 시각 {datetime.now():%Y-%m-%d %H:%M:%S}",
|
||||
"-" * 60,
|
||||
]
|
||||
return "\n".join(header) + "\n" + self.buffer.text() + "\n"
|
||||
|
||||
def copy_to_clipboard(self) -> None:
|
||||
QGuiApplication.clipboard().setText(self.report())
|
||||
self.notice.setText(f"{len(self.buffer.lines())}줄을 복사했습니다")
|
||||
|
||||
def save_to(self, path: str) -> None:
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
f.write(self.report())
|
||||
self.notice.setText(f"저장했습니다: {path}")
|
||||
|
||||
def _save_dialog(self) -> None:
|
||||
default = user_data_dir() / datetime.now().strftime("livesub-log-%Y%m%d-%H%M%S.txt")
|
||||
path, _ = QFileDialog.getSaveFileName(
|
||||
self, "로그 저장", str(default), "텍스트 파일 (*.txt)"
|
||||
)
|
||||
if not path:
|
||||
return
|
||||
try:
|
||||
self.save_to(path)
|
||||
except OSError as exc:
|
||||
self.notice.setText(f"저장하지 못했습니다: {exc}")
|
||||
|
||||
def clear(self) -> None:
|
||||
self.buffer.clear()
|
||||
self.view.clear()
|
||||
self.notice.setText("")
|
||||
|
||||
def _append(self, line: str) -> None:
|
||||
bar = self.view.verticalScrollBar()
|
||||
at_bottom = bar.value() >= bar.maximum() - 4
|
||||
self.view.appendPlainText(line)
|
||||
# 위로 올려 읽는 중이면 끌어내리지 않는다.
|
||||
if at_bottom:
|
||||
bar.setValue(bar.maximum())
|
||||
|
||||
def showEvent(self, event) -> None: # noqa: N802
|
||||
# 숨어 있는 동안 쌓인 줄은 스크롤 위치를 못 맞춘다. 열 때 최신 줄로 내린다.
|
||||
super().showEvent(event)
|
||||
bar = self.view.verticalScrollBar()
|
||||
bar.setValue(bar.maximum())
|
||||
@@ -17,8 +17,8 @@ from PySide6.QtWidgets import (
|
||||
)
|
||||
|
||||
from ...config import AppConfig
|
||||
from ...models import Tier, detect_gpu, ordered_tiers
|
||||
from ...models.manager import GpuInfo, tier_availability
|
||||
from ...models import Tier, detect_gpu, get_tier, ordered_tiers
|
||||
from ...models.manager import GpuInfo, recommended_tier, tier_availability
|
||||
from ..theme import SPACING, palette
|
||||
from ..widgets import Card, PageHeader
|
||||
|
||||
@@ -26,7 +26,13 @@ from ..widgets import Card, PageHeader
|
||||
class TierCard(QFrame):
|
||||
"""티어 하나를 라디오 버튼 카드로."""
|
||||
|
||||
def __init__(self, tier: Tier, gpu: GpuInfo, parent: QWidget | None = None):
|
||||
def __init__(
|
||||
self,
|
||||
tier: Tier,
|
||||
gpu: GpuInfo,
|
||||
recommended: bool = False,
|
||||
parent: QWidget | None = None,
|
||||
):
|
||||
super().__init__(parent)
|
||||
self.tier = tier
|
||||
gpu_vram_gb = gpu.total_vram_mb / 1024 if gpu.available else 0.0
|
||||
@@ -49,8 +55,10 @@ class TierCard(QFrame):
|
||||
name = QLabel(f"{tier.order}. {tier.name}")
|
||||
name.setStyleSheet("font-size: 16px; font-weight: 700;")
|
||||
head.addWidget(name)
|
||||
if tier.recommended:
|
||||
head.addWidget(_badge("추천", p.accent))
|
||||
# '추천'은 표에 박힌 값이 아니라 이 PC 기준으로 계산해서 붙인다.
|
||||
# GPU 가 없는데 10GB 짜리에 추천 배지가 달려 있으면 안내가 아니라 함정이다.
|
||||
if recommended:
|
||||
head.addWidget(_badge("CPU 추천" if not gpu.available else "추천", p.accent))
|
||||
if tier.best_after_finetune:
|
||||
head.addWidget(_badge("추가학습 최적", p.success))
|
||||
if gpu_vram_gb and gpu_vram_gb < tier.min_vram_gb:
|
||||
@@ -106,6 +114,8 @@ class ModelsPage(QWidget):
|
||||
# 티어 카드마다 조회하면 nvidia-smi 를 다섯 번 부른다. 한 번만 본다.
|
||||
self._gpu = detect_gpu()
|
||||
self._gpu_vram_gb = self._gpu.total_vram_mb / 1024 if self._gpu.available else 0.0
|
||||
#: 이 PC 기준 추천 티어. GPU 가 없으면 CPU 에서 실제로 돌아가는 쪽을 권한다.
|
||||
self._recommended = recommended_tier(self._gpu)
|
||||
|
||||
root = QVBoxLayout(self)
|
||||
root.setContentsMargins(0, 0, 0, 0)
|
||||
@@ -123,7 +133,7 @@ class ModelsPage(QWidget):
|
||||
self._group = QButtonGroup(self)
|
||||
self._group.setExclusive(True)
|
||||
for tier in ordered_tiers():
|
||||
card = TierCard(tier, self._gpu)
|
||||
card = TierCard(tier, self._gpu, recommended=tier.key == self._recommended)
|
||||
self._group.addButton(card.radio, tier.order)
|
||||
card.radio.toggled.connect(
|
||||
lambda checked, t=tier: self._on_tier_selected(t) if checked else None
|
||||
@@ -163,6 +173,10 @@ class ModelsPage(QWidget):
|
||||
self.device_combo = QComboBox()
|
||||
self.device_combo.addItem("GPU (CUDA)", "cuda")
|
||||
self.device_combo.addItem("CPU", "cpu")
|
||||
# GPU 가 없으면 콤보를 비활성화만 하고 "GPU (CUDA)" 를 그대로 띄워두면
|
||||
# 실제로는 CPU 로 도는데 화면은 GPU 라고 말하는 상태가 된다. 맞춰둔다.
|
||||
if not gpu.available:
|
||||
self.config.models.device = "cpu"
|
||||
self.device_combo.setCurrentIndex(
|
||||
max(0, self.device_combo.findData(self.config.models.device))
|
||||
)
|
||||
@@ -171,8 +185,42 @@ class ModelsPage(QWidget):
|
||||
layout.addWidget(self.device_combo)
|
||||
|
||||
card.add(row)
|
||||
|
||||
if not gpu.available:
|
||||
card.add(self._build_cpu_advice_row())
|
||||
return card
|
||||
|
||||
def _build_cpu_advice_row(self) -> QWidget:
|
||||
"""GPU 를 못 찾았을 때 CPU 에서 실제로 쓸 만한 설정을 권한다."""
|
||||
tier = get_tier(self._recommended)
|
||||
row = QWidget()
|
||||
row.setObjectName("Row")
|
||||
layout = QHBoxLayout(row)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
layout.setSpacing(10)
|
||||
|
||||
advice = QLabel(
|
||||
f"CPU 에서는 '{tier.order}. {tier.name}' 를 권합니다 — "
|
||||
f"CPU 로 실시간 자막이 따라오는 가장 무거운 구성입니다. "
|
||||
f"상위 티어는 한 문장에 수십 초가 걸려 실시간으로 쓸 수 없습니다."
|
||||
)
|
||||
advice.setObjectName("Hint")
|
||||
advice.setWordWrap(True)
|
||||
layout.addWidget(advice, 1)
|
||||
|
||||
apply_button = QPushButton("추천대로 맞추기")
|
||||
apply_button.clicked.connect(self._apply_recommended)
|
||||
layout.addWidget(apply_button)
|
||||
return row
|
||||
|
||||
def _apply_recommended(self) -> None:
|
||||
self.config.models.device = "cpu"
|
||||
self.device_combo.blockSignals(True)
|
||||
self.device_combo.setCurrentIndex(max(0, self.device_combo.findData("cpu")))
|
||||
self.device_combo.blockSignals(False)
|
||||
self._apply_selection(self._recommended)
|
||||
self._on_tier_selected(get_tier(self._recommended))
|
||||
|
||||
def _build_lora_card(self) -> Card:
|
||||
card = Card(
|
||||
"추가학습 어댑터 (선택)",
|
||||
|
||||
@@ -61,6 +61,8 @@ class SubtitlePage(QWidget):
|
||||
overlay_toggled = Signal(bool)
|
||||
#: 자막을 띄울 모니터 / 9분할 위치가 바뀜
|
||||
placement_changed = Signal()
|
||||
#: '자막 위치 조정' 버튼 — 오버레이를 조정 가능한 상태로 열고 닫는다
|
||||
edit_mode_requested = Signal(bool)
|
||||
|
||||
def __init__(self, config: AppConfig, parent: QWidget | None = None):
|
||||
super().__init__(parent)
|
||||
@@ -88,7 +90,7 @@ class SubtitlePage(QWidget):
|
||||
card = Card(
|
||||
"표시 위치",
|
||||
"모니터를 고르고 네모칸을 누르면 그 자리에 자막이 붙습니다. "
|
||||
"직접 드래그해서 옮기면 그 위치를 그대로 기억합니다.",
|
||||
"칸에 없는 자리에 두고 싶으면 아래 '자막 위치 조정'으로 직접 옮기세요.",
|
||||
)
|
||||
|
||||
# --- on/off + 단축키 안내 ---
|
||||
@@ -159,9 +161,55 @@ class SubtitlePage(QWidget):
|
||||
margin_layout.addStretch(1)
|
||||
card.add(margin_row)
|
||||
|
||||
# --- 직접 옮기기 ---
|
||||
# 자막 창은 기본적으로 잠겨 있다. 게임 중에 잘못 건드려 끌고 다니는
|
||||
# 사고를 막기 위해서다. 옮기거나 크기를 바꿀 때만 여기서 연다.
|
||||
adjust_row = QWidget()
|
||||
adjust_layout = QHBoxLayout(adjust_row)
|
||||
adjust_layout.setContentsMargins(0, 0, 0, 0)
|
||||
adjust_layout.setSpacing(10)
|
||||
|
||||
self.adjust_button = QPushButton("자막 위치 조정")
|
||||
self.adjust_button.setCheckable(True)
|
||||
self.adjust_button.setMinimumWidth(150)
|
||||
self.adjust_button.toggled.connect(self.edit_mode_requested.emit)
|
||||
adjust_layout.addWidget(self.adjust_button)
|
||||
|
||||
self.adjust_hint = QLabel()
|
||||
self.adjust_hint.setObjectName("Hint")
|
||||
self.adjust_hint.setWordWrap(True)
|
||||
adjust_layout.addWidget(self.adjust_hint, 1)
|
||||
card.add(adjust_row)
|
||||
self.set_edit_mode(False)
|
||||
|
||||
self.refresh_screens()
|
||||
return card
|
||||
|
||||
def set_edit_mode(self, on: bool) -> None:
|
||||
"""오버레이의 위치 조정 상태를 버튼과 안내에 반영한다."""
|
||||
self.adjust_button.blockSignals(True)
|
||||
self.adjust_button.setChecked(on)
|
||||
self.adjust_button.blockSignals(False)
|
||||
self.adjust_button.setText("조정 끝내기" if on else "자막 위치 조정")
|
||||
self.adjust_button.setObjectName("Danger" if on else "")
|
||||
self.adjust_button.style().polish(self.adjust_button)
|
||||
self.adjust_hint.setText(
|
||||
"자막 창을 끌어서 옮기고, 네 모서리를 잡아 크기를 바꾸세요. "
|
||||
"크기를 바꾸면 글자 크기도 같이 따라옵니다."
|
||||
if on
|
||||
else "평소에는 자막이 잠겨 있어 게임 중에 실수로 움직이지 않습니다."
|
||||
)
|
||||
|
||||
def set_font_size(self, size: int) -> None:
|
||||
"""자막 창에서 크기를 바꿨을 때 설정 화면 숫자를 맞춘다."""
|
||||
if size == self.size_spin.value():
|
||||
return
|
||||
self.size_spin.blockSignals(True)
|
||||
self.size_spin.setValue(size)
|
||||
self.size_spin.blockSignals(False)
|
||||
self.config.subtitle.font_size = size
|
||||
self._sync_preview()
|
||||
|
||||
def _build_preview_card(self) -> Card:
|
||||
card = Card("미리보기", "실제 자막 창과 같은 방식으로 그립니다.")
|
||||
self.preview = SubtitlePreview(self.config.subtitle)
|
||||
@@ -238,6 +286,17 @@ class SubtitlePage(QWidget):
|
||||
layout.addWidget(self.opacity_value)
|
||||
form.addRow("배경 투명도", opacity_row)
|
||||
|
||||
self.padding_spin = QSpinBox()
|
||||
self.padding_spin.setRange(0, 80)
|
||||
self.padding_spin.setSuffix(" px")
|
||||
self.padding_spin.setValue(st.padding)
|
||||
self.padding_spin.setToolTip(
|
||||
"배경 상자는 글자를 감싸는 크기로 그려집니다. 이 값이 글자와 상자 "
|
||||
"가장자리 사이 간격, 곧 배경 크기를 정합니다."
|
||||
)
|
||||
self.padding_spin.valueChanged.connect(self._on_change)
|
||||
form.addRow("배경 여백", self.padding_spin)
|
||||
|
||||
self.align_combo = QComboBox()
|
||||
for label, value in (("가운데", "center"), ("왼쪽", "left"), ("오른쪽", "right")):
|
||||
self.align_combo.addItem(label, value)
|
||||
@@ -345,6 +404,7 @@ class SubtitlePage(QWidget):
|
||||
st.outline_width = self.outline_spin.value()
|
||||
st.background_color = self.bg_color.color
|
||||
st.background_opacity = self.opacity_slider.value()
|
||||
st.padding = self.padding_spin.value()
|
||||
st.align = self.align_combo.currentData()
|
||||
st.max_lines = self.lines_spin.value()
|
||||
st.fade_out_ms = self.fade_spin.value()
|
||||
|
||||
@@ -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:
|
||||
|
||||
21
tests/conftest.py
Normal file
21
tests/conftest.py
Normal file
@@ -0,0 +1,21 @@
|
||||
"""모든 테스트 공통 설정."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _no_cublas_download(monkeypatch):
|
||||
"""엔진 테스트가 Windows 에서 cuBLAS(541MB)를 실제로 받지 않게 한다.
|
||||
|
||||
기본 설정이 device=cuda 라 엔진을 띄우면 Windows 에서는 시작 때 cuBLAS 를
|
||||
준비한다. 그러면 시작이 느려져 시간 제한이 있는 테스트가 실패한다. 엔진이
|
||||
붙잡은 모듈 참조만 바꾸므로 `test_cuda_runtime` 은 진짜 모듈을 그대로 본다.
|
||||
"""
|
||||
monkeypatch.setattr(
|
||||
"livesub.core.engine.cuda_runtime",
|
||||
SimpleNamespace(ensure=lambda *args, **kwargs: False),
|
||||
)
|
||||
229
tests/test_asr_language.py
Normal file
229
tests/test_asr_language.py
Normal file
@@ -0,0 +1,229 @@
|
||||
"""억양 때문에 언어를 잘못 감지했을 때 다시 받아 적는지 (모델 없이 가짜로)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from types import SimpleNamespace
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
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] = []
|
||||
self.prompts: list[str | None] = []
|
||||
|
||||
def transcribe(self, audio, language=None, vad_filter=False, initial_prompt=None, **_):
|
||||
self.vad_calls.append(vad_filter)
|
||||
self.prompts.append(initial_prompt)
|
||||
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_retry_without_vad_does_not_echo_previous_line():
|
||||
"""말소리가 없으면 Whisper 는 prompt 를 따라 적는다. 다시 받을 때는 넘기지 않는다."""
|
||||
fake = SileroDropsWhisper(EFFECT_VOICE)
|
||||
recognizer(fake).transcribe(FIVE_SECONDS, prompt="Okay.", target_lang="ko")
|
||||
assert fake.prompts == ["Okay.", None]
|
||||
|
||||
|
||||
# 실측값 (turbo, 잡음만 넣고 Silero 없이 받음). 모두 확률·길이 기준을 통과한다.
|
||||
@pytest.mark.parametrize(
|
||||
"noise",
|
||||
[
|
||||
raw(" Okay.", 2.0, -0.76), # 직전 자막 "Okay." 를 prompt 로 줬을 때
|
||||
raw(" Obrigado.", 1.0, -0.31),
|
||||
raw(" you", 3.0, -0.95),
|
||||
],
|
||||
ids=["okay", "obrigado", "you"],
|
||||
)
|
||||
def test_stock_hallucination_without_vad_is_dropped(noise):
|
||||
fake = SileroDropsWhisper([noise])
|
||||
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]
|
||||
75
tests/test_audio_sources.py
Normal file
75
tests/test_audio_sources.py
Normal file
@@ -0,0 +1,75 @@
|
||||
"""캡처 대상 목록 — 출력(게임 소리)과 입력(마이크) 전환."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
from livesub import audio
|
||||
from livesub.audio import (
|
||||
SOURCE_MODE_INPUT,
|
||||
SOURCE_MODE_OUTPUT,
|
||||
AudioSource,
|
||||
CaptureError,
|
||||
InputDeviceCapture,
|
||||
create_capture,
|
||||
list_sources,
|
||||
)
|
||||
from livesub.config import AudioConfig
|
||||
|
||||
MIC = AudioSource(kind="input", identifier="3", label="마이크 (Realtek)", detail="기본 입력 장치")
|
||||
SPEAKER = AudioSource(kind="device", identifier="7", label="스피커", detail="기본 출력 장치")
|
||||
GAME = AudioSource(kind="process", identifier="4242", label="Overwatch.exe")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_devices(monkeypatch):
|
||||
monkeypatch.setattr(InputDeviceCapture, "available", staticmethod(lambda: True))
|
||||
monkeypatch.setattr(InputDeviceCapture, "list_sources", staticmethod(lambda: [MIC]))
|
||||
monkeypatch.setattr(
|
||||
audio.WasapiLoopbackCapture, "list_sources", staticmethod(lambda: [SPEAKER])
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
audio.ProcessLoopbackCapture, "available", staticmethod(lambda: True)
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
audio.ProcessLoopbackCapture, "list_sources", staticmethod(lambda: [GAME])
|
||||
)
|
||||
|
||||
|
||||
def test_기본은_프로그램과_출력_장치를_보여준다(fake_devices):
|
||||
kinds = [s.kind for s in list_sources()]
|
||||
assert kinds == ["process", "device"]
|
||||
assert list_sources() == list_sources(SOURCE_MODE_OUTPUT)
|
||||
|
||||
|
||||
def test_입력_모드는_마이크만_보여준다(fake_devices):
|
||||
"""두 목록을 섞으면 찾으려던 게임이 라인입력 사이에 파묻힌다."""
|
||||
sources = list_sources(SOURCE_MODE_INPUT)
|
||||
assert [s.kind for s in sources] == ["input"]
|
||||
assert sources[0].label == "마이크 (Realtek)"
|
||||
|
||||
|
||||
def test_입력_장치도_장치_번호를_준다():
|
||||
assert MIC.device_index == 3
|
||||
assert MIC.pid == 0
|
||||
|
||||
|
||||
def test_입력_백엔드로_캡처를_만든다(fake_devices):
|
||||
cfg = AudioConfig(backend="input", device_index=3)
|
||||
capture = create_capture(cfg)
|
||||
assert isinstance(capture, InputDeviceCapture)
|
||||
assert capture.device_index == 3
|
||||
|
||||
|
||||
def test_입력_장치를_못_열면_이유를_알려준다(monkeypatch):
|
||||
monkeypatch.setattr(InputDeviceCapture, "available", staticmethod(lambda: False))
|
||||
with pytest.raises(CaptureError, match="입력 장치"):
|
||||
create_capture(AudioConfig(backend="input", device_index=3))
|
||||
|
||||
|
||||
def test_입력_가능_여부가_환경_보고에_들어간다():
|
||||
assert "input" in audio.capture_capabilities()
|
||||
|
||||
|
||||
def test_고른_목록_쪽을_설정에_기억한다():
|
||||
assert AudioConfig().source_mode == SOURCE_MODE_OUTPUT
|
||||
76
tests/test_cuda_runtime.py
Normal file
76
tests/test_cuda_runtime.py
Normal file
@@ -0,0 +1,76 @@
|
||||
"""cuBLAS 내려받기·꺼내기 (Windows exe 에서 GPU 로 받아 적는 데 필요)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import zipfile
|
||||
|
||||
import pytest
|
||||
|
||||
from livesub.models import cuda_runtime
|
||||
|
||||
|
||||
def _fake_wheel(tmp_path):
|
||||
wheel = tmp_path / "fake.whl"
|
||||
with zipfile.ZipFile(wheel, "w") as zf:
|
||||
zf.writestr("nvidia/cublas/bin/cublasLt64_12.dll", b"LT" * 1000)
|
||||
zf.writestr("nvidia/cublas/bin/cublas64_12.dll", b"BLAS" * 1000)
|
||||
zf.writestr("nvidia/cublas/bin/nvblas64_12.dll", b"unused")
|
||||
zf.writestr("nvidia/cublas/include/cublas.h", b"header")
|
||||
data = wheel.read_bytes()
|
||||
return wheel.as_uri(), hashlib.sha256(data).hexdigest(), len(data)
|
||||
|
||||
|
||||
def test_download_extracts_only_the_two_dlls(tmp_path):
|
||||
url, sha, size = _fake_wheel(tmp_path)
|
||||
target = tmp_path / "runtime"
|
||||
seen = []
|
||||
|
||||
cuda_runtime.download(target, lambda msg, pct: seen.append(pct), url, sha, size)
|
||||
|
||||
assert cuda_runtime.installed(target)
|
||||
assert (target / "cublasLt64_12.dll").read_bytes() == b"LT" * 1000
|
||||
assert (target / "cublas64_12.dll").read_bytes() == b"BLAS" * 1000
|
||||
assert sorted(p.name for p in target.iterdir()) == ["cublas64_12.dll", "cublasLt64_12.dll"]
|
||||
assert seen and seen[-1] == 1.0
|
||||
|
||||
|
||||
def test_corrupted_download_leaves_nothing_behind(tmp_path):
|
||||
url, _sha, size = _fake_wheel(tmp_path)
|
||||
target = tmp_path / "runtime"
|
||||
|
||||
with pytest.raises(RuntimeError, match="손상"):
|
||||
cuda_runtime.download(target, None, url, "0" * 64, size)
|
||||
|
||||
assert not cuda_runtime.installed(target)
|
||||
assert list(target.iterdir()) == []
|
||||
|
||||
|
||||
def test_pinned_wheel_is_the_blackwell_capable_cublas():
|
||||
# RTX 50 계열(sm_120)은 cuBLAS 12.8 부터 지원한다.
|
||||
major, minor = (int(x) for x in cuda_runtime.WHEEL_VERSION.split(".")[:2])
|
||||
assert (major, minor) >= (12, 8)
|
||||
assert cuda_runtime.WHEEL_VERSION in cuda_runtime.WHEEL_URL
|
||||
assert cuda_runtime.WHEEL_URL.endswith("win_amd64.whl")
|
||||
|
||||
|
||||
def test_ensure_is_a_no_op_off_windows_or_on_cpu(monkeypatch):
|
||||
monkeypatch.setattr(cuda_runtime.sys, "platform", "linux")
|
||||
assert cuda_runtime.ensure(device="cuda") is False
|
||||
monkeypatch.setattr(cuda_runtime.sys, "platform", "win32")
|
||||
assert cuda_runtime.ensure(device="cpu") is False
|
||||
|
||||
|
||||
def test_download_stops_when_cancelled(tmp_path):
|
||||
import threading
|
||||
|
||||
url, sha, size = _fake_wheel(tmp_path)
|
||||
target = tmp_path / "runtime"
|
||||
cancel = threading.Event()
|
||||
cancel.set()
|
||||
|
||||
with pytest.raises(cuda_runtime.DownloadCancelled):
|
||||
cuda_runtime.download(target, None, url, sha, size, cancel=cancel)
|
||||
|
||||
assert not cuda_runtime.installed(target)
|
||||
assert list(target.iterdir()) == []
|
||||
156
tests/test_level_meter.py
Normal file
156
tests/test_level_meter.py
Normal 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() == "번역을 시작하면 움직입니다"
|
||||
37
tests/test_model_repos.py
Normal file
37
tests/test_model_repos.py
Normal file
@@ -0,0 +1,37 @@
|
||||
"""티어에 적힌 Hugging Face 저장소가 실제로 로그인 없이 받아지는지 확인한다.
|
||||
|
||||
저장소 이름이 틀리면 사용자 PC에서 "번역 시작"을 누를 때 401/404 로 처음 드러난다.
|
||||
(v0.3.0-test4: 존재하지 않는 Systran/faster-whisper-large-v3-turbo 를 가리키고 있었다.)
|
||||
네트워크가 없으면 건너뛴다.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
|
||||
from livesub.models.tiers import TIERS
|
||||
|
||||
huggingface_hub = pytest.importorskip("huggingface_hub")
|
||||
|
||||
|
||||
def _repos() -> list[str]:
|
||||
return sorted({r for t in TIERS.values() for r in (t.asr.repo, t.mt.repo)})
|
||||
|
||||
|
||||
def _online() -> bool:
|
||||
try:
|
||||
huggingface_hub.HfApi().model_info("Systran/faster-whisper-small", token=False)
|
||||
except Exception:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
@pytest.mark.parametrize("repo", _repos())
|
||||
def test_repo_is_public_and_has_weights(repo):
|
||||
if not _online():
|
||||
pytest.skip("Hugging Face 에 접속할 수 없음")
|
||||
info = huggingface_hub.HfApi().model_info(repo, token=False)
|
||||
assert not info.private
|
||||
assert not info.gated
|
||||
files = {s.rfilename for s in info.siblings}
|
||||
assert files & {"model.bin", "model.safetensors"} or any(
|
||||
f.endswith(".safetensors") for f in files
|
||||
), f"{repo}: 가중치 파일이 없음 ({sorted(files)})"
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import threading
|
||||
import time
|
||||
|
||||
import numpy as np
|
||||
@@ -55,7 +56,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)
|
||||
|
||||
|
||||
@@ -129,3 +130,126 @@ def test_to_mono_16k_passthrough_when_already_correct():
|
||||
mono = np.linspace(-1, 1, 16_000, dtype=np.float32)
|
||||
out = to_mono_16k(mono, channels=1, src_rate=16_000)
|
||||
assert np.array_equal(out, mono)
|
||||
|
||||
|
||||
class CublasMissingRecognizer(FakeRecognizer):
|
||||
"""Windows exe 에서 cuBLAS 가 없을 때 CTranslate2 가 내는 오류를 흉내 낸다."""
|
||||
|
||||
def transcribe(self, *args, **kwargs):
|
||||
raise RuntimeError("Library cublas64_12.dll is not found or cannot be loaded")
|
||||
|
||||
|
||||
def _wait_for(predicate, timeout=12.0):
|
||||
deadline = time.time() + timeout
|
||||
while time.time() < deadline and not predicate():
|
||||
time.sleep(0.05)
|
||||
return predicate()
|
||||
|
||||
|
||||
def test_gpu_failure_falls_back_to_cpu_and_still_produces_lines(engine, monkeypatch):
|
||||
statuses = []
|
||||
engine._on_status = statuses.append
|
||||
monkeypatch.setattr(
|
||||
engine.models,
|
||||
"recognizer",
|
||||
lambda: CublasMissingRecognizer() if engine.models.device == "cuda" else FakeRecognizer(),
|
||||
)
|
||||
assert engine.models.device == "cuda"
|
||||
|
||||
engine.start()
|
||||
assert _wait_for(lambda: engine.lines), "CPU 로 바꾼 뒤에도 자막이 나오지 않았습니다"
|
||||
engine.stop()
|
||||
|
||||
assert engine.models.device == "cpu"
|
||||
assert engine.config.models.device == "cuda", "설정 파일 값은 그대로 둬야 한다"
|
||||
assert any("CPU로" in s.message and "cublas" in s.message for s in statuses)
|
||||
|
||||
|
||||
def test_non_gpu_failure_is_shown_on_status(engine, monkeypatch):
|
||||
statuses = []
|
||||
engine._on_status = statuses.append
|
||||
|
||||
class Broken(FakeRecognizer):
|
||||
def transcribe(self, *args, **kwargs):
|
||||
raise ValueError("토크나이저가 깨졌습니다")
|
||||
|
||||
monkeypatch.setattr(engine.models, "recognizer", lambda: Broken())
|
||||
engine.start()
|
||||
assert _wait_for(lambda: any("문장 처리 실패" in s.message for s in statuses))
|
||||
engine.stop()
|
||||
assert engine.models.device == "cuda", "GPU 와 상관없는 오류로 CPU 로 바꾸면 안 된다"
|
||||
assert any("토크나이저가 깨졌습니다" in s.message for s in statuses)
|
||||
|
||||
|
||||
def test_gpu_runtime_download_failure_runs_on_cpu(engine, monkeypatch):
|
||||
statuses = []
|
||||
engine._on_status = statuses.append
|
||||
|
||||
def fail(*args, **kwargs):
|
||||
raise OSError("네트워크 연결 없음")
|
||||
|
||||
monkeypatch.setattr("livesub.core.engine.cuda_runtime.ensure", fail)
|
||||
engine.start()
|
||||
assert _wait_for(lambda: engine.lines)
|
||||
engine.stop()
|
||||
assert engine.models.device == "cpu"
|
||||
running = [s for s in statuses if s.state.value == "running"]
|
||||
assert running and "GPU 계산 파일을 받지 못했습니다" in running[0].message
|
||||
|
||||
|
||||
def test_gpu_failure_while_preloading_falls_back_to_cpu(engine, monkeypatch):
|
||||
"""기본값(preload_on_start=True)에서 GPU 로 모델이 안 올라가도 CPU 로 시작한다."""
|
||||
statuses = []
|
||||
engine._on_status = statuses.append
|
||||
engine.config.models.preload_on_start = True
|
||||
devices = []
|
||||
|
||||
def preload(progress=None):
|
||||
devices.append(engine.models.device)
|
||||
if engine.models.device == "cuda":
|
||||
raise RuntimeError("CUDA failed with error no CUDA-capable device is detected")
|
||||
|
||||
monkeypatch.setattr(engine.models, "preload", preload)
|
||||
engine.start()
|
||||
assert _wait_for(lambda: engine.lines), "CPU 로 바꾼 뒤에도 자막이 나오지 않았습니다"
|
||||
engine.stop()
|
||||
|
||||
assert devices == ["cuda", "cpu"]
|
||||
assert not any(s.state.value == "error" for s in statuses)
|
||||
running = [s for s in statuses if s.state.value == "running"]
|
||||
assert running and "CPU로" in running[0].message
|
||||
|
||||
|
||||
def test_stop_while_downloading_gpu_runtime_never_starts_capture(engine, monkeypatch):
|
||||
"""cuBLAS 를 받는 중에 정지하면 받기를 멈추고, 캡처를 켜지 않는다."""
|
||||
from livesub.models.cuda_runtime import DownloadCancelled
|
||||
|
||||
statuses = []
|
||||
engine._on_status = statuses.append
|
||||
downloading = threading.Event()
|
||||
captures = []
|
||||
|
||||
def slow_download(progress=None, device="cuda", cancel=None):
|
||||
downloading.set()
|
||||
while not cancel.is_set():
|
||||
progress("GPU 계산 파일 받는 중", 0.1)
|
||||
time.sleep(0.05)
|
||||
raise DownloadCancelled("멈춤")
|
||||
|
||||
def make_capture(cfg):
|
||||
captures.append(cfg)
|
||||
return FakeCapture()
|
||||
|
||||
monkeypatch.setattr("livesub.core.engine.cuda_runtime.ensure", slow_download)
|
||||
monkeypatch.setattr("livesub.core.engine.create_capture", make_capture)
|
||||
engine.start()
|
||||
assert downloading.wait(5)
|
||||
engine.stop()
|
||||
boot_done = _wait_for(lambda: not any(t.name == "engine-boot" for t in threading.enumerate()), 5)
|
||||
time.sleep(0.3)
|
||||
|
||||
assert boot_done, "정지했는데 시작 작업이 끝나지 않았습니다"
|
||||
assert captures == [], "정지한 뒤에 캡처가 켜졌습니다"
|
||||
assert engine.status.state.value == "idle"
|
||||
assert statuses[-1].state.value == "idle"
|
||||
assert engine.models.device == "cuda", "정지는 GPU 실패가 아니다"
|
||||
|
||||
@@ -133,7 +133,7 @@ def test_app_window_builds_without_torch(tmp_path, monkeypatch):
|
||||
cfg.glossary.path = str(tmp_path / "g.json")
|
||||
win = MainWindow(cfg)
|
||||
try:
|
||||
assert win.stack.count() == 5
|
||||
assert win.stack.count() == 6
|
||||
finally:
|
||||
win.engine.shutdown()
|
||||
win.overlay.close()
|
||||
|
||||
@@ -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 = []
|
||||
|
||||
149
tests/test_subtitle_box.py
Normal file
149
tests/test_subtitle_box.py
Normal file
@@ -0,0 +1,149 @@
|
||||
"""자막 배경 상자(padding)와 위치 조정 모드."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
import pytest
|
||||
|
||||
pytest.importorskip("PySide6")
|
||||
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
||||
|
||||
from PySide6.QtCore import QPoint, QRect # noqa: E402
|
||||
from PySide6.QtWidgets import QApplication # noqa: E402
|
||||
|
||||
from livesub.config import OverlayConfig, SubtitleStyle # noqa: E402
|
||||
from livesub.ui.overlay import SubtitleOverlay, _content_box # noqa: E402
|
||||
|
||||
WINDOW = QRect(0, 0, 1000, 400)
|
||||
|
||||
|
||||
@pytest.fixture(scope="session")
|
||||
def qapp():
|
||||
app = QApplication.instance() or QApplication([])
|
||||
yield app
|
||||
|
||||
|
||||
# --- 배경 상자 -------------------------------------------------------------
|
||||
|
||||
|
||||
def test_배경은_글자를_감싼다():
|
||||
"""창 전체가 아니라 글자 크기에 맞춰야 여백이 곧 배경 크기가 된다."""
|
||||
box = _content_box(WINDOW, text_w=300, text_h=60, pad=18, align="center")
|
||||
assert box.width() == 300 + 18 * 2
|
||||
assert box.height() == 60 + 18 * 2
|
||||
assert box.width() < WINDOW.width()
|
||||
|
||||
|
||||
def test_여백을_키우면_배경이_커진다():
|
||||
small = _content_box(WINDOW, 300, 60, pad=8, align="center")
|
||||
large = _content_box(WINDOW, 300, 60, pad=40, align="center")
|
||||
assert large.width() - small.width() == (40 - 8) * 2
|
||||
assert large.height() - small.height() == (40 - 8) * 2
|
||||
|
||||
|
||||
def test_배경은_창_밖으로_넘지_않는다():
|
||||
box = _content_box(WINDOW, text_w=5000, text_h=5000, pad=40, align="center")
|
||||
assert box.width() == WINDOW.width()
|
||||
assert box.height() == WINDOW.height()
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("align", "expected_left"),
|
||||
[("left", 0), ("center", (1000 - 336) // 2), ("right", 1000 - 336)],
|
||||
)
|
||||
def test_정렬에_따라_상자가_붙는_쪽이_달라진다(align, expected_left):
|
||||
box = _content_box(WINDOW, text_w=300, text_h=60, pad=18, align=align)
|
||||
assert box.width() == 336
|
||||
assert abs(box.x() - expected_left) <= 1
|
||||
|
||||
|
||||
def test_기본_여백이_설정에_있다():
|
||||
assert SubtitleStyle().padding > 0
|
||||
|
||||
|
||||
# --- 위치 조정 모드 --------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def overlay(qapp):
|
||||
cfg = OverlayConfig()
|
||||
cfg.visible = False
|
||||
widget = SubtitleOverlay(SubtitleStyle(), cfg)
|
||||
yield widget
|
||||
widget.close()
|
||||
|
||||
|
||||
def test_기본은_잠겨_있어_움직이지_않는다(overlay):
|
||||
"""게임 중에 자막을 실수로 끌고 다니는 사고를 막는 기본값이다."""
|
||||
assert OverlayConfig().locked is True
|
||||
assert overlay.edit_mode is False
|
||||
assert overlay._interactive is False
|
||||
|
||||
|
||||
def test_위치_조정을_켜면_잡을_수_있다(overlay):
|
||||
overlay.set_edit_mode(True)
|
||||
assert overlay.edit_mode is True
|
||||
assert overlay._interactive is True
|
||||
# 클릭 통과가 켜져 있으면 마우스가 창을 그냥 지나가 잡을 수가 없다.
|
||||
from PySide6.QtCore import Qt
|
||||
|
||||
assert not overlay.testAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
|
||||
|
||||
overlay.set_edit_mode(False)
|
||||
assert overlay._interactive is False
|
||||
|
||||
|
||||
def test_모서리를_집었는지_알아본다(overlay):
|
||||
overlay.setGeometry(0, 0, 600, 200)
|
||||
assert overlay._corner_at(QPoint(2, 2)) == "topleft"
|
||||
assert overlay._corner_at(QPoint(598, 2)) == "topright"
|
||||
assert overlay._corner_at(QPoint(2, 198)) == "bottomleft"
|
||||
assert overlay._corner_at(QPoint(598, 198)) == "bottomright"
|
||||
# 가운데는 이동용이지 크기 조절이 아니다
|
||||
assert overlay._corner_at(QPoint(300, 100)) == ""
|
||||
|
||||
|
||||
def test_크기를_키우면_글자도_같이_커진다(overlay):
|
||||
overlay.set_edit_mode(True)
|
||||
overlay.setGeometry(100, 100, 600, 200)
|
||||
overlay.style_cfg.font_size = 40
|
||||
|
||||
overlay._resize_corner = "bottomright"
|
||||
overlay._resize_geo = QRect(overlay.geometry())
|
||||
overlay._resize_mouse = QPoint(700, 300)
|
||||
overlay._resize_font = 40
|
||||
overlay._resize_to(QPoint(700, 500)) # 높이 200 -> 400
|
||||
|
||||
assert overlay.height() == 400
|
||||
assert overlay.style_cfg.font_size == 80
|
||||
|
||||
|
||||
def test_반대쪽_모서리는_제자리에_있는다(overlay):
|
||||
"""왼쪽 위를 끌면 오른쪽 아래는 움직이지 않아야 한다."""
|
||||
overlay.set_edit_mode(True)
|
||||
overlay.setGeometry(200, 200, 600, 200)
|
||||
start = QRect(overlay.geometry())
|
||||
|
||||
overlay._resize_corner = "topleft"
|
||||
overlay._resize_geo = start
|
||||
overlay._resize_mouse = QPoint(200, 200)
|
||||
overlay._resize_font = overlay.style_cfg.font_size
|
||||
overlay._resize_to(QPoint(300, 250))
|
||||
|
||||
assert overlay.geometry().right() == start.right()
|
||||
assert overlay.geometry().bottom() == start.bottom()
|
||||
assert overlay.geometry().x() == 300
|
||||
|
||||
|
||||
def test_최소_크기_아래로는_줄지_않는다(overlay):
|
||||
overlay.set_edit_mode(True)
|
||||
overlay.setGeometry(0, 0, 600, 200)
|
||||
overlay._resize_corner = "bottomright"
|
||||
overlay._resize_geo = QRect(overlay.geometry())
|
||||
overlay._resize_mouse = QPoint(600, 200)
|
||||
overlay._resize_font = overlay.style_cfg.font_size
|
||||
overlay._resize_to(QPoint(-5000, -5000))
|
||||
|
||||
assert overlay.width() >= overlay.minimumWidth()
|
||||
assert overlay.height() >= overlay.minimumHeight()
|
||||
@@ -49,3 +49,21 @@ def test_unknown_key_falls_back_to_default():
|
||||
|
||||
def test_default_tier_exists():
|
||||
assert DEFAULT_TIER in TIERS
|
||||
|
||||
|
||||
def test_gpu_가_없으면_cpu_에서_도는_티어를_추천한다():
|
||||
"""표에 박힌 '추천'은 GPU 가 넉넉할 때 얘기다. 없는 사람에게 10GB 짜리를
|
||||
권하면 안내가 아니라 함정이 된다."""
|
||||
from livesub.models.manager import GpuInfo, recommended_tier
|
||||
|
||||
key = recommended_tier(GpuInfo(False, reason="GPU 없음"))
|
||||
tier = get_tier(key)
|
||||
assert tier.mt.backend is MTBackend.CTRANSLATE2
|
||||
assert tier.order == 1 # CPU 에서는 연산량이 그대로 지연이 된다
|
||||
|
||||
|
||||
def test_vram_이_모자라면_추천도_내려간다():
|
||||
from livesub.models.manager import GpuInfo, recommended_tier
|
||||
|
||||
small = get_tier(recommended_tier(GpuInfo(True, "RTX 5050", 7680, 7000)))
|
||||
assert small.min_vram_gb <= 7.5
|
||||
|
||||
@@ -40,11 +40,11 @@ def window(qapp, tmp_path, monkeypatch):
|
||||
|
||||
|
||||
def test_main_window_builds_all_pages(window):
|
||||
assert window.stack.count() == 5
|
||||
assert window.stack.count() == 6
|
||||
|
||||
|
||||
def test_navigation_switches_pages(window):
|
||||
for index in range(5):
|
||||
for index in range(6):
|
||||
window._goto_page(index)
|
||||
assert window.stack.currentIndex() == index
|
||||
|
||||
@@ -71,6 +71,34 @@ def test_partial_line_is_not_logged(window):
|
||||
assert window.home_page.log_list.count() == 0
|
||||
|
||||
|
||||
def test_log_page_shows_and_exports_app_logs(window, qapp, tmp_path):
|
||||
"""엔진 스레드에서 남긴 로그가 로그 화면에 뜨고, 복사·저장 내용에 들어간다."""
|
||||
import logging
|
||||
import threading
|
||||
|
||||
from livesub.app import setup_logging
|
||||
|
||||
setup_logging(to_file=False)
|
||||
worker = threading.Thread(
|
||||
target=lambda: logging.getLogger("livesub.core.engine").warning("구간 처리 실패: 테스트")
|
||||
)
|
||||
worker.start()
|
||||
worker.join()
|
||||
qapp.processEvents()
|
||||
|
||||
page = window.log_page
|
||||
assert "구간 처리 실패: 테스트" in page.view.toPlainText()
|
||||
|
||||
page.copy_to_clipboard()
|
||||
copied = qapp.clipboard().text()
|
||||
assert copied.startswith("LiveSub v")
|
||||
assert "구간 처리 실패: 테스트" in copied
|
||||
|
||||
out = tmp_path / "log.txt"
|
||||
page.save_to(str(out))
|
||||
assert "구간 처리 실패: 테스트" in out.read_text(encoding="utf-8")
|
||||
|
||||
|
||||
def test_tier_selection_updates_config(window):
|
||||
window.models_page._on_tier_selected(window.models_page._cards[3].tier)
|
||||
assert window.config.models.tier == "precision"
|
||||
|
||||
Reference in New Issue
Block a user