""" This module contains functions to generate song covers using RVC-based voice models. """ from typing import Any from typings.extra import F0Method, InputAudioExt, InputType, OutputAudioExt import gc import glob import os import shlex import shutil import subprocess from contextlib import suppress from logging import WARNING from pathlib import Path, PurePath from urllib.parse import parse_qs, urlparse import yt_dlp import gradio as gr import soundfile as sf import sox from audio_separator.separator import Separator from pedalboard import Compressor, HighpassFilter, Reverb from pedalboard._pedalboard import Pedalboard from pedalboard.io import AudioFile from pydub import AudioSegment from pydub import utils as pydub_utils from vc.rvc import Config, get_vc, load_hubert, rvc_infer from backend.common import ( INTERMEDIATE_AUDIO_DIR, OUTPUT_AUDIO_DIR, display_progress, get_file_hash, get_hash, get_path_stem, get_rvc_model, json_dump, json_load, ) from backend.exceptions import InputMissingError, InvalidPathError, PathNotFoundError from common import RVC_MODELS_DIR, SEPARATOR_MODELS_DIR SEPARATOR = Separator( log_level=WARNING, model_file_dir=SEPARATOR_MODELS_DIR, output_dir=INTERMEDIATE_AUDIO_DIR, mdx_params={ "hop_length": 1024, "segment_size": 256, "overlap": 0.001, "batch_size": 1, "enable_denoise": False, }, mdxc_params={"segment_size": 256, "batch_size": 1, "overlap": 2}, ) def _get_youtube_video_id(url: str, ignore_playlist: bool = True) -> str | None: """ Get video id from a YouTube URL. Parameters ---------- url : str The YouTube URL. ignore_playlist : bool, default=True Whether to get id of first video in playlist or the playlist id itself. Returns ------- str The video id. """ query = urlparse(url) if query.hostname == "youtu.be": if query.path[1:] == "watch": return query.query[2:] return query.path[1:] if query.hostname in {"www.youtube.com", "youtube.com", "music.youtube.com"}: if not ignore_playlist: # use case: get playlist id not current video in playlist with suppress(KeyError): return parse_qs(query.query)["list"][0] if query.path == "/watch": return parse_qs(query.query)["v"][0] if query.path[:7] == "/watch/": return query.path.split("/")[1] if query.path[:7] == "/embed/": return query.path.split("/")[2] if query.path[:3] == "/v/": return query.path.split("/")[2] return None def _yt_download(link: str, song_dir: str) -> str: """ Download audio from a YouTube link. Parameters ---------- link : str The YouTube link. song_dir : str The directory to save the downloaded audio to. Returns ------- str The path to the downloaded audio file. """ outtmpl = os.path.join(song_dir, "0_%(title)s_Original") ydl_opts = { "quiet": True, "no_warnings": True, "format": "bestaudio", "outtmpl": outtmpl, "ignoreerrors": True, "nocheckcertificate": True, "postprocessors": [ { "key": "FFmpegExtractAudio", "preferredcodec": "wav", "preferredquality": 0, } ], } with yt_dlp.YoutubeDL(ydl_opts) as ydl: result = ydl.extract_info(link, download=True) if not result: raise PathNotFoundError("No audio found in the provided YouTube link!") download_path = ydl.prepare_filename(result, outtmpl=f"{outtmpl}.wav") return download_path def _get_input_audio_paths() -> list[str]: """ Get the paths of all cached input audio files. Returns ------- list[str] The paths of all cached input audio files """ # TODO if we later add .json file for input then we need to exclude those here return glob.glob(os.path.join(INTERMEDIATE_AUDIO_DIR, "*", "0_*_Original*")) def _get_input_audio_path(song_dir: str) -> str | None: """ Get the path of the cached input audio file in a given song directory. Parameters ---------- song_dir : str The path to a song directory. Returns ------- str The path of the cached input audio file, if it exists. """ # NOTE orig_song_paths should never contain more than one element return next(iter(glob.glob(os.path.join(song_dir, "0_*_Original*"))), None) def _pitch_shift(audio_path: str, output_path: str, n_semi_tones: int) -> None: """ Pitch-shift an audio file. Parameters ---------- audio_path : str The path of the audio file to pitch-shift. output_path : str The path to save the pitch-shifted audio file to. n_semi_tones : int The number of semi-tones to pitch-shift the audio by. """ y, sr = sf.read(audio_path) tfm = sox.Transformer() tfm.pitch(n_semi_tones) y_shifted = tfm.build_array(input_array=y, sample_rate_in=sr) sf.write(output_path, y_shifted, sr) # TODO consider increasing hash_size to 16 # otherwise we might have problems with hash collisions # when using app as CLI def _get_unique_base_path( song_dir: str, prefix: str, arg_dict: dict[str, Any], progress_bar: gr.Progress | None = None, percentage: float = 0.0, hash_size: int = 5, ) -> str: """ Get a unique base path for an audio file in a song directory by hashing the arguments used to generate the audio. Parameters ---------- song_dir : str The path to a song directory. prefix : str The prefix to use for the base path. arg_dict : dict The dictionary of arguments used to generate the audio in the given file. progress_bar : gr.Progress, optional Gradio progress bar to update. percentage : float, default=0.0 Percentage to display in the progress bar. hash_size : int, default=5 The size (in bytes) of the hash to use for the base path. Returns ------- str The unique base path for the audio file. """ dict_hash = get_hash(arg_dict, size=hash_size) while True: base_path = os.path.join(song_dir, f"{prefix}_{dict_hash}") json_path = f"{base_path}.json" if os.path.exists(json_path): file_dict = json_load(json_path) if file_dict == arg_dict: return base_path display_progress("[~] Rehashing...", percentage, progress_bar) dict_hash = get_hash(dict_hash, size=hash_size) else: return base_path def _convert_voice( voice_model: str, voice_path: str, output_path: str, pitch_change: int, f0_method: F0Method, index_rate: float, filter_radius: int, rms_mix_rate: float, protect: float, crepe_hop_length: int, output_sr: int, ) -> None: """ Convert a voice track using a voice model. Parameters ---------- voice_model : str The name of the voice model to use. voice_path : str The path to the voice track to convert. output_path : str The path to save the converted voice to. pitch_change : int The number of semi-tones to pitch-shift the converted voice by. f0_method : F0Method The method to use for pitch extraction. index_rate : float The influence of index file on voice conversion. filter_radius : int The filter radius to use for the voice conversion. rms_mix_rate : float The blending rate of the volume envelope of converted voice. protect : float The protection rate for consonants and breathing sounds. crepe_hop_length : int The hop length to use for Crepe pitch extraction method. output_sr : int The sample rate to use for the output audio. """ rvc_model_path, rvc_index_path = get_rvc_model(voice_model) device = "cuda:0" config = Config(device, True) hubert_model = load_hubert( device, config.is_half, os.path.join(RVC_MODELS_DIR, "hubert_base.pt") ) cpt, version, net_g, tgt_sr, vc = get_vc( device, config.is_half, config, rvc_model_path ) # convert main vocals rvc_infer( rvc_index_path, index_rate, voice_path, output_path, pitch_change, f0_method, cpt, version, net_g, filter_radius, tgt_sr, rms_mix_rate, protect, crepe_hop_length, vc, hubert_model, output_sr, ) del hubert_model, cpt gc.collect() def _add_audio_effects( audio_path: str, output_path: str, reverb_rm_size: float, reverb_wet: float, reverb_dry: float, reverb_damping: float, ) -> None: """ Add high-pass filter, compressor and reverb effects to an audio file. Parameters ---------- audio_path : str The path of the audio file to add effects to. output_path : str The path to save the effected audio file to. reverb_rm_size : float The room size of the reverb effect. reverb_wet : float The wet level of the reverb effect. reverb_dry : float The dry level of the reverb effect. reverb_damping : float The damping of the reverb effect. """ board = Pedalboard( [ HighpassFilter(), Compressor(ratio=4, threshold_db=-15), Reverb( room_size=reverb_rm_size, dry_level=reverb_dry, wet_level=reverb_wet, damping=reverb_damping, ), ] ) with AudioFile(audio_path) as f: with AudioFile(output_path, "w", f.samplerate, f.num_channels) as o: # Read one second of audio at a time, until the file is empty: while f.tell() < f.frames: chunk = f.read(int(f.samplerate)) effected = board(chunk, f.samplerate, reset=False) o.write(effected) def _map_audio_ext(input_audio_ext: InputAudioExt) -> OutputAudioExt: """ Map an input audio extension to an output audio extension. Parameters ---------- input_audio_ext : InputAudioExt The input audio extension. Returns ------- OutputAudioExt The output audio extension. """ match input_audio_ext: case "m4a": return "ipod" case "aac": return "adts" case _: return input_audio_ext def _mix_audio( main_vocal_path: str, backup_vocal_path: str, instrumental_path: str, main_gain: int, backup_gain: int, inst_gain: int, output_format: InputAudioExt, output_sr: int, output_path: str, ) -> None: """ Mix main vocals, backup vocals and instrumentals. Parameters ---------- main_vocal_path : str The path of an audio file containing main vocals. backup_vocal_path : str The path of an audio file containing backup vocals. instrumental_path : str The path of an audio file containing instrumentals. main_gain : int The gain to apply to the main vocals. backup_gain : int The gain to apply to the backup vocals. inst_gain : int The gain to apply to the instrumental. output_format : InputAudioExt The format to save the mixed audio file in. output_sr : int The sample rate to use for the mixed audio file. output_path : str The path to save the mixed audio file to. """ main_vocal_audio = AudioSegment.from_wav(main_vocal_path) + main_gain backup_vocal_audio = AudioSegment.from_wav(backup_vocal_path) + backup_gain instrumental_audio = AudioSegment.from_wav(instrumental_path) + inst_gain combined_audio = main_vocal_audio.overlay(backup_vocal_audio).overlay( instrumental_audio ) combined_audio_resampled = combined_audio.set_frame_rate(output_sr) mapped_output_format = _map_audio_ext(output_format) combined_audio_resampled.export(output_path, format=mapped_output_format) def get_named_song_dirs() -> list[tuple[str, str]]: """ Get the names and paths of all song directories. Returns ------- list[tuple[str, str]] A list of tuples containing the name and path of each song directory. """ input_paths = _get_input_audio_paths() named_song_dirs: list[tuple[str, str]] = [] for path in input_paths: song_dir, song_basename = os.path.split(path) song_name = ( os.path.splitext(song_basename)[0] .removeprefix("0_") .removesuffix("_Original") ) named_song_dirs.append((song_name, song_dir)) return sorted(named_song_dirs, key=lambda x: x[0]) def convert_to_stereo( song_path: str, song_dir: str, progress_bar: gr.Progress | None = None, percentage: float = 0.0, ) -> str: """ Converts an audio file to stereo. Parameters ---------- song_path : str The path to the audio file to convert. song_dir : str The path to the directory where the stereo audio file will be saved. progress_bar : gr.Progress, optional Gradio progress bar to update. percentage : float, default=0.0 Percentage to display in the progress bar. Returns ------- str The path to the stereo audio file. Raises ------ InputMissingError If no audio file or song directory path is provided. PathNotFoundError If the provided audio file or song directory path does not point to an existing file or directory. """ if not song_path: raise InputMissingError("Input song missing!") if not os.path.isfile(song_path): raise PathNotFoundError("Input song does not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("Song directory does not exist!") stereo_path = song_path song_info = pydub_utils.mediainfo(song_path) if song_info["channels"] == "1": arg_dict = { "input-files": [ {"name": os.path.basename(song_path), "hash": get_file_hash(song_path)} ], } stereo_path_base = _get_unique_base_path( song_dir, "0_Stereo", arg_dict, progress_bar, percentage ) stereo_path = f"{stereo_path_base}.wav" stereo_json_path = f"{stereo_path_base}.json" if not (os.path.exists(stereo_path) and os.path.exists(stereo_json_path)): display_progress( "[~] Converting song to stereo...", percentage, progress_bar ) command = shlex.split( f'ffmpeg -y -loglevel error -i "{song_path}" -ac 2 -f wav' f' "{stereo_path}"' ) subprocess.run(command) json_dump(arg_dict, stereo_json_path) return stereo_path def _make_song_dir( song_input: str, progress_bar: gr.Progress | None = None, percentage: float = 0.0 ) -> tuple[str, InputType]: """ Create a song directory for a given song input. * If the song input is a YouTube URL, the song directory will be named after the video id. * If the song input is a local audio file, the song directory will be named after the file hash. * if the song input is a song directory, the song directory will be used as is. Parameters ---------- song_input : str The song input to create a directory for. progress_bar : gr.Progress, optional Gradio progress bar to update. percentage : float, default=0.0 Percentage to display in the progress bar. Returns ------- song_dir : str The path to the created song directory. input_type : InputType The type of input provided. Raises ------ InputMissingError If no song input is provided. InvalidPathError If the provided YouTube URL is invalid or if the provided song directory is not located in the root of the intermediate audio directory. PathNotFoundError If the provided song input is neither a valid HTTPS-based URL nor the path of an existing song directory or audio file. """ # if song directory if os.path.isdir(song_input): if not PurePath(song_input).parent == PurePath(INTERMEDIATE_AUDIO_DIR): raise InvalidPathError( "Song directory not located in the root of the intermediate audio" " directory." ) display_progress( "[~] Using existing song directory...", percentage, progress_bar ) input_type = "local" return song_input, input_type display_progress("[~] Creating song directory...", percentage, progress_bar) # if youtube url if urlparse(song_input).scheme == "https": input_type = "yt" song_id = _get_youtube_video_id(song_input) if song_id is None: raise InvalidPathError("Invalid YouTube url!") # if local audio file elif os.path.isfile(song_input): input_type = "local" song_id = get_file_hash(song_input) else: raise PathNotFoundError(f"Song input {song_input} does not exist.") song_dir = os.path.join(INTERMEDIATE_AUDIO_DIR, song_id) Path(song_dir).mkdir(parents=True, exist_ok=True) return song_dir, input_type def retrieve_song( song_input: str, progress_bar: gr.Progress | None = None, percentages: tuple[float, float, float] = (0, 0.33, 0.67), ) -> tuple[str, str]: """ Retrieve a song from a YouTube URL, local audio file or a song directory. Parameters ---------- song_input : str A Youtube URL, the path of a local audio file or the path of a song directory. progress_bar : gr.Progress, optional Gradio progress bar to update. percentages : tuple[float,float,float], default=(0, 0.33, 0.67) Percentages to display in the progress bar. Returns ------- song_path : str The path to the retrieved audio file song_dir : str The path to the song directory containing it. Raises ------ InputMissingError If no song input is provided. InvalidPathError If the provided Youtube URL is invalid or if the provided song directory is not located in the root of the intermediate audio directory. PathNotFoundError If the provided song input is neither a valid HTTPS-based URL nor the path of an existing song directory or audio file. """ if not song_input: raise InputMissingError( "Song input missing! Please provide a valid YouTube url, local audio file" " path or cached song directory path." ) song_dir, input_type = _make_song_dir(song_input, progress_bar, percentages[0]) orig_song_path = _get_input_audio_path(song_dir) if not orig_song_path: if input_type == "yt": display_progress("[~] Downloading song...", percentages[1], progress_bar) song_link = song_input.split("&")[0] orig_song_path = _yt_download(song_link, song_dir) else: display_progress("[~] Copying song...", percentages[1], progress_bar) song_input_base = os.path.basename(song_input) song_input_name, song_input_ext = os.path.splitext(song_input_base) orig_song_name = f"0_{song_input_name}_Original" orig_song_path = os.path.join(song_dir, orig_song_name + song_input_ext) shutil.copyfile(song_input, orig_song_path) stereo_path = convert_to_stereo( orig_song_path, song_dir, progress_bar, percentages[2] ) return stereo_path, song_dir def separate_vocals( song_path: str, song_dir: str, stereofy: bool = True, progress_bar: gr.Progress | None = None, percentages: tuple[float, float] = (0.0, 0.5), ) -> tuple[str, str]: """ Separate a song into vocals and instrumentals. Parameters ---------- song_path : str The path to the song to separate. song_dir : str The path to the song directory where the separated vocals and instrumentals will be saved. stereofy : bool, default=True Whether to convert the song to stereo before separating its vocals and instrumentals. progress_bar : gr.Progress, optional Gradio progress bar to update. percentages : tuple[float,float], default=(0.0, 0.5) Percentages to display in the progress bar. Returns ------- vocals_path : str The path to the separated vocals. instrumentals_path : str The path to the separated instrumentals. Raises ------ InputMissingError If no song path or song directory path is provided. PathNotFoundError If the provided song path or song directory path does not point to an existing file or directory. """ if not song_path: raise InputMissingError("Input song missing!") if not os.path.isfile(song_path): raise PathNotFoundError("Input song does not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("Song directory does not exist!") song_path = ( convert_to_stereo(song_path, song_dir, progress_bar, percentages[0]) if stereofy else song_path ) arg_dict = { "input-files": [ {"name": os.path.basename(song_path), "hash": get_file_hash(song_path)} ], } vocals_path_base = _get_unique_base_path( song_dir, "1_Vocals", arg_dict, progress_bar, percentages[1] ) instrumentals_path_base = _get_unique_base_path( song_dir, "1_Instrumental", arg_dict, progress_bar, percentages[1] ) vocals_path = f"{vocals_path_base}.wav" vocals_json_path = f"{vocals_path_base}.json" instrumentals_path = f"{instrumentals_path_base}.wav" instrumentals_json_path = f"{instrumentals_path_base}.json" if not ( os.path.exists(vocals_path) and os.path.exists(vocals_json_path) and os.path.exists(instrumentals_path) and os.path.exists(instrumentals_json_path) ): display_progress( "[~] Separating vocals from instrumentals...", percentages[1], progress_bar ) SEPARATOR.arch_specific_params["MDX"]["segment_size"] = 512 SEPARATOR.load_model("UVR-MDX-NET-Voc_FT.onnx") temp_instrumentals_name, temp_vocals_name = SEPARATOR.separate(song_path) shutil.move( os.path.join(INTERMEDIATE_AUDIO_DIR, temp_instrumentals_name), instrumentals_path, ) shutil.move(os.path.join(INTERMEDIATE_AUDIO_DIR, temp_vocals_name), vocals_path) json_dump(arg_dict, vocals_json_path) json_dump(arg_dict, instrumentals_json_path) return vocals_path, instrumentals_path def separate_main_vocals( vocals_path: str, song_dir: str, stereofy: bool = True, progress_bar: gr.Progress | None = None, percentages: tuple[float, float] = (0.0, 0.5), ) -> tuple[str, str]: """ Separate a vocals track into main vocals and backup vocals. Parameters ---------- vocals_path : str The path to the vocals track to separate. song_dir : str The path to the directory where the separated main vocals and backup vocals will be saved. stereofy : bool, default=True Whether to convert the vocals track to stereo before separating its main vocals and backup vocals. progress_bar : gr.Progress, optional Gradio progress bar to update. percentages : tuple[float,float], default=(0.0, 0.5) Percentages to display in the progress bar. Returns ------- main_vocals_path : str The path to the separated main vocals. backup_vocals_path : str The path to the separated backup vocals. Raises ------ InputMissingError If no vocals track path or song directory path is provided. PathNotFoundError If the provided vocals path or song directory path does not point to an existing file or directory. """ if not vocals_path: raise InputMissingError("Vocals missing!") if not os.path.isfile(vocals_path): raise PathNotFoundError("Vocals do not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("song directory does not exist!") vocals_path = ( convert_to_stereo(vocals_path, song_dir, progress_bar, percentages[0]) if stereofy else vocals_path ) arg_dict = { "input-files": [ {"name": os.path.basename(vocals_path), "hash": get_file_hash(vocals_path)} ], } main_vocals_path_base = _get_unique_base_path( song_dir, "2_Vocals_Main", arg_dict, progress_bar, percentages[1] ) backup_vocals_path_base = _get_unique_base_path( song_dir, "2_Vocals_Backup", arg_dict, progress_bar, percentages[1] ) main_vocals_path = f"{main_vocals_path_base}.wav" main_vocals_json_path = f"{main_vocals_path_base}.json" backup_vocals_path = f"{backup_vocals_path_base}.wav" backup_vocals_json_path = f"{backup_vocals_path_base}.json" if not ( os.path.exists(main_vocals_path) and os.path.exists(main_vocals_json_path) and os.path.exists(backup_vocals_path) and os.path.exists(backup_vocals_json_path) ): display_progress( "[~] Separating main vocals from backup vocals...", percentages[1], progress_bar, ) SEPARATOR.arch_specific_params["MDX"]["segment_size"] = 512 SEPARATOR.load_model("UVR_MDXNET_KARA_2.onnx") temp_main_vocals_name, temp_backup_vocals_name = SEPARATOR.separate(vocals_path) shutil.move( os.path.join(INTERMEDIATE_AUDIO_DIR, temp_main_vocals_name), main_vocals_path, ) shutil.move( os.path.join(INTERMEDIATE_AUDIO_DIR, temp_backup_vocals_name), backup_vocals_path, ) json_dump(arg_dict, main_vocals_json_path) json_dump(arg_dict, backup_vocals_json_path) return main_vocals_path, backup_vocals_path def dereverb_vocals( vocals_path: str, song_dir: str, stereofy: bool = True, progress_bar: gr.Progress | None = None, percentages: tuple[float, float] = (0.0, 0.5), ) -> tuple[str, str]: """ De-reverb a vocals track. Parameters ---------- vocals_path : str The path to the vocals track to de-reverb. song_dir : str The path to the directory where the de-reverbed vocals will be saved. stereofy : bool, default=True Whether to convert the vocals track to stereo before de-reverbing it. progress_bar : gr.Progress, optional Gradio progress bar to update. percentages : tuple[float,float], default=(0.0, 0.5) Percentages to display in the progress bar. Returns ------- vocals_dereverb_path : str The path to the de-reverbed vocals. vocals_reverb_path : str The path to the reverb of the vocals. Raises ------ InputMissingError If no vocals track path or song directory path is provided. PathNotFoundError If the provided vocals path or song directory path does not point to an existing file or directory. """ if not vocals_path: raise InputMissingError("Vocals missing!") if not os.path.isfile(vocals_path): raise PathNotFoundError("Vocals do not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("song directory does not exist!") vocals_path = ( convert_to_stereo(vocals_path, song_dir, progress_bar, percentages[0]) if stereofy else vocals_path ) arg_dict = { "input-files": [ {"name": os.path.basename(vocals_path), "hash": get_file_hash(vocals_path)} ], } vocals_dereverb_path_base = _get_unique_base_path( song_dir, "3_Vocals_DeReverb", arg_dict, progress_bar, percentages[1] ) vocals_reverb_path_base = _get_unique_base_path( song_dir, "3_Vocals_Reverb", arg_dict, progress_bar, percentages[1] ) vocals_dereverb_path = f"{vocals_dereverb_path_base}.wav" vocals_dereverb_json_path = f"{vocals_dereverb_path_base}.json" vocals_reverb_path = f"{vocals_reverb_path_base}.wav" vocals_reverb_json_path = f"{vocals_reverb_path_base}.json" if not ( os.path.exists(vocals_dereverb_path) and os.path.exists(vocals_dereverb_json_path) and os.path.exists(vocals_reverb_path) and os.path.exists(vocals_reverb_json_path) ): display_progress("[~] De-reverbing vocals...", percentages[1], progress_bar) SEPARATOR.arch_specific_params["MDX"]["segment_size"] = 256 SEPARATOR.load_model("Reverb_HQ_By_FoxJoy.onnx") temp_vocals_dereverb_name, temp_vocals_reverb_name = SEPARATOR.separate( vocals_path ) shutil.move( os.path.join(INTERMEDIATE_AUDIO_DIR, temp_vocals_dereverb_name), vocals_dereverb_path, ) shutil.move( os.path.join(INTERMEDIATE_AUDIO_DIR, temp_vocals_reverb_name), vocals_reverb_path, ) json_dump(arg_dict, vocals_dereverb_json_path) json_dump(arg_dict, vocals_reverb_json_path) return vocals_dereverb_path, vocals_reverb_path def convert_vocals( vocals_path: str, song_dir: str, voice_model: str, pitch_change_octaves: int = 0, pitch_change_semi_tones: int = 0, index_rate: float = 0.5, filter_radius: int = 3, rms_mix_rate: float = 0.25, protect: float = 0.33, f0_method: F0Method = "rmvpe", crepe_hop_length: int = 128, progress_bar: gr.Progress | None = None, percentage: float = 0.0, ) -> str: """ Convert a vocals track using a voice model. Parameters ---------- vocals_path : str The path to the vocals track to convert. song_dir : str The path to the directory where the converted vocals will be saved. voice_model : str The name of the voice model to use. pitch_change_octaves : int, default=0 The number of octaves to pitch-shift the converted vocals by. pitch_change_semi_tones : int, default=0 The number of semi-tones to pitch-shift the converted vocals by. index_rate : float, default=0.5 The influence of the index file on the vocal conversion. filter_radius : int, default=3 The filter radius to use for the vocal conversion. rms_mix_rate : float, default=0.25 The blending rate of the volume envelope of the converted vocals. protect : float, default=0.33 The protection rate for consonants and breathing sounds. f0_method : F0Method, default="rmvpe" The method to use for pitch extraction. crepe_hop_length : int, default=128 The hop length to use for crepe-based pitch extraction. progress_bar : gr.Progress, optional Gradio progress bar to update. percentage : float, default=0.0 Percentage to display in the progress bar. Returns ------- str The path to the converted vocals. Raises ------ InputMissingError If no vocals track path, song directory path or voice model name is provided. PathNotFoundError If the provided vocals path, song directory path or voice model name does not point to an existing file or directory. """ if not vocals_path: raise InputMissingError("Vocals missing!") if not os.path.isfile(vocals_path): raise PathNotFoundError("Vocals do not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("song directory does not exist!") if not voice_model: raise InputMissingError("Voice model missing!") if not os.path.isdir(os.path.join(RVC_MODELS_DIR, voice_model)): raise PathNotFoundError("Voice model does not exist!") pitch_change = pitch_change_octaves * 12 + pitch_change_semi_tones hop_length_suffix = "" if f0_method != "mangio-crepe" else f"_{crepe_hop_length}" arg_dict = { "input-files": [ {"name": os.path.basename(vocals_path), "hash": get_file_hash(vocals_path)} ], "voice-model": voice_model, "pitch-shift": pitch_change, "index-rate": index_rate, "filter-radius": filter_radius, "rms-mix-rate": rms_mix_rate, "protect": protect, "f0-method": f"{f0_method}{hop_length_suffix}", } converted_vocals_path_base = _get_unique_base_path( song_dir, "4_Vocals_Converted", arg_dict, progress_bar, percentage ) converted_vocals_path = f"{converted_vocals_path_base}.wav" converted_vocals_json_path = f"{converted_vocals_path_base}.json" if not ( os.path.exists(converted_vocals_path) and os.path.exists(converted_vocals_json_path) ): display_progress("[~] Converting vocals using RVC...", percentage, progress_bar) _convert_voice( voice_model, vocals_path, converted_vocals_path, pitch_change, f0_method, index_rate, filter_radius, rms_mix_rate, protect, crepe_hop_length, 44100, ) json_dump(arg_dict, converted_vocals_json_path) return converted_vocals_path def postprocess_vocals( vocals_path: str, song_dir: str, reverb_rm_size: float = 0.15, reverb_wet: float = 0.2, reverb_dry: float = 0.8, reverb_damping: float = 0.7, progress_bar: gr.Progress | None = None, percentage: float = 0.0, ) -> str: """ Apply high-pass filter, compressor and reverb effects to a vocals track. Parameters ---------- vocals_path : str The path to the vocals track to add effects to. song_dir : str The path to the directory where the effected vocals will be saved. reverb_rm_size : float, default=0.15 The room size of the reverb effect. reverb_wet : float, default=0.2 The wet level of the reverb effect. reverb_dry : float, default=0.8 The dry level of the reverb effect. reverb_damping : float, default=0.7 The damping of the reverb effect. progress_bar : gr.Progress, optional Gradio progress bar to update. percentage : float, default=0.0 Percentage to display in the progress bar. Returns ------- str The path to the effected vocals. Raises ------ InputMissingError If no vocals track path or song directory path is provided. PathNotFoundError If the provided vocals path or song directory path does not point to an existing file or directory. """ if not vocals_path: raise InputMissingError("Vocals missing!") if not os.path.isfile(vocals_path): raise PathNotFoundError("Vocals do not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("song directory does not exist!") arg_dict = { "input-files": [ {"name": os.path.basename(vocals_path), "hash": get_file_hash(vocals_path)} ], "reverb-room-size": reverb_rm_size, "reverb-wet": reverb_wet, "reverb-dry": reverb_dry, "reverb-damping": reverb_damping, } vocals_mixed_path_base = _get_unique_base_path( song_dir, "5_Vocals_Postprocessed", arg_dict, progress_bar, percentage ) vocals_mixed_path = f"{vocals_mixed_path_base}.wav" vocals_mixed_json_path = f"{vocals_mixed_path_base}.json" if not ( os.path.exists(vocals_mixed_path) and os.path.exists(vocals_mixed_json_path) ): display_progress( "[~] Applying audio effects to vocals...", percentage, progress_bar ) _add_audio_effects( vocals_path, vocals_mixed_path, reverb_rm_size, reverb_wet, reverb_dry, reverb_damping, ) json_dump(arg_dict, vocals_mixed_json_path) return vocals_mixed_path def pitch_shift_background( instrumentals_path: str, backup_vocals_path: str, song_dir: str, pitch_change: int = 0, progress_bar: gr.Progress | None = None, percentages: tuple[float, float] = (0.0, 0.5), ) -> tuple[str, str]: """ Pitch shift instrumentals and backup vocals by a given number of semi-tones. Parameters ---------- instrumentals_path : str The path to the instrumentals to pitch shift. backup_vocals_path : str The path to the backup vocals to pitch shift. song_dir : str The path to the directory where the pitch-shifted instrumentals and backup vocals will be saved. pitch_change : int, default=0 The number of semi-tones to pitch-shift the instrumentals and backup vocals by. progress_bar : gr.Progress, optional Gradio progress bar to update. percentages : tuple[float,float], default=(0.0, 0.5) Percentages to display in the progress bar. Returns ------- instrumentals_shifted_path : str The path to the pitch-shifted instrumentals. backup_vocals_shifted_path : str The path to the pitch-shifted backup vocals. Raises ------ InputMissingError If no instrumentals path, backup vocals path or song directory path is provided. PathNotFoundError If the provided instrumentals path, backup vocals path or song directory path does not point to an existing file or directory. """ if not instrumentals_path: raise InputMissingError("Instrumentals missing!") if not os.path.isfile(instrumentals_path): raise PathNotFoundError("Instrumentals do not exist!") if not backup_vocals_path: raise InputMissingError("Backup vocals missing!") if not os.path.isfile(backup_vocals_path): raise PathNotFoundError("Backup vocals do not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("song directory does not exist!") instrumentals_shifted_path = instrumentals_path backup_vocals_shifted_path = backup_vocals_path if pitch_change != 0: instrumentals_dict = { "input-files": [ { "name": os.path.basename(instrumentals_path), "hash": get_file_hash(instrumentals_path), } ], "pitch-shift": pitch_change, } instrumentals_shifted_path_base = _get_unique_base_path( song_dir, "6_Instrumental_Shifted", instrumentals_dict, progress_bar, percentages[0], ) instrumentals_shifted_path = f"{instrumentals_shifted_path_base}.wav" instrumentals_shifted_json_path = f"{instrumentals_shifted_path_base}.json" if not ( os.path.exists(instrumentals_shifted_path) and os.path.exists(instrumentals_shifted_json_path) ): display_progress( "[~] Applying pitch shift to instrumentals", percentages[0], progress_bar, ) _pitch_shift(instrumentals_path, instrumentals_shifted_path, pitch_change) json_dump(instrumentals_dict, instrumentals_shifted_json_path) backup_vocals_dict = { "input-files": [ { "name": os.path.basename(backup_vocals_path), "hash": get_file_hash(backup_vocals_path), } ], "pitch-shift": pitch_change, } backup_vocals_shifted_path_base = _get_unique_base_path( song_dir, "6_Vocals_Backup_Shifted", backup_vocals_dict, progress_bar, percentages[1], ) backup_vocals_shifted_path = f"{backup_vocals_shifted_path_base}.wav" backup_vocals_shifted_json_path = f"{backup_vocals_shifted_path_base}.json" if not ( os.path.exists(backup_vocals_shifted_path) and os.path.exists(backup_vocals_shifted_json_path) ): display_progress( "[~] Applying pitch shift to backup vocals", percentages[1], progress_bar, ) _pitch_shift(backup_vocals_path, backup_vocals_shifted_path, pitch_change) json_dump(backup_vocals_dict, backup_vocals_shifted_json_path) return instrumentals_shifted_path, backup_vocals_shifted_path def _get_voice_model( mixed_vocals_path: str | None = None, song_dir: str | None = None ) -> str: """ Infer the voice model used for vocal conversion from a mixed vocals file in a given song directory. If the voice model cannot be inferred, "Unknown" is returned. Parameters ---------- mixed_vocals_path : str, optional The path to a mixed vocals file. song_dir : str, optional The path to a song directory. Returns ------- str The voice model used for vocal conversion. """ voice_model = "Unknown" if not (mixed_vocals_path and song_dir): return voice_model mixed_vocals_stem = get_path_stem(mixed_vocals_path) mixed_vocals_json_path = os.path.join(song_dir, f"{mixed_vocals_stem}.json") if not os.path.isfile(mixed_vocals_json_path): return voice_model mixed_vocals_json_dict = json_load(mixed_vocals_json_path) input_files = mixed_vocals_json_dict.get("input-files") input_path = input_files[0].get("name") if input_files else None if not input_path: return voice_model input_stem = get_path_stem(input_path) converted_vocals_json_path = os.path.join(song_dir, f"{input_stem}.json") if not os.path.isfile(converted_vocals_json_path): return voice_model converted_vocals_dict = json_load(converted_vocals_json_path) return converted_vocals_dict.get("voice-model", voice_model) def get_song_cover_name( mixed_vocals_path: str | None = None, song_dir: str | None = None, voice_model: str | None = None, progress_bar: gr.Progress | None = None, percentage: float = 0.0, ) -> str: """ Generates a suitable name for a cover of a song based on that song's original name and the voice model used for vocal conversion. If the path of an existing song directory is provided, the original song name is inferred from that directory. If a voice model is not provided but the path of an existing song directory and the path of a mixed vocals file in that directory are provided, then the voice model is inferred from the mixed vocals file. Parameters ---------- mixed_vocals_path : str, optional The path to a mixed vocals file. song_dir : str, optional The path to a song directory. voice_model : str, optional A voice model name. progress_bar : gr.Progress, optional Gradio progress bar to update. percentage : float, default=0.0 Percentage to display in the progress bar. Returns ------- str The song cover name """ display_progress("[~] Getting song cover name...", percentage, progress_bar) orig_song_path = _get_input_audio_path(song_dir) if song_dir else None orig_song_name = ( (get_path_stem(orig_song_path).removeprefix("0_").removesuffix("_Original")) if orig_song_path else "Unknown" ) voice_model = voice_model or _get_voice_model(mixed_vocals_path, song_dir) return f"{orig_song_name} ({voice_model} Ver)" def mix_song_cover( main_vocals_path: str, instrumentals_path: str, backup_vocals_path: str, song_dir: str, main_gain: int = 0, inst_gain: int = 0, backup_gain: int = 0, output_sr: int = 44100, output_format: InputAudioExt = "mp3", output_name: str | None = None, progress_bar: gr.Progress | None = None, percentages: tuple[float, float] = (0.0, 0.5), ) -> str: """ Mix main vocals, instrumentals, and backup vocals to create a song cover. Parameters ---------- main_vocals_path : str The path to the main vocals to mix. instrumentals_path : str The path to the instrumentals to mix. backup_vocals_path : str The path to the backup vocals to mix. song_dir : str The path to the song directory where the song cover will be saved. main_gain : int, default=0 The gain to apply to the main vocals. inst_gain : int, default=0 The gain to apply to the instrumentals. backup_gain : int, default=0 The gain to apply to the backup vocals. output_sr : int, default=44100 The sample rate of the song cover. output_format : InputAudioExt, default="mp3" The audio format of the song cover. output_name : str, optional The name of the song cover. progress_bar : gr.Progress, optional Gradio progress bar to update. percentages : tuple[float,float], default=(0.0, 0.5) Percentages to display in the progress bar. Returns ------- str The path to the song cover. Raises ------ InputMissingError If no main vocals, instrumentals, backup vocals or song directory path is provided. PathNotFoundError If the provided main vocals, instrumentals, backup vocals or song directory path does not point to an existing file or directory. """ if not main_vocals_path: raise InputMissingError("Main vocals missing!") if not os.path.isfile(main_vocals_path): raise PathNotFoundError("Main vocals do not exist!") if not instrumentals_path: raise InputMissingError("Instrumentals missing!") if not os.path.isfile(instrumentals_path): raise PathNotFoundError("Instrumentals do not exist!") if not backup_vocals_path: raise InputMissingError("Backup vocals missing!") if not os.path.isfile(backup_vocals_path): raise PathNotFoundError("Backup vocals do not exist!") if not song_dir: raise InputMissingError("Song directory missing!") if not os.path.isdir(song_dir): raise PathNotFoundError("song directory does not exist!") arg_dict = { "input-files": [ { "name": os.path.basename(main_vocals_path), "hash": get_file_hash(main_vocals_path), }, { "name": os.path.basename(instrumentals_path), "hash": get_file_hash(instrumentals_path), }, { "name": os.path.basename(backup_vocals_path), "hash": get_file_hash(backup_vocals_path), }, ], "main-gain": main_gain, "instrument-gain": inst_gain, "backup-gain": backup_gain, "sample-rate": output_sr, } mixdown_path_base = _get_unique_base_path( song_dir, "7_Mixdown", arg_dict, progress_bar, percentages[0] ) mixdown_path = f"{mixdown_path_base}.{output_format}" mixdown_json_path = f"{mixdown_path_base}.json" if not (os.path.exists(mixdown_path) and os.path.exists(mixdown_json_path)): display_progress( "[~] Mixing main vocals, instrumentals, and backup vocals...", percentages[0], progress_bar, ) _mix_audio( main_vocals_path, backup_vocals_path, instrumentals_path, main_gain, backup_gain, inst_gain, output_format, output_sr, mixdown_path, ) json_dump(arg_dict, mixdown_json_path) output_name = output_name or get_song_cover_name( main_vocals_path, song_dir, None, progress_bar, percentages[1] ) song_cover_path = os.path.join(OUTPUT_AUDIO_DIR, f"{output_name}.{output_format}") os.makedirs(OUTPUT_AUDIO_DIR, exist_ok=True) shutil.copyfile(mixdown_path, song_cover_path) return song_cover_path def run_pipeline( song_input: str, voice_model: str, pitch_change_vocals: int = 0, pitch_change_all: int = 0, index_rate: float = 0.5, filter_radius: int = 3, rms_mix_rate: float = 0.25, protect: float = 0.33, f0_method: F0Method = "rmvpe", crepe_hop_length: int = 128, reverb_rm_size: float = 0.15, reverb_wet: float = 0.2, reverb_dry: float = 0.8, reverb_damping: float = 0.7, main_gain: int = 0, inst_gain: int = 0, backup_gain: int = 0, output_sr: int = 44100, output_format: InputAudioExt = "mp3", output_name: str | None = None, return_files: bool = False, progress_bar: gr.Progress | None = None, ) -> str | tuple[str, ...]: """ Run the song cover generation pipeline. Parameters ---------- song_input : str A Youtube URL, the path of a local audio file or the path of a song directory. voice_model : str The name of the voice model to use for vocal conversion. pitch_change_vocals : int, default=0 The number of octaves to pitch-shift the converted vocals by. pitch_change_all : int, default=0 The number of semi-tones to pitch-shift the converted vocals, instrumentals, and backup vocals by. index_rate : float, default=0.5 The influence of the index file on the vocal conversion. filter_radius : int, default=3 The filter radius to use for the vocal conversion. rms_mix_rate : float, default=0.25 The blending rate of the volume envelope of the converted vocals. protect : float, default=0.33 The protection rate for consonants and breathing sounds in the vocal conversion. f0_method : F0Method, default="rmvpe" The method to use for pitch extraction in the vocal conversion. crepe_hop_length : int, default=128 The hop length to use for crepe-based pitch extraction. reverb_rm_size : float, default=0.15 The room size of the reverb effect to apply to the converted vocals. reverb_wet : float, default=0.2 The wet level of the reverb effect to apply to the converted vocals. reverb_dry : float, default=0.8 The dry level of the reverb effect to apply to the converted vocals. reverb_damping : float, default=0.7 The damping of the reverb effect to apply to the converted vocals. main_gain : int, default=0 The gain to apply to the post-processed vocals. inst_gain : int, default=0 The gain to apply to the pitch-shifted instrumentals. backup_gain : int, default=0 The gain to apply to the pitch-shifted backup vocals. output_sr : int, default=44100 The sample rate of the song cover. output_format : InputAudioExt, default="mp3" The audio format of the song cover. output_name : str, optional The name of the song cover. return_files : bool, default=False Whether to return the paths of the generated intermediate audio files. progress_bar : gr.Progress, optional Gradio progress bar to update. Returns ------- str | tuple[str,...] The path to the generated song cover and, if `return_files=True`, also the paths of any generated intermediate audio files. """ if not song_input: raise InputMissingError( "Song input missing! Please provide a valid YouTube url, local audio file" " path or cached song directory path." ) if not voice_model: raise InputMissingError("Voice model missing!") if not os.path.isdir(os.path.join(RVC_MODELS_DIR, voice_model)): raise PathNotFoundError("Voice model does not exist!") display_progress("[~] Starting song cover generation pipeline...", 0, progress_bar) orig_song_path, song_dir = retrieve_song( song_input, progress_bar, (0 / 15, 1 / 15, 2 / 15) ) vocals_path, instrumentals_path = separate_vocals( orig_song_path, song_dir, False, progress_bar, (3 / 15, 4 / 15) ) main_vocals_path, backup_vocals_path = separate_main_vocals( vocals_path, song_dir, False, progress_bar, (5 / 15, 6 / 15) ) vocals_dereverb_path, reverb_path = dereverb_vocals( main_vocals_path, song_dir, False, progress_bar, (7 / 15, 8 / 15) ) converted_vocals_path = convert_vocals( vocals_dereverb_path, song_dir, voice_model, pitch_change_vocals, pitch_change_all, index_rate, filter_radius, rms_mix_rate, protect, f0_method, crepe_hop_length, progress_bar, 9 / 15, ) vocals_mixed_path = postprocess_vocals( converted_vocals_path, song_dir, reverb_rm_size, reverb_wet, reverb_dry, reverb_damping, progress_bar, 10 / 15, ) instrumentals_shifted_path, backup_vocals_shifted_path = pitch_shift_background( instrumentals_path, backup_vocals_path, song_dir, pitch_change_all, progress_bar, (11 / 15, 12 / 15), ) song_cover_path = mix_song_cover( vocals_mixed_path, instrumentals_shifted_path or instrumentals_path, backup_vocals_shifted_path or backup_vocals_path, song_dir, main_gain, inst_gain, backup_gain, output_sr, output_format, output_name, progress_bar, (13 / 15, 14 / 15), ) if return_files: return ( orig_song_path, vocals_path, instrumentals_path, main_vocals_path, backup_vocals_path, vocals_dereverb_path, reverb_path, converted_vocals_path, vocals_mixed_path, instrumentals_shifted_path, backup_vocals_shifted_path, song_cover_path, ) else: return song_cover_path