Files
voice_copy/voice-changer/app/voice_changer.py
EJClaw 32ad429773 Pick recording servers from the voice-changer app; fix per-server recording status
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>
2026-11-11 21:16:53 +09:00

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())