| import sys, os
|
| import subprocess
|
| import torch
|
| from functools import lru_cache
|
| import shutil
|
| from pedalboard import Pedalboard, Reverb
|
| from pedalboard.io import AudioFile
|
| from pydub import AudioSegment
|
| from audio_separator.separator import Separator
|
| import logging
|
| import yaml
|
|
|
| now_dir = os.getcwd()
|
| sys.path.append(now_dir)
|
| from programs.applio_code.rvc.infer.infer import VoiceConverter
|
| from programs.applio_code.rvc.lib.tools.model_download import model_download_pipeline
|
| from programs.music_separation_code.inference import proc_file
|
|
|
| models_vocals = [
|
| {
|
| "name": "Mel-Roformer by KimberleyJSN",
|
| "path": os.path.join(now_dir, "models", "mel-vocals"),
|
| "model": os.path.join(now_dir, "models", "mel-vocals", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "mel-vocals", "config.yaml"),
|
| "type": "mel_band_roformer",
|
| "config_url": "https://raw.githubusercontent.com/ZFTurbo/Music-Source-Separation-Training/main/configs/KimberleyJensen/config_vocals_mel_band_roformer_kj.yaml",
|
| "model_url": "https://huggingface.co/KimberleyJSN/melbandroformer/resolve/main/MelBandRoformer.ckpt",
|
| },
|
| {
|
| "name": "BS-Roformer by ViperX",
|
| "path": os.path.join(now_dir, "models", "bs-vocals"),
|
| "model": os.path.join(now_dir, "models", "bs-vocals", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "bs-vocals", "config.yaml"),
|
| "type": "bs_roformer",
|
| "config_url": "https://raw.githubusercontent.com/ZFTurbo/Music-Source-Separation-Training/main/configs/viperx/model_bs_roformer_ep_317_sdr_12.9755.yaml",
|
| "model_url": "https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/model_bs_roformer_ep_317_sdr_12.9755.ckpt",
|
| },
|
| {
|
| "name": "MDX23C",
|
| "path": os.path.join(now_dir, "models", "mdx23c-vocals"),
|
| "model": os.path.join(now_dir, "models", "mdx23c-vocals", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "mdx23c-vocals", "config.yaml"),
|
| "type": "mdx23c",
|
| "config_url": "https://raw.githubusercontent.com/ZFTurbo/Music-Source-Separation-Training/main/configs/config_vocals_mdx23c.yaml",
|
| "model_url": "https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/model_vocals_mdx23c_sdr_10.17.ckpt",
|
| },
|
| ]
|
|
|
| karaoke_models = [
|
| {
|
| "name": "Mel-Roformer Karaoke by aufr33 and viperx",
|
| "path": os.path.join(now_dir, "models", "mel-kara"),
|
| "model": os.path.join(now_dir, "models", "mel-kara", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "mel-kara", "config.yaml"),
|
| "type": "mel_band_roformer",
|
| "config_url": "https://huggingface.co/shiromiya/audio-separation-models/resolve/main/mel_band_roformer_karaoke_aufr33_viperx/config_mel_band_roformer_karaoke.yaml",
|
| "model_url": "https://huggingface.co/shiromiya/audio-separation-models/resolve/main/mel_band_roformer_karaoke_aufr33_viperx/mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt",
|
| },
|
| {
|
| "name": "UVR-BVE",
|
| "full_name": "UVR-BVE-4B_SN-44100-1.pth",
|
| "arch": "vr",
|
| },
|
| ]
|
|
|
| denoise_models = [
|
| {
|
| "name": "Mel-Roformer Denoise Normal by aufr33",
|
| "path": os.path.join(now_dir, "models", "mel-denoise"),
|
| "model": os.path.join(now_dir, "models", "mel-denoise", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "mel-denoise", "config.yaml"),
|
| "type": "mel_band_roformer",
|
| "config_url": "https://huggingface.co/shiromiya/audio-separation-models/resolve/main/mel-denoise/model_mel_band_roformer_denoise.yaml",
|
| "model_url": "https://huggingface.co/jarredou/aufr33_MelBand_Denoise/resolve/main/denoise_mel_band_roformer_aufr33_sdr_27.9959.ckpt",
|
| },
|
| {
|
| "name": "Mel-Roformer Denoise Aggressive by aufr33",
|
| "path": os.path.join(now_dir, "models", "mel-denoise-aggr"),
|
| "model": os.path.join(now_dir, "models", "mel-denoise-aggr", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "mel-denoise-aggr", "config.yaml"),
|
| "type": "mel_band_roformer",
|
| "config_url": "https://huggingface.co/shiromiya/audio-separation-models/resolve/main/mel-denoise/model_mel_band_roformer_denoise.yaml",
|
| "model_url": "https://huggingface.co/jarredou/aufr33_MelBand_Denoise/resolve/main/denoise_mel_band_roformer_aufr33_aggr_sdr_27.9768.ckpt",
|
| },
|
| {
|
| "name": "UVR Denoise",
|
| "full_name": "UVR-DeNoise.pth",
|
| "arch": "vr",
|
| },
|
| ]
|
|
|
| dereverb_models = [
|
| {
|
| "name": "MDX23C DeReverb by aufr33 and jarredou",
|
| "path": os.path.join(now_dir, "models", "mdx23c-dereveb"),
|
| "model": os.path.join(now_dir, "models", "mdx23c-dereveb", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "mdx23c-dereveb", "config.yaml"),
|
| "type": "mdx23c",
|
| "config_url": "https://huggingface.co/jarredou/aufr33_jarredou_MDXv3_DeReverb/resolve/main/config_dereverb_mdx23c.yaml",
|
| "model_url": "https://huggingface.co/jarredou/aufr33_jarredou_MDXv3_DeReverb/resolve/main/dereverb_mdx23c_sdr_6.9096.ckpt",
|
| },
|
| {
|
| "name": "BS-Roformer Dereverb by anvuew",
|
| "path": os.path.join(now_dir, "models", "mdx23c-dereveb"),
|
| "model": os.path.join(now_dir, "models", "mdx23c-dereveb", "model.ckpt"),
|
| "config": os.path.join(now_dir, "models", "mdx23c-dereveb", "config.yaml"),
|
| "type": "bs_roformer",
|
| "config_url": "https://huggingface.co/anvuew/deverb_bs_roformer/resolve/main/deverb_bs_roformer_8_384dim_10depth.yaml",
|
| "model_url": "https://huggingface.co/anvuew/deverb_bs_roformer/resolve/main/deverb_bs_roformer_8_384dim_10depth.ckpt",
|
| },
|
| {
|
| "name": "UVR-Deecho-Dereverb",
|
| "full_name": "UVR-DeEcho-DeReverb.pth",
|
| "arch": "vr",
|
| },
|
| {
|
| "name": "MDX Reverb HQ by FoxJoy",
|
| "full_name": "Reverb_HQ_By_FoxJoy.onnx",
|
| "arch": "mdx",
|
| },
|
| ]
|
|
|
| deecho_models = [
|
| {
|
| "name": "UVR-Deecho-Normal",
|
| "full_name": "UVR-De-Echo-Normal.pth",
|
| "arch": "vr",
|
| },
|
| {
|
| "name": "UVR-Deecho-Agggressive",
|
| "full_name": "UVR-De-Echo-Aggressive.pth",
|
| "arch": "vr",
|
| },
|
| ]
|
|
|
|
|
| @lru_cache(maxsize=None)
|
| def import_voice_converter():
|
| from programs.applio_code.rvc.infer.infer import VoiceConverter
|
|
|
| return VoiceConverter()
|
|
|
|
|
| @lru_cache(maxsize=1)
|
| def get_config():
|
| from programs.applio_code.rvc.configs.config import Config
|
|
|
| return Config()
|
|
|
|
|
| def download_file(url, path, filename):
|
| os.makedirs(path, exist_ok=True)
|
| file_path = os.path.join(path, filename)
|
|
|
| if os.path.exists(file_path):
|
| print(f"File '{filename}' already exists at '{path}'.")
|
| return
|
|
|
| try:
|
| response = torch.hub.download_url_to_file(url, file_path)
|
| print(f"File '{filename}' downloaded successfully")
|
| except Exception as e:
|
| print(f"Error downloading file '{filename}' from '{url}': {e}")
|
|
|
|
|
| def get_model_info_by_name(model_name):
|
| all_models = (
|
| models_vocals
|
| + karaoke_models
|
| + dereverb_models
|
| + deecho_models
|
| + denoise_models
|
| )
|
| for model in all_models:
|
| if model["name"] == model_name:
|
| return model
|
| return None
|
|
|
|
|
| def get_last_modified_file(pasta):
|
| if not os.path.isdir(pasta):
|
| raise NotADirectoryError(f"{pasta} is not a valid directory.")
|
| arquivos = [f for f in os.listdir(pasta) if os.path.isfile(os.path.join(pasta, f))]
|
| if not arquivos:
|
| return None
|
| return max(arquivos, key=lambda x: os.path.getmtime(os.path.join(pasta, x)))
|
|
|
|
|
| def search_with_word(folder, word):
|
| if not os.path.isdir(folder):
|
| raise NotADirectoryError(f"{folder} is not a valid directory.")
|
| file_with_word = [file for file in os.listdir(folder) if word in file]
|
| if not file_with_word:
|
| return None
|
| most_recent_file = max(
|
| file_with_word, key=lambda file: os.path.getmtime(os.path.join(folder, file))
|
| )
|
| return most_recent_file
|
|
|
|
|
| def search_with_two_words(folder, word1, word2):
|
| if not os.path.isdir(folder):
|
| raise NotADirectoryError(f"{folder} is not a valid directory.")
|
| file_with_words = [
|
| file for file in os.listdir(folder) if word1 in file and word2 in file
|
| ]
|
| if not file_with_words:
|
| return None
|
| most_recent_file = max(
|
| file_with_words, key=lambda file: os.path.getmtime(os.path.join(folder, file))
|
| )
|
| return most_recent_file
|
|
|
|
|
| def get_last_modified_folder(path):
|
| directories = [
|
| os.path.join(path, d)
|
| for d in os.listdir(path)
|
| if os.path.isdir(os.path.join(path, d))
|
| ]
|
| if not directories:
|
| return None
|
| last_modified_folder = max(directories, key=os.path.getmtime)
|
| return last_modified_folder
|
|
|
|
|
| def add_audio_effects(
|
| audio_path,
|
| reverb_size,
|
| reverb_wet,
|
| reverb_dry,
|
| reverb_damping,
|
| reverb_width,
|
| output_path,
|
| ):
|
| board = Pedalboard([])
|
| board.append(
|
| Reverb(
|
| room_size=reverb_size,
|
| dry_level=reverb_dry,
|
| wet_level=reverb_wet,
|
| damping=reverb_damping,
|
| width=reverb_width,
|
| )
|
| )
|
| with AudioFile(audio_path) as f:
|
| with AudioFile(output_path, "w", f.samplerate, f.num_channels) as o:
|
| while f.tell() < f.frames:
|
| chunk = f.read(int(f.samplerate))
|
| effected = board(chunk, f.samplerate, reset=False)
|
| o.write(effected)
|
| return output_path
|
|
|
|
|
| def merge_audios(
|
| vocals_path,
|
| inst_path,
|
| backing_path,
|
| output_path,
|
| main_gain,
|
| inst_gain,
|
| backing_Vol,
|
| output_format,
|
| ):
|
| main_vocal_audio = AudioSegment.from_file(vocals_path, format="flac") + main_gain
|
| instrumental_audio = AudioSegment.from_file(inst_path, format="flac") + inst_gain
|
| backing_vocal_audio = (
|
| AudioSegment.from_file(backing_path, format="flac") + backing_Vol
|
| )
|
| combined_audio = main_vocal_audio.overlay(
|
| instrumental_audio.overlay(backing_vocal_audio)
|
| )
|
| combined_audio.export(output_path, format=output_format)
|
| return output_path
|
|
|
|
|
| def check_fp16_support(device):
|
| i_device = int(str(device).split(":")[-1])
|
| gpu_name = torch.cuda.get_device_name(i_device)
|
| low_end_gpus = ["16", "P40", "P10", "1060", "1070", "1080"]
|
| if any(gpu in gpu_name for gpu in low_end_gpus) and "V100" not in gpu_name.upper():
|
| print(f"Your GPU {gpu_name} not support FP16 inference. Using FP32 instead.")
|
| return False
|
| return True
|
|
|
|
|
| def full_inference_program(
|
| model_path,
|
| index_path,
|
| input_audio_path,
|
| output_path,
|
| export_format_rvc,
|
| split_audio,
|
| autotune,
|
| vocal_model,
|
| karaoke_model,
|
| dereverb_model,
|
| deecho,
|
| deecho_model,
|
| denoise,
|
| denoise_model,
|
| reverb,
|
| vocals_volume,
|
| instrumentals_volume,
|
| backing_vocals_volume,
|
| export_format_final,
|
| devices,
|
| pitch,
|
| filter_radius,
|
| index_rate,
|
| rms_mix_rate,
|
| protect,
|
| pitch_extract,
|
| hop_lenght,
|
| reverb_room_size,
|
| reverb_damping,
|
| reverb_wet_gain,
|
| reverb_dry_gain,
|
| reverb_width,
|
| embedder_model,
|
| delete_audios,
|
| use_tta,
|
| batch_size,
|
| infer_backing_vocals,
|
| infer_backing_vocals_model,
|
| infer_backing_vocals_index,
|
| change_inst_pitch,
|
| pitch_back,
|
| filter_radius_back,
|
| index_rate_back,
|
| rms_mix_rate_back,
|
| protect_back,
|
| pitch_extract_back,
|
| hop_length_back,
|
| export_format_rvc_back,
|
| split_audio_back,
|
| autotune_back,
|
| embedder_model_back,
|
| ):
|
| if torch.cuda.is_available():
|
| n_gpu = torch.cuda.device_count()
|
| devices = devices.replace("-", " ")
|
| print(f"Number of GPUs available: {n_gpu}")
|
| first_device = devices.split()[0]
|
| fp16 = check_fp16_support(first_device)
|
| else:
|
| devices = "cpu"
|
| print("Using CPU")
|
| fp16 = False
|
|
|
| music_folder = os.path.splitext(os.path.basename(input_audio_path))[0]
|
|
|
|
|
| model_info = get_model_info_by_name(vocal_model)
|
| model_ckpt_path = os.path.join(model_info["path"], "model.ckpt")
|
| if not os.path.exists(model_ckpt_path):
|
| download_file(
|
| model_info["model_url"],
|
| model_info["path"],
|
| "model.ckpt",
|
| )
|
| config_json_path = os.path.join(model_info["path"], "config.yaml")
|
| if not os.path.exists(config_json_path):
|
| download_file(
|
| model_info["config_url"],
|
| model_info["path"],
|
| "config.yaml",
|
| )
|
| if not fp16:
|
| with open(model_info["config"], "r") as file:
|
| config = yaml.safe_load(file)
|
|
|
| config["training"]["use_amp"] = False
|
|
|
| with open(model_info["config"], "w") as file:
|
| yaml.safe_dump(config, file)
|
| store_dir = os.path.join(now_dir, "audio_files", music_folder, "vocals")
|
| inst_dir = os.path.join(now_dir, "audio_files", music_folder, "instrumentals")
|
| os.makedirs(store_dir, exist_ok=True)
|
| os.makedirs(inst_dir, exist_ok=True)
|
| input_audio_basename = os.path.splitext(os.path.basename(input_audio_path))[0]
|
| search_result = search_with_word(store_dir, "vocals")
|
| if search_result:
|
| print("Vocals already separated"),
|
| else:
|
| print("Separating vocals")
|
| command = [
|
| "python",
|
| os.path.join(now_dir, "programs", "music_separation_code", "inference.py"),
|
| "--model_type",
|
| model_info["type"],
|
| "--config_path",
|
| model_info["config"],
|
| "--start_check_point",
|
| model_info["model"],
|
| "--input_file",
|
| input_audio_path,
|
| "--store_dir",
|
| store_dir,
|
| "--flac_file",
|
| "--pcm_type",
|
| "PCM_16",
|
| "--extract_instrumental",
|
| ]
|
|
|
| if devices == "cpu":
|
| command.append("--force_cpu")
|
| else:
|
| device_ids = [str(int(device)) for device in devices.split()]
|
| command.extend(["--device_ids"] + device_ids)
|
|
|
| subprocess.run(command)
|
| os.rename(
|
| os.path.join(
|
| store_dir,
|
| search_with_two_words(
|
| store_dir,
|
| os.path.basename(input_audio_path).split(".")[0],
|
| "instrumental",
|
| ),
|
| ),
|
| os.path.join(
|
| inst_dir,
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_instrumentals.flac",
|
| ),
|
| )
|
| inst_file = os.path.join(
|
| inst_dir,
|
| search_with_two_words(
|
| inst_dir, os.path.basename(input_audio_path).split(".")[0], "instrumentals"
|
| ),
|
| )
|
|
|
|
|
| model_info = get_model_info_by_name(karaoke_model)
|
| store_dir = os.path.join(now_dir, "audio_files", music_folder, "karaoke")
|
| os.makedirs(store_dir, exist_ok=True)
|
| vocals_path = os.path.join(now_dir, "audio_files", music_folder, "vocals")
|
| input_file = search_with_word(vocals_path, "vocals")
|
| karaoke_exists = search_with_word(store_dir, "karaoke") is not None
|
|
|
| if karaoke_exists:
|
| print("Backing vocals already separated")
|
| else:
|
| if input_file:
|
| input_file = os.path.join(vocals_path, input_file)
|
| print("Separating Backing vocals")
|
| if model_info["name"] == "Mel-Roformer Karaoke by aufr33 and viperx":
|
| model_ckpt_path = os.path.join(model_info["path"], "model.ckpt")
|
| if not os.path.exists(model_ckpt_path):
|
| download_file(
|
| model_info["model_url"],
|
| model_info["path"],
|
| "model.ckpt",
|
| )
|
| config_json_path = os.path.join(model_info["path"], "config.yaml")
|
| if not os.path.exists(config_json_path):
|
| download_file(
|
| model_info["config_url"],
|
| model_info["path"],
|
| "config.yaml",
|
| )
|
| if not fp16:
|
| with open(model_info["config"], "r") as file:
|
| config = yaml.safe_load(file)
|
|
|
| config["training"]["use_amp"] = False
|
|
|
| with open(model_info["config"], "w") as file:
|
| yaml.safe_dump(config, file)
|
|
|
| command = [
|
| "python",
|
| os.path.join(
|
| now_dir, "programs", "music_separation_code", "inference.py"
|
| ),
|
| "--model_type",
|
| model_info["type"],
|
| "--config_path",
|
| model_info["config"],
|
| "--start_check_point",
|
| model_info["model"],
|
| "--input_file",
|
| input_file,
|
| "--store_dir",
|
| store_dir,
|
| "--flac_file",
|
| "--pcm_type",
|
| "PCM_16",
|
| "--extract_instrumental",
|
| ]
|
|
|
| if devices == "cpu":
|
| command.append("--force_cpu")
|
| else:
|
| device_ids = [str(int(device)) for device in devices.split()]
|
| command.extend(["--device_ids"] + device_ids)
|
|
|
| subprocess.run(command)
|
| else:
|
| separator = Separator(
|
| model_file_dir=os.path.join(now_dir, "models", "karaoke"),
|
| log_level=logging.WARNING,
|
| normalization_threshold=1.0,
|
| output_format="flac",
|
| output_dir=store_dir,
|
| vr_params={
|
| "batch_size": batch_size,
|
| "enable_tta": use_tta,
|
| },
|
| )
|
| separator.load_model(model_filename=model_info["full_name"])
|
| separator.separate(input_file)
|
| karaoke_path = os.path.join(now_dir, "audio_files", music_folder, "karaoke")
|
| vocals_result = search_with_two_words(
|
| karaoke_path,
|
| os.path.basename(input_audio_path).split(".")[0],
|
| "Vocals",
|
| )
|
| instrumental_result = search_with_two_words(
|
| karaoke_path,
|
| os.path.basename(input_audio_path).split(".")[0],
|
| "Instrumental",
|
| )
|
| if "UVR-BVE-4B_SN-44100-1" in os.path.basename(vocals_result):
|
| os.rename(
|
| os.path.join(karaoke_path, vocals_result),
|
| os.path.join(
|
| karaoke_path,
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_karaoke.flac",
|
| ),
|
| )
|
| if "UVR-BVE-4B_SN-44100-1" in os.path.basename(instrumental_result):
|
| os.rename(
|
| os.path.join(karaoke_path, instrumental_result),
|
| os.path.join(
|
| karaoke_path,
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_instrumental.flac",
|
| ),
|
| )
|
|
|
|
|
| model_info = get_model_info_by_name(dereverb_model)
|
| store_dir = os.path.join(now_dir, "audio_files", music_folder, "dereverb")
|
| os.makedirs(store_dir, exist_ok=True)
|
| karaoke_path = os.path.join(now_dir, "audio_files", music_folder, "karaoke")
|
| input_file = search_with_word(karaoke_path, "karaoke")
|
| noreverb_exists = search_with_word(store_dir, "noreverb") is not None
|
| if noreverb_exists:
|
| print("Reverb already removed")
|
| else:
|
| if input_file:
|
| input_file = os.path.join(karaoke_path, input_file)
|
| print("Removing reverb")
|
| if (
|
| model_info["name"] == "BS-Roformer Dereverb by anvuew"
|
| or model_info["name"] == "MDX23C DeReverb by aufr33 and jarredou"
|
| ):
|
| model_ckpt_path = os.path.join(model_info["path"], "model.ckpt")
|
| if not os.path.exists(model_ckpt_path):
|
| download_file(
|
| model_info["model_url"],
|
| model_info["path"],
|
| "model.ckpt",
|
| )
|
| config_json_path = os.path.join(model_info["path"], "config.yaml")
|
| if not os.path.exists(config_json_path):
|
| download_file(
|
| model_info["config_url"],
|
| model_info["path"],
|
| "config.yaml",
|
| )
|
| if not fp16:
|
| with open(model_info["config"], "r") as file:
|
| config = yaml.safe_load(file)
|
|
|
| config["training"]["use_amp"] = False
|
|
|
| with open(model_info["config"], "w") as file:
|
| yaml.safe_dump(config, file)
|
| command = [
|
| "python",
|
| os.path.join(
|
| now_dir, "programs", "music_separation_code", "inference.py"
|
| ),
|
| "--model_type",
|
| model_info["type"],
|
| "--config_path",
|
| model_info["config"],
|
| "--start_check_point",
|
| model_info["model"],
|
| "--input_file",
|
| input_file,
|
| "--store_dir",
|
| store_dir,
|
| "--flac_file",
|
| "--pcm_type",
|
| "PCM_16",
|
| ]
|
|
|
| if devices == "cpu":
|
| command.append("--force_cpu")
|
| else:
|
| device_ids = [str(int(device)) for device in devices.split()]
|
| command.extend(["--device_ids"] + device_ids)
|
|
|
| subprocess.run(command)
|
| else:
|
| if model_info["arch"] == "vr":
|
| separator = Separator(
|
| model_file_dir=os.path.join(now_dir, "models", "dereverb"),
|
| log_level=logging.WARNING,
|
| normalization_threshold=1.0,
|
| output_format="flac",
|
| output_dir=store_dir,
|
| output_single_stem="No Reverb",
|
| vr_params={
|
| "batch_size": batch_size,
|
| "enable_tta": use_tta,
|
| },
|
| )
|
| else:
|
| separator = Separator(
|
| model_file_dir=os.path.join(now_dir, "models", "dereverb"),
|
| log_level=logging.WARNING,
|
| normalization_threshold=1.0,
|
| output_format="flac",
|
| output_dir=store_dir,
|
| output_single_stem="No Reverb",
|
| )
|
| separator.load_model(model_filename=model_info["full_name"])
|
| separator.separate(input_file)
|
| dereverb_path = os.path.join(
|
| now_dir, "audio_files", music_folder, "dereverb"
|
| )
|
| search_result = search_with_two_words(
|
| dereverb_path,
|
| os.path.basename(input_audio_path).split(".")[0],
|
| "No Reverb",
|
| )
|
| if "UVR-DeEcho-DeReverb" in os.path.basename(
|
| search_result
|
| ) or "MDX Reverb HQ by FoxJoy" in os.path.basename(search_result):
|
| os.rename(
|
| os.path.join(dereverb_path, search_result),
|
| os.path.join(
|
| dereverb_path,
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_noreverb.flac",
|
| ),
|
| )
|
|
|
|
|
| store_dir = os.path.join(now_dir, "audio_files", music_folder, "deecho")
|
| os.makedirs(store_dir, exist_ok=True)
|
| if deecho:
|
| no_echo_exists = search_with_word(store_dir, "noecho") is not None
|
| if no_echo_exists:
|
| print("Echo already removed")
|
| else:
|
| print("Removing echo")
|
| model_info = get_model_info_by_name(deecho_model)
|
|
|
| dereverb_path = os.path.join(
|
| now_dir, "audio_files", music_folder, "dereverb"
|
| )
|
| noreverb_file = search_with_word(dereverb_path, "noreverb")
|
|
|
| input_file = os.path.join(dereverb_path, noreverb_file)
|
|
|
| separator = Separator(
|
| model_file_dir=os.path.join(now_dir, "models", "deecho"),
|
| log_level=logging.WARNING,
|
| normalization_threshold=1.0,
|
| output_format="flac",
|
| output_dir=store_dir,
|
| output_single_stem="No Echo",
|
| vr_params={
|
| "batch_size": batch_size,
|
| "enable_tta": use_tta,
|
| },
|
| )
|
| separator.load_model(model_filename=model_info["full_name"])
|
| separator.separate(input_file)
|
| deecho_path = os.path.join(now_dir, "audio_files", music_folder, "deecho")
|
| search_result = search_with_two_words(
|
| deecho_path,
|
| os.path.basename(input_audio_path).split(".")[0],
|
| "No Echo",
|
| )
|
| if "UVR-De-Echo-Normal" in os.path.basename(
|
| search_result
|
| ) or "UVR-Deecho-Agggressive" in os.path.basename(search_result):
|
| os.rename(
|
| os.path.join(deecho_path, search_result),
|
| os.path.join(
|
| deecho_path,
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_noecho.flac",
|
| ),
|
| )
|
|
|
|
|
| store_dir = os.path.join(now_dir, "audio_files", music_folder, "denoise")
|
| os.makedirs(store_dir, exist_ok=True)
|
| if denoise:
|
| no_noise_exists = search_with_word(store_dir, "dry") is not None
|
| if no_noise_exists:
|
| print("Noise already removed")
|
| else:
|
| model_info = get_model_info_by_name(denoise_model)
|
| print("Removing noise")
|
| input_file = (
|
| os.path.join(
|
| now_dir,
|
| "audio_files",
|
| music_folder,
|
| "deecho",
|
| search_with_word(
|
| os.path.join(now_dir, "audio_files", music_folder, "deecho"),
|
| "noecho",
|
| ),
|
| )
|
| if deecho
|
| else os.path.join(
|
| now_dir,
|
| "audio_files",
|
| music_folder,
|
| "dereverb",
|
| search_with_word(
|
| os.path.join(now_dir, "audio_files", music_folder, "dereverb"),
|
| "noreverb",
|
| ),
|
| )
|
| )
|
|
|
| if (
|
| model_info["name"] == "Mel-Roformer Denoise Normal by aufr33"
|
| or model_info["name"] == "Mel-Roformer Denoise Aggressive by aufr33"
|
| ):
|
| model_ckpt_path = os.path.join(model_info["path"], "model.ckpt")
|
| if not os.path.exists(model_ckpt_path):
|
| download_file(
|
| model_info["model_url"],
|
| model_info["path"],
|
| "model.ckpt",
|
| )
|
| config_json_path = os.path.join(model_info["path"], "config.yaml")
|
| if not os.path.exists(config_json_path):
|
| download_file(
|
| model_info["config_url"], model_info["path"], "config.yaml"
|
| )
|
| if not fp16:
|
| with open(model_info["config"], "r") as file:
|
| config = yaml.safe_load(file)
|
|
|
| config["training"]["use_amp"] = False
|
|
|
| with open(model_info["config"], "w") as file:
|
| yaml.safe_dump(config, file)
|
| command = [
|
| "python",
|
| os.path.join(
|
| now_dir, "programs", "music_separation_code", "inference.py"
|
| ),
|
| "--model_type",
|
| model_info["type"],
|
| "--config_path",
|
| model_info["config"],
|
| "--start_check_point",
|
| model_info["model"],
|
| "--input_file",
|
| input_file,
|
| "--store_dir",
|
| store_dir,
|
| "--flac_file",
|
| "--pcm_type",
|
| "PCM_16",
|
| ]
|
|
|
| if devices == "cpu":
|
| command.append("--force_cpu")
|
| else:
|
| device_ids = [str(int(device)) for device in devices.split()]
|
| command.extend(["--device_ids"] + device_ids)
|
|
|
| subprocess.run(command)
|
| else:
|
| separator = Separator(
|
| model_file_dir=os.path.join(now_dir, "models", "denoise"),
|
| log_level=logging.WARNING,
|
| normalization_threshold=1.0,
|
| output_format="flac",
|
| output_dir=store_dir,
|
| output_single_stem="No Noise",
|
| vr_params={
|
| "batch_size": batch_size,
|
| "enable_tta": use_tta,
|
| },
|
| )
|
| separator.load_model(model_filename=model_info["full_name"])
|
| separator.separate(input_file)
|
| search_result = search_with_two_words(
|
| deecho_path,
|
| os.path.basename(input_audio_path).split(".")[0],
|
| "No Noise",
|
| )
|
| if "UVR Denoise" in os.path.basename(search_result):
|
| os.rename(
|
| os.path.join(deecho_path, search_result),
|
| os.path.join(
|
| deecho_path,
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_dry.flac",
|
| ),
|
| )
|
|
|
|
|
| denoise_path = os.path.join(now_dir, "audio_files", music_folder, "denoise")
|
| deecho_path = os.path.join(now_dir, "audio_files", music_folder, "deecho")
|
| dereverb_path = os.path.join(now_dir, "audio_files", music_folder, "dereverb")
|
|
|
| denoise_audio = search_with_two_words(
|
| denoise_path, os.path.basename(input_audio_path).split(".")[0], "dry"
|
| )
|
| deecho_audio = search_with_two_words(
|
| deecho_path, os.path.basename(input_audio_path).split(".")[0], "noecho"
|
| )
|
| dereverb = search_with_two_words(
|
| dereverb_path, os.path.basename(input_audio_path).split(".")[0], "noreverb"
|
| )
|
|
|
| if denoise_audio:
|
| final_path = os.path.join(
|
| now_dir, "audio_files", music_folder, "denoise", denoise_audio
|
| )
|
| elif deecho_audio:
|
| final_path = os.path.join(
|
| now_dir, "audio_files", music_folder, "deecho", deecho_audio
|
| )
|
| elif dereverb:
|
| final_path = os.path.join(
|
| now_dir, "audio_files", music_folder, "dereverb", dereverb
|
| )
|
| else:
|
| final_path = None
|
|
|
| store_dir = os.path.join(now_dir, "audio_files", music_folder, "rvc")
|
| os.makedirs(store_dir, exist_ok=True)
|
| print("Making RVC inference")
|
| output_rvc = os.path.join(
|
| now_dir,
|
| "audio_files",
|
| music_folder,
|
| "rvc",
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_rvc.wav",
|
| )
|
| inference_vc = import_voice_converter()
|
| inference_vc.convert_audio(
|
| audio_input_path=final_path,
|
| audio_output_path=output_rvc,
|
| model_path=model_path,
|
| index_path=index_path,
|
| embedder_model=embedder_model,
|
| pitch=pitch,
|
| f0_file=None,
|
| f0_method=pitch_extract,
|
| filter_radius=filter_radius,
|
| index_rate=index_rate,
|
| volume_envelope=rms_mix_rate,
|
| protect=protect,
|
| split_audio=split_audio,
|
| f0_autotune=autotune,
|
| hop_length=hop_lenght,
|
| export_format=export_format_rvc,
|
| embedder_model_custom=None,
|
| )
|
| backing_vocals = os.path.join(
|
| karaoke_path, search_with_word(karaoke_path, "instrumental")
|
| )
|
|
|
| if infer_backing_vocals:
|
| print("Infering backing vocals")
|
| karaoke_path = os.path.join(now_dir, "audio_files", music_folder, "karaoke")
|
| instrumental_file = search_with_word(karaoke_path, "instrumental")
|
| backing_vocals = os.path.join(karaoke_path, instrumental_file)
|
| output_backing_vocals = os.path.join(
|
| karaoke_path, f"{input_audio_basename}_instrumental_output.wav"
|
| )
|
| inference_vc.convert_audio(
|
| audio_input_path=backing_vocals,
|
| audio_output_path=output_backing_vocals,
|
| model_path=infer_backing_vocals_model,
|
| index_path=infer_backing_vocals_index,
|
| embedder_model=embedder_model_back,
|
| pitch=pitch_back,
|
| f0_file=None,
|
| f0_method=pitch_extract_back,
|
| filter_radius=filter_radius_back,
|
| index_rate=index_rate_back,
|
| volume_envelope=rms_mix_rate_back,
|
| protect=protect_back,
|
| split_audio=split_audio_back,
|
| f0_autotune=autotune_back,
|
| hop_length=hop_length_back,
|
| export_format=export_format_rvc_back,
|
| embedder_model_custom=None,
|
| )
|
| backing_vocals = output_backing_vocals
|
|
|
|
|
| if reverb:
|
| add_audio_effects(
|
| os.path.join(
|
| now_dir,
|
| "audio_files",
|
| music_folder,
|
| "rvc",
|
| get_last_modified_file(
|
| os.path.join(now_dir, "audio_files", music_folder, "rvc")
|
| ),
|
| ),
|
| reverb_room_size,
|
| reverb_wet_gain,
|
| reverb_dry_gain,
|
| reverb_damping,
|
| reverb_width,
|
| os.path.join(
|
| now_dir,
|
| "audio_files",
|
| music_folder,
|
| "rvc",
|
| os.path.basename(input_audio_path),
|
| ),
|
| )
|
| if change_inst_pitch != 0:
|
| print("Changing instrumental pitch")
|
| inst_path = os.path.join(
|
| now_dir,
|
| "audio_files",
|
| music_folder,
|
| "instrumentals",
|
| search_with_word(
|
| os.path.join(now_dir, "audio_files", music_folder, "instrumentals"),
|
| "instrumentals",
|
| ),
|
| )
|
| audio = AudioSegment.from_file(inst_path)
|
|
|
| factor = 2 ** (change_inst_pitch / 12)
|
|
|
| new_frame_rate = int(audio.frame_rate * factor)
|
| audio = audio._spawn(audio.raw_data, overrides={"frame_rate": new_frame_rate})
|
|
|
| audio = audio.set_frame_rate(audio.frame_rate)
|
| output_dir_pitch = os.path.join(
|
| now_dir, "audio_files", music_folder, "instrumentals"
|
| )
|
| output_path_pitch = os.path.join(
|
| output_dir_pitch, "inst_with_changed_pitch.flac"
|
| )
|
| audio.export(output_path_pitch, format="flac")
|
|
|
|
|
| store_dir = os.path.join(now_dir, "audio_files", music_folder, "final")
|
| os.makedirs(store_dir, exist_ok=True)
|
|
|
| vocals_path = os.path.join(now_dir, "audio_files", music_folder, "rvc")
|
| vocals_file = get_last_modified_file(
|
| os.path.join(now_dir, "audio_files", music_folder, "rvc")
|
| )
|
| vocals_file = os.path.join(vocals_path, vocals_file)
|
|
|
| karaoke_path = os.path.join(now_dir, "audio_files", music_folder, "karaoke")
|
| karaoke_file = search_with_word(karaoke_path, "Instrumental") or search_with_word(
|
| karaoke_path, "instrumental"
|
| )
|
| karaoke_file = os.path.join(karaoke_path, karaoke_file)
|
| final_output_path = os.path.join(
|
| now_dir,
|
| "audio_files",
|
| music_folder,
|
| "final",
|
| f"{os.path.basename(input_audio_path).split('.')[0]}_final.{export_format_final.lower()}",
|
| )
|
| print("Merging audios")
|
| result = merge_audios(
|
| vocals_file,
|
| inst_file,
|
| backing_vocals,
|
| final_output_path,
|
| vocals_volume,
|
| instrumentals_volume,
|
| backing_vocals_volume,
|
| export_format_final,
|
| )
|
| print("Audios merged!")
|
| if delete_audios:
|
| main_directory = os.path.join(now_dir, "audio_files", music_folder)
|
| folder_to_keep = "final"
|
| for folder_name in os.listdir(main_directory):
|
| folder_path = os.path.join(main_directory, folder_name)
|
| if os.path.isdir(folder_path) and folder_name != folder_to_keep:
|
| shutil.rmtree(folder_path)
|
| return (
|
| f"Audio file {os.path.basename(input_audio_path).split('.')[0]} converted with success",
|
| result,
|
| )
|
|
|
|
|
| def download_model(link):
|
| model_download_pipeline(link)
|
| return "Model downloaded with success"
|
|
|
|
|
| def download_music(link):
|
| os.makedirs(os.path.join(now_dir, "audio_files", "original_files"), exist_ok=True)
|
| command = [
|
| "yt-dlp",
|
| "-x",
|
| "--output",
|
| os.path.join(now_dir, "audio_files", "original_files", "%(title)s.%(ext)s"),
|
| link,
|
| ]
|
| subprocess.run(command)
|
| return "Music downloaded with success"
|
|
|
