diff --git a/api.py b/api.py new file mode 100644 index 0000000..8ea1eb8 --- /dev/null +++ b/api.py @@ -0,0 +1,402 @@ +import os +import sys +import json +import re +import time +import librosa +import torch +import numpy as np +import torch.nn.functional as F +import torchaudio.transforms as tat +import sounddevice as sd +from dotenv import load_dotenv +from fastapi import FastAPI, HTTPException +from pydantic import BaseModel +import threading +import uvicorn + +from tools.torchgate import TorchGate +import tools.rvc_for_realtime as rvc_for_realtime +from configs.config import Config + +load_dotenv() +os.environ["OMP_NUM_THREADS"] = "4" +if sys.platform == "darwin": + os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" + +now_dir = os.getcwd() +sys.path.append(now_dir) + +stream_latency = -1 + +app = FastAPI() + +class GUIConfig: + def __init__(self) -> None: + self.pth_path: str = "" + self.index_path: str = "" + self.pitch: int = 0 + self.samplerate: int = 40000 + self.block_time: float = 1.0 # s + self.buffer_num: int = 1 + self.threhold: int = -60 + self.crossfade_time: float = 0.05 + self.extra_time: float = 2.5 + self.I_noise_reduce = False + self.O_noise_reduce = False + self.rms_mix_rate = 0.0 + self.index_rate = 0.3 + self.f0method = "rmvpe" + self.sg_input_device = "" + self.sg_output_device = "" + +class ConfigData(BaseModel): + pth_path: str + index_path: str + sg_input_device: str + sg_output_device: str + threhold: int = -60 + pitch: int = 0 + index_rate: float = 0.3 + rms_mix_rate: float = 0.0 + block_time: float = 0.25 + crossfade_length: float = 0.05 + extra_time: float = 2.5 + n_cpu: int = 4 + I_noise_reduce: bool = False + O_noise_reduce: bool = False + +class AudioAPI: + def __init__(self) -> None: + self.gui_config = GUIConfig() + self.config = Config() + self.flag_vc = False + self.function = "vc" + self.delay_time = 0 + + def load(self): + input_devices, output_devices, _, _ = self.get_devices() + try: + with open("configs/config.json", "r") as j: + data = json.load(j) + data["rmvpe"] = True # Ensure rmvpe is the only f0method + if data["sg_input_device"] not in input_devices: + data["sg_input_device"] = input_devices[sd.default.device[0]] + if data["sg_output_device"] not in output_devices: + data["sg_output_device"] = output_devices[sd.default.device[1]] + except: + with open("configs/config.json", "w") as j: + data = { + "pth_path": " ", + "index_path": " ", + "sg_input_device": input_devices[sd.default.device[0]], + "sg_output_device": output_devices[sd.default.device[1]], + "threhold": "-60", + "pitch": "0", + "index_rate": "0", + "rms_mix_rate": "0", + "block_time": "0.25", + "crossfade_length": "0.05", + "extra_time": "2.5", + "f0method": "rmvpe", + "use_jit": False, + } + data["rmvpe"] = True # Ensure rmvpe is the only f0method + return data + + def set_values(self, values): + if len(values.pth_path.strip()) == 0: + raise HTTPException(status_code=400, detail="Please select a .pth file") + if len(values.index_path.strip()) == 0: + raise HTTPException(status_code=400, detail="Please select an index file") + pattern = re.compile("[^\x00-\x7F]+") + if pattern.findall(values.pth_path): + raise HTTPException(status_code=400, detail=".pth file path should not contain non-ASCII characters") + if pattern.findall(values.index_path): + raise HTTPException(status_code=400, detail="Index file path should not contain non-ASCII characters") + self.set_devices(values.sg_input_device, values.sg_output_device) + self.config.use_jit = False + self.gui_config.pth_path = values.pth_path + self.gui_config.index_path = values.index_path + self.gui_config.threhold = values.threhold + self.gui_config.pitch = values.pitch + self.gui_config.block_time = values.block_time + self.gui_config.crossfade_time = values.crossfade_length + self.gui_config.extra_time = values.extra_time + self.gui_config.I_noise_reduce = values.I_noise_reduce + self.gui_config.O_noise_reduce = values.O_noise_reduce + self.gui_config.rms_mix_rate = values.rms_mix_rate + self.gui_config.index_rate = values.index_rate + self.gui_config.n_cpu = values.n_cpu + self.gui_config.f0method = "rmvpe" + return True + + def start_vc(self): + torch.cuda.empty_cache() + self.flag_vc = True + self.rvc = rvc_for_realtime.RVC( + self.gui_config.pitch, + self.gui_config.pth_path, + self.gui_config.index_path, + self.gui_config.index_rate, + 0, + 0, + 0, + self.config, + self.rvc if hasattr(self, "rvc") else None, + ) + if not hasattr(self.rvc, 'tgt_sr'): + self.rvc.tgt_sr = 44100 + self.gui_config.samplerate = self.rvc.tgt_sr + self.zc = self.rvc.tgt_sr // 100 + self.block_frame = ( + int( + np.round( + self.gui_config.block_time + * self.gui_config.samplerate + / self.zc + ) + ) + * self.zc + ) + self.block_frame_16k = 160 * self.block_frame // self.zc + self.crossfade_frame = ( + int( + np.round( + self.gui_config.crossfade_time + * self.gui_config.samplerate + / self.zc + ) + ) + * self.zc + ) + self.sola_search_frame = self.zc + self.extra_frame = ( + int( + np.round( + self.gui_config.extra_time + * self.gui_config.samplerate + / self.zc + ) + ) + * self.zc + ) + self.input_wav = torch.zeros( + self.extra_frame + self.crossfade_frame + self.sola_search_frame + self.block_frame, + device=self.config.device, + dtype=torch.float32, + ) + self.input_wav_res = torch.zeros( + 160 * self.input_wav.shape[0] // self.zc, + device=self.config.device, + dtype=torch.float32, + ) + self.pitch = np.zeros(self.input_wav.shape[0] // self.zc, dtype="int32") + self.pitchf = np.zeros(self.input_wav.shape[0] // self.zc, dtype="float64") + self.sola_buffer = torch.zeros(self.crossfade_frame, device=self.config.device, dtype=torch.float32) + self.nr_buffer = self.sola_buffer.clone() + self.output_buffer = self.input_wav.clone() + self.res_buffer = torch.zeros(2 * self.zc, device=self.config.device, dtype=torch.float32) + self.valid_rate = 1 - (self.extra_frame - 1) / self.input_wav.shape[0] + self.fade_in_window = ( + torch.sin(0.5 * np.pi * torch.linspace(0.0, 1.0, steps=self.crossfade_frame, device=self.config.device, dtype=torch.float32)) ** 2 + ) + self.fade_out_window = 1 - self.fade_in_window + self.resampler = tat.Resample( + orig_freq=self.gui_config.samplerate, + new_freq=16000, + dtype=torch.float32, + ).to(self.config.device) + self.tg = TorchGate( + sr=self.gui_config.samplerate, n_fft=4 * self.zc, prop_decrease=0.9 + ).to(self.config.device) + thread_vc = threading.Thread(target=self.soundinput) + thread_vc.start() + + def soundinput(self): + channels = 1 if sys.platform == "darwin" else 2 + with sd.Stream( + channels=channels, + callback=self.audio_callback, + blocksize=self.block_frame, + samplerate=self.gui_config.samplerate, + dtype="float32", + ) as stream: + global stream_latency + stream_latency = stream.latency[-1] + while self.flag_vc: + time.sleep(self.gui_config.block_time) + print("Audio block passed.") + print("ENDing VC") + + def audio_callback(self, indata: np.ndarray, outdata: np.ndarray, frames, times, status): + start_time = time.perf_counter() + indata = librosa.to_mono(indata.T) + if self.gui_config.threhold > -60: + rms = librosa.feature.rms(y=indata, frame_length=4 * self.zc, hop_length=self.zc) + db_threhold = (librosa.amplitude_to_db(rms, ref=1.0)[0] < self.gui_config.threhold) + for i in range(db_threhold.shape[0]): + if db_threhold[i]: + indata[i * self.zc : (i + 1) * self.zc] = 0 + self.input_wav[: -self.block_frame] = self.input_wav[self.block_frame :].clone() + self.input_wav[-self.block_frame :] = torch.from_numpy(indata).to(self.config.device) + self.input_wav_res[: -self.block_frame_16k] = self.input_wav_res[self.block_frame_16k :].clone() + if self.gui_config.I_noise_reduce and self.function == "vc": + input_wav = self.input_wav[-self.crossfade_frame - self.block_frame - 2 * self.zc :] + input_wav = self.tg(input_wav.unsqueeze(0), self.input_wav.unsqueeze(0))[0, 2 * self.zc :] + input_wav[: self.crossfade_frame] *= self.fade_in_window + input_wav[: self.crossfade_frame] += self.nr_buffer * self.fade_out_window + self.nr_buffer[:] = input_wav[-self.crossfade_frame :] + input_wav = torch.cat((self.res_buffer[:], input_wav[: self.block_frame])) + self.res_buffer[:] = input_wav[-2 * self.zc :] + self.input_wav_res[-self.block_frame_16k - 160 :] = self.resampler(input_wav)[160:] + else: + self.input_wav_res[-self.block_frame_16k - 160 :] = self.resampler(self.input_wav[-self.block_frame - 2 * self.zc :])[160:] + if self.function == "vc": + f0_extractor_frame = self.block_frame_16k + 800 + if self.gui_config.f0method == "rmvpe": + f0_extractor_frame = (5120 * ((f0_extractor_frame - 1) // 5120 + 1) - 160) + infer_wav = self.rvc.infer( + self.input_wav_res, + self.input_wav_res[-f0_extractor_frame:].cpu().numpy(), + self.block_frame_16k, + self.valid_rate, + self.pitch, + self.pitchf, + self.gui_config.f0method, + ) + infer_wav = infer_wav[-self.crossfade_frame - self.sola_search_frame - self.block_frame :] + else: + infer_wav = self.input_wav[-self.crossfade_frame - self.sola_search_frame - self.block_frame :].clone() + if (self.gui_config.O_noise_reduce and self.function == "vc") or (self.gui_config.I_noise_reduce and self.function == "im"): + self.output_buffer[: -self.block_frame] = self.output_buffer[self.block_frame :].clone() + self.output_buffer[-self.block_frame :] = infer_wav[-self.block_frame :] + infer_wav = self.tg(infer_wav.unsqueeze(0), self.output_buffer.unsqueeze(0)).squeeze(0) + if self.gui_config.rms_mix_rate < 1 and self.function == "vc": + rms1 = librosa.feature.rms(y=self.input_wav_res[-160 * infer_wav.shape[0] // self.zc :].cpu().numpy(), frame_length=640, hop_length=160) + rms1 = torch.from_numpy(rms1).to(self.config.device) + rms1 = F.interpolate(rms1.unsqueeze(0), size=infer_wav.shape[0] + 1, mode="linear", align_corners=True)[0, 0, :-1] + rms2 = librosa.feature.rms(y=infer_wav[:].cpu().numpy(), frame_length=4 * self.zc, hop_length=self.zc) + rms2 = torch.from_numpy(rms2).to(self.config.device) + rms2 = F.interpolate(rms2.unsqueeze(0), size=infer_wav.shape[0] + 1, mode="linear", align_corners=True)[0, 0, :-1] + rms2 = torch.max(rms2, torch.zeros_like(rms2) + 1e-3) + infer_wav *= torch.pow(rms1 / rms2, torch.tensor(1 - self.gui_config.rms_mix_rate)) + conv_input = infer_wav[None, None, : self.crossfade_frame + self.sola_search_frame] + cor_nom = F.conv1d(conv_input, self.sola_buffer[None, None, :]) + cor_den = torch.sqrt(F.conv1d(conv_input**2, torch.ones(1, 1, self.crossfade_frame, device=self.config.device)) + 1e-8) + if sys.platform == "darwin": + _, sola_offset = torch.max(cor_nom[0, 0] / cor_den[0, 0]) + sola_offset = sola_offset.item() + else: + sola_offset = torch.argmax(cor_nom[0, 0] / cor_den[0, 0]) + print("sola_offset = %d" % int(sola_offset)) + infer_wav = infer_wav[sola_offset : sola_offset + self.block_frame + self.crossfade_frame] + infer_wav[: self.crossfade_frame] *= self.fade_in_window + infer_wav[: self.crossfade_frame] += self.sola_buffer * self.fade_out_window + self.sola_buffer[:] = infer_wav[-self.crossfade_frame :] + if sys.platform == "darwin": + outdata[:] = infer_wav[: -self.crossfade_frame].cpu().numpy()[:, np.newaxis] + else: + outdata[:] = infer_wav[: -self.crossfade_frame].repeat(2, 1).t().cpu().numpy() + total_time = time.perf_counter() - start_time + print("Infer time: %.2f" % total_time) + + def get_devices(self, update: bool = True): + if update: + sd._terminate() + sd._initialize() + devices = sd.query_devices() + hostapis = sd.query_hostapis() + for hostapi in hostapis: + for device_idx in hostapi["devices"]: + devices[device_idx]["hostapi_name"] = hostapi["name"] + input_devices = [ + f"{d['name']} ({d['hostapi_name']})" + for d in devices + if d["max_input_channels"] > 0 + ] + output_devices = [ + f"{d['name']} ({d['hostapi_name']})" + for d in devices + if d["max_output_channels"] > 0 + ] + input_devices_indices = [ + d["index"] if "index" in d else d["name"] + for d in devices + if d["max_input_channels"] > 0 + ] + output_devices_indices = [ + d["index"] if "index" in d else d["name"] + for d in devices + if d["max_output_channels"] > 0 + ] + return ( + input_devices, + output_devices, + input_devices_indices, + output_devices_indices, + ) + + def set_devices(self, input_device, output_device): + ( + input_devices, + output_devices, + input_device_indices, + output_device_indices, + ) = self.get_devices() + sd.default.device[0] = input_device_indices[input_devices.index(input_device)] + sd.default.device[1] = output_device_indices[output_devices.index(output_device)] + print("Input device: %s:%s" % (str(sd.default.device[0]), input_device)) + print("Output device: %s:%s" % (str(sd.default.device[1]), output_device)) + +audio_api = AudioAPI() + +@app.get("/inputDevices") +def get_input_devices(): + input_devices, _, _, _ = audio_api.get_devices() + return input_devices + +@app.get("/outputDevices") +def get_output_devices(): + _, output_devices, _, _ = audio_api.get_devices() + return output_devices + +@app.post("/config") +def configure_audio(config_data: ConfigData): + try: + if audio_api.set_values(config_data): + settings = config_data.dict() + settings["use_jit"] = False + settings["f0method"] = "rmvpe" + with open("configs/config.json", "w") as j: + json.dump(settings, j) + return {"message": "Configuration set successfully"} + except Exception as e: + raise HTTPException(status_code=400, detail=f"Configuration failed: {e}") + +@app.post("/start") +def start_conversion(): + try: + if not audio_api.flag_vc: + audio_api.start_vc() + return {"message": "Audio conversion started"} + else: + raise HTTPException(status_code=400, detail="Audio conversion already running") + except Exception as e: + raise HTTPException(status_code=500, detail=f"Failed to start conversion: {e}") + +@app.post("/stop") +def stop_conversion(): + try: + if audio_api.flag_vc: + audio_api.flag_vc = False + global stream_latency + stream_latency = -1 + return {"message": "Audio conversion stopped"} + else: + raise HTTPException(status_code=400, detail="Audio conversion not running") + except Exception as e: + raise HTTPException(status_code=500, detail=f"Failed to stop conversion: {e}") + +if __name__ == "__main__": + uvicorn.run(app, host="0.0.0.0", port=8043)