- voice-changer/: install.bat (uv + Python 3.12 + pinned Applio + torch cu128), VoiceChanger.exe launcher (mingw), tkinter GUI (model list, auto ±12 pitch across genders, mic/output/monitor devices, latency, noise gate), train.bat (preprocess/extract/train/index → models/<id>), examples.bat (Korean example models from KSS + Zeroth-Korean), build-release.sh - consent-recorder: default OPERATOR_NAME=사금향 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
314 lines
14 KiB
Python
314 lines
14 KiB
Python
"""실시간 음성 변환기 (Windows 게임PC 용 화면).
|
|
|
|
마이크로 들어온 내 말소리를 고른 목소리 모델로 바꿔서 출력 장치로 내보낸다.
|
|
디스코드 · 게임에 쓰려면 출력을 가상 케이블(VB-CABLE 의 "CABLE Input")로 두고,
|
|
디스코드 입력 장치를 "CABLE Output" 으로 고른다.
|
|
"""
|
|
import multiprocessing as mp
|
|
import queue
|
|
import sys
|
|
import threading
|
|
import time
|
|
import tkinter as tk
|
|
from tkinter import messagebox, ttk
|
|
|
|
from common import SETTINGS, load_json, save_json, use_engine
|
|
from models import GENDERS, auto_pitch, list_models
|
|
|
|
LATENCY = {"낮음 (약 0.15초, GPU 여유 필요)": 128, "보통 (약 0.25초)": 250, "안정 (약 0.4초)": 400}
|
|
|
|
|
|
def list_devices():
|
|
"""(입력 이름→번호, 출력 이름→번호). 가상 케이블을 출력 맨 앞에 둔다."""
|
|
from rvc.realtime.audio import list_audio_device
|
|
|
|
ins, outs = list_audio_device()
|
|
|
|
def is_virtual(d):
|
|
n = d.name.lower()
|
|
return "cable" in n or "virtual" in n or "vb-audio" in n
|
|
|
|
outs = sorted(outs, key=lambda d: not is_virtual(d))
|
|
ins = sorted(ins, key=is_virtual) # 마이크를 앞에, 가상 케이블은 뒤에
|
|
fmt = lambda d: f"{d.name} ({d.host_api})"
|
|
return {fmt(d): d.index for d in ins}, {fmt(d): d.index for d in outs}
|
|
|
|
|
|
class Converter:
|
|
"""Applio 실시간 엔진(AudioCallbacks) 하나를 켜고 끈다."""
|
|
|
|
def __init__(self):
|
|
self.callbacks = None
|
|
|
|
@property
|
|
def running(self):
|
|
return self.callbacks is not None
|
|
|
|
def start(self, model, pitch, in_id, out_id, monitor_id, chunk_ms, threshold, index_rate, on_status):
|
|
from rvc.realtime.audio import resolve_sample_rate
|
|
from rvc.realtime.callbacks import AudioCallbacks
|
|
|
|
sr = resolve_sample_rate(in_id, False, 48000)
|
|
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
|
|
try:
|
|
cb.audio.start(
|
|
input_device_id=in_id,
|
|
output_device_id=out_id,
|
|
output_monitor_id=monitor_id,
|
|
block_frame=block,
|
|
audio_sample_rate=sr,
|
|
asio_input_channel=-1,
|
|
asio_output_channel=-1,
|
|
asio_output_monitor_channel=-1,
|
|
)
|
|
except Exception:
|
|
self.stop()
|
|
raise
|
|
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)
|
|
|
|
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 stop(self):
|
|
cb, self.callbacks = self.callbacks, None
|
|
if cb is None:
|
|
return
|
|
try:
|
|
cb.audio.stop()
|
|
finally:
|
|
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.out_dev, self.mon_dev = tk.StringVar(), 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, columnspan=2, sticky="ew", padx=10)
|
|
ttk.Label(f, text="출력 (디스코드용은 CABLE Input)").grid(row=7, column=0, sticky="w", **pad)
|
|
self.out_box = ttk.Combobox(f, textvariable=self.out_dev, state="readonly")
|
|
self.out_box.grid(row=7, column=1, columnspan=2, sticky="ew", 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)
|
|
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.in_box["values"] = list(self.ins)
|
|
self.out_box["values"] = list(self.outs)
|
|
self.mon_box["values"] = list(self.outs)
|
|
for var, choices, key in ((self.in_dev, self.ins, "input"), (self.out_dev, self.outs, "output"), (self.mon_dev, self.outs, "monitor")):
|
|
saved = self.settings.get(key)
|
|
var.set(saved if saved in choices else next(iter(choices), ""))
|
|
|
|
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 or self.out_dev.get() not in self.outs:
|
|
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.ins[self.in_dev.get()], self.outs[self.out_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)
|
|
if self.conv.running and str(self.stop_btn["state"]) == "normal":
|
|
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(),
|
|
output=self.out_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())
|