consent-recorder: operators (ADMIN_DISCORD_IDS) create an app key on the site; the app calls GET/POST /api/guilds with it to turn servers on/off. Turned-off servers are left immediately. recordingNow() now checks the user picked that server, so someone who only chose server A is not shown as recorded while sitting in a B channel the bot records for others. voice-changer: new "녹음 서버" dialog (record_servers.py), network in a worker thread, key saved in config/record-servers.json; upgrade cleanup list knows the new file. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
518 lines
24 KiB
Python
518 lines
24 KiB
Python
"""실시간 음성 변환기 (Windows 게임PC 용 화면).
|
|
|
|
마이크로 들어온 내 말소리를 고른 목소리 모델로 바꿔서, 그 마이크에서 나가는 소리를 바꿔치기한다.
|
|
마이크에 붙인 오디오 처리 모듈(apo/VoiceChangerAPO.dll)이 소리를 주고받으므로 가상 케이블이 필요 없다.
|
|
디스코드 · 게임의 입력 장치는 평소 마이크 그대로 두면 된다.
|
|
"""
|
|
import json
|
|
import multiprocessing as mp
|
|
import queue
|
|
import sys
|
|
import threading
|
|
import time
|
|
import tkinter as tk
|
|
from tkinter import messagebox, ttk
|
|
|
|
from common import ROOT, SETTINGS, load_json, save_json, use_engine
|
|
from models import GENDERS, auto_pitch, list_models
|
|
from record_servers import ServerDialog
|
|
|
|
LATENCY = {"낮음 (약 0.15초, GPU 여유 필요)": 128, "보통 (약 0.25초)": 250, "안정 (약 0.4초)": 400}
|
|
|
|
|
|
def list_devices():
|
|
"""(마이크 이름→번호, 출력 이름→번호). 마이크는 WASAPI 항목만 쓴다 (이름이 윈도우 장치 이름과 같아서
|
|
마이크 모듈이 자기 마이크인지 알아볼 수 있음)."""
|
|
from rvc.realtime.audio import list_audio_device
|
|
|
|
ins, outs = list_audio_device()
|
|
mics = {d.name: d.index for d in ins if "WASAPI" in d.host_api and "loopback" not in d.name.lower()}
|
|
fmt = lambda d: f"{d.name} ({d.host_api})"
|
|
return mics, {fmt(d): d.index for d in outs}
|
|
|
|
|
|
def hooked_mics() -> list:
|
|
"""설치할 때 마이크 모듈을 붙인 마이크들 (scripts/mic-apo.ps1 이 apo\\ 에 남긴 목록)."""
|
|
try:
|
|
items = json.loads((ROOT / "apo" / "mic-apo.json").read_text(encoding="utf-8-sig"))
|
|
except (OSError, ValueError):
|
|
return []
|
|
items = items if isinstance(items, list) else [items]
|
|
return [(i.get("desc") or "", i.get("iface") or "") for i in items if isinstance(i, dict)]
|
|
|
|
|
|
def is_hooked(name: str, hooked: list) -> bool:
|
|
return any(d and d in name and (not f or f in name) for d, f in hooked)
|
|
|
|
|
|
def reconnect_params(root=None) -> str:
|
|
"""관리자 PowerShell 에 넘길 인자. Windows 경로에는 " 가 들어갈 수 없어서 큰따옴표로만 감싸면 공백 · 한글 경로도 안전하다."""
|
|
root = ROOT if root is None else root
|
|
script, r = str(root / "scripts" / "mic-apo.ps1"), str(root)
|
|
if r.endswith("\\"): # "D:\" 처럼 \ 로 끝나면 닫는 따옴표가 이스케이프되므로 "D:\." 로
|
|
r += "."
|
|
return f'-NoProfile -ExecutionPolicy Bypass -File "{script}" -Install -Root "{r}"'
|
|
|
|
|
|
def mic_apo_log_tail(lines: int = 8) -> str:
|
|
"""scripts/mic-apo.ps1 이 apo\\mic-apo.log 에 남긴 마지막 기록."""
|
|
try:
|
|
text = (ROOT / "apo" / "mic-apo.log").read_text(encoding="utf-8-sig", errors="replace")
|
|
except OSError:
|
|
return "(기록 없음)"
|
|
return "\n".join(text.strip().splitlines()[-lines:])
|
|
|
|
|
|
def reconnect_mics() -> int:
|
|
"""관리자 권한으로 mic-apo.ps1 -Install 을 돌린다 (UAC 확인 창이 뜸). 스크립트의 종료 코드를 돌려준다.
|
|
ShellExecuteExW("runas") 로 PowerShell 하나만 띄우고 끝날 때까지 기다린다. -1223 = 사용자가 UAC 를 취소함."""
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
|
|
class SHELLEXECUTEINFOW(ctypes.Structure):
|
|
_fields_ = [("cbSize", wintypes.DWORD), ("fMask", wintypes.ULONG), ("hwnd", wintypes.HWND),
|
|
("lpVerb", wintypes.LPCWSTR), ("lpFile", wintypes.LPCWSTR), ("lpParameters", wintypes.LPCWSTR),
|
|
("lpDirectory", wintypes.LPCWSTR), ("nShow", ctypes.c_int), ("hInstApp", wintypes.HINSTANCE),
|
|
("lpIDList", ctypes.c_void_p), ("lpClass", wintypes.LPCWSTR), ("hkeyClass", wintypes.HKEY),
|
|
("dwHotKey", wintypes.DWORD), ("hIconOrMonitor", wintypes.HANDLE), ("hProcess", wintypes.HANDLE)]
|
|
|
|
shell32 = ctypes.WinDLL("shell32", use_last_error=True)
|
|
k32 = ctypes.WinDLL("kernel32", use_last_error=True)
|
|
k32.WaitForSingleObject.argtypes = [wintypes.HANDLE, wintypes.DWORD]
|
|
k32.GetExitCodeProcess.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD)]
|
|
k32.CloseHandle.argtypes = [wintypes.HANDLE]
|
|
sei = SHELLEXECUTEINFOW(cbSize=ctypes.sizeof(SHELLEXECUTEINFOW), fMask=0x40, # SEE_MASK_NOCLOSEPROCESS
|
|
lpVerb="runas", lpFile="powershell.exe", lpParameters=reconnect_params(),
|
|
lpDirectory=str(ROOT), nShow=0)
|
|
if not shell32.ShellExecuteExW(ctypes.byref(sei)):
|
|
return -ctypes.get_last_error()
|
|
try:
|
|
k32.WaitForSingleObject(sei.hProcess, 0xFFFFFFFF)
|
|
code = wintypes.DWORD()
|
|
k32.GetExitCodeProcess(sei.hProcess, ctypes.byref(code))
|
|
return int(code.value)
|
|
finally:
|
|
k32.CloseHandle(sei.hProcess)
|
|
|
|
|
|
class Converter:
|
|
"""Applio 실시간 엔진 하나를 켜고, 마이크 모듈과 소리를 주고받는다."""
|
|
|
|
def __init__(self):
|
|
self.callbacks = None
|
|
self.bridge = None
|
|
self.streams = []
|
|
self.halt = threading.Event()
|
|
self.worker = None
|
|
self.error = None
|
|
|
|
@property
|
|
def running(self):
|
|
return self.callbacks is not None
|
|
|
|
def start(self, model, pitch, mic_name, mic_id, monitor_id, chunk_ms, threshold, index_rate, on_status):
|
|
import numpy as np
|
|
import sounddevice as sd
|
|
from mic_bridge import Bridge, NotConnected
|
|
from rvc.realtime.callbacks import AudioCallbacks
|
|
from rvc.realtime.core import AUDIO_SAMPLE_RATE
|
|
|
|
# 엔진은 받은 소리를 항상 48kHz 로 보고 분석·합성한다. 마이크 소리는 장치 샘플레이트로 오므로
|
|
# 48kHz 로 바꿔서 넣고, 나온 소리를 다시 장치 샘플레이트로 바꿔 마이크로 돌려보낸다.
|
|
sr = AUDIO_SAMPLE_RATE
|
|
block = int(chunk_ms * sr / 1000)
|
|
cb = AudioCallbacks(
|
|
block_frame=block,
|
|
cross_fade_overlap_size=0.05,
|
|
extra_convert_size=2.5,
|
|
model_path=str(model.pth),
|
|
index_path=str(model.index) if model.index else "",
|
|
f0_method="rmvpe",
|
|
embedder_model="contentvec",
|
|
silent_threshold=threshold,
|
|
f0_up_key=pitch,
|
|
index_rate=index_rate if model.index else 0.0,
|
|
protect=0.33,
|
|
volume_envelope=1.0,
|
|
monitor=monitor_id is not None,
|
|
audio_sample_rate=sr,
|
|
)
|
|
self.callbacks = cb
|
|
self.halt.clear()
|
|
self.error = None
|
|
t0 = time.time()
|
|
while not cb.vc.ready:
|
|
if self.callbacks is not cb:
|
|
raise RuntimeError("시작하는 중에 정지했습니다.")
|
|
proc = getattr(cb.vc, "_process", None)
|
|
if proc is not None and not proc.is_alive():
|
|
self.stop()
|
|
raise RuntimeError("모델을 불러오다 변환 작업이 멈췄습니다. 모델 파일을 확인해 주세요.")
|
|
if time.time() - t0 > 300:
|
|
self.stop()
|
|
raise RuntimeError("모델을 5분 안에 불러오지 못했습니다.")
|
|
on_status(f"모델 불러오는 중... {int(time.time() - t0)}초")
|
|
time.sleep(0.5)
|
|
|
|
try:
|
|
on_status("마이크에 연결하는 중...")
|
|
# 마이크를 쓰는 앱이 하나라도 있어야 윈도우가 마이크 모듈을 돌린다. 디스코드가 꺼져 있어도
|
|
# 변환이 돌도록 이 앱도 마이크를 연다 (받은 소리는 쓰지 않음).
|
|
keep = sd.InputStream(device=mic_id, channels=1, dtype="float32", callback=lambda *a: None,
|
|
extra_settings=sd.WasapiSettings(auto_convert=True))
|
|
keep.start()
|
|
self.streams.append(keep)
|
|
b, err = None, None
|
|
for _ in range(50):
|
|
try:
|
|
b = Bridge.open()
|
|
break
|
|
except NotConnected as e:
|
|
err = e
|
|
time.sleep(0.1)
|
|
if b is None:
|
|
raise RuntimeError(f"{err}\n'마이크 다시 연결' 을 눌러 주세요.")
|
|
self.bridge = b
|
|
b.start(mic_name, prefill_ms=60)
|
|
for _ in range(30):
|
|
if b.owner_alive() and b.rate:
|
|
break
|
|
b.beat()
|
|
time.sleep(0.1)
|
|
else:
|
|
seen = ", ".join(b.endpoints()) or "없음"
|
|
raise RuntimeError(
|
|
f"'{mic_name}' 에 마이크 모듈이 붙어 있지 않습니다 (모듈이 붙은 마이크: {seen}).\n"
|
|
"'마이크 다시 연결' 을 누르고, 윈도우 소리 설정에서 이 마이크의 '오디오 향상' 이 켜져 있는지 확인해 주세요."
|
|
)
|
|
if monitor_id is not None: # 엔진의 모니터 큐(cb.audio.mon_queue)를 헤드셋으로
|
|
dev = sd.query_devices(monitor_id)
|
|
api = sd.query_hostapis(dev["hostapi"])["name"]
|
|
mon = sd.OutputStream(
|
|
callback=lambda outdata, frames, times, status: cb.audio.audio_queue(cb.audio.mon_queue, outdata, cb.audio.monitor_audio_gain),
|
|
latency="low", dtype=np.float32, device=monitor_id, blocksize=block, samplerate=sr,
|
|
channels=min(2, dev["max_output_channels"]),
|
|
extra_settings=sd.WasapiSettings(auto_convert=True) if "WASAPI" in api else None,
|
|
)
|
|
cb.audio.running = True
|
|
mon.start()
|
|
self.streams.append(mon)
|
|
except Exception as e:
|
|
self.stop()
|
|
if isinstance(e, RuntimeError):
|
|
raise
|
|
raise RuntimeError(f"마이크를 열지 못했습니다: {e}") from e
|
|
self.worker = threading.Thread(target=self._pump, args=(b, cb, block, sr), daemon=True)
|
|
self.worker.start()
|
|
|
|
def _pump(self, b, cb, block, sr):
|
|
"""마이크 모듈 ↔ 엔진. 장치 샘플레이트 ↔ 48kHz 는 끊김 없이 이어지는 리샘플러로 바꾼다."""
|
|
import numpy as np
|
|
import soxr
|
|
from rvc.realtime.audio import queue_latest
|
|
|
|
rate, rs_in, rs_out = None, None, None
|
|
pending = np.zeros(0, np.float32)
|
|
try:
|
|
while not self.halt.is_set():
|
|
b.beat()
|
|
if not b.rate: # 마이크 모듈이 아직 소리를 쓰기 전
|
|
time.sleep(0.005)
|
|
continue
|
|
if b.rate != rate:
|
|
rate = b.rate
|
|
rs_in = soxr.ResampleStream(rate, sr, 1, dtype="float32") if rate != sr else None
|
|
rs_out = soxr.ResampleStream(sr, rate, 1, dtype="float32") if rate != sr else None
|
|
pending = np.zeros(0, np.float32)
|
|
x = b.read(max_lag=rate) # 1초 넘게 밀렸으면 버리고 따라잡는다
|
|
if len(x):
|
|
pending = np.concatenate([pending, rs_in.resample_chunk(x) if rs_in else x])
|
|
while len(pending) >= block and not self.halt.is_set():
|
|
blk, pending = pending[:block], pending[block:]
|
|
out = np.asarray(cb.audio.process_data_with_time(blk[:, None]), np.float32) * cb.audio.output_audio_gain
|
|
if cb.audio.use_monitor:
|
|
queue_latest(cb.audio.mon_queue, out)
|
|
b.write(rs_out.resample_chunk(out) if rs_out else out)
|
|
time.sleep(0.005)
|
|
except Exception as e: # 화면이 알 수 있게 남긴다
|
|
self.error = e
|
|
|
|
def set_pitch(self, pitch: int):
|
|
if self.callbacks is not None:
|
|
self.callbacks.audio.f0_up_key = pitch
|
|
|
|
def latency_ms(self) -> float:
|
|
return float(getattr(self.callbacks.audio, "latency", 0) or 0) if self.callbacks else 0.0
|
|
|
|
def mic_ok(self) -> bool:
|
|
return self.bridge is not None and self.bridge.owner_alive(1000)
|
|
|
|
def stop(self):
|
|
cb, self.callbacks = self.callbacks, None
|
|
self.halt.set()
|
|
if self.worker is not None:
|
|
self.worker.join(timeout=3)
|
|
self.worker = None
|
|
if self.bridge is not None:
|
|
self.bridge.stop() # 마이크 모듈이 바로 원래 목소리로 돌아감
|
|
self.bridge.close()
|
|
self.bridge = None
|
|
for s in self.streams:
|
|
try:
|
|
s.abort()
|
|
s.close()
|
|
except Exception:
|
|
pass
|
|
self.streams = []
|
|
if cb is not None:
|
|
cb.audio.running = False
|
|
cb.vc.stop()
|
|
|
|
|
|
class App:
|
|
def __init__(self, root: tk.Tk):
|
|
self.root = root
|
|
self.conv = Converter()
|
|
self.events = queue.Queue() # 작업 스레드 → 화면 (tk 는 메인 스레드에서만 만진다)
|
|
self.settings = load_json(SETTINGS, {})
|
|
self.models = []
|
|
root.title("실시간 음성 변환기")
|
|
root.minsize(560, 520)
|
|
root.protocol("WM_DELETE_WINDOW", self.close)
|
|
|
|
pad = dict(padx=10, pady=4)
|
|
f = ttk.Frame(root)
|
|
f.pack(fill="both", expand=True, padx=8, pady=8)
|
|
|
|
ttk.Label(f, text="목소리 모델").grid(row=0, column=0, sticky="w", **pad)
|
|
self.model_list = tk.Listbox(f, height=8, exportselection=False)
|
|
self.model_list.grid(row=1, column=0, columnspan=3, sticky="nsew", padx=10)
|
|
self.model_list.bind("<<ListboxSelect>>", lambda e: self.on_model())
|
|
ttk.Button(f, text="새로고침", command=self.load_models).grid(row=0, column=2, sticky="e", **pad)
|
|
self.model_info = ttk.Label(f, text="", foreground="#555")
|
|
self.model_info.grid(row=2, column=0, columnspan=3, sticky="w", **pad)
|
|
|
|
ttk.Label(f, text="내 목소리 성별").grid(row=3, column=0, sticky="w", **pad)
|
|
self.my_gender = tk.StringVar(value=self.settings.get("my_gender", "male"))
|
|
g = ttk.Frame(f)
|
|
g.grid(row=3, column=1, columnspan=2, sticky="w")
|
|
for k, v in GENDERS.items():
|
|
ttk.Radiobutton(g, text=v, value=k, variable=self.my_gender, command=self.on_model).pack(side="left", padx=4)
|
|
|
|
ttk.Label(f, text="음높이 (반음)").grid(row=4, column=0, sticky="w", **pad)
|
|
self.pitch = tk.IntVar(value=0)
|
|
self.pitch_scale = tk.Scale(f, from_=-24, to=24, orient="horizontal", variable=self.pitch, command=lambda v: self.conv.set_pitch(int(float(v))))
|
|
self.pitch_scale.grid(row=4, column=1, columnspan=2, sticky="ew", padx=10)
|
|
ttk.Label(f, text="성별이 다른 모델을 고르면 ±12 로 자동으로 맞춥니다. 켜 둔 채로 바꿔도 됩니다.", foreground="#555").grid(row=5, column=0, columnspan=3, sticky="w", padx=10)
|
|
|
|
self.in_dev, self.mon_dev = tk.StringVar(), tk.StringVar()
|
|
self.use_monitor = tk.BooleanVar(value=self.settings.get("use_monitor", False))
|
|
ttk.Label(f, text="마이크").grid(row=6, column=0, sticky="w", **pad)
|
|
self.in_box = ttk.Combobox(f, textvariable=self.in_dev, state="readonly")
|
|
self.in_box.grid(row=6, column=1, sticky="ew", padx=10)
|
|
self.in_box.bind("<<ComboboxSelected>>", lambda e: self.show_mic_state())
|
|
self.reconnect_btn = ttk.Button(f, text="마이크 다시 연결", command=self.reconnect)
|
|
self.reconnect_btn.grid(row=6, column=2, sticky="e", padx=10)
|
|
self.mic_state = ttk.Label(f, text="", foreground="#555")
|
|
self.mic_state.grid(row=7, column=0, columnspan=3, sticky="w", padx=10)
|
|
ttk.Checkbutton(f, text="내 귀로 듣기", variable=self.use_monitor).grid(row=8, column=0, sticky="w", **pad)
|
|
self.mon_box = ttk.Combobox(f, textvariable=self.mon_dev, state="readonly")
|
|
self.mon_box.grid(row=8, column=1, columnspan=2, sticky="ew", padx=10)
|
|
|
|
ttk.Label(f, text="지연").grid(row=9, column=0, sticky="w", **pad)
|
|
self.latency = tk.StringVar(value=self.settings.get("latency", "보통 (약 0.25초)"))
|
|
ttk.Combobox(f, textvariable=self.latency, values=list(LATENCY), state="readonly").grid(row=9, column=1, columnspan=2, sticky="ew", padx=10)
|
|
ttk.Label(f, text="잡음 무시 (dB)").grid(row=10, column=0, sticky="w", **pad)
|
|
self.threshold = tk.IntVar(value=self.settings.get("threshold", -60))
|
|
tk.Scale(f, from_=-90, to=-20, orient="horizontal", variable=self.threshold).grid(row=10, column=1, columnspan=2, sticky="ew", padx=10)
|
|
|
|
b = ttk.Frame(f)
|
|
b.grid(row=11, column=0, columnspan=3, pady=10)
|
|
self.start_btn = ttk.Button(b, text="▶ 변환 시작", command=self.start)
|
|
self.start_btn.pack(side="left", padx=6)
|
|
self.stop_btn = ttk.Button(b, text="■ 정지", command=self.stop, state="disabled")
|
|
self.stop_btn.pack(side="left", padx=6)
|
|
ttk.Button(b, text="녹음 서버…", command=lambda: ServerDialog(self.root)).pack(side="left", padx=6)
|
|
self.status = ttk.Label(f, text="꺼짐")
|
|
self.status.grid(row=12, column=0, columnspan=3, sticky="w", **pad)
|
|
|
|
f.columnconfigure(1, weight=1)
|
|
f.rowconfigure(1, weight=1)
|
|
self.load_models()
|
|
self.load_devices()
|
|
self.tick()
|
|
|
|
# ---- 목록 ----
|
|
def load_models(self):
|
|
self.models = list_models()
|
|
self.model_list.delete(0, "end")
|
|
for m in self.models:
|
|
self.model_list.insert("end", m.label)
|
|
if not self.models:
|
|
self.model_info.config(text="모델이 없습니다. train.bat 로 학습하거나 examples.bat 로 예시 모델을 만들어 주세요.")
|
|
return
|
|
last = self.settings.get("model")
|
|
i = next((n for n, m in enumerate(self.models) if m.id == last), None)
|
|
self.model_list.selection_set(i or 0)
|
|
self.on_model(keep_pitch=self.settings.get("pitch") if i is not None else None)
|
|
|
|
def load_devices(self):
|
|
try:
|
|
self.ins, self.outs = list_devices()
|
|
except Exception as e:
|
|
self.ins, self.outs = {}, {}
|
|
self.status.config(text=f"오디오 장치를 읽지 못했습니다: {e}")
|
|
self.hooked = hooked_mics()
|
|
self.in_box["values"] = list(self.ins)
|
|
self.mon_box["values"] = list(self.outs)
|
|
for var, choices, key in ((self.in_dev, self.ins, "input"), (self.mon_dev, self.outs, "monitor")):
|
|
saved = self.settings.get(key)
|
|
var.set(saved if saved in choices else next(iter(choices), ""))
|
|
self.show_mic_state()
|
|
|
|
def show_mic_state(self):
|
|
name = self.in_dev.get()
|
|
if not name:
|
|
self.mic_state.config(text="마이크가 없습니다.")
|
|
elif is_hooked(name, self.hooked):
|
|
self.mic_state.config(text="디스코드 · 게임의 입력 장치는 이 마이크 그대로 두세요. 변환을 켜면 이 마이크로 바뀐 목소리가 나갑니다.")
|
|
else:
|
|
self.mic_state.config(text="이 마이크에는 아직 변환 모듈이 없습니다. '마이크 다시 연결' 을 눌러 주세요 (새로 꽂은 마이크 등).")
|
|
|
|
def reconnect(self):
|
|
if self.conv.running:
|
|
messagebox.showinfo("음성 변환기", "변환을 정지한 뒤에 눌러 주세요.")
|
|
return
|
|
if not messagebox.askokcancel("음성 변환기", "관리자 권한으로 모든 마이크에 변환 모듈을 붙입니다.\n윈도우 소리가 1~2초 끊겼다가 돌아옵니다."):
|
|
return
|
|
self.reconnect_btn.config(state="disabled")
|
|
self.status.config(text="마이크 연결 중...")
|
|
|
|
def run():
|
|
try:
|
|
code = reconnect_mics()
|
|
except Exception as e:
|
|
code = str(e)
|
|
self.events.put(("reconnected", code))
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
def selected(self):
|
|
sel = self.model_list.curselection()
|
|
return self.models[sel[0]] if sel else None
|
|
|
|
def on_model(self, keep_pitch=None):
|
|
m = self.selected()
|
|
if not m:
|
|
return
|
|
p = keep_pitch if isinstance(keep_pitch, int) else auto_pitch(self.my_gender.get(), m.gender)
|
|
self.pitch.set(p)
|
|
self.conv.set_pitch(p)
|
|
extra = " · ".join(x for x in (m.source, m.license, "검색 인덱스 있음" if m.index else "인덱스 없음") if x)
|
|
self.model_info.config(text=extra)
|
|
if self.conv.running:
|
|
self.status.config(text="모델을 바꾸려면 정지 후 다시 시작해 주세요. (음높이는 바로 바뀝니다)")
|
|
|
|
# ---- 시작/정지 ----
|
|
def start(self):
|
|
m = self.selected()
|
|
if not m:
|
|
messagebox.showwarning("음성 변환기", "목소리 모델을 골라 주세요.")
|
|
return
|
|
if self.in_dev.get() not in self.ins:
|
|
messagebox.showwarning("음성 변환기", "마이크를 골라 주세요.")
|
|
return
|
|
mon = self.outs.get(self.mon_dev.get()) if self.use_monitor.get() else None
|
|
if self.use_monitor.get() and mon is None:
|
|
messagebox.showwarning("음성 변환기", "내 귀로 들을 장치를 골라 주세요.")
|
|
return
|
|
self.save_settings(m)
|
|
self.start_btn.config(state="disabled")
|
|
args = (m, self.pitch.get(), self.in_dev.get(), self.ins[self.in_dev.get()], mon,
|
|
LATENCY.get(self.latency.get(), 250), self.threshold.get(), 0.5)
|
|
|
|
def run():
|
|
try:
|
|
self.conv.start(*args, on_status=lambda s: self.events.put(("status", s)))
|
|
self.events.put(("started", m))
|
|
except Exception as e:
|
|
self.events.put(("failed", e))
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
def on_started(self, m):
|
|
self.running_name = m.name
|
|
self.stop_btn.config(state="normal")
|
|
self.status.config(text=f"● 변환 중: {m.name}")
|
|
|
|
def on_failed(self, e):
|
|
self.start_btn.config(state="normal")
|
|
self.stop_btn.config(state="disabled")
|
|
self.status.config(text="꺼짐")
|
|
messagebox.showerror("음성 변환기", f"시작하지 못했습니다.\n{e}")
|
|
|
|
def stop(self):
|
|
self.conv.stop()
|
|
self.start_btn.config(state="normal")
|
|
self.stop_btn.config(state="disabled")
|
|
self.status.config(text="꺼짐")
|
|
|
|
def tick(self):
|
|
while True:
|
|
try:
|
|
kind, val = self.events.get_nowait()
|
|
except queue.Empty:
|
|
break
|
|
if kind == "status":
|
|
self.status.config(text=val)
|
|
elif kind == "started":
|
|
self.on_started(val)
|
|
elif kind == "failed":
|
|
self.on_failed(val)
|
|
elif kind == "reconnected":
|
|
self.reconnect_btn.config(state="normal")
|
|
self.load_devices()
|
|
if val == 0:
|
|
self.status.config(text="마이크를 다시 연결했습니다.")
|
|
else:
|
|
self.status.config(text="마이크 연결을 취소했습니다." if val == -1223 else f"마이크를 연결하지 못했습니다 (코드 {val}).")
|
|
if val != -1223:
|
|
messagebox.showerror("음성 변환기", f"마이크를 연결하지 못했습니다 (코드 {val}).\n\n{mic_apo_log_tail()}")
|
|
if self.conv.running and str(self.stop_btn["state"]) == "normal":
|
|
if self.conv.error is not None:
|
|
err, self.conv.error = self.conv.error, None
|
|
self.stop()
|
|
messagebox.showerror("음성 변환기", f"변환이 멈췄습니다.\n{err}")
|
|
elif not self.conv.mic_ok():
|
|
self.status.config(text=f"● 변환 중: {self.running_name} · 마이크 신호 없음 (마이크가 뽑혔거나 윈도우 소리가 다시 시작됨)")
|
|
else:
|
|
self.status.config(text=f"● 변환 중: {self.running_name} · 처리 {self.conv.latency_ms():.0f}ms · 디스코드 입력 장치는 이 마이크 그대로")
|
|
self.root.after(200, self.tick)
|
|
|
|
def save_settings(self, m):
|
|
self.settings.update(model=m.id, pitch=self.pitch.get(), my_gender=self.my_gender.get(), input=self.in_dev.get(),
|
|
monitor=self.mon_dev.get(), use_monitor=self.use_monitor.get(),
|
|
latency=self.latency.get(), threshold=self.threshold.get())
|
|
save_json(SETTINGS, self.settings)
|
|
|
|
def close(self):
|
|
self.conv.stop()
|
|
self.root.destroy()
|
|
|
|
|
|
def main():
|
|
root = tk.Tk()
|
|
try:
|
|
use_engine()
|
|
App(root)
|
|
except SystemExit as e:
|
|
root.withdraw()
|
|
messagebox.showerror("음성 변환기", str(e))
|
|
return 1
|
|
root.mainloop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
mp.freeze_support()
|
|
sys.exit(main())
|