|
|
import os |
|
|
import gradio as gr |
|
|
import soundfile as sf |
|
|
import librosa |
|
|
import numpy as np |
|
|
from pydub import AudioSegment |
|
|
from pedalboard import Pedalboard, Compressor, Reverb, Delay, NoiseGate, Chorus |
|
|
from pedalboard.io import AudioFile |
|
|
from separator.audio_writer import write_audio_file |
|
|
import tempfile |
|
|
from model_list import models_data as mvsepless_models |
|
|
from multi_inference import single_multi_inference |
|
|
|
|
|
RVC_MODELS_DIR = os.path.join(os.getcwd(), "voice_models") |
|
|
OUTPUT_FORMAT = ["mp3", "wav", "flac", "aiff", "m4a", "aac", "ogg", "opus"] |
|
|
|
|
|
|
|
|
saved_processing_data = None |
|
|
|
|
|
|
|
|
TRANSLATIONS = { |
|
|
"ru": { |
|
|
|
|
|
"model_name_label": "Имя модели", |
|
|
"update_button": "Обновить", |
|
|
"input_audio_label": "Входная песня", |
|
|
"generate_btn": "Сгенерировать кавер", |
|
|
"remix_btn": "Пересвести кавер", |
|
|
"final_result": "Финальный результат", |
|
|
"intermediate_files": "Промежуточные файлы", |
|
|
"status_label": "Статус", |
|
|
"tab_separation": "Разделение", |
|
|
"tab_voice_settings": "Настройки преобразования голоса", |
|
|
"tab_mixing_settings": "Настройки сведения аудио", |
|
|
|
|
|
|
|
|
"preclear_vocals": "Очистить вокал от реверба/эха", |
|
|
"split_vocals": "Разделить вокал на лид/бэк-вокалы", |
|
|
"vocal_model": "Вокальная модель", |
|
|
"dereverb_model": "Dereverb/Deecho модель", |
|
|
"karaoke_model": "Караоке модель", |
|
|
|
|
|
|
|
|
"conversion_mode": "Режим преобразования", |
|
|
"conversion_info": "lead - только основной вокал\nback - только бэк-вокал\nlead/back - основной и бэк-вокалы\nfull - весь вокал", |
|
|
"vocal_pitch": "Высота тона вокала", |
|
|
"backing_pitch": "Высота тона бэк-вокала", |
|
|
"pitch_method": "Метод извлечения тона", |
|
|
"max_pitch": "Верхний лимит определения высоты тона", |
|
|
"index_rate": "Влияние индекса", |
|
|
"filter_radius": "Радиус фильтра", |
|
|
"rms_envelope": "Огибающая громкости", |
|
|
"protect_cons": "Защита согласных", |
|
|
"hop_length": "Длина шага", |
|
|
|
|
|
|
|
|
"volume_adjust": "Изменение громкости", |
|
|
"vocals_gain": "Вокал", |
|
|
"backing_gain": "Бэк-вокал", |
|
|
"inst_gain": "Инструментал", |
|
|
"output_format": "Формат вывода", |
|
|
"add_unconv": "Добавить к инструменталу непреобразованный вокал", |
|
|
"add_effects": "Добавить эффекты на голос", |
|
|
|
|
|
|
|
|
"effects_tab": "Эффекты", |
|
|
"echo_tab": "Эхо", |
|
|
"echo_delay": "Время задержки (сек)", |
|
|
"echo_feedback": "Обратная связь", |
|
|
"echo_mix": "Смешение", |
|
|
"reverb_tab": "Реверберация", |
|
|
"reverb_size": "Размер комнаты", |
|
|
"reverb_width": "Ширина реверберации", |
|
|
"reverb_wet": "Уровень влажности", |
|
|
"reverb_dry": "Уровень сухости", |
|
|
"reverb_damping": "Уровень демпфирования", |
|
|
"chorus_tab": "Хорус", |
|
|
"chorus_rate": "Скорость хоруса", |
|
|
"chorus_depth": "Глубина хоруса", |
|
|
"chorus_delay": "Задержка центра (мс)", |
|
|
"chorus_feedback": "Обратная связь", |
|
|
"chorus_mix": "Смешение", |
|
|
|
|
|
|
|
|
"processing_tab": "Обработка", |
|
|
"compressor_tab": "Компрессор", |
|
|
"comp_ratio": "Соотношение", |
|
|
"comp_threshold": "Порог", |
|
|
"comp_attack": "Время атаки (мс)", |
|
|
"comp_release": "Время спада (мс)", |
|
|
"noise_gate_tab": "Подавление шума", |
|
|
"gate_threshold": "Порог", |
|
|
"gate_ratio": "Соотношение", |
|
|
"gate_attack": "Время атаки (мс)", |
|
|
"gate_release": "Время спада (мс)", |
|
|
|
|
|
|
|
|
"start_processing": "Начало обработки...", |
|
|
"separation": "Разделение на музыку и вокал...", |
|
|
"extracting": "Извлечение лид/бэк-вокала...", |
|
|
"cleaning": "Очистка вокалов...", |
|
|
"converting": "Преобразование вокалов...", |
|
|
"mixing": "Сведение итогового кавера...", |
|
|
|
|
|
|
|
|
"error_audio_model": "Сначала загрузите аудио и выберите модель", |
|
|
"error_audio": "Сначала загрузите аудио", |
|
|
"error_model": "Сначала выберите модель", |
|
|
"error_generate_first": "Сначала сгенерируйте кавер хотя бы один раз!", |
|
|
|
|
|
"vbach_required": "Vbach (RVC) не установлен. В блокноте запустите ячейку 'Установка' с флагом install_vbach [✓]" |
|
|
}, |
|
|
"en": { |
|
|
|
|
|
"model_name_label": "Model name", |
|
|
"update_button": "Update", |
|
|
"input_audio_label": "Input song", |
|
|
"generate_btn": "Generate cover", |
|
|
"remix_btn": "Remix cover", |
|
|
"final_result": "Final result", |
|
|
"intermediate_files": "Intermediate files", |
|
|
"status_label": "Status", |
|
|
"tab_separation": "Separation", |
|
|
"tab_voice_settings": "Voice conversion settings", |
|
|
"tab_mixing_settings": "Audio mixing settings", |
|
|
|
|
|
|
|
|
"preclear_vocals": "Clear vocals from reverb/echo", |
|
|
"split_vocals": "Split vocals into lead/backing", |
|
|
"vocal_model": "Vocal model", |
|
|
"dereverb_model": "Dereverb/Deecho model", |
|
|
"karaoke_model": "Karaoke model", |
|
|
|
|
|
|
|
|
"conversion_mode": "Conversion mode", |
|
|
"conversion_info": "lead - lead vocals only\nback - backing vocals only\nlead/back - both vocals\nfull - full vocals", |
|
|
"vocal_pitch": "Vocal pitch", |
|
|
"backing_pitch": "Backing vocals pitch", |
|
|
"pitch_method": "Pitch extraction method", |
|
|
"max_pitch": "Max pitch detection frequency", |
|
|
"index_rate": "Index rate", |
|
|
"filter_radius": "Filter radius", |
|
|
"rms_envelope": "RMS envelope", |
|
|
"protect_cons": "Protect consonants", |
|
|
"hop_length": "Hop length", |
|
|
|
|
|
|
|
|
"volume_adjust": "Volume adjustment", |
|
|
"vocals_gain": "Vocals", |
|
|
"backing_gain": "Backing vocals", |
|
|
"inst_gain": "Instrumental", |
|
|
"output_format": "Output format", |
|
|
"add_unconv": "Add unconverted vocals to instrumental", |
|
|
"add_effects": "Apply effects to vocals", |
|
|
|
|
|
|
|
|
"effects_tab": "Effects", |
|
|
"echo_tab": "Echo", |
|
|
"echo_delay": "Delay time (sec)", |
|
|
"echo_feedback": "Feedback", |
|
|
"echo_mix": "Mix", |
|
|
"reverb_tab": "Reverb", |
|
|
"reverb_size": "Room size", |
|
|
"reverb_width": "Reverb width", |
|
|
"reverb_wet": "Wet level", |
|
|
"reverb_dry": "Dry level", |
|
|
"reverb_damping": "Damping", |
|
|
"chorus_tab": "Chorus", |
|
|
"chorus_rate": "Rate (Hz)", |
|
|
"chorus_depth": "Depth", |
|
|
"chorus_delay": "Center delay (ms)", |
|
|
"chorus_feedback": "Feedback", |
|
|
"chorus_mix": "Mix", |
|
|
|
|
|
|
|
|
"processing_tab": "Processing", |
|
|
"compressor_tab": "Compressor", |
|
|
"comp_ratio": "Ratio", |
|
|
"comp_threshold": "Threshold (dB)", |
|
|
"comp_attack": "Attack time (ms)", |
|
|
"comp_release": "Release time (ms)", |
|
|
"noise_gate_tab": "Noise Gate", |
|
|
"gate_threshold": "Threshold (dB)", |
|
|
"gate_ratio": "Ratio", |
|
|
"gate_attack": "Attack time (ms)", |
|
|
"gate_release": "Release time (ms)", |
|
|
|
|
|
|
|
|
"start_processing": "Starting processing...", |
|
|
"separation": "Separating music and vocals...", |
|
|
"extracting": "Extracting lead/backing vocals...", |
|
|
"cleaning": "Cleaning vocals...", |
|
|
"converting": "Converting vocals...", |
|
|
"mixing": "Mixing final cover...", |
|
|
|
|
|
|
|
|
"error_audio_model": "Please upload audio and select model first", |
|
|
"error_audio": "Please upload audio first", |
|
|
"error_model": "Please select model first", |
|
|
"error_generate_first": "Generate a cover at least once first!", |
|
|
|
|
|
"vbach_required": "Vbach (RVC) is not installed. In the notebook, run the 'Установка' cell with the flag install_vbach [✓]" |
|
|
} |
|
|
} |
|
|
|
|
|
CURRENT_LANG = "ru" |
|
|
|
|
|
def set_language(lang): |
|
|
global CURRENT_LANG |
|
|
CURRENT_LANG = lang |
|
|
|
|
|
def t(key): |
|
|
"""Функция для получения перевода""" |
|
|
return TRANSLATIONS[CURRENT_LANG].get(key, key) |
|
|
|
|
|
def list_models(category, model_type=None): |
|
|
list_models = [] |
|
|
if not model_type: |
|
|
for m_type in list(mvsepless_models.keys()): |
|
|
for m_name in list(mvsepless_models[m_type].keys()): |
|
|
if mvsepless_models[m_type][m_name]["category"] in category: |
|
|
list_models.append(f"{m_type} / {m_name}") |
|
|
else: |
|
|
for m_type in model_type: |
|
|
for m_name in list(mvsepless_models[m_type].keys()): |
|
|
if mvsepless_models[m_type][m_name]["category"] in category: |
|
|
list_models.append(f"{m_type} / {m_name}") |
|
|
return list_models |
|
|
|
|
|
def find_file_from_stem(results, stem_names=["Vocals", "vocals"]): |
|
|
for stem_name, stem_file in results: |
|
|
if stem_name in stem_names: |
|
|
stem_path = stem_file |
|
|
return stem_path |
|
|
|
|
|
def mix_and_save( |
|
|
inst_path, |
|
|
list_vocals, |
|
|
converted_vocals_list, |
|
|
mix_params, |
|
|
params, |
|
|
rvc_params, |
|
|
temp_dir, |
|
|
input_audio |
|
|
): |
|
|
|
|
|
final_audio = None |
|
|
samplerate = 44100 |
|
|
|
|
|
|
|
|
if inst_path and os.path.exists(inst_path): |
|
|
inst_data, samplerate = librosa.load(inst_path, mono=False, sr=None, dtype='float32') |
|
|
if inst_data.ndim == 1: |
|
|
inst_data = np.expand_dims(inst_data, axis=0) |
|
|
inst_gain = 10 ** (mix_params["gain"]["instrum"] / 20.0) |
|
|
inst_data *= inst_gain |
|
|
final_audio = inst_data.copy() |
|
|
|
|
|
|
|
|
if mix_params["add_unconverted_vocals_to_instrumental"]: |
|
|
if params["conversion_mode"] == "lead" and list_vocals[1][1]: |
|
|
back_vocals, _ = librosa.load(list_vocals[1][1], mono=False, sr=samplerate, dtype='float32') |
|
|
if back_vocals.ndim == 1: |
|
|
back_vocals = np.expand_dims(back_vocals, axis=0) |
|
|
final_audio = back_vocals * (10 ** (mix_params["gain"]["vocals2"] / 20.0)) if final_audio is None else final_audio + back_vocals * (10 ** (mix_params["gain"]["vocals2"] / 20.0)) |
|
|
elif params["conversion_mode"] == "back" and list_vocals[2][1]: |
|
|
lead_vocals, _ = librosa.load(list_vocals[2][1], mono=False, sr=samplerate, dtype='float32') |
|
|
if lead_vocals.ndim == 1: |
|
|
lead_vocals = np.expand_dims(lead_vocals, axis=0) |
|
|
final_audio = lead_vocals * (10 ** (mix_params["gain"]["vocals1"] / 20.0)) if final_audio is None else final_audio + lead_vocals * (10 ** (mix_params["gain"]["vocals1"] / 20.0)) |
|
|
|
|
|
|
|
|
for i, vocal_path in enumerate(converted_vocals_list): |
|
|
if not vocal_path or not os.path.exists(vocal_path): |
|
|
continue |
|
|
|
|
|
vocal_data, sr = librosa.load(vocal_path, mono=False, sr=None, dtype='float32') |
|
|
if vocal_data.ndim == 1: |
|
|
vocal_data = np.expand_dims(vocal_data, axis=0) |
|
|
|
|
|
|
|
|
if sr != samplerate: |
|
|
audio_segment = AudioSegment.from_wav(vocal_path) |
|
|
audio_segment = audio_segment.set_frame_rate(samplerate) |
|
|
samples = np.array(audio_segment.get_array_of_samples()) |
|
|
channels = audio_segment.channels |
|
|
|
|
|
samples = samples.astype(np.float32) |
|
|
max_value = 2 ** (8 * audio_segment.sample_width - 1) |
|
|
samples /= max_value |
|
|
|
|
|
vocal_data = samples.reshape((-1, channels)).T |
|
|
|
|
|
|
|
|
if mix_params.get("use_effects", False): |
|
|
board = Pedalboard() |
|
|
effects = mix_params.get("pedalboard_settings", {}) |
|
|
|
|
|
if "compressor" in effects: |
|
|
comp = effects["compressor"] |
|
|
board.append(Compressor( |
|
|
ratio=comp["ratio"], |
|
|
threshold_db=comp["threshold"], |
|
|
attack_ms=comp["attack"], |
|
|
release_ms=comp["release"] |
|
|
)) |
|
|
|
|
|
if "noise_gate" in effects: |
|
|
ng = effects["noise_gate"] |
|
|
board.append(NoiseGate( |
|
|
threshold_db=ng["threshold"], |
|
|
ratio=ng["ratio"], |
|
|
attack_ms=ng["attack"], |
|
|
release_ms=ng["release"] |
|
|
)) |
|
|
|
|
|
if "echo" in effects: |
|
|
echo = effects["echo"] |
|
|
board.append(Delay( |
|
|
delay_seconds=echo["delay"], |
|
|
feedback=echo["feedback"], |
|
|
mix=echo["mix"] |
|
|
)) |
|
|
|
|
|
if "reverb" in effects: |
|
|
rev = effects["reverb"] |
|
|
board.append(Reverb( |
|
|
room_size=rev["room_size"], |
|
|
dry_level=rev["dry"], |
|
|
wet_level=rev["wet"], |
|
|
damping=rev["damping"], |
|
|
width=rev["width"] |
|
|
)) |
|
|
|
|
|
if "chorus" in effects: |
|
|
chorus = effects["chorus"] |
|
|
board.append(Chorus( |
|
|
rate_hz=chorus["rate"], |
|
|
depth=chorus["depth"], |
|
|
centre_delay_ms=chorus["center_delay"], |
|
|
feedback=chorus["feedback"], |
|
|
mix=chorus["mix"] |
|
|
)) |
|
|
|
|
|
vocal_data = board(vocal_data, samplerate) |
|
|
|
|
|
|
|
|
gain_db = mix_params["gain"]["vocals1"] if i == 0 else mix_params["gain"]["vocals2"] |
|
|
vocal_data *= 10 ** (gain_db / 20.0) |
|
|
|
|
|
|
|
|
if final_audio is None: |
|
|
final_audio = vocal_data.copy() |
|
|
else: |
|
|
|
|
|
min_len = min(final_audio.shape[1], vocal_data.shape[1]) |
|
|
final_audio = final_audio[:, :min_len] + vocal_data[:, :min_len] |
|
|
|
|
|
|
|
|
max_amplitude = np.max(np.abs(final_audio)) |
|
|
if max_amplitude > 0: |
|
|
normalization_factor = 1.0 / max_amplitude |
|
|
final_audio = final_audio * normalization_factor |
|
|
filename = f"{rvc_params['model_name']} - {os.path.splitext(os.path.basename(input_audio))[0]}.{params['output_format']}" if input_audio else f"remixed.{params['output_format']}" |
|
|
final_path = os.path.join(temp_dir, filename) |
|
|
write_audio_file(final_path, final_audio, samplerate, params['output_format'], "320k") |
|
|
|
|
|
return final_path |
|
|
|
|
|
def gen_cover( |
|
|
input_audio, |
|
|
anti_instrum_model, |
|
|
karaoke_model, |
|
|
dereverb_model, |
|
|
output_format, |
|
|
karaoke_check, |
|
|
conversion_mode, |
|
|
preclear_vocals_check, |
|
|
voice_name, |
|
|
pitch1_val, |
|
|
pitch2_val, |
|
|
method_pitch, |
|
|
index_rate, |
|
|
fr, |
|
|
rms, |
|
|
protect, |
|
|
hop_mangio_crepe, |
|
|
f0_max, |
|
|
unconv_vocals_check, |
|
|
use_effects, |
|
|
instrumental_gain, |
|
|
vocal1_gain, |
|
|
vocal2_gain, |
|
|
echo_delay, |
|
|
echo_feedback, |
|
|
echo_mix, |
|
|
reverb_rm_size, |
|
|
reverb_width, |
|
|
reverb_wet, |
|
|
reverb_dry, |
|
|
reverb_damping, |
|
|
chorus_rate_hz, |
|
|
chorus_depth, |
|
|
chorus_centre_delay_ms, |
|
|
chorus_feedback, |
|
|
chorus_mix, |
|
|
compressor_ratio, |
|
|
compressor_threshold, |
|
|
compressor_attack, |
|
|
compressor_release, |
|
|
noise_gate_threshold, |
|
|
noise_gate_ratio, |
|
|
noise_gate_attack, |
|
|
noise_gate_release |
|
|
): |
|
|
|
|
|
global saved_processing_data |
|
|
|
|
|
if not input_audio and not voice_name: |
|
|
raise gr.Error(t("error_audio_model")) |
|
|
|
|
|
if not input_audio: |
|
|
raise gr.Error(t("error_audio")) |
|
|
|
|
|
if not voice_name: |
|
|
raise gr.Error(t("error_model")) |
|
|
|
|
|
|
|
|
models = [ |
|
|
anti_instrum_model, |
|
|
karaoke_model, |
|
|
dereverb_model |
|
|
] |
|
|
|
|
|
params = { |
|
|
"output_format": output_format, |
|
|
"extract_karaoke": karaoke_check, |
|
|
"conversion_mode": conversion_mode, |
|
|
"preclear_vocals": preclear_vocals_check |
|
|
} |
|
|
|
|
|
rvc_params = { |
|
|
"model_name": voice_name, |
|
|
"pitch1": pitch1_val, |
|
|
"pitch2": pitch2_val, |
|
|
"f0_method": method_pitch, |
|
|
'index_rate': index_rate, |
|
|
'filter_radius': fr, |
|
|
'rms': rms, |
|
|
'protect': protect, |
|
|
'hop_length': hop_mangio_crepe, |
|
|
'f0_max': f0_max |
|
|
} |
|
|
|
|
|
mix_params = { |
|
|
"add_unconverted_vocals_to_instrumental": unconv_vocals_check, |
|
|
"use_effects": use_effects, |
|
|
"gain": { |
|
|
"instrum": instrumental_gain, |
|
|
"vocals1": vocal1_gain, |
|
|
"vocals2": vocal2_gain |
|
|
}, |
|
|
"pedalboard_settings": { |
|
|
"echo": { |
|
|
"delay": echo_delay, |
|
|
"feedback": echo_feedback, |
|
|
"mix": echo_mix |
|
|
}, |
|
|
"reverb": { |
|
|
"room_size": reverb_rm_size, |
|
|
"wet": reverb_wet, |
|
|
"dry": reverb_dry, |
|
|
"damping": reverb_damping, |
|
|
"width": reverb_width, |
|
|
}, |
|
|
"compressor": { |
|
|
"ratio": compressor_ratio, |
|
|
"threshold": compressor_threshold, |
|
|
"attack": compressor_attack, |
|
|
"release": compressor_release |
|
|
}, |
|
|
"noise_gate": { |
|
|
"threshold": noise_gate_threshold, |
|
|
"ratio": noise_gate_ratio, |
|
|
"attack": noise_gate_attack, |
|
|
"release": noise_gate_release, |
|
|
}, |
|
|
"chorus": { |
|
|
"rate": chorus_rate_hz, |
|
|
"depth": chorus_depth, |
|
|
"center_delay": chorus_centre_delay_ms, |
|
|
"feedback": chorus_feedback, |
|
|
"mix": chorus_mix |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
progress = gr.Progress() |
|
|
|
|
|
progress(0, desc=t("start_processing")) |
|
|
|
|
|
generated_files = [] |
|
|
converted_vocals_list = [] |
|
|
temp_dir = tempfile.mkdtemp() |
|
|
inst_model = models[0] |
|
|
kar_model = models[1] |
|
|
dereverb_model = models[2] |
|
|
|
|
|
progress(0.1, desc=t("separation")) |
|
|
|
|
|
|
|
|
inst_output = single_multi_inference(input_audio, os.path.join(temp_dir, "inst_output"), |
|
|
inst_model.split(" / ")[0], inst_model.split(" / ")[1], |
|
|
True, vr_aggr=5, output_format="wav", |
|
|
output_bitrate="320k", template="VbachGen_NAME_STEM", |
|
|
call_method="cli", selected_stems=[]) |
|
|
inst_file = ("instrumental", find_file_from_stem(inst_output, ["Instrumental", "instrumental", "other", "Other"])) |
|
|
full_vocals_file = ("full_vocals", find_file_from_stem(inst_output, ["Vocals", "vocals"])) |
|
|
|
|
|
progress(0.2, desc=t("extracting")) |
|
|
|
|
|
back_vocals_file = (None, None) |
|
|
lead_vocals_file = (None, None) |
|
|
|
|
|
if params["extract_karaoke"] == True: |
|
|
karaoke_output = single_multi_inference(full_vocals_file[1], os.path.join(temp_dir, "kar_output"), |
|
|
kar_model.split(" / ")[0], kar_model.split(" / ")[1], |
|
|
True, vr_aggr=5, output_format="wav", |
|
|
output_bitrate="320k", template="NAME_MODEL_STEM", |
|
|
call_method="cli", selected_stems=[]) |
|
|
back_vocals_file = ("back_vocals", find_file_from_stem(karaoke_output, ["Instrumental", "instrumental", "other", "Other"])) |
|
|
lead_vocals_file = ("lead_vocals", find_file_from_stem(karaoke_output, ["Vocals", "vocals", "karaoke"])) |
|
|
|
|
|
list_vocals = [ |
|
|
full_vocals_file, |
|
|
back_vocals_file if params["extract_karaoke"] else (None, None), |
|
|
lead_vocals_file if params["extract_karaoke"] else (None, None) |
|
|
] |
|
|
|
|
|
clear_list_vocals = [ |
|
|
full_vocals_file, |
|
|
back_vocals_file if params["extract_karaoke"] and params["conversion_mode"] in ["back", "lead/back"] else (None, None), |
|
|
lead_vocals_file if params["extract_karaoke"] and params["conversion_mode"] in ["lead", "lead/back"] else (None, None) |
|
|
] |
|
|
|
|
|
progress(0.3, desc=t("cleaning")) |
|
|
|
|
|
|
|
|
cleared_vocals = [] |
|
|
if params["preclear_vocals"] == True: |
|
|
for i, (name, file) in enumerate(clear_list_vocals): |
|
|
if file and os.path.exists(file): |
|
|
clear_output = single_multi_inference(file, os.path.join(temp_dir, f"cleared_output_{i}"), |
|
|
dereverb_model.split(" / ")[0], dereverb_model.split(" / ")[1], |
|
|
True, vr_aggr=5, output_format="wav", |
|
|
output_bitrate="320k", template="NAME_STEM", |
|
|
call_method="cli", selected_stems=[]) |
|
|
cleared_file = find_file_from_stem(clear_output, ["No Echo", "No Reverb", "Dry", "Other"]) |
|
|
cleared_vocals.append((name, cleared_file)) |
|
|
for i, voc in enumerate(list_vocals): |
|
|
for clear_voc in cleared_vocals: |
|
|
if clear_voc[0] == voc[0]: |
|
|
list_vocals[i] = clear_voc |
|
|
break |
|
|
|
|
|
progress(0.5, desc=t("converting")) |
|
|
|
|
|
|
|
|
if params["conversion_mode"] == "full" and list_vocals[0][1]: |
|
|
full_vocals_converted_path = os.path.join(os.path.join(temp_dir, 'converted'), "full_vocals_converted.wav") |
|
|
cmd = f"python -m vbach.cli.vbach '{list_vocals[0][1]}' '{os.path.join(temp_dir, 'converted')}' '{rvc_params['model_name']}' --template 'full_vocals_converted' --pitch {rvc_params['pitch1']} --method_pitch {rvc_params['f0_method']} --index_rate {rvc_params['index_rate']} --filter_radius {rvc_params['filter_radius']} --rms {rvc_params['rms']} --protect {rvc_params['protect']} --hop_length {rvc_params['hop_length']} --f0_min 50 --f0_max {rvc_params['f0_max']} --output_format wav --stereo_mode 'mono'" |
|
|
os.system(cmd) |
|
|
converted_vocals_list.append(full_vocals_converted_path) |
|
|
|
|
|
elif params["conversion_mode"] == "lead/back" and list_vocals[1][1] and list_vocals[2][1]: |
|
|
lead_vocals_converted_path = os.path.join(os.path.join(temp_dir, 'converted'), "lead_vocals_converted.wav") |
|
|
cmd = f"python -m vbach.cli.vbach '{list_vocals[2][1]}' '{os.path.join(temp_dir, 'converted')}' '{rvc_params['model_name']}' --template 'lead_vocals_converted' --pitch {rvc_params['pitch1']} --method_pitch {rvc_params['f0_method']} --index_rate {rvc_params['index_rate']} --filter_radius {rvc_params['filter_radius']} --rms {rvc_params['rms']} --protect {rvc_params['protect']} --hop_length {rvc_params['hop_length']} --f0_min 50 --f0_max {rvc_params['f0_max']} --output_format wav --stereo_mode 'mono'" |
|
|
os.system(cmd) |
|
|
|
|
|
back_vocals_converted_path = os.path.join(os.path.join(temp_dir, 'converted'), "back_vocals_converted.wav") |
|
|
cmd = f"python -m vbach.cli.vbach '{list_vocals[1][1]}' '{os.path.join(temp_dir, 'converted')}' '{rvc_params['model_name']}' --template 'back_vocals_converted' --pitch {rvc_params['pitch2']} --method_pitch {rvc_params['f0_method']} --index_rate {rvc_params['index_rate']} --filter_radius {rvc_params['filter_radius']} --rms {rvc_params['rms']} --protect {rvc_params['protect']} --hop_length {rvc_params['hop_length']} --f0_min 50 --f0_max {rvc_params['f0_max']} --output_format wav --stereo_mode 'mono'" |
|
|
os.system(cmd) |
|
|
|
|
|
converted_vocals_list.append(back_vocals_converted_path) |
|
|
converted_vocals_list.append(lead_vocals_converted_path) |
|
|
|
|
|
elif params["conversion_mode"] == "back" and list_vocals[1][1]: |
|
|
back_vocals_converted_path = os.path.join(os.path.join(temp_dir, 'converted'), "back_vocals_converted.wav") |
|
|
cmd = f"python -m vbach.cli.vbach '{list_vocals[1][1]}' '{os.path.join(temp_dir, 'converted')}' '{rvc_params['model_name']}' --template 'back_vocals_converted' --pitch {rvc_params['pitch2']} --method_pitch {rvc_params['f0_method']} --index_rate {rvc_params['index_rate']} --filter_radius {rvc_params['filter_radius']} --rms {rvc_params['protect']} --protect {rvc_params['rms']} --hop_length {rvc_params['hop_length']} --f0_min 50 --f0_max {rvc_params['f0_max']} --output_format wav --stereo_mode 'mono'" |
|
|
os.system(cmd) |
|
|
converted_vocals_list.append(back_vocals_converted_path) |
|
|
|
|
|
elif params["conversion_mode"] == "lead" and list_vocals[2][1]: |
|
|
lead_vocals_converted_path = os.path.join(os.path.join(temp_dir, 'converted'), "lead_vocals_converted.wav") |
|
|
cmd = f"python -m vbach.cli.vbach '{list_vocals[2][1]}' '{os.path.join(temp_dir, 'converted')}' '{rvc_params['model_name']}' --template 'lead_vocals_converted' --pitch {rvc_params['pitch1']} --method_pitch {rvc_params['f0_method']} --index_rate {rvc_params['index_rate']} --filter_radius {rvc_params['filter_radius']} --rms {rvc_params['rms']} --protect {rvc_params['protect']} --hop_length {rvc_params['hop_length']} --f0_min 50 --f0_max {rvc_params['f0_max']} --output_format wav --stereo_mode 'mono'" |
|
|
os.system(cmd) |
|
|
converted_vocals_list.append(lead_vocals_converted_path) |
|
|
|
|
|
|
|
|
generated_files.append(inst_file[1]) |
|
|
for name, file in list_vocals: |
|
|
if file: |
|
|
generated_files.append(file) |
|
|
generated_files.extend(converted_vocals_list) |
|
|
|
|
|
|
|
|
saved_processing_data = { |
|
|
"inst_path": inst_file[1], |
|
|
"list_vocals": list_vocals, |
|
|
"converted_vocals_list": converted_vocals_list, |
|
|
"params": params, |
|
|
"rvc_params": rvc_params, |
|
|
"input_audio": input_audio |
|
|
} |
|
|
|
|
|
progress(0.9, desc=t("mixing")) |
|
|
|
|
|
|
|
|
final_path = mix_and_save( |
|
|
inst_file[1], |
|
|
list_vocals, |
|
|
converted_vocals_list, |
|
|
mix_params, |
|
|
params, |
|
|
rvc_params, |
|
|
temp_dir, |
|
|
input_audio |
|
|
) |
|
|
|
|
|
generated_files.append(final_path) |
|
|
|
|
|
return generated_files, final_path |
|
|
|
|
|
def remix_cover( |
|
|
use_effects, |
|
|
instrumental_gain, |
|
|
vocal1_gain, |
|
|
vocal2_gain, |
|
|
echo_delay, |
|
|
echo_feedback, |
|
|
echo_mix, |
|
|
reverb_rm_size, |
|
|
reverb_width, |
|
|
reverb_wet, |
|
|
reverb_dry, |
|
|
reverb_damping, |
|
|
chorus_rate_hz, |
|
|
chorus_depth, |
|
|
chorus_centre_delay_ms, |
|
|
chorus_feedback, |
|
|
chorus_mix, |
|
|
compressor_ratio, |
|
|
compressor_threshold, |
|
|
compressor_attack, |
|
|
compressor_release, |
|
|
noise_gate_threshold, |
|
|
noise_gate_ratio, |
|
|
noise_gate_attack, |
|
|
noise_gate_release |
|
|
): |
|
|
global saved_processing_data |
|
|
if not saved_processing_data: |
|
|
raise gr.Error(t("error_generate_first")) |
|
|
|
|
|
|
|
|
data = saved_processing_data |
|
|
temp_dir = tempfile.mkdtemp() |
|
|
|
|
|
|
|
|
mix_params = { |
|
|
"add_unconverted_vocals_to_instrumental": True, |
|
|
"use_effects": use_effects, |
|
|
"gain": { |
|
|
"instrum": instrumental_gain, |
|
|
"vocals1": vocal1_gain, |
|
|
"vocals2": vocal2_gain |
|
|
}, |
|
|
"pedalboard_settings": { |
|
|
"echo": { |
|
|
"delay": echo_delay, |
|
|
"feedback": echo_feedback, |
|
|
"mix": echo_mix |
|
|
}, |
|
|
"reverb": { |
|
|
"room_size": reverb_rm_size, |
|
|
"wet": reverb_wet, |
|
|
"dry": reverb_dry, |
|
|
"damping": reverb_damping, |
|
|
"width": reverb_width, |
|
|
}, |
|
|
"compressor": { |
|
|
"ratio": compressor_ratio, |
|
|
"threshold": compressor_threshold, |
|
|
"attack": compressor_attack, |
|
|
"release": compressor_release |
|
|
}, |
|
|
"noise_gate": { |
|
|
"threshold": noise_gate_threshold, |
|
|
"ratio": noise_gate_ratio, |
|
|
"attack": noise_gate_attack, |
|
|
"release": noise_gate_release, |
|
|
}, |
|
|
"chorus": { |
|
|
"rate": chorus_rate_hz, |
|
|
"depth": chorus_depth, |
|
|
"center_delay": chorus_centre_delay_ms, |
|
|
"feedback": chorus_feedback, |
|
|
"mix": chorus_mix |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
final_path = mix_and_save( |
|
|
data["inst_path"], |
|
|
data["list_vocals"], |
|
|
data["converted_vocals_list"], |
|
|
mix_params, |
|
|
data["params"], |
|
|
data["rvc_params"], |
|
|
temp_dir, |
|
|
data["input_audio"] |
|
|
) |
|
|
|
|
|
return final_path |
|
|
|
|
|
def vbach_plugin_name(): |
|
|
return "VbachGen" |
|
|
|
|
|
def vbachgen_plugin(lang): |
|
|
set_language(lang) |
|
|
with gr.Blocks(): |
|
|
if os.path.exists("vbach"): |
|
|
with gr.Row(equal_height=False, variant="panel"): |
|
|
with gr.Column(): |
|
|
model_name = gr.Dropdown(label=t("model_name_label"), interactive=True, filterable=False, scale=6) |
|
|
model_update_btn = gr.Button(t("update_button"), variant="primary", scale=3, size="lg") |
|
|
with gr.Row(min_height=150): |
|
|
input_audio = gr.File(label=t("input_audio_label"), interactive=True, type="filepath", file_count="single") |
|
|
|
|
|
with gr.Row(): |
|
|
with gr.Column(): |
|
|
|
|
|
with gr.Tab(t("tab_separation")): |
|
|
preclear_vocals_check = gr.Checkbox(label=t("preclear_vocals"), value=False) |
|
|
karaoke_check = gr.Checkbox(label=t("split_vocals"), value=False) |
|
|
|
|
|
with gr.Column(variant="panel"): |
|
|
with gr.Group() as extract_vocals_group: |
|
|
anti_instrum_model = gr.Dropdown( |
|
|
label=t("vocal_model"), |
|
|
choices=list_models(["Инструментал", "Вокал", "Инструментал и вокал"], ["mel_band_roformer", "bs_roformer", "mdx23c", "mdx", "htdemucs"]), |
|
|
interactive=True, |
|
|
filterable=False |
|
|
) |
|
|
|
|
|
with gr.Group(visible=False) as deecho_group: |
|
|
dereverb_model = gr.Dropdown( |
|
|
label=t("dereverb_model"), |
|
|
choices=list_models(["Реверб и эхо", "Реверб", "Эхо"], ["vr"]), |
|
|
interactive=True, |
|
|
filterable=False |
|
|
) |
|
|
|
|
|
with gr.Group(visible=False) as karaoke_group: |
|
|
karaoke_model = gr.Dropdown( |
|
|
label=t("karaoke_model"), |
|
|
choices=list_models(["Караоке"]), |
|
|
interactive=True, |
|
|
filterable=False |
|
|
) |
|
|
|
|
|
|
|
|
with gr.Tab(t("tab_voice_settings")): |
|
|
conversion_mode = gr.Dropdown( |
|
|
label=t("conversion_mode"), |
|
|
choices=["lead", "back", "lead/back", "full"], |
|
|
value="full", |
|
|
filterable=False, |
|
|
visible=False, |
|
|
info=t("conversion_info") |
|
|
) |
|
|
with gr.Row(): |
|
|
pitch1 = gr.Slider(-48, 48, value=0, step=12, label=t("vocal_pitch"), interactive=True) |
|
|
pitch2 = gr.Slider(-48, 48, value=0, step=12, label=t("backing_pitch"), visible=False, interactive=True) |
|
|
with gr.Row(): |
|
|
method_pitch = gr.Dropdown( |
|
|
label=t("pitch_method"), |
|
|
choices=["mangio-crepe", "rmvpe+", "fcpe"], |
|
|
value="rmvpe+", |
|
|
interactive=True, |
|
|
filterable=False |
|
|
) |
|
|
f0_max = gr.Slider(50, 2000, value=1100, step=50, label=t("max_pitch"), interactive=True) |
|
|
with gr.Row(): |
|
|
with gr.Column(scale=1): |
|
|
index_rate = gr.Slider(0, 1, value=0, step=0.1, label=t("index_rate"), interactive=True) |
|
|
fr = gr.Slider(0, 7, value=3, step=1, label=t("filter_radius"), interactive=True) |
|
|
with gr.Column(scale=1): |
|
|
rms = gr.Slider(0, 1, value=0.25, step=0.05, label=t("rms_envelope"), interactive=True) |
|
|
protect = gr.Slider(minimum=0, maximum=0.5, step=0.01, value=0.33, label=t("protect_cons"), interactive=True) |
|
|
hop_mangio_crepe = gr.Slider(1, 512, value=128, step=1, label=t("hop_length"), interactive=True, visible=False) |
|
|
|
|
|
|
|
|
with gr.Tab(t("tab_mixing_settings")): |
|
|
gr.Markdown(f"<center><h2>{t('volume_adjust')}</h2></center>") |
|
|
with gr.Row(variant="panel"): |
|
|
vocal1_gain = gr.Slider(-30, 30, value=0, step=1, label=t("vocals_gain"), scale=3, interactive=True) |
|
|
vocal2_gain = gr.Slider(-30, 30, value=0, step=1, label=t("backing_gain"), scale=3, visible=False, interactive=True) |
|
|
instrumental_gain = gr.Slider(-30, 30, value=0, step=1, label=t("inst_gain"), scale=3, interactive=True) |
|
|
|
|
|
output_format = gr.Dropdown( |
|
|
label=t("output_format"), |
|
|
choices=OUTPUT_FORMAT, |
|
|
value="wav", |
|
|
interactive=True, |
|
|
filterable=False |
|
|
) |
|
|
unconv_vocals_check = gr.Checkbox(label=t("add_unconv"), visible=False) |
|
|
use_effects = gr.Checkbox(label=t("add_effects"), value=False) |
|
|
with gr.Column(variant="panel", visible=False) as effects_accordion: |
|
|
with gr.Tab(t("effects_tab")): |
|
|
with gr.Tab(t("echo_tab")): |
|
|
with gr.Group(): |
|
|
with gr.Column(variant="panel"): |
|
|
with gr.Row(): |
|
|
echo_delay = gr.Slider(0, 3, value=0, label=t("echo_delay"), interactive=True) |
|
|
echo_feedback = gr.Slider(0, 1, value=0, label=t("echo_feedback"), interactive=True) |
|
|
echo_mix = gr.Slider(0, 1, value=0, label=t("echo_mix"), interactive=True) |
|
|
|
|
|
with gr.Tab(t("reverb_tab")): |
|
|
with gr.Group(): |
|
|
with gr.Column(variant="panel"): |
|
|
with gr.Row(): |
|
|
reverb_rm_size = gr.Slider(0, 1, value=0.1, label=t("reverb_size"), interactive=True) |
|
|
reverb_width = gr.Slider(0, 1, value=1.0, label=t("reverb_width"), interactive=True) |
|
|
with gr.Row(): |
|
|
reverb_wet = gr.Slider(0, 1, value=0.1, label=t("reverb_wet"), interactive=True) |
|
|
reverb_dry = gr.Slider(0, 1, value=0.8, label=t("reverb_dry"), interactive=True) |
|
|
with gr.Row(): |
|
|
reverb_damping = gr.Slider(0, 1, value=0.9, label=t("reverb_damping"), interactive=True) |
|
|
|
|
|
with gr.Tab(t("chorus_tab")): |
|
|
with gr.Group(): |
|
|
with gr.Column(variant="panel"): |
|
|
with gr.Row(): |
|
|
chorus_rate_hz = gr.Slider(0.1, 10, value=0, label=t("chorus_rate"), interactive=True) |
|
|
chorus_depth = gr.Slider(0, 1, value=0, label=t("chorus_depth"), interactive=True) |
|
|
with gr.Row(): |
|
|
chorus_centre_delay_ms = gr.Slider(0, 50, value=0, label=t("chorus_delay"), interactive=True) |
|
|
chorus_feedback = gr.Slider(0, 1, value=0, label=t("chorus_feedback"), interactive=True) |
|
|
with gr.Row(): |
|
|
chorus_mix = gr.Slider(0, 1, value=0, label=t("chorus_mix"), interactive=True) |
|
|
|
|
|
with gr.Tab(t("processing_tab")): |
|
|
with gr.Tab(t("compressor_tab")): |
|
|
with gr.Row(variant="panel"): |
|
|
compressor_ratio = gr.Slider(1, 20, value=4, label=t("comp_ratio"), interactive=True) |
|
|
compressor_threshold = gr.Slider(-60, 0, value=-12, label=t("comp_threshold"), interactive=True) |
|
|
compressor_attack = gr.Slider(0, 2000, value=100, label=t("comp_attack"), interactive=True) |
|
|
compressor_release = gr.Slider(0, 2000, value=100, label=t("comp_release"), interactive=True) |
|
|
|
|
|
with gr.Tab(t("noise_gate_tab")): |
|
|
with gr.Group(): |
|
|
with gr.Column(variant="panel"): |
|
|
with gr.Row(): |
|
|
noise_gate_threshold = gr.Slider(-60, 0, value=-40, label=t("gate_threshold"), interactive=True) |
|
|
noise_gate_ratio = gr.Slider(1, 20, value=8, label=t("gate_ratio"), interactive=True) |
|
|
with gr.Row(): |
|
|
noise_gate_attack = gr.Slider(0, 100, value=10, label=t("gate_attack"), interactive=True) |
|
|
noise_gate_release = gr.Slider(0, 1000, value=100, label=t("gate_release"), interactive=True) |
|
|
|
|
|
|
|
|
with gr.Column(variant="panel"): |
|
|
final_ai_cover = gr.Audio(label=t("final_result"), interactive=False, streaming=True) |
|
|
generated_files_list = gr.Files(label=t("intermediate_files")) |
|
|
with gr.Row(): |
|
|
generate_btn = gr.Button(t("generate_btn"), variant="primary") |
|
|
remix_btn = gr.Button(t("remix_btn"), variant="secondary") |
|
|
status_text = gr.Textbox(label=t("status_label"), interactive=False) |
|
|
|
|
|
|
|
|
method_pitch.change(fn=lambda x: gr.update(visible=True if x == "mangio-crepe" else False), inputs=method_pitch, outputs=hop_mangio_crepe) |
|
|
|
|
|
model_update_btn.click(fn=(lambda : gr.update(choices=[d for d in os.listdir(RVC_MODELS_DIR) if os.path.isdir(os.path.join(RVC_MODELS_DIR, d))])), inputs=None, outputs=model_name) |
|
|
|
|
|
|
|
|
use_effects.change( |
|
|
fn=lambda x: gr.update(visible=x), |
|
|
inputs=use_effects, |
|
|
outputs=effects_accordion |
|
|
) |
|
|
|
|
|
karaoke_check.change( |
|
|
fn=lambda x: gr.update(visible=x), |
|
|
inputs=karaoke_check, |
|
|
outputs=karaoke_group |
|
|
).then(fn=lambda x: gr.update(value="full", visible=x), inputs=karaoke_check, outputs=conversion_mode).then(fn=lambda x: gr.update(visible=True if x in ["back", "lead"] else False, value=False), inputs=conversion_mode, outputs=unconv_vocals_check) |
|
|
|
|
|
preclear_vocals_check.change( |
|
|
fn=lambda x: gr.update(visible=x), |
|
|
inputs=preclear_vocals_check, |
|
|
outputs=deecho_group |
|
|
) |
|
|
|
|
|
conversion_mode.change( |
|
|
fn=lambda mode: ( |
|
|
gr.update(visible=mode in ["lead", "lead/back"]), |
|
|
gr.update(visible=mode in ["back", "lead/back"]), |
|
|
gr.update(visible=mode in ["lead/back"]) |
|
|
), |
|
|
inputs=conversion_mode, |
|
|
outputs=[vocal1_gain, vocal2_gain, pitch2] |
|
|
).then(fn=lambda x: gr.update(visible=True if x in ["back", "lead"] else False, value=False), inputs=conversion_mode, outputs=unconv_vocals_check) |
|
|
|
|
|
generate_btn.click( |
|
|
fn=gen_cover, |
|
|
inputs=[ |
|
|
input_audio, |
|
|
anti_instrum_model, |
|
|
karaoke_model, |
|
|
dereverb_model, |
|
|
output_format, |
|
|
karaoke_check, |
|
|
conversion_mode, |
|
|
preclear_vocals_check, |
|
|
model_name, |
|
|
pitch1, |
|
|
pitch2, |
|
|
method_pitch, |
|
|
index_rate, |
|
|
fr, |
|
|
rms, |
|
|
protect, |
|
|
hop_mangio_crepe, |
|
|
f0_max, |
|
|
unconv_vocals_check, |
|
|
use_effects, |
|
|
instrumental_gain, |
|
|
vocal1_gain, |
|
|
vocal2_gain, |
|
|
echo_delay, |
|
|
echo_feedback, |
|
|
echo_mix, |
|
|
reverb_rm_size, |
|
|
reverb_width, |
|
|
reverb_wet, |
|
|
reverb_dry, |
|
|
reverb_damping, |
|
|
chorus_rate_hz, |
|
|
chorus_depth, |
|
|
chorus_centre_delay_ms, |
|
|
chorus_feedback, |
|
|
chorus_mix, |
|
|
compressor_ratio, |
|
|
compressor_threshold, |
|
|
compressor_attack, |
|
|
compressor_release, |
|
|
noise_gate_threshold, |
|
|
noise_gate_ratio, |
|
|
noise_gate_attack, |
|
|
noise_gate_release |
|
|
], |
|
|
outputs=[generated_files_list, final_ai_cover] |
|
|
) |
|
|
|
|
|
remix_btn.click( |
|
|
fn=remix_cover, |
|
|
inputs=[ |
|
|
use_effects, |
|
|
instrumental_gain, |
|
|
vocal1_gain, |
|
|
vocal2_gain, |
|
|
echo_delay, |
|
|
echo_feedback, |
|
|
echo_mix, |
|
|
reverb_rm_size, |
|
|
reverb_width, |
|
|
reverb_wet, |
|
|
reverb_dry, |
|
|
reverb_damping, |
|
|
chorus_rate_hz, |
|
|
chorus_depth, |
|
|
chorus_centre_delay_ms, |
|
|
chorus_feedback, |
|
|
chorus_mix, |
|
|
compressor_ratio, |
|
|
compressor_threshold, |
|
|
compressor_attack, |
|
|
compressor_release, |
|
|
noise_gate_threshold, |
|
|
noise_gate_ratio, |
|
|
noise_gate_attack, |
|
|
noise_gate_release |
|
|
], |
|
|
outputs=[final_ai_cover] |
|
|
) |
|
|
else: |
|
|
gr.Markdown(f"<center><h2>{t('vbach_required')}</h2></center>") |
