diff --git a/main/app/app.py b/main/app/app.py
deleted file mode 100644
index ad0ac945204e8dfe497599c3436fcd9ea8eaabec..0000000000000000000000000000000000000000
--- a/main/app/app.py
+++ /dev/null
@@ -1,190 +0,0 @@
-import os
-import io
-import ssl
-import sys
-import time
-import codecs
-import logging
-import warnings
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-start_time = time.time()
-
-from main.app.variables import logger, config, translations, theme, font, configs, language, allow_disk, gradio_version
-
-from main.app.core.realtime import js_code
-from main.app.tabs.extra.extra import extra_tab
-from main.app.tabs.editing.editing import editing_tab
-from main.app.tabs.training.training import training_tab
-from main.app.tabs.realtime.realtime import realtime_tab
-from main.app.tabs.downloads.downloads import download_tab
-from main.app.tabs.inference.inference import inference_tab
-from main.configs.rpc import connect_discord_ipc, send_discord_rpc
-
-ssl._create_default_https_context = ssl._create_unverified_context
-
-if not config.debug_mode:
- warnings.filterwarnings("ignore")
- for l in ["httpx", "gradio", "uvicorn", "httpcore", "urllib3"]:
- logging.getLogger(l).setLevel(logging.ERROR)
-
-if sys.platform == "win32":
- import asyncio.proactor_events as _pe
-
- _orig_ccl = _pe._ProactorBasePipeTransport._call_connection_lost
-
- def _ccl_patched(self, exc):
- try:
- _orig_ccl(self, exc)
- except ConnectionResetError:
- pass
-
- _pe._ProactorBasePipeTransport._call_connection_lost = _ccl_patched
-
-css = """
-
-""".format(
- font_urls=font or "https://fonts.googleapis.com/css2?family=Saira&display=swap",
- fonts=(
- font or "https://fonts.googleapis.com/css2?family=Saira&display=swap"
- ).replace("https://fonts.googleapis.com/css2?family=", "").replace("+", " ").split(":")[0].split("&")[0]
-
-)
-
-client_mode = True # "--client" in sys.argv
-
-gr_params = {
- "js": (
- ("() => {\n" + js_code + "\n}")
- if gradio_version else
- js_code
- ) if client_mode else None,
- "theme": theme,
- "css": css
-}
-
-with gr.Blocks(
- title="📱 Vietnamese-RVC GUI",
- **gr_params if gradio_version else {}
-) as app:
- gr.HTML("
🎵VIETNAMESE RVC🎵
", padding=True)
- gr.HTML(f"{translations['title']}
", padding=True)
-
- with gr.Tabs():
- if configs.get("inference_tab", True): inference_tab()
- if configs.get("editing_tab", True): editing_tab()
- if configs.get("realtime_tab", True) and not config.is_zluda: realtime_tab()
- if configs.get("create_and_training_tab", True): training_tab()
- if configs.get("downloads_tab", True): download_tab()
- if configs.get("extra_tab", True): extra_tab(app)
-
- with gr.Row():
- gr.Markdown(
- translations["rick_roll"].format(
- rickroll=codecs.decode('uggcf://jjj.lbhghor.pbz/jngpu?i=qDj4j9JtKpD', 'rot13')
- )
- )
-
- with gr.Row():
- gr.Markdown(translations["terms_of_use"])
-
- with gr.Row():
- gr.Markdown(translations["exemption"])
-
- if __name__ == "__main__":
- device = config.device.replace("privateuseone", "dml")
- if config.is_zluda: device = device.replace("cuda", "zluda")
- if config.hip_version is not None: device = device.replace("cuda", "hip")
-
- logger.info(f"Pytorch: {device} | Onnxruntime: {config.providers[0].replace('Dml', 'Ocl') if device.startswith('ocl') else config.providers[0]}")
- if config.compile_all: logger.info(translations["compile_model"].format(compile_mode=config.compile_mode))
- logger.info(f'{translations["precision"]}: {("BF16" if config.brain else "FP16") if config.is_half else "FP32"}')
- logger.info(translations["start_app"])
- logger.info(translations["set_lang"].format(lang=language))
-
- port = configs.get("app_port", 7860)
- server_name = configs.get("server_name", "0.0.0.0")
- share = "--share" in sys.argv
-
- original_stdout = sys.stdout
- sys.stdout = io.StringIO()
-
- for i in range(configs.get("num_of_restart", 5)):
- try:
- gradio_app, _, share_url = app.queue().launch(
- favicon_path=configs["ico_path"],
- server_name=server_name,
- server_port=port,
- show_error=configs.get("app_show_error", False),
- inbrowser="--open" in sys.argv,
- share=share,
- allowed_paths=allow_disk,
- prevent_thread_lock=True,
- quiet=not config.debug_mode,
- **gr_params if not gradio_version else {}
- )
- break
- except OSError:
- logger.debug(translations["port"].format(port=port))
- port -= 1
- except Exception as e:
- logger.error(translations["error_occurred"].format(e=e))
- sys.exit(1)
-
- if client_mode:
- logger.debug(translations["mount_fastapi"])
-
- from main.inference.realtime.client import app as fastapi_app
- gradio_app.mount("/api", fastapi_app)
-
- logger.debug("\n" + sys.stdout.getvalue())
- sys.stdout = original_stdout
-
- if configs.get("discord_presence", True) and "--no_discord" not in sys.argv:
- pipe = connect_discord_ipc()
- if pipe:
- try:
- logger.info(translations["start_rpc"])
- send_discord_rpc(pipe)
- except KeyboardInterrupt:
- logger.info(translations["stop_rpc"])
- pipe.close()
-
- logger.info(f"{translations['running_local_url']}: {server_name}:{port}")
- if share: logger.info(f"{translations['running_share_url']}: {share_url}")
-
- if "--tensorboard" in sys.argv:
- logger.info(translations["run_tensorboard"])
-
- from main.app.run_tensorboard import launch_tensorboard
- launch_tensorboard()
-
- logger.info(f"{translations['gradio_start']}: {(time.time() - start_time):.2f}s")
-
- while 1:
- time.sleep(5)
\ No newline at end of file
diff --git a/main/app/core/csrt.py b/main/app/core/csrt.py
deleted file mode 100644
index 476532ac42f4d2ee40ac6eed010612f450a8c63d..0000000000000000000000000000000000000000
--- a/main/app/core/csrt.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import os
-import gc
-import sys
-
-sys.path.append(os.getcwd())
-
-from main.app.core.ui import gr_info, gr_warning, process_output
-from main.app.variables import config, translations, configs, logger
-from main.library.utils import check_spk_diarization, clear_gpu_cache
-
-def whisper_process(
- model_size,
- input_audio,
- configs,
- device,
- out_queue,
- language="vi"
-):
- from main.library.speaker_diarization.whisper import load_model
-
- try:
- model = load_model(
- model_size,
- device=device
- )
-
- if config.compile_all:
- import torch
-
- model.encoder = torch.compile(model.encoder, mode=config.compile_mode)
- model.decoder = torch.compile(model.decoder, mode=config.compile_mode)
-
- segments = model.transcribe(
- input_audio,
- fp16=configs.get("fp16", False),
- word_timestamps=True,
- language=language
- )
-
- out_queue.put(segments["segments"])
- except Exception as e:
- out_queue.put(e)
- finally:
- clear_gpu_cache()
- del segments
- gc.collect()
-
-def create_srt(
- model_size,
- input_audio,
- output_file,
- language
-):
- import multiprocessing as mp
-
- if not input_audio or not os.path.exists(input_audio) or os.path.isdir(input_audio):
- gr_warning(translations["input_not_valid"])
- return [None]*2
-
- if not output_file.endswith(".srt"): output_file += ".srt"
-
- if not output_file:
- gr_warning(translations["output_not_valid"])
- return [None]*2
-
- output_dir = os.path.dirname(output_file)
- if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True)
-
- info = ""
- output_file = process_output(output_file)
-
- check_spk_diarization(model_size, speechbrain=False)
- gr_info(translations["csrt"])
-
- ctx = mp.get_context("spawn")
- whisper_queue = ctx.Queue()
-
- whisperprocess = ctx.Process(
- target=whisper_process,
- args=(
- model_size,
- input_audio,
- configs,
- config.device,
- whisper_queue,
- language
- )
- )
-
- whisperprocess.start()
- segments = whisper_queue.get()
- whisperprocess.join()
-
- with open(output_file, "w", encoding="utf-8") as f:
- for i, segment in enumerate(segments):
- start = segment["start"]
- end = segment["end"]
- text = segment["text"].strip()
-
- index = f"{i+1}\n"
- timestamp = f"{format_timestamp(start)} --> {format_timestamp(end)}\n"
- text1 = f"{text}\n\n"
-
- f.write(index)
- f.write(timestamp)
- f.write(text1)
-
- info = info + index + timestamp + text1
- logger.info(info)
-
- gr_info(translations["success"])
-
- return [{"value": output_file, "visible": True, "__type__": "update"}, info]
-
-def format_timestamp(seconds):
- hours = int(seconds // 3600)
- minutes = int((seconds % 3600) // 60)
-
- seconds = int(seconds % 60)
- miliseconds = int(round((seconds % 1) * 1000))
-
- return f"{hours:02}:{minutes:02}:{seconds:02},{miliseconds:03}"
\ No newline at end of file
diff --git a/main/app/core/downloads.py b/main/app/core/downloads.py
deleted file mode 100644
index 7813eef7c10507d92f28102616ad11c34bb1a11c..0000000000000000000000000000000000000000
--- a/main/app/core/downloads.py
+++ /dev/null
@@ -1,351 +0,0 @@
-import os
-import re
-import sys
-import json
-import codecs
-import shutil
-import yt_dlp
-import warnings
-import requests
-
-from bs4 import BeautifulSoup
-
-sys.path.append(os.getcwd())
-
-from main.tools import huggingface, gdown, meganz, mediafire, pixeldrain
-from main.app.variables import logger, translations, model_options, configs
-from main.app.core.process import move_files_from_directory, fetch_pretrained_data, extract_name_model
-from main.app.core.ui import gr_info, gr_warning, gr_error, process_output, replace_url, replace_modelname
-
-def download_url(url):
- if not url:
- gr_warning(translations["provide_url"])
- return [None]*3
-
- if not os.path.exists(configs["audios_path"]): os.makedirs(configs["audios_path"], exist_ok=True)
-
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore")
-
- ydl_opts = {
- "format": "bestaudio/best",
- "postprocessors": [{
- "key": "FFmpegExtractAudio",
- "preferredcodec": "wav",
- "preferredquality": "192"
- }],
- "quiet": True,
- "no_warnings": True,
- "noplaylist": True,
- "verbose": False
- }
-
- gr_info(translations["start"].format(start=translations["download_music"]))
- audio_output = ""
-
- with yt_dlp.YoutubeDL(ydl_opts) as ydl:
- audio_output = process_output(os.path.join(
- configs["audios_path"],
- re.sub(
- r'\s+', '-',
- re.sub(
- r'[^\w\s\u4e00-\u9fff\uac00-\ud7af\u0400-\u04FF\u1100-\u11FF]',
- '',
- ydl.extract_info(url, download=False).get('title', 'video')
- ).strip()
- )
- ) + ".wav")
-
- if os.path.exists(audio_output):
- shutil.rmtree(audio_output, ignore_errors=True)
-
- ydl_opts['outtmpl'] = audio_output.replace(".wav", "")
-
- with yt_dlp.YoutubeDL(ydl_opts) as ydl:
- ydl.download([url])
-
- gr_info(translations["success"])
-
- return [
- audio_output,
- audio_output,
- translations["success"]
- ]
-
-def move_file(
- file,
- download_dir,
- model,
- use_orig_weight_name=False
-):
- weights_dir = configs["weights_path"]
- logs_dir = configs["logs_path"]
-
- if not os.path.exists(weights_dir): os.makedirs(weights_dir, exist_ok=True)
- if not os.path.exists(logs_dir): os.makedirs(logs_dir, exist_ok=True)
-
- if file.endswith(".zip"): shutil.unpack_archive(file, download_dir)
- move_files_from_directory(download_dir, weights_dir, logs_dir, model, use_orig_weight_name)
-
-def download_model(url=None, model=None):
- if not url: return gr_warning(translations["provide_url"])
- logger.debug(model + ": " + url)
-
- url = replace_url(url)
- download_dir = "download_model"
- use_orig_weight_name = False
-
- os.makedirs(download_dir, exist_ok=True)
-
- try:
- gr_info(translations["start"].format(start=translations["download"]))
-
- if "huggingface.co" in url:
- file = huggingface.HF_download_file(
- url,
- download_dir
- )
- elif "google.com" in url:
- file = gdown.gdown_download(
- url,
- download_dir
- )
- elif "mediafire.com" in url:
- file = mediafire.Mediafire_Download(
- url,
- download_dir
- )
- elif "pixeldrain.com" in url:
- file = pixeldrain.pixeldrain(
- url,
- download_dir
- )
- elif "mega.nz" in url:
- file = meganz.mega_download_url(
- url,
- download_dir
- )
- else:
- gr_warning(translations["not_support_url"])
- return translations["not_support_url"]
-
- if not model:
- use_orig_weight_name = True
- modelname = os.path.basename(file)
-
- model = (
- extract_name_model(modelname)
- if modelname.endswith(".index") else
- os.path.splitext(modelname)[0]
- )
-
- if model is None: model = os.path.splitext(modelname)[0]
-
- model = replace_modelname(model)
- move_file(file, download_dir, model, use_orig_weight_name)
-
- gr_info(translations["success"])
- return translations["success"]
- except Exception as e:
- gr_error(message=translations["error_occurred"].format(e=e))
-
- return translations["error_occurred"].format(e=e)
- finally:
- shutil.rmtree(download_dir, ignore_errors=True)
-
-def download_pretrained_model(
- choices,
- model,
- sample_rate
-):
- pretraineds_custom_path = configs["pretrained_custom_path"]
-
- if choices == translations["list_model"]:
- paths = fetch_pretrained_data()[model][sample_rate]
- if not os.path.exists(pretraineds_custom_path):
- os.makedirs(pretraineds_custom_path, exist_ok=True)
-
- url = codecs.decode(
- "uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/cergenvarq_phfgbz/",
- "rot13"
- ) + paths
-
- gr_info(translations["download_pretrain"])
-
- file = huggingface.HF_download_file(
- replace_url(url),
- os.path.join(pretraineds_custom_path, paths)
- )
-
- if file.endswith(".zip"):
- shutil.unpack_archive(file, pretraineds_custom_path)
- os.remove(file)
-
- gr_info(translations["success"])
- return translations["success"]
- elif choices == translations["download_url"]:
- pretrain_is_zip = (
- model.endswith(".zip") or
- model.endswith(".zip?download=true") or
- sample_rate.endswith(".zip") or
- sample_rate.endswith(".zip?download=true")
- )
-
- urls = []
-
- if not model and not pretrain_is_zip:
- gr_warning(translations["provide_pretrain"].format(dg="D"))
- return [None]*2
-
- if not sample_rate and not pretrain_is_zip:
- gr_warning(translations["provide_pretrain"].format(dg="G"))
- return [None]*2
-
- gr_info(translations["download_pretrain"])
-
- if model: urls.append(model)
- if sample_rate: urls.append(sample_rate)
-
- for url in urls:
- url = replace_url(url)
-
- if "huggingface.co" in url:
- file = huggingface.HF_download_file(
- url,
- pretraineds_custom_path
- )
- elif "google.com" in url:
- file = gdown.gdown_download(
- url,
- pretraineds_custom_path
- )
- elif "mediafire.com" in url:
- file = mediafire.Mediafire_Download(
- url,
- pretraineds_custom_path
- )
- elif "pixeldrain.com" in url:
- file = pixeldrain.pixeldrain(
- url,
- pretraineds_custom_path
- )
- elif "mega.nz" in url:
- file = meganz.mega_download_url(
- url,
- pretraineds_custom_path
- )
- else:
- gr_warning(translations["not_support_url"])
- return translations["not_support_url"], translations["not_support_url"]
-
- if file.endswith(".zip"):
- shutil.unpack_archive(file, pretraineds_custom_path)
- if os.path.exists(file): os.remove(file)
-
- gr_info(translations["success"])
- return translations["success"], translations["success"]
-
-def is_empty_table(html):
- return (' {str(datetime.timedelta(seconds=int(end_t)))}"
- dur_str = f"{dur:.2f}s"
-
- rows.append([spk, time_range, dur_str])
- speaker_stats[spk] = speaker_stats.get(spk, 0.0) + dur
- col_widths = []
- for i in range(3):
- max_len = max(len(headers[i].replace("-", " ")), *(len(row[i]) for row in rows))
- col_widths.append(max_len)
-
- def make_line(left, mid, right):
- return left + mid.join("─" * (w + 2) for w in col_widths) + right
-
- def format_row(row):
- return "│ " + " │ ".join(f"{cell:<{col_widths[i]}}" for i, cell in enumerate(row)) + " │"
-
- lines.append("\n")
- lines.append(make_line("┌", "┬", "┐"))
- lines.append(format_row(headers))
- lines.append(make_line("├", "┼", "┤"))
-
- for row in rows:
- lines.append(format_row(row))
-
- lines.append(make_line("└", "┴", "┘"))
- return "\n".join(lines)
-
- def merge_audio(
- files_list,
- time_stamps,
- original_file_path,
- output_path,
- export_format
- ):
- def extract_number(filename):
- match = re.search(r'_(\d+)', filename)
- return int(match.group(1)) if match else 0
-
- total_duration = len(pydub_load(original_file_path))
- combined = AudioSegment.empty()
- current_position = 0
-
- for file, (start_i, end_i) in zip(sorted(files_list, key=extract_number), time_stamps):
- if start_i > current_position:
- combined += AudioSegment.silent(
- duration=start_i - current_position
- )
-
- combined += pydub_load(file)
- current_position = end_i
-
- if current_position < total_duration:
- combined += AudioSegment.silent(
- duration=total_duration - current_position
- )
-
- combined.export(output_path, format=export_format)
- return output_path
-
- embeddings = np.zeros(shape=(len(segments), 192))
- for i, segment in enumerate(segments):
- embeddings[i] = segment_embedding(segment)
-
- labels = AgglomerativeClustering(num_spk).fit(np.nan_to_num(embeddings)).labels_
- for i in range(len(segments)):
- segments[i]["speaker"] = f"SPEAKER {labels[i] + 1}"
-
- merged_segments = []
-
- if segments:
- curr = segments[0].copy()
-
- for i in range(1, len(segments)):
- if segments[i]["speaker"] == curr["speaker"]: curr["end"] = segments[i]["end"]
- else:
- merged_segments.append(curr)
- curr = segments[i].copy()
-
- merged_segments.append(curr)
-
- gr_info(translations["analysis_completed"].format(length=len(merged_segments)))
-
- del audio, embedding_model, segments, labels
- clear_gpu_cache()
- gc.collect()
-
- gr_info(translations["process_audio"])
-
- pydub_audio = pydub_load(input_audio)
- output_folder = "audios_temp"
-
- if os.path.exists(output_folder): shutil.rmtree(output_folder, ignore_errors=True)
-
- for f in [
- output_folder,
- os.path.join(output_folder, "1"),
- os.path.join(output_folder, "2")
- ]:
- os.makedirs(f, exist_ok=True)
-
- time_stamps, processed_segments = [], []
- for i, seg in enumerate(merged_segments):
- model_id = 1 if int(seg["speaker"].split()[-1]) % 2 != 0 else 2
- start_ms, end_ms = int(seg["start"] * 1000), int(seg["end"] * 1000)
-
- target_path = os.path.join(output_folder, str(model_id), f"segment_{i+1}.wav")
- pydub_audio[start_ms:end_ms].export(target_path, format="wav")
-
- processed_segments.append(os.path.join(output_folder, str(model_id), f"segment_{i+1}_output.wav"))
- time_stamps.append((start_ms, end_ms))
-
- logger.info(get_formatted_stats(merged_segments))
-
- f0method, embedder_model = (
- f0_method if f0_method != "hybrid" else hybrid_method,
- embedders if embedders != "custom" else custom_embedders
- )
-
- gr_info(translations["process_done_start_convert"])
-
- convert(
- pitch_1,
- filter_radius,
- index_strength_1,
- rms_mix_rate,
- protect,
- hop_length,
- f0method,
- os.path.join(output_folder, "1"),
- output_folder,
- model_pth_1,
- model_index_1,
- autotune,
- cleaner,
- clean_strength,
- "wav",
- embedder_model,
- 48000 if resample_sr == 0 else resample_sr,
- False,
- f0_autotune_strength,
- checkpointing,
- predictor_onnx,
- embed_mode,
- formant_shifting,
- formant_qfrency_1,
- formant_timbre_1,
- "",
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sid_1,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale_1,
- nprobe_1,
- False
- )
-
- convert(
- pitch_2,
- filter_radius,
- index_strength_2,
- rms_mix_rate,
- protect,
- hop_length,
- f0method,
- os.path.join(output_folder, "2"),
- output_folder,
- model_pth_2,
- model_index_2,
- autotune,
- cleaner,
- clean_strength,
- "wav",
- embedder_model,
- 48000 if resample_sr == 0 else resample_sr,
- False,
- f0_autotune_strength,
- checkpointing,
- predictor_onnx,
- embed_mode,
- formant_shifting,
- formant_qfrency_2,
- formant_timbre_2,
- "",
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sid_2,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale_2,
- nprobe_2,
- False
- )
-
- gr_info(translations["convert_success"])
-
- return merge_audio(
- processed_segments,
- time_stamps,
- input_audio,
- replace_export_format(output_audio, export_format),
- export_format
- )
- except Exception as e:
- import traceback
-
- gr_error(translations["error_occurred"].format(e=e))
- logger.debug(traceback.format_exc())
-
- return None
- finally:
- if os.path.exists("audios_temp"):
- shutil.rmtree("audios_temp", ignore_errors=True)
-
-def convert_tts(
- clean_audio,
- autotune,
- pitch,
- clean_strength,
- model,
- index,
- index_rate,
- input_path,
- output_path,
- export_format,
- method,
- hybrid_method,
- hop_length,
- embedders,
- custom_embedders,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- checkpointing,
- predictor_onnx,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- f0_file,
- embedders_mode,
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing=False,
- alpha=0.5,
- sid=0,
- embedders_mix = False,
- embedders_mix_layers = 9,
- embedders_mix_ratio = 0.5,
- noise_scale = 0.35,
- nprobe = 1,
- audio_upscaler = False
-):
- model_path = os.path.join(configs["weights_path"], model) if not os.path.exists(model) else model
-
- if (
- not model_path or
- not os.path.exists(model_path) or
- os.path.isdir(model_path) or
- not model.endswith((".pth", ".onnx"))
- ):
- gr_warning(translations["provide_file"].format(filename=translations["model"]))
- return None
-
- if not input_path or not os.path.exists(input_path):
- gr_warning(translations["input_not_valid"])
- return None
-
- if os.path.isdir(input_path):
- input_audio = [
- f for f in os.listdir(input_path)
- if "tts" in f and f.lower().endswith(tuple(file_types))
- ]
-
- if not input_audio:
- gr_warning(translations["not_found_in_folder"])
- return None
-
- input_path = os.path.join(input_path, input_audio[0])
-
- if not output_path:
- gr_warning(translations["output_not_valid"])
- return None
-
- output_path = replace_export_format(output_path, export_format)
- if os.path.isdir(output_path): output_path = os.path.join(output_path, f"tts.{export_format}")
-
- output_dir = os.path.dirname(output_path)
- if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True)
-
- output_path = process_output(output_path)
-
- f0method, embedder_model = (
- method if method != "hybrid" else hybrid_method,
- embedders if embedders != "custom" else custom_embedders
- )
-
- gr_info(translations["convert_vocal"])
-
- convert(
- pitch,
- filter_radius,
- index_rate,
- rms_mix_rate,
- protect,
- hop_length,
- f0method,
- input_path,
- output_path,
- model_path,
- index,
- autotune,
- clean_audio,
- clean_strength,
- export_format,
- embedder_model,
- resample_sr,
- split_audio,
- f0_autotune_strength,
- checkpointing,
- predictor_onnx,
- embedders_mode,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- f0_file,
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sid,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale,
- nprobe,
- audio_upscaler
- )
-
- gr_info(translations["convert_success"])
- return output_path
\ No newline at end of file
diff --git a/main/app/core/model_utils.py b/main/app/core/model_utils.py
deleted file mode 100644
index 56e6eb9100f240a2d7332d0043325dbbd7900598..0000000000000000000000000000000000000000
--- a/main/app/core/model_utils.py
+++ /dev/null
@@ -1,301 +0,0 @@
-import os
-import sys
-import json
-import torch
-import datetime
-
-sys.path.append(os.getcwd())
-
-from main.app.core.ui import gr_info, gr_warning, gr_error
-from main.app.variables import config, logger, translations, configs
-
-def fushion_model_pth(
- name,
- model_path_1,
- model_path_2,
- ratio
-):
- if not name.endswith(".pth"): name = name + ".pth"
-
- model_path_1 = os.path.join(configs["weights_path"], model_path_1) if not os.path.exists(model_path_1) else model_path_1
- model_path_2 = os.path.join(configs["weights_path"], model_path_2) if not os.path.exists(model_path_2) else model_path_2
-
- if (
- not model_path_1 or
- not os.path.exists(model_path_1) or
- not model_path_1.endswith(".pth")
- ):
- gr_warning(translations["provide_file"].format(filename=translations["model"] + " 1"))
- return [translations["provide_file"].format(filename=translations["model"] + " 1"), None]
-
- if (
- not model_path_2 or
- not os.path.exists(model_path_2) or
- not model_path_2.endswith(".pth")
- ):
- gr_warning(translations["provide_file"].format(filename=translations["model"] + " 2"))
- return [translations["provide_file"].format(filename=translations["model"] + " 2"), None]
-
- from collections import OrderedDict
-
- def extract(ckpt):
- a = ckpt["model"]
- opt = OrderedDict()
- opt["weight"] = {}
-
- for key in a.keys():
- if "enc_q" in key: continue
-
- opt["weight"][key] = a[key]
-
- return opt
-
- try:
- ckpt1 = torch.load(model_path_1, map_location="cpu", weights_only=True)
- ckpt2 = torch.load(model_path_2, map_location="cpu", weights_only=True)
-
- if ckpt1["sr"] != ckpt2["sr"]:
- gr_warning(translations["sr_not_same"])
- return [translations["sr_not_same"], None]
-
- cfg = ckpt1["config"]
- cfg_f0 = ckpt1["f0"]
- cfg_version = ckpt1["version"]
- cfg_sr = ckpt1["sr"]
-
- vocoder = ckpt1.get("vocoder", "Default")
- rms_extract = ckpt1.get("energy", False)
-
- ckpt1 = extract(ckpt1) if "model" in ckpt1 else ckpt1["weight"]
- ckpt2 = extract(ckpt2) if "model" in ckpt2 else ckpt2["weight"]
-
- if sorted(list(ckpt1.keys())) != sorted(list(ckpt2.keys())):
- gr_warning(translations["architectures_not_same"])
-
- return [translations["architectures_not_same"], None]
-
- gr_info(translations["start"].format(start=translations["fushion_model"]))
-
- opt = OrderedDict()
- opt["weight"] = {}
-
- for key in ckpt1.keys():
- if key == "emb_g.weight" and ckpt1[key].shape != ckpt2[key].shape:
- min_shape0 = min(ckpt1[key].shape[0], ckpt2[key].shape[0])
-
- opt["weight"][key] = (
- ratio * (ckpt1[key][:min_shape0].float()) + (1 - ratio) * (ckpt2[key][:min_shape0].float())
- ).half()
- else:
- opt["weight"][key] = (
- ratio * (ckpt1[key].float()) + (1 - ratio) * (ckpt2[key].float())
- ).half()
-
- opt["config"] = cfg
- opt["sr"] = cfg_sr
- opt["f0"] = cfg_f0
- opt["version"] = cfg_version
-
- opt["infos"] = translations["model_fushion_info"].format(
- name=name,
- model_path_1=model_path_1,
- model_path_2=model_path_2,
- ratio=ratio
- )
-
- opt["vocoder"] = vocoder
- opt["energy"] = rms_extract
-
- output_model = configs["weights_path"]
- if not os.path.exists(output_model): os.makedirs(output_model, exist_ok=True)
-
- torch.save(opt, os.path.join(output_model, name))
-
- gr_info(translations["success"])
- return [translations["success"], os.path.join(output_model, name)]
- except Exception as e:
- gr_error(message=translations["error_occurred"].format(e=e))
- return [e, None]
-
-def fushion_model(
- modelname,
- model_path_1,
- model_path_2,
- ratio
-):
- if not modelname:
- gr_warning(translations["provide_name_is_save"])
- return [translations["provide_name_is_save"], None]
-
- if model_path_1.endswith(".pth") and model_path_2.endswith(".pth"):
- return fushion_model_pth(
- modelname,
- model_path_1,
- model_path_2,
- ratio
- )
- else:
- gr_warning(translations["format_not_valid"])
- return [None, None]
-
-def onnx_export(model_path):
- if not model_path.endswith(".pth"): model_path += ".pth"
- model_path = os.path.join(configs["weights_path"], model_path) if not os.path.exists(model_path) else model_path
-
- if (
- not model_path or
- not os.path.exists(model_path) or
- not model_path.endswith(".pth")
- ):
- return gr_warning(translations["provide_file"].format(filename=translations["model"]))
-
- try:
- gr_info(translations["start_onnx_export"])
-
- from main.library.onnx.onnx_export import onnx_exporter
-
- output = onnx_exporter(
- model_path,
- model_path.replace(".pth", ".onnx"),
- is_half=config.is_half,
- device=config.device
- )
-
- gr_info(translations["success"])
- return output
- except Exception as e:
- return gr_error(e)
-
-def svc_export(model_path, config_path, modelname, delete_when_success):
- if not model_path.endswith(".pth"): model_path += ".pth"
- model_path = os.path.join(configs["weights_path"], model_path) if not os.path.exists(model_path) else model_path
-
- if (
- not model_path or
- not os.path.exists(model_path) or
- not model_path.endswith(".pth")
- ):
- gr_warning(translations["provide_file"].format(filename=translations["model"]))
- return None
-
- if (
- not config_path or
- not os.path.exists(config_path) or
- not config_path.endswith(".json")
- ):
- gr_warning(translations["provide_file"].format(filename=translations["config"]))
- return None
-
- if modelname is None: modelname = os.path.basename(model_path)
- if not modelname.endswith(".pth"): modelname += ".pth"
- output_path = os.path.join(configs["weights_path"], modelname) if not os.path.exists(modelname) else modelname
-
- if (
- not model_path or
- not os.path.exists(model_path) or
- not model_path.endswith(".pth")
- ):
- return gr_warning(translations["provide_file"].format(filename=translations["model"]))
-
- try:
- gr_info(translations["start_convert_svc"])
-
- from main.tools.export_svc import svc_converter
-
- output = svc_converter(
- model_path,
- config_path,
- output_path,
- is_half=config.is_half
- )
-
- if output == translations["not_svc"]:
- gr_warning(output)
- return None
-
- if delete_when_success: os.remove(model_path); os.remove(config_path)
- gr_info(translations["success"])
- return output
- except Exception as e:
- return gr_error(e)
-
-def model_info(model_path):
- model_path = os.path.join(configs["weights_path"], model_path) if not os.path.exists(model_path) else model_path
-
- if (
- not model_path or
- not os.path.exists(model_path) or
- os.path.isdir(model_path) or
- not model_path.endswith((".pth", ".onnx"))
- ):
- return gr_warning(translations["provide_file"].format(filename=translations["model"]))
-
- def prettify_date(date_str):
- if date_str == translations["not_found_create_time"]: return None
-
- try:
- return datetime.datetime.strptime(
- date_str,
- "%Y-%m-%dT%H:%M:%S.%f"
- ).strftime("%Y-%m-%d %H:%M:%S")
- except ValueError as e:
- logger.debug(e)
- return translations["format_not_valid"]
-
- if model_path.endswith(".pth"):
- model_data = torch.load(model_path, map_location="cpu")
- else:
- import onnx
-
- model = onnx.load(model_path)
- model_data = None
-
- for prop in model.metadata_props:
- if prop.key == "model_info":
- model_data = json.loads(prop.value)
- break
-
- gr_info(translations["read_info"])
-
- epochs = model_data.get("epoch", None)
- if not epochs:
- epochs = model_data.get("info", None)
-
- try:
- epochs = int(epochs.split("e")[0].isdigit())
- if not epochs: epochs = translations["not_found"].format(name=translations["epoch"])
- except:
- epochs = translations["not_found"].format(name=translations["epoch"])
-
- steps = model_data.get("step", translations["not_found"].format(name=translations["step"]))
- sr = model_data.get("sr", translations["not_found"].format(name=translations["sr"]))
- f0 = model_data.get("f0", translations["not_found"].format(name=translations["f0"]))
- version = model_data.get("version", translations["not_found"].format(name=translations["version"]))
- creation_date = model_data.get("creation_date", translations["not_found_create_time"])
- model_hash = model_data.get("model_hash", translations["not_found"].format(name="model_hash"))
- pitch_guidance = translations["trained_f0"] if f0 else translations["not_f0"]
- creation_date_str = prettify_date(creation_date) if creation_date else translations["not_found_create_time"]
- model_name = model_data.get("model_name", translations["unregistered"])
- model_author = model_data.get("author", translations["not_author"])
- vocoder = model_data.get("vocoder", "Default")
- rms_extract = model_data.get("energy", False)
- speakers_id = model_data.get("speakers_id", 1)
- architecture = model_data.get("architecture", "RVC")
-
- gr_info(translations["success"])
-
- return translations["model_info"].format(
- model_name=model_name,
- model_author=model_author,
- epochs=epochs,
- steps=steps,
- version=version,
- sr=sr,
- pitch_guidance=pitch_guidance,
- model_hash=model_hash,
- creation_date_str=creation_date_str,
- vocoder=vocoder,
- rms_extract=rms_extract,
- speakers_id=speakers_id,
- architecture=architecture
- )
\ No newline at end of file
diff --git a/main/app/core/presets.py b/main/app/core/presets.py
deleted file mode 100644
index 05b865db02c1669b00d3c64d0a1f899963795a4c..0000000000000000000000000000000000000000
--- a/main/app/core/presets.py
+++ /dev/null
@@ -1,744 +0,0 @@
-import os
-import sys
-import json
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import translations, configs
-from main.app.core.ui import gr_info, gr_warning, change_preset_choices, change_effect_preset_choices, change_realtime_preset_choices
-
-def load_presets(
- presets,
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
-):
- if not presets: gr_warning(translations["provide_file_settings"])
-
- file = {}
- if presets:
- with open(os.path.join(configs["presets_path"], presets)) as f:
- file = json.load(f)
-
- gr_info(translations["load_presets"].format(presets=presets))
-
- return [
- file.get("cleaner", cleaner),
- file.get("autotune", autotune),
- file.get("pitch", pitch),
- file.get("clean_strength", clean_strength),
- file.get("index_strength", index_strength),
- file.get("resample_sr", resample_sr),
- file.get("filter_radius", filter_radius),
- file.get("rms_mix_rate", rms_mix_rate),
- file.get("protect", protect),
- file.get("split_audio", split_audio),
- file.get("f0_autotune_strength", f0_autotune_strength),
- file.get("formant_shifting", formant_shifting),
- file.get("formant_qfrency", formant_qfrency),
- file.get("formant_timbre", formant_timbre),
- file.get("proposal_pitch", proposal_pitch),
- file.get("proposal_pitch_threshold", proposal_pitch_threshold),
- file.get("embedders_mix", embedders_mix),
- file.get("embedders_mix_layers", embedders_mix_layers),
- file.get("embedders_mix_ratio", embedders_mix_ratio)
- ]
-
-def save_presets(
- name,
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- cleaner_checkbox,
- autotune_checkbox,
- pitch_checkbox,
- index_strength_checkbox,
- resample_sr_checkbox,
- filter_radius_checkbox,
- rms_mix_rate_checkbox,
- protect_checkbox,
- split_audio_checkbox,
- formant_shifting_checkbox,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
-):
- if not name: return gr_warning(translations["provide_filename_settings"])
-
- if not any([
- cleaner_checkbox,
- autotune_checkbox,
- pitch_checkbox,
- index_strength_checkbox,
- resample_sr_checkbox,
- filter_radius_checkbox,
- rms_mix_rate_checkbox,
- protect_checkbox,
- split_audio_checkbox,
- formant_shifting_checkbox
- ]):
- return gr_warning(translations["choose1"])
-
- settings = {}
-
- for checkbox, data in [
- (
- cleaner_checkbox,
- {"cleaner": cleaner, "clean_strength": clean_strength}
- ),
- (
- autotune_checkbox,
- {"autotune": autotune, "f0_autotune_strength": f0_autotune_strength}),
- (
- pitch_checkbox,
- {"pitch": pitch}
- ),
- (
- index_strength_checkbox,
- {"index_strength": index_strength}
- ),
- (
- resample_sr_checkbox,
- {"resample_sr": resample_sr}
- ),
- (
- filter_radius_checkbox,
- {"filter_radius": filter_radius}
- ),
- (
- rms_mix_rate_checkbox,
- {"rms_mix_rate": rms_mix_rate}
- ),
- (
- protect_checkbox,
- {"protect": protect}
- ),
- (
- split_audio_checkbox,
- {"split_audio": split_audio}
- ),
- (
- formant_shifting_checkbox,
- {"formant_shifting": formant_shifting, "formant_qfrency": formant_qfrency, "formant_timbre": formant_timbre}
- ),
- (
- proposal_pitch,
- {"proposal_pitch": proposal_pitch, "proposal_pitch_threshold": proposal_pitch_threshold}
- ),
- (
- embedders_mix,
- {"embedders_mix_layers": embedders_mix_layers, "embedders_mix_ratio": embedders_mix_ratio}
- )
- ]:
- if checkbox: settings.update(data)
-
- with open(os.path.join(configs["presets_path"], name + ".conversion.json"), "w") as f:
- json.dump(settings, f, indent=4)
-
- gr_info(translations["export_settings"].format(name=name))
- return change_preset_choices()
-
-def audio_effect_load_presets(
- presets,
- resample_checkbox,
- audio_effect_resample_sr,
- chorus_depth,
- chorus_rate_hz,
- chorus_mix,
- chorus_center_delay_ms,
- chorus_feedback,
- distortion_drive_db,
- reverb_room_size,
- reverb_damping,
- reverb_wet_level,
- reverb_dry_level,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_second,
- delay_feedback,
- delay_mix,
- compressor_threshold_db,
- compressor_ratio,
- compressor_attack_ms,
- compressor_release_ms,
- limiter_threshold_db,
- limiter_release_ms,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold_db,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- bass_boost,
- bass_frequency,
- treble_boost,
- treble_frequency,
- fade_in,
- fade_out,
- chorus_check_box,
- distortion_checkbox,
- reverb_check_box,
- delay_check_box,
- compressor_check_box,
- limiter,
- gain_checkbox,
- bitcrush_checkbox,
- clipping_checkbox,
- phaser_check_box,
- bass_or_treble,
- fade
-):
- if not presets: gr_warning(translations["provide_file_settings"])
-
- file = {}
- if presets:
- with open(os.path.join(configs["presets_path"], presets)) as f:
- file = json.load(f)
-
- gr_info(translations["load_presets"].format(presets=presets))
-
- return [
- file.get("resample_checkbox", resample_checkbox),
- file.get("audio_effect_resample_sr", audio_effect_resample_sr),
- file.get("chorus_depth", chorus_depth),
- file.get("chorus_rate_hz", chorus_rate_hz),
- file.get("chorus_mix", chorus_mix),
- file.get("chorus_center_delay_ms", chorus_center_delay_ms),
- file.get("chorus_feedback", chorus_feedback),
- file.get("distortion_drive_db", distortion_drive_db),
- file.get("reverb_room_size", reverb_room_size),
- file.get("reverb_damping", reverb_damping),
- file.get("reverb_wet_level", reverb_wet_level),
- file.get("reverb_dry_level", reverb_dry_level),
- file.get("reverb_width", reverb_width),
- file.get("reverb_freeze_mode", reverb_freeze_mode),
- file.get("pitch_shift_semitones", pitch_shift_semitones),
- file.get("delay_second", delay_second),
- file.get("delay_feedback", delay_feedback),
- file.get("delay_mix", delay_mix),
- file.get("compressor_threshold_db", compressor_threshold_db),
- file.get("compressor_ratio", compressor_ratio),
- file.get("compressor_attack_ms", compressor_attack_ms),
- file.get("compressor_release_ms", compressor_release_ms),
- file.get("limiter_threshold_db", limiter_threshold_db),
- file.get("limiter_release_ms", limiter_release_ms),
- file.get("gain_db", gain_db),
- file.get("bitcrush_bit_depth", bitcrush_bit_depth),
- file.get("clipping_threshold_db", clipping_threshold_db),
- file.get("phaser_rate_hz", phaser_rate_hz),
- file.get("phaser_depth", phaser_depth),
- file.get("phaser_centre_frequency_hz", phaser_centre_frequency_hz),
- file.get("phaser_feedback", phaser_feedback),
- file.get("phaser_mix", phaser_mix),
- file.get("bass_boost", bass_boost),
- file.get("bass_frequency", bass_frequency),
- file.get("treble_boost", treble_boost),
- file.get("treble_frequency", treble_frequency),
- file.get("fade_in", fade_in),
- file.get("fade_out", fade_out),
- file.get("chorus_check_box", chorus_check_box),
- file.get("distortion_checkbox", distortion_checkbox),
- file.get("reverb_check_box", reverb_check_box),
- file.get("delay_check_box", delay_check_box),
- file.get("compressor_check_box", compressor_check_box),
- file.get("limiter", limiter),
- file.get("gain_checkbox", gain_checkbox),
- file.get("bitcrush_checkbox", bitcrush_checkbox),
- file.get("clipping_checkbox", clipping_checkbox),
- file.get("phaser_check_box", phaser_check_box),
- file.get("bass_or_treble", bass_or_treble),
- file.get("fade", fade)
- ]
-
-def audio_effect_save_presets(
- name,
- resample_checkbox,
- audio_effect_resample_sr,
- chorus_depth,
- chorus_rate_hz,
- chorus_mix,
- chorus_center_delay_ms,
- chorus_feedback,
- distortion_drive_db,
- reverb_room_size,
- reverb_damping,
- reverb_wet_level,
- reverb_dry_level,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_second,
- delay_feedback,
- delay_mix,
- compressor_threshold_db,
- compressor_ratio,
- compressor_attack_ms,
- compressor_release_ms,
- limiter_threshold_db,
- limiter_release_ms,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold_db,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- bass_boost,
- bass_frequency,
- treble_boost,
- treble_frequency,
- fade_in,
- fade_out,
- chorus_check_box,
- distortion_checkbox,
- reverb_check_box,
- delay_check_box,
- compressor_check_box,
- limiter,
- gain_checkbox,
- bitcrush_checkbox,
- clipping_checkbox,
- phaser_check_box,
- bass_or_treble,
- fade
-):
- if not name: return gr_warning(translations["provide_filename_settings"])
-
- if not any([
- resample_checkbox,
- chorus_check_box,
- distortion_checkbox,
- reverb_check_box,
- delay_check_box,
- compressor_check_box,
- limiter,
- gain_checkbox,
- bitcrush_checkbox,
- clipping_checkbox,
- phaser_check_box,
- bass_or_treble,
- fade,
- pitch_shift_semitones != 0
- ]):
- return gr_warning(translations["choose1"])
-
- settings = {}
-
- for checkbox, data in [
- (resample_checkbox, {
- "resample_checkbox": resample_checkbox,
- "audio_effect_resample_sr": audio_effect_resample_sr
- }),
- (chorus_check_box, {
- "chorus_check_box": chorus_check_box,
- "chorus_depth": chorus_depth,
- "chorus_rate_hz": chorus_rate_hz,
- "chorus_mix": chorus_mix,
- "chorus_center_delay_ms": chorus_center_delay_ms,
- "chorus_feedback": chorus_feedback
- }),
- (distortion_checkbox, {
- "distortion_checkbox": distortion_checkbox,
- "distortion_drive_db": distortion_drive_db
- }),
- (reverb_check_box, {
- "reverb_check_box": reverb_check_box,
- "reverb_room_size": reverb_room_size,
- "reverb_damping": reverb_damping,
- "reverb_wet_level": reverb_wet_level,
- "reverb_dry_level": reverb_dry_level,
- "reverb_width": reverb_width,
- "reverb_freeze_mode": reverb_freeze_mode
- }),
- (pitch_shift_semitones != 0, {
- "pitch_shift_semitones": pitch_shift_semitones
- }),
- (delay_check_box, {
- "delay_check_box": delay_check_box,
- "delay_second": delay_second,
- "delay_feedback": delay_feedback,
- "delay_mix": delay_mix
- }),
- (compressor_check_box, {
- "compressor_check_box": compressor_check_box,
- "compressor_threshold_db": compressor_threshold_db,
- "compressor_ratio": compressor_ratio,
- "compressor_attack_ms": compressor_attack_ms,
- "compressor_release_ms": compressor_release_ms
- }),
- (limiter, {
- "limiter": limiter,
- "limiter_threshold_db": limiter_threshold_db,
- "limiter_release_ms": limiter_release_ms
- }),
- (gain_checkbox, {
- "gain_checkbox": gain_checkbox,
- "gain_db": gain_db
- }),
- (bitcrush_checkbox, {
- "bitcrush_checkbox": bitcrush_checkbox,
- "bitcrush_bit_depth": bitcrush_bit_depth
- }),
- (clipping_checkbox, {
- "clipping_checkbox": clipping_checkbox,
- "clipping_threshold_db": clipping_threshold_db
- }),
- (phaser_check_box, {
- "phaser_check_box": phaser_check_box,
- "phaser_rate_hz": phaser_rate_hz,
- "phaser_depth": phaser_depth,
- "phaser_centre_frequency_hz": phaser_centre_frequency_hz,
- "phaser_feedback": phaser_feedback,
- "phaser_mix": phaser_mix
- }),
- (bass_or_treble, {
- "bass_or_treble": bass_or_treble,
- "bass_boost": bass_boost,
- "bass_frequency": bass_frequency,
- "treble_boost": treble_boost,
- "treble_frequency": treble_frequency
- }),
- (fade, {
- "fade": fade,
- "fade_in": fade_in,
- "fade_out": fade_out
- })
- ]:
- if checkbox: settings.update(data)
-
- with open(os.path.join(configs["presets_path"], name + ".effect.json"), "w") as f:
- json.dump(settings, f, indent=4)
-
- gr_info(translations["export_settings"].format(name=name))
- return change_effect_preset_choices()
-
-def save_realtime_config(
- name,
- exclusive_mode,
- vad_enabled,
- chunk_size,
- pitch,
- index_strength,
- predictor_onnx,
- hop_length,
- embedder_mode,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- post_process,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix
-):
- if not name: return gr_warning(translations["provide_filename_settings"])
-
- settings = {
- "exclusive_mode": exclusive_mode,
- "vad_enabled": vad_enabled,
- "chunk_size": chunk_size,
- "pitch": pitch,
- "index_strength": index_strength,
- "predictor_onnx": predictor_onnx,
- "hop_length": hop_length,
- "embedder_mode": embedder_mode,
- "embedders_mix": embedders_mix,
- "embedders_mix_layers": embedders_mix_layers,
- "embedders_mix_ratio": embedders_mix_ratio,
- "f0_autotune": f0_autotune,
- "proposal_pitch": proposal_pitch,
- "f0_autotune_strength": f0_autotune_strength,
- "proposal_pitch_threshold": proposal_pitch_threshold,
- "rms_mix_rate": rms_mix_rate,
- "protect": protect,
- "filter_radius": filter_radius,
- "silent_threshold": silent_threshold,
- "extra_convert_size": extra_convert_size,
- "cross_fade_overlap_size": cross_fade_overlap_size,
- "vad_sensitivity": vad_sensitivity,
- "vad_frame_ms": vad_frame_ms,
- "clean_audio": clean_audio,
- "clean_strength": clean_strength,
- "post_process": post_process,
- "chorus": chorus,
- "distortion": distortion,
- "reverb": reverb,
- "pitch_shift": pitch_shift,
- "delay": delay,
- "compressor": compressor,
- "limiter": limiter,
- "gain": gain,
- "bitcrush": bitcrush,
- "clipping": clipping,
- "phaser": phaser,
- "chorus_depth": chorus_depth,
- "chorus_rate": chorus_rate,
- "chorus_mix": chorus_mix,
- "chorus_center_delay": chorus_center_delay,
- "chorus_feedback": chorus_feedback,
- "distortion_gain": distortion_gain,
- "reverb_room_size": reverb_room_size,
- "reverb_damping": reverb_damping,
- "reverb_wet_gain": reverb_wet_gain,
- "reverb_dry_gain": reverb_dry_gain,
- "reverb_width": reverb_width,
- "reverb_freeze_mode": reverb_freeze_mode,
- "pitch_shift_semitones": pitch_shift_semitones,
- "delay_seconds": delay_seconds,
- "delay_feedback": delay_feedback,
- "delay_mix": delay_mix,
- "compressor_threshold": compressor_threshold,
- "compressor_ratio": compressor_ratio,
- "compressor_attack": compressor_attack,
- "compressor_release": compressor_release,
- "limiter_threshold": limiter_threshold,
- "limiter_release_time": limiter_release_time,
- "gain_db": gain_db,
- "bitcrush_bit_depth": bitcrush_bit_depth,
- "clipping_threshold": clipping_threshold,
- "phaser_rate_hz": phaser_rate_hz,
- "phaser_depth": phaser_depth,
- "phaser_centre_frequency_hz": phaser_centre_frequency_hz,
- "phaser_feedback": phaser_feedback,
- "phaser_mix": phaser_mix
- }
-
- path = os.path.join(configs["presets_path"], name + ".realtime.json")
- with open(path, "w") as f:
- json.dump(settings, f, indent=4)
-
- gr_info(translations["export_settings"].format(name=name))
- return change_realtime_preset_choices()
-
-def load_realtime_config(
- presets,
- exclusive_mode,
- vad_enabled,
- chunk_size,
- pitch,
- index_strength,
- predictor_onnx,
- hop_length,
- embedder_mode,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- post_process,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix
-):
- if not presets: gr_warning(translations["provide_file_settings"])
-
- file = {}
- if presets:
- with open(os.path.join(configs["presets_path"], presets)) as f:
- file = json.load(f)
-
- gr_info(translations["load_presets"].format(presets=presets))
-
- return [
- file.get("exclusive_mode", exclusive_mode),
- file.get("vad_enabled", vad_enabled),
- file.get("chunk_size", chunk_size),
- file.get("pitch", pitch),
- file.get("index_strength", index_strength),
- file.get("predictor_onnx", predictor_onnx),
- file.get("hop_length", hop_length),
- file.get("embedder_mode", embedder_mode),
- file.get("f0_autotune", f0_autotune),
- file.get("proposal_pitch", proposal_pitch),
- file.get("f0_autotune_strength", f0_autotune_strength),
- file.get("proposal_pitch_threshold", proposal_pitch_threshold),
- file.get("rms_mix_rate", rms_mix_rate),
- file.get("protect", protect),
- file.get("filter_radius", filter_radius),
- file.get("silent_threshold", silent_threshold),
- file.get("extra_convert_size", extra_convert_size),
- file.get("cross_fade_overlap_size", cross_fade_overlap_size),
- file.get("vad_sensitivity", vad_sensitivity),
- file.get("vad_frame_ms", vad_frame_ms),
- file.get("clean_audio", clean_audio),
- file.get("clean_strength", clean_strength),
- file.get("post_process", post_process),
- file.get("embedders_mix", embedders_mix),
- file.get("embedders_mix_layers", embedders_mix_layers),
- file.get("embedders_mix_ratio", embedders_mix_ratio),
- file.get("chorus", chorus),
- file.get("distortion", distortion),
- file.get("reverb", reverb),
- file.get("pitch_shift", pitch_shift),
- file.get("delay", delay),
- file.get("compressor", compressor),
- file.get("limiter", limiter),
- file.get("gain", gain),
- file.get("bitcrush", bitcrush),
- file.get("clipping", clipping),
- file.get("phaser", phaser),
- file.get("chorus_depth", chorus_depth),
- file.get("chorus_rate", chorus_rate),
- file.get("chorus_mix", chorus_mix),
- file.get("chorus_center_delay", chorus_center_delay),
- file.get("chorus_feedback", chorus_feedback),
- file.get("distortion_gain", distortion_gain),
- file.get("reverb_room_size", reverb_room_size),
- file.get("reverb_damping", reverb_damping),
- file.get("reverb_wet_gain", reverb_wet_gain),
- file.get("reverb_dry_gain", reverb_dry_gain),
- file.get("reverb_width", reverb_width),
- file.get("reverb_freeze_mode", reverb_freeze_mode),
- file.get("pitch_shift_semitones", pitch_shift_semitones),
- file.get("delay_seconds", delay_seconds),
- file.get("delay_feedback", delay_feedback),
- file.get("delay_mix", delay_mix),
- file.get("compressor_threshold", compressor_threshold),
- file.get("compressor_ratio", compressor_ratio),
- file.get("compressor_attack", compressor_attack),
- file.get("compressor_release", compressor_release),
- file.get("limiter_threshold", limiter_threshold),
- file.get("limiter_release_time", limiter_release_time),
- file.get("gain_db", gain_db),
- file.get("bitcrush_bit_depth", bitcrush_bit_depth),
- file.get("clipping_threshold", clipping_threshold),
- file.get("phaser_rate_hz", phaser_rate_hz),
- file.get("phaser_depth", phaser_depth),
- file.get("phaser_centre_frequency_hz", phaser_centre_frequency_hz),
- file.get("phaser_feedback", phaser_feedback),
- file.get("phaser_mix", phaser_mix)
- ]
\ No newline at end of file
diff --git a/main/app/core/process.py b/main/app/core/process.py
deleted file mode 100644
index c8e72955dea44867b1f93110614df079ced3bd24..0000000000000000000000000000000000000000
--- a/main/app/core/process.py
+++ /dev/null
@@ -1,192 +0,0 @@
-import os
-import re
-import sys
-import shutil
-import codecs
-import zipfile
-import requests
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import logger, translations, configs
-from main.app.core.ui import gr_info, gr_warning, gr_error, process_output, replace_punctuation
-
-def read_docx_text(path):
- import xml.etree.ElementTree
-
- with zipfile.ZipFile(path) as docx:
- with docx.open("word/document.xml") as document_xml:
- xml_content = document_xml.read()
-
- WORD_NAMESPACE = codecs.decode(
- "{uggc://fpurznf.bcrakzysbezngf.bet/jbeqcebprffvatzy/2006/znva}",
- "rot13"
- )
- paragraphs = []
-
- for paragraph in xml.etree.ElementTree.XML(xml_content).iter(WORD_NAMESPACE + 'p'):
- texts = [node.text for node in paragraph.iter(WORD_NAMESPACE + 't') if node.text]
- if texts: paragraphs.append(''.join(texts))
-
- return '\n'.join(paragraphs)
-
-def process_input(file_path):
- if file_path.endswith(".srt"):
- file_contents = ""
- elif file_path.endswith(".docx"):
- file_contents = read_docx_text(file_path)
- else:
- try:
- with open(file_path, "r", encoding="utf-8") as file:
- file_contents = file.read()
- except Exception as e:
- gr_warning(translations["read_error"])
-
- logger.debug(e)
- file_contents = ""
-
- gr_info(translations["upload_success"].format(name=translations["text"]))
- return file_contents
-
-def move_files_from_directory(
- src_dir,
- dest_weights,
- dest_logs,
- model_name,
- use_orig_weight_name=False
-):
- for root, _, files in os.walk(src_dir):
- for file in files:
- file_path = os.path.join(root, file)
-
- if file.endswith(".index"):
- model_log_dir = os.path.join(dest_logs, model_name)
- os.makedirs(model_log_dir, exist_ok=True)
-
- filepath = process_output(os.path.join(model_log_dir, replace_punctuation(file)))
-
- shutil.move(file_path, filepath)
- elif file.endswith(".pth") and not file.startswith("D_") and not file.startswith("G_"):
- pth_path = process_output(os.path.join(dest_weights, model_name + ".pth"))
-
- shutil.move(file_path, pth_path if not use_orig_weight_name else dest_weights)
- elif file.endswith(".onnx") and not file.startswith("D_") and not file.startswith("G_"):
- pth_path = process_output(os.path.join(dest_weights, model_name + ".onnx"))
-
- shutil.move(file_path, pth_path if not use_orig_weight_name else dest_weights)
-
-def extract_name_model(filename):
- match = re.search(
- r"_([A-Za-z0-9]+)(?=_v\d*)",
- replace_punctuation(filename)
- )
-
- return match.group(1) if match else None
-
-def save_drop_model(dropboxs):
- weight_folder = configs["weights_path"]
- logs_folder = configs["logs_path"]
- save_model_temp = "save_model_temp"
-
- if not os.path.exists(weight_folder): os.makedirs(weight_folder, exist_ok=True)
- if not os.path.exists(logs_folder): os.makedirs(logs_folder, exist_ok=True)
- if not os.path.exists(save_model_temp): os.makedirs(save_model_temp, exist_ok=True)
-
- try:
- for dropbox in dropboxs:
- shutil.move(dropbox, save_model_temp)
- file_name = os.path.basename(dropbox)
-
- if file_name.endswith(".zip"):
- shutil.unpack_archive(
- os.path.join(save_model_temp, file_name),
- save_model_temp
- )
-
- move_files_from_directory(
- save_model_temp,
- weight_folder,
- logs_folder,
- file_name.replace(".zip", "")
- )
- elif file_name.endswith((".pth", ".onnx")):
- output_file = process_output(os.path.join(weight_folder, file_name))
-
- shutil.move(os.path.join(save_model_temp, file_name), output_file)
- elif file_name.endswith(".index"):
- modelname = extract_name_model(file_name)
- if modelname is None:
- modelname = os.path.splitext(os.path.basename(file_name))[0]
-
- model_logs = os.path.join(logs_folder, modelname)
- if not os.path.exists(model_logs):
- os.makedirs(model_logs, exist_ok=True)
-
- shutil.move(
- os.path.join(save_model_temp, file_name),
- model_logs
- )
- else:
- gr_warning(translations["unable_analyze_model"])
- return None
-
- gr_info(translations["upload_success"].format(name=translations["model"]))
- return None
- except Exception as e:
- gr_error(message=translations["error_occurred"].format(e=e))
- return None
- finally:
- shutil.rmtree(save_model_temp, ignore_errors=True)
-
-def zip_file(
- modelname,
- pth_name,
- index_path
-):
- pth_path = os.path.join(configs["weights_path"], pth_name)
-
- if (
- not pth_name or
- not os.path.exists(pth_path) or
- not pth_name.endswith((".pth", ".onnx"))
- ):
- return gr_warning(translations["provide_file"].format(filename=translations["model"]))
-
- zip_file_path = os.path.join(configs["logs_path"], modelname, modelname + ".zip")
- gr_info(translations["start"].format(start=translations["zip"]))
-
- with zipfile.ZipFile(zip_file_path, 'w') as zipf:
- zipf.write(pth_path, os.path.basename(pth_path))
- if index_path: zipf.write(index_path, os.path.basename(index_path))
-
- gr_info(translations["success"])
-
- return {
- "visible": True,
- "value": zip_file_path,
- "__type__": "update"
- }
-
-def fetch_pretrained_data():
- try:
- response = requests.get(
- codecs.decode(
- "uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/wfba/phfgbz_cergenvarq.wfba",
- "rot13"
- )
- )
- response.raise_for_status()
-
- return response.json()
- except:
- return {}
-
-def update_sample_rate_dropdown(model):
- data = fetch_pretrained_data()
-
- if model != translations["success"]:
- return {
- "choices": list(data[model].keys()),
- "value": list(data[model].keys())[0],
- "__type__": "update"
- }
\ No newline at end of file
diff --git a/main/app/core/realtime.py b/main/app/core/realtime.py
deleted file mode 100644
index 56e2dd83655eee445a031e0bf20d4e302b8bfcbc..0000000000000000000000000000000000000000
--- a/main/app/core/realtime.py
+++ /dev/null
@@ -1,1142 +0,0 @@
-import os
-import sys
-import time
-
-sys.path.append(os.getcwd())
-
-from main.app.core.ui import gr_info, gr_warning
-from main.app.variables import translations, configs, config, logger
-
-running, callbacks, audio_manager = False, None, None
-
-PIPELINE_SAMPLE_RATE = 16000
-
-interactive_true = {"interactive": True, "__type__": "update"}
-interactive_false = {"interactive": False, "__type__": "update"}
-callbacks_kwargs = {}
-
-js_code = """
-window._activeStream = null;
-window._audioCtx = null;
-window._workletNode = null;
-window._playbackNode = null;
-window._ws = null;
-window.OutputAudioRoute = null;
-window.MonitorAudioRoute = null;
-window.lastSend = 0;
-window.responseMs = 0;
-
-function setStatus(msg, use_alert = true) {
- const realtimeStatus = document.querySelector("#realtime-status-info h2.output-class");
- if (use_alert) alert(msg);
-
- if (realtimeStatus) {
- realtimeStatus.innerText = msg;
- realtimeStatus.style.whiteSpace = "nowrap";
- realtimeStatus.style.textAlign = "center";
- }
-}
-
-async function addModuleFromString(ctx, codeStr) {
- const blob = new Blob([codeStr], {type: 'application/javascript'});
- const url = URL.createObjectURL(blob);
-
- await ctx.audioWorklet.addModule(url);
- URL.revokeObjectURL(url);
-};
-
-function createOutputRoute(audioCtx, playbackNode, sinkId, gainValue = 1.0) {
- const dest = audioCtx.createMediaStreamDestination();
- const gainNode = audioCtx.createGain();
- gainNode.gain.value = gainValue;
-
- playbackNode.connect(gainNode);
- gainNode.connect(dest);
-
- const el = document.createElement('audio');
- el.autoplay = true;
- el.srcObject = dest.stream;
- el.style.display = 'none';
- document.body.appendChild(el);
-
- if (el.setSinkId) el.setSinkId(sinkId).catch(err => console.error(err));
- return { dest, gainNode, el };
-}
-
-const inputWorkletSource = `
- class InputProcessor extends AudioWorkletProcessor {
- constructor() {
- super();
- this.buffer = new Float32Array(0);
- this.block_frame = 128;
- this.port.onmessage = (e) => {
- if (e.data && e.data.block_frame) this.block_frame = e.data.block_frame;
- };
- }
-
- process(inputs) {
- const input = inputs[0];
- if (!input || !input[0]) return true;
- const frame = input[0];
-
- const newBuf = new Float32Array(this.buffer.length + frame.length);
- newBuf.set(this.buffer, 0);
- newBuf.set(frame, this.buffer.length);
- this.buffer = newBuf;
-
- while (this.buffer.length >= this.block_frame) {
- const chunk = this.buffer.slice(0, this.block_frame);
-
- this.port.postMessage({chunk}, [chunk.buffer]);
- this.buffer = this.buffer.slice(this.block_frame);
- }
-
- return true;
- }
- }
- registerProcessor('input-processor', InputProcessor);
- `;
-
- const playbackWorkletSource = `
- class PlaybackProcessor extends AudioWorkletProcessor {
- constructor(options) {
- super(options);
- const bufferSize = options.processorOptions && options.processorOptions.bufferSize ? options.processorOptions.bufferSize: 98304;
- this.buffer = new Float32Array(bufferSize);
- this.bufferCapacity = bufferSize;
- this.writePointer = 0;
- this.readPointer = 0;
- this.availableSamples = 0;
- this.port.onmessage = (e) => {
- if (e.data && e.data.chunk) {
- const chunk = new Float32Array(e.data.chunk);
- const chunkSize = chunk.length;
-
- if (this.availableSamples + chunkSize > this.bufferCapacity) return;
-
- for (let i = 0; i < chunkSize; i++) {
- this.buffer[this.writePointer] = chunk[i];
- this.writePointer = (this.writePointer + 1) % this.bufferCapacity;
- }
-
- this.availableSamples += chunkSize;
- }
- };
- }
-
- process(inputs, outputs) {
- const output = outputs[0];
- if (!output || !output[0]) return true;
-
- const frame = output[0];
- const frameSize = frame.length;
-
- if (this.availableSamples >= frameSize) {
- for (let i = 0; i < frameSize; i++) {
- frame[i] = this.buffer[this.readPointer];
- this.readPointer = (this.readPointer + 1) % this.bufferCapacity;
- }
- this.availableSamples -= frameSize;
- } else {
- frame.fill(0);
- }
-
- if (output.length > 1) output[1].set(output[0]);
- return true;
- }
- }
- registerProcessor('playback-processor', PlaybackProcessor);
- `;
-
-window.getAudioDevices = async function() {
- if (!navigator.mediaDevices) {
- setStatus("__MEDIA_DEVICES__");
- return {"inputs": {}, "outputs": {}};
- }
-
- try {
- await navigator.mediaDevices.getUserMedia({ audio: true });
- } catch (err) {
- console.error(err);
- setStatus("__MIC_INACCESSIBLE__")
-
- return {"inputs": {}, "outputs": {}};
- }
-
- const devices = await navigator.mediaDevices.enumerateDevices();
- const inputs = {};
- const outputs = {};
-
- for (const device of devices) {
- if (device.kind === "audioinput") {
- inputs[device.label] = device.deviceId
- } else if (device.kind === "audiooutput") {
- outputs[device.label] = device.deviceId
- }
- }
-
- if (!Object.keys(inputs).length && !Object.keys(outputs).length) return {"inputs": {}, "outputs": {}};
- return {"inputs": inputs, "outputs": outputs};
-};
-
-window.StreamAudioRealtime = async function(
- monitor,
- vad_enabled,
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- input_audio_gain,
- output_audio_gain,
- monitor_audio_gain,
- chunk_size,
- pitch,
- model_pth,
- model_index,
- index_strength,
- predictor_onnx,
- f0_method,
- hop_length,
- embed_mode,
- embedders,
- custom_embedders,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- exclusive_mode,
- post_process,
- sid,
- noise_scale,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- nprobe
-) {
- const SampleRate = 48000;
- const ReadChunkSize = Math.round(chunk_size * SampleRate / 1000 / 128);
- const block_frame = parseInt(ReadChunkSize) * 128;
- const ButtonState = { start_button: true, stop_button: false };
- const devices = await window.getAudioDevices();
-
- input_audio_device = devices["inputs"][input_audio_device];
- output_audio_device = devices["outputs"][output_audio_device];
- if (monitor && devices["outputs"][monitor_output_device]) monitor_output_device = devices["outputs"][monitor_output_device];
-
- try {
- if (!input_audio_device || !output_audio_device) {
- setStatus("__PROVIDE_AUDIO_DEVICE__");
- return ButtonState;
- }
-
- if (monitor && !monitor_output_device) {
- setStatus("__PROVIDE_MONITOR_DEVICE__");
- return ButtonState;
- }
-
- if (!model_pth) {
- setStatus("__PROVIDE_MODEL__")
- return ButtonState;
- }
-
- setStatus("__START_REALTIME__", false)
-
- const stream = await navigator.mediaDevices.getUserMedia({
- audio: {
- deviceId: { exact: input_audio_device },
- channelCount: 1,
- sampleRate: SampleRate,
- echoCancellation: !exclusive_mode,
- noiseSuppression: !exclusive_mode,
- autoGainControl: !exclusive_mode
- }
- });
-
- let latencyHint = "playback";
- if (exclusive_mode) latencyHint = "interactive";
-
- window._activeStream = stream;
- window._audioCtx = new AudioContext({ sampleRate: SampleRate, latencyHint: latencyHint });
-
- await addModuleFromString(window._audioCtx, inputWorkletSource);
- await addModuleFromString(window._audioCtx, playbackWorkletSource);
-
- const src = window._audioCtx.createMediaStreamSource(stream);
- const inputNode = new AudioWorkletNode(window._audioCtx, 'input-processor');
- const playbackNode = new AudioWorkletNode(window._audioCtx, 'playback-processor', {
- processorOptions: {
- bufferSize: block_frame * 2
- }
- });
-
- inputNode.port.postMessage({ block_frame: block_frame });
- src.connect(inputNode);
-
- window.OutputAudioRoute = createOutputRoute(window._audioCtx, playbackNode, output_audio_device, output_audio_gain / 100);
- if (monitor && monitor_output_device) window.MonitorAudioRoute = createOutputRoute(window._audioCtx, playbackNode, monitor_output_device, monitor_audio_gain / 100);
-
- const protocol = (location.protocol === "https:") ? "wss:" : "ws:";
- const wsUrl = protocol + '//' + location.hostname + `:${location.port}` + '/api/ws-audio';
- const ws = new WebSocket(wsUrl);
-
- ButtonState.start_button = false;
- ButtonState.stop_button = true;
-
- ws.binaryType = "arraybuffer";
- window._ws = ws;
-
- ws.onopen = () => {
- console.log("__WS_CONNECTED__")
-
- ws.send(
- JSON.stringify({
- type: 'init',
- chunk_size: ReadChunkSize,
- embedders: embedders,
- model_pth: model_pth,
- custom_embedders: custom_embedders,
- cross_fade_overlap_size: cross_fade_overlap_size,
- extra_convert_size: extra_convert_size,
- model_index: model_index,
- f0_method: f0_method,
- predictor_onnx: predictor_onnx,
- embedders_mode: embed_mode,
- hop_length: hop_length,
- silent_threshold: silent_threshold,
- vad_enabled: vad_enabled,
- vad_sensitivity: vad_sensitivity,
- vad_frame_ms: vad_frame_ms,
- clean_audio: clean_audio,
- clean_strength: clean_strength,
- f0_up_key: pitch,
- index_rate: index_strength,
- protect: protect,
- filter_radius: filter_radius,
- rms_mix_rate: rms_mix_rate,
- f0_autotune: f0_autotune,
- f0_autotune_strength: f0_autotune_strength,
- proposal_pitch: proposal_pitch,
- proposal_pitch_threshold: proposal_pitch_threshold,
- input_audio_gain: input_audio_gain,
- post_process: post_process,
- sid: sid,
- noise_scale: noise_scale,
- embedders_mix: embedders_mix,
- embedders_mix_layers: embedders_mix_layers,
- embedders_mix_ratio: embedders_mix_ratio,
- nprobe: nprobe,
- kwargs: {
- chorus: chorus,
- distortion: distortion,
- reverb: reverb,
- pitch_shift: pitch_shift,
- delay: delay,
- compressor: compressor,
- limiter: limiter,
- gain: gain,
- bitcrush: bitcrush,
- clipping: clipping,
- phaser: phaser,
- chorus_depth: chorus_depth,
- chorus_rate: chorus_rate,
- chorus_mix: chorus_mix,
- chorus_delay: chorus_center_delay,
- chorus_feedback: chorus_feedback,
- distortion_gain: distortion_gain,
- reverb_room_size: reverb_room_size,
- reverb_damping: reverb_damping,
- reverb_wet_level: reverb_wet_gain,
- reverb_dry_level: reverb_dry_gain,
- reverb_width: reverb_width,
- reverb_freeze_mode: reverb_freeze_mode,
- pitch_shift_semitones: pitch_shift_semitones,
- delay_seconds: delay_seconds,
- delay_feedback: delay_feedback,
- delay_mix: delay_mix,
- compressor_threshold: compressor_threshold,
- compressor_ratio: compressor_ratio,
- compressor_attack: compressor_attack,
- compressor_release: compressor_release,
- limiter_threshold: limiter_threshold,
- limiter_release: limiter_release_time,
- gain_db: gain_db,
- bitcrush_bit_depth: bitcrush_bit_depth,
- clipping_threshold: clipping_threshold,
- phaser_rate_hz: phaser_rate_hz,
- phaser_depth: phaser_depth,
- phaser_centre_frequency_hz: phaser_centre_frequency_hz,
- phaser_feedback: phaser_feedback,
- phaser_mix: phaser_mix
- }
- })
- );
- };
-
- inputNode.port.onmessage = (e) => {
- const chunk = e.data && e.data.chunk;
-
- if (!chunk) return;
- if (ws.readyState === WebSocket.OPEN) {
- window.lastSend = performance.now();
- ws.send(chunk);
- }
- };
-
- ws.onmessage = (ev) => {
- if (typeof ev.data === 'string') {
- const msg = JSON.parse(ev.data);
-
- if (msg.type === 'latency') setStatus(`__LATENCY__: ${msg.value.toFixed(2)} ms | __VOLUME__: ${msg.volume.toFixed(2)} dB | __RESPONSE__: ${window.responseMs.toFixed(2)} ms`, use_alert=false)
- if (msg.type === 'warnings') {
- setStatus(msg.value);
- StopAudioStream();
- }
-
- return;
- }
-
- const ab = ev.data;
- playbackNode.port.postMessage({ chunk: ab }, [ab]);
- window.responseMs = performance.now() - window.lastSend;
- };
-
- ws.onclose = () => console.log("__WS_CLOSED__");
- window._workletNode = inputNode;
- window._playbackNode = playbackNode;
-
- if (window._audioCtx.state === 'suspended') await window._audioCtx.resume();
-
- console.log("__REALTIME_STARTED__");
- return ButtonState;
- } catch (err) {
- console.error("__ERROR__", err);
- alert("__ERROR__" + err.message);
-
- return StopAudioStream();
- }
-};
-
-window.ChangeConfig = async function(value, key, if_kwargs=false) {
- if (key === "output_audio_gain") {
- window.OutputAudioRoute.gainNode.gain.value = value / 100
- } else if (key == "monitor_audio_gain") {
- if (window.MonitorAudioRoute) window.MonitorAudioRoute.gainNode.gain.value = value / 100
- } else {
- const protocol = (location.protocol === "https:") ? "wss:" : "ws:";
- const wsUrl = protocol + '//' + location.hostname + `:${location.port}` + '/api/change-config';
- const ws = new WebSocket(wsUrl);
-
- ws.binaryType = "arraybuffer";
- ws.onopen = () => {
- ws.send(
- JSON.stringify({
- type: 'init',
- key: key,
- value: value,
- if_kwargs: if_kwargs
- })
- );
-
- ws.close();
- };
- }
-}
-
-window.StopAudioStream = async function() {
- try {
- if (window._ws) {
- window._ws.close();
- window._ws = null;
- }
-
- if (window._activeStream) {
- window._activeStream.getTracks().forEach(t => t.stop());
- window._activeStream = null;
- }
-
- if (window._workletNode) {
- window._workletNode.disconnect();
- window._workletNode = null;
- }
-
- if (window._playbackNode) {
- window._playbackNode.disconnect();
- window._playbackNode = null;
- }
-
- if (window._audioCtx) {
- await window._audioCtx.close();
- window._audioCtx = null;
- }
-
- if (window.OutputAudioRoute) window.OutputAudioRoute = null;
- if (window.MonitorAudioRoute) window.MonitorAudioRoute = null;
-
- document.querySelectorAll('audio').forEach(a => a.remove());
- setStatus("__REALTIME_HAS_STOP__", false);
-
- return {"start_button": true, "stop_button": false};
- } catch (e) {
- setStatus(`__ERROR__ ${e}`);
-
- return {"start_button": false, "stop_button": true}
- }
-};
-
-window.SoundfileRecordAudio = async function (RecordButton, RecordAudioPath, ExportFormat) {
- const protocol = (location.protocol === "https:") ? "https:" : "http:";
- const url = protocol + '//' + location.hostname + `:${location.port}` + '/api/record';
-
- const res = await fetch(url, {
- method: "POST",
- headers: {
- "Content-Type": "application/json"
- },
- body: JSON.stringify({
- record_button: RecordButton,
- record_audio_path: RecordAudioPath,
- export_format: ExportFormat
- })
- });
-
- const msg = await res.json();
-
- if (msg.type === "info" || msg.type === "warnings") {
- alert(msg.value);
-
- return {
- "button": msg.button,
- "path": msg.path
- };
- }
-};
-""".replace(
- "__MEDIA_DEVICES__", translations["media_devices"]
-).replace(
- "__MIC_INACCESSIBLE__", translations["mic_inaccessible"]
-).replace(
- "__PROVIDE_AUDIO_DEVICE__", translations["provide_audio_device"]
-).replace(
- "__PROVIDE_MONITOR_DEVICE__", translations["provide_monitor_device"]
-).replace(
- "__START_REALTIME__", translations["start_realtime"]
-).replace(
- "__LATENCY__", translations['latency']
-).replace(
- "__WS_CONNECTED__", translations["ws_connected"]
-).replace(
- "__WS_CLOSED__", translations["ws_closed"]
-).replace(
- "__REALTIME_STARTED__", translations["realtime_is_ready"]
-).replace(
- "__ERROR__", translations["error_occurred"].format(e="")
-).replace(
- "__REALTIME_HAS_STOP__", translations["realtime_has_stop"]
-).replace(
- "__PROVIDE_MODEL__", translations["provide_file"].format(filename=translations["model"])
-).replace(
- "__VOLUME__", translations["volume"]
-).replace(
- "__RESPONSE__", translations["response"]
-)
-
-def realtime_start(
- monitor,
- exclusive_mode,
- vad_enabled,
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- input_audio_gain,
- output_audio_gain,
- monitor_audio_gain,
- input_asio_channels,
- output_asio_channels,
- monitor_asio_channels,
- input_audio_sample_rate,
- output_audio_sample_rate,
- monitor_audio_sample_rate,
- chunk_size,
- pitch,
- model_pth,
- model_index,
- index_strength,
- predictor_onnx,
- f0_method,
- hop_length,
- embed_mode,
- embedders,
- custom_embedders,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- post_process,
- sid,
- noise_scale,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- nprobe = 1
-):
- global running, callbacks, audio_manager, callbacks_kwargs
- running = True
-
- gr_info(translations["start_realtime"])
-
- yield (
- translations["start_realtime"],
- interactive_false,
- interactive_true
- )
-
- if not input_audio_device or not output_audio_device:
- gr_warning(translations["provide_audio_device"])
-
- yield (
- translations["provide_audio_device"],
- interactive_true,
- interactive_false
- )
- return
-
- if monitor and not monitor_output_device:
- gr_warning(translations["provide_monitor_device"])
-
- yield (
- translations["provide_monitor_device"],
- interactive_true,
- interactive_false
- )
- return
-
- model_pth = os.path.join(configs["weights_path"], model_pth) if not os.path.exists(model_pth) else model_pth
- embedder_model = (embedders if embedders != "custom" else custom_embedders)
-
- if (
- not model_pth or
- not os.path.exists(model_pth) or
- os.path.isdir(model_pth) or
- not model_pth.endswith((".pth", ".onnx"))
- ):
- gr_warning(translations["provide_file"].format(filename=translations["model"]))
-
- yield (
- translations["provide_file"].format(filename=translations["model"]),
- interactive_true,
- interactive_false
- )
- return
-
- input_is_asio = "ASIO" in input_audio_device
- output_is_asio = "ASIO" in output_audio_device
- monitor_is_asio = "ASIO" in monitor_output_device
-
- if input_is_asio or output_is_asio or monitor_is_asio:
- import main.library.audio.sounddevice as sd
-
- sd.terminate()
- sd.initialize()
-
- import main.app.core.ui as ui
-
- input_device_id = ui.input_channels_map[input_audio_device][0]
- output_device_id = ui.output_channels_map[output_audio_device][0]
- output_monitor_id = ui.output_channels_map[monitor_output_device][0] if monitor else None
-
- input_audio_gain /= 100.0
- output_audio_gain /= 100.0
- monitor_audio_gain /= 100.0
-
- chunk_size = int(chunk_size * input_audio_sample_rate / 1000 / 128)
-
- from main.inference.realtime.callbacks import AudioCallbacks
-
- callbacks_kwargs = {
- "pass_through": False,
- "read_chunk_size": chunk_size,
- "cross_fade_overlap_size": cross_fade_overlap_size,
- "input_sample_rate": input_audio_sample_rate,
- "output_sample_rate": input_audio_sample_rate,
- "extra_convert_size": extra_convert_size,
- "model_path": model_pth,
- "index_path": model_index,
- "f0_method": f0_method,
- "predictor_onnx": predictor_onnx,
- "embedder_model": embedder_model,
- "embedders_mode": embed_mode,
- "sample_rate": PIPELINE_SAMPLE_RATE,
- "hop_length": hop_length,
- "silent_threshold": silent_threshold,
- "f0_up_key": pitch,
- "index_rate": index_strength,
- "protect": protect,
- "filter_radius": filter_radius,
- "rms_mix_rate": rms_mix_rate,
- "f0_autotune": f0_autotune,
- "f0_autotune_strength": f0_autotune_strength,
- "proposal_pitch": proposal_pitch,
- "proposal_pitch_threshold": proposal_pitch_threshold,
- "input_audio_gain": input_audio_gain,
- "output_audio_gain": output_audio_gain,
- "monitor_audio_gain": monitor_audio_gain,
- "monitor": monitor,
- "vad_enabled": vad_enabled,
- "vad_sensitivity": vad_sensitivity,
- "vad_frame_ms": vad_frame_ms,
- "clean_audio": clean_audio,
- "clean_strength": clean_strength,
- "post_process": post_process,
- "sid": sid,
- "noise_scale": noise_scale,
- "nprobe": nprobe,
- "embedders_mix": embedders_mix,
- "embedders_mix_layers": embedders_mix_layers,
- "embedders_mix_ratio": embedders_mix_ratio,
- "kwargs": {
- "chorus": chorus,
- "distortion": distortion,
- "reverb": reverb,
- "pitch_shift": pitch_shift,
- "delay": delay,
- "compressor": compressor,
- "limiter": limiter,
- "gain": gain,
- "bitcrush": bitcrush,
- "clipping": clipping,
- "phaser": phaser,
- "chorus_depth": chorus_depth,
- "chorus_rate": chorus_rate,
- "chorus_mix": chorus_mix,
- "chorus_delay": chorus_center_delay,
- "chorus_feedback": chorus_feedback,
- "distortion_gain": distortion_gain,
- "reverb_room_size": reverb_room_size,
- "reverb_damping": reverb_damping,
- "reverb_wet_level": reverb_wet_gain,
- "reverb_dry_level": reverb_dry_gain,
- "reverb_width": reverb_width,
- "reverb_freeze_mode": reverb_freeze_mode,
- "pitch_shift_semitones": pitch_shift_semitones,
- "delay_seconds": delay_seconds,
- "delay_feedback": delay_feedback,
- "delay_mix": delay_mix,
- "compressor_threshold": compressor_threshold,
- "compressor_ratio": compressor_ratio,
- "compressor_attack": compressor_attack,
- "compressor_release": compressor_release,
- "limiter_threshold": limiter_threshold,
- "limiter_release": limiter_release_time,
- "gain_db": gain_db,
- "bitcrush_bit_depth": bitcrush_bit_depth,
- "clipping_threshold": clipping_threshold,
- "phaser_rate_hz": phaser_rate_hz,
- "phaser_depth": phaser_depth,
- "phaser_centre_frequency_hz": phaser_centre_frequency_hz,
- "phaser_feedback": phaser_feedback,
- "phaser_mix": phaser_mix
- }
- }
-
- callbacks = AudioCallbacks(**callbacks_kwargs)
-
- def stop_with_error():
- global running
-
- realtime_stop()
- running = False
-
- return (
- translations["realtime_has_stop_with_error"],
- interactive_true,
- interactive_false
- )
-
- try:
- audio_manager = callbacks.audio
- audio_manager.start(
- input_device_id=input_device_id,
- output_device_id=output_device_id,
- output_monitor_id=output_monitor_id,
- exclusive_mode=exclusive_mode,
- asio_input_channel=input_asio_channels,
- asio_output_channel=output_asio_channels,
- asio_output_monitor_channel=monitor_asio_channels,
- read_chunk_size=chunk_size,
- input_audio_sample_rate=input_audio_sample_rate,
- output_audio_sample_rate=output_audio_sample_rate,
- output_monitor_sample_rate=monitor_audio_sample_rate
- )
- except Exception as e:
- import traceback
-
- logger.error(e)
- logger.debug(traceback.format_exc())
-
- return stop_with_error()
-
- gr_info(translations["realtime_is_ready"])
-
- while running and callbacks is not None and audio_manager is not None:
- time.sleep(0.1)
- if hasattr(callbacks, "audio") and hasattr(callbacks.audio, "performance") and hasattr(callbacks.audio, "volume"):
- yield (
- f"{translations['latency']}: {callbacks.audio.performance:.2f} ms | {translations['volume']}: {callbacks.audio.volume:.2f} dB",
- interactive_false,
- interactive_true
- )
-
- return (
- translations["realtime_has_stop"],
- interactive_true,
- interactive_false
- )
-
-def change_callbacks_config():
- global callbacks
-
- if running and audio_manager is not None and callbacks is not None:
- crossfade_frame = int(callbacks_kwargs.get("cross_fade_overlap_size", 0.1) * callbacks.input_sample_rate)
- extra_frame = int(callbacks_kwargs.get("extra_convert_size", 0.5) * callbacks.input_sample_rate)
-
- if (
- callbacks.vc.crossfade_frame != crossfade_frame or
- callbacks.vc.extra_frame != extra_frame
- ):
- del (
- callbacks.vc.fade_in_window,
- callbacks.vc.fade_out_window,
- callbacks.vc.sola_buffer
- )
-
- callbacks.vc.vc_model.realloc(
- callbacks.vc.block_frame,
- callbacks.vc.extra_frame,
- callbacks.vc.crossfade_frame,
- callbacks.vc.sola_search_frame,
- )
- callbacks.vc.generate_strength()
-
- callbacks.vc.vc_model.input_sensitivity = 10 ** (callbacks_kwargs.get("silent_threshold", -90) / 20)
-
- vad_enabled = callbacks_kwargs.get("vad_enabled", True)
- sensitivity_mode = callbacks_kwargs.get("vad_sensitivity", 3)
- vad_frame_ms = callbacks_kwargs.get("vad_frame_ms", 30)
-
- if vad_enabled is False:
- callbacks.vc.vc_model.vad = None
- elif vad_enabled and callbacks.vc.vc_model.vad is None:
- from main.inference.realtime.vad_utils import VADProcessor
-
- callbacks.vc.vc_model.vad = VADProcessor(
- sensitivity_mode=sensitivity_mode,
- sample_rate=callbacks.vc.vc_model.sample_rate,
- frame_duration_ms=vad_frame_ms
- )
-
- if callbacks.vc.vc_model.vad is not None:
- callbacks.vc.vc_model.vad.vad.set_mode(sensitivity_mode)
- callbacks.vc.vc_model.vad.frame_length = int(callbacks.vc.vc_model.sample_rate * (vad_frame_ms / 1000.0))
-
- clean_audio = callbacks_kwargs.get("clean_audio", False)
- clean_strength = callbacks_kwargs.get("clean_strength", 0.5)
-
- if clean_audio is False:
- callbacks.vc.vc_model.tg = None
- elif clean_audio and callbacks.vc.vc_model.tg is None:
- from main.library.audio.noisereduce import TorchGate
-
- callbacks.vc.vc_model.tg = (
- TorchGate(
- callbacks.vc.vc_model.pipeline.tgt_sr,
- prop_decrease=clean_strength,
- ).to(config.device)
- )
-
- if callbacks.vc.vc_model.tg is not None:
- callbacks.vc.vc_model.tg.prop_decrease = clean_strength
-
- post_process = callbacks_kwargs.get("post_process", False)
- kwargs = callbacks_kwargs.get("kwargs", {})
-
- if post_process is False:
- callbacks.vc.vc_model.board = None
- callbacks.vc.vc_model.kwargs = None
- elif post_process and callbacks.vc.vc_model.kwargs != kwargs:
- new_board = callbacks.vc.vc_model.setup_pedalboard(**kwargs)
- callbacks.vc.vc_model.board = new_board
- callbacks.vc.vc_model.kwargs = kwargs.copy()
-
- callbacks.audio.f0_up_key = callbacks_kwargs.get("f0_up_key", 0)
- callbacks.audio.index_rate = callbacks_kwargs.get("index_rate", 0.75)
- callbacks.audio.protect = callbacks_kwargs.get("protect", 0.5)
- callbacks.audio.rms_mix_rate = callbacks_kwargs.get("rms_mix_rate", 1)
-
- callbacks.audio.f0_autotune = callbacks_kwargs.get("f0_autotune", False)
- callbacks.audio.f0_autotune_strength = callbacks_kwargs.get("f0_autotune_strength", 1.0)
- callbacks.audio.proposal_pitch = callbacks_kwargs.get("proposal_pitch", False)
- callbacks.audio.proposal_pitch_threshold = callbacks_kwargs.get("proposal_pitch_threshold", 155.0)
-
- callbacks.audio.input_audio_gain = callbacks_kwargs.get("input_audio_gain", 1.0)
- callbacks.audio.output_audio_gain = callbacks_kwargs.get("output_audio_gain", 1.0)
- callbacks.audio.monitor_audio_gain = callbacks_kwargs.get("monitor_audio_gain", 1.0)
-
- callbacks.audio.embedders_mix = callbacks_kwargs.get("embedders_mix", False)
- callbacks.audio.embedders_mix_layers = callbacks_kwargs.get("embedders_mix_layers", 9)
- callbacks.audio.embedders_mix_ratio = callbacks_kwargs.get("embedders_mix_ratio", 0.5)
-
- noise_scale = callbacks_kwargs.get("noise_scale", 0.35)
- model_pth = callbacks_kwargs.get("model_path", callbacks.vc.vc_model.model_path)
- model_pth = os.path.join(configs["weights_path"], model_pth) if not os.path.exists(model_pth) else model_pth
-
- if model_pth and callbacks.vc.vc_model.model_path != model_pth:
- callbacks.vc.vc_model.model_path = model_pth
- callbacks.vc.vc_model.pipeline.vc.setup(model_pth, noise_scale)
- callbacks.vc.vc_model.pipeline.version = callbacks.vc.vc_model.pipeline.vc.version
- callbacks.vc.vc_model.pipeline.energy = callbacks.vc.vc_model.pipeline.vc.energy
- callbacks.vc.vc_model.pipeline.rms = callbacks.vc.vc_model.pipeline.setup_rms() if callbacks.vc.vc_model.pipeline.vc.energy else None
-
- sid = callbacks_kwargs.get("sid", callbacks.vc.vc_model.pipeline.sid)
- if callbacks.vc.vc_model.pipeline.sid != sid:
- import torch
- callbacks.vc.vc_model.pipeline.torch_sid = torch.tensor(
- [sid], device=callbacks.vc.vc_model.pipeline.device, dtype=torch.int64
- )
-
- index_path = callbacks_kwargs.get("index_path", None)
- if index_path:
- if callbacks.vc.vc_model.index_path != index_path:
- from main.library.utils import load_faiss_index
-
- nprobe = callbacks_kwargs.get("nprobe", 1)
- index, index_reconstruct = load_faiss_index(
- index_path.strip().strip('"').strip("\n").strip('"').strip().replace("trained", "added"),
- nprobe=nprobe
- )
-
- callbacks.vc.vc_model.pipeline.index = index
- if callbacks.vc.vc_model.pipeline.index.index is not None: callbacks.vc.vc_model.pipeline.index.index.nprobe = nprobe
- callbacks.vc.vc_model.pipeline.big_tsr = index_reconstruct
- callbacks.vc.vc_model.index_path = index_path
- else:
- callbacks.vc.vc_model.pipeline.index = None
- callbacks.vc.vc_model.pipeline.big_tsr = None
- callbacks.vc.vc_model.index_path = None
-
- f0_method = callbacks_kwargs.get("f0_method", callbacks.vc.vc_model.pipeline.f0_method)
- predictor_onnx = callbacks_kwargs.get("predictor_onnx", callbacks.vc.vc_model.pipeline.predictor.predictor_onnx)
- embedders = callbacks_kwargs.get("embedder_model", callbacks.vc.vc_model.embedder_model)
- embedders_mode = callbacks_kwargs.get("embedders_mode", callbacks.vc.vc_model.embedders_mode)
- custom_embedders = callbacks_kwargs.get("embedder_model_custom", None)
- embedder_model = (embedders if embedders != "custom" else custom_embedders)
-
- from main.library.utils import check_assets
- check_assets(f0_method, embedders, predictor_onnx, embedders_mode)
-
- if (
- callbacks.vc.vc_model.pipeline.f0_method != f0_method or
- callbacks.vc.vc_model.pipeline.predictor.predictor_onnx != predictor_onnx
- ):
- old_predictor = callbacks.vc.vc_model.pipeline.predictor
- del old_predictor
-
- callbacks.vc.vc_model.pipeline.predictor = callbacks.vc.vc_model.pipeline.setup_predictor(PIPELINE_SAMPLE_RATE, callbacks_kwargs.get("hop_length", callbacks.vc.vc_model.pipeline.predictor.hop_length), predictor_onnx)
- callbacks.vc.vc_model.pipeline.f0_method = f0_method
- callbacks.vc.vc_model.pipeline.predictor.predictor_onnx = predictor_onnx
-
- if embedder_model:
- if (
- callbacks.vc.vc_model.embedder_model != embedder_model or
- callbacks.vc.vc_model.embedders_mode != embedders_mode
- ):
- old_embedder = callbacks.vc.vc_model.pipeline.embedder
- del old_embedder
-
- callbacks.vc.vc_model.pipeline.embedder = callbacks.vc.vc_model.pipeline.setup_embedder(embedder_model, embedders_mode)
- callbacks.vc.vc_model.embedder_model = embedder_model
- callbacks.vc.vc_model.embedders_mode = embedders_mode
-
- if (
- callbacks.vc.vc_model.pipeline.vc.architecture == "SVC" and
- callbacks.vc.vc_model.pipeline.vc.net_g.noise_scale != noise_scale
- ):
- callbacks.vc.vc_model.pipeline.vc.net_g.noise_scale = noise_scale
-
-def change_config(value, key, if_kwargs=False):
- global callbacks_kwargs
-
- if running and audio_manager is not None and callbacks is not None:
- if if_kwargs:
- callbacks_kwargs["kwargs"][key] = value
- else:
- callbacks_kwargs[key] = value
-
- change_callbacks_config()
-
-def realtime_stop():
- global running, callbacks, audio_manager
-
- if running and audio_manager is not None and callbacks is not None:
- gr_info(translations["stop_realtime"])
-
- audio_manager.stop()
- running = False
-
- if hasattr(callbacks.audio, "performance"): del callbacks.audio.performance
- if hasattr(callbacks.audio, "volume"): del callbacks.audio.volume
-
- del callbacks.vc.vc_model.pipeline, callbacks.vc.vc_model
- del audio_manager, callbacks
-
- audio_manager = callbacks = None
- gr_info(translations["realtime_has_stop"])
-
- from main.library.utils import clear_gpu_cache
- clear_gpu_cache()
-
- return (
- translations["realtime_has_stop"],
- interactive_true,
- interactive_false
- )
- else:
- gr_warning(translations["realtime_not_found"])
-
- return (
- translations["realtime_not_found"],
- interactive_true,
- interactive_false
- )
-
-def soundfile_record_audio(
- record_button,
- record_audio_path = None,
- export_format = "wav"
-):
- global callbacks
-
- if running and audio_manager is not None and callbacks is not None:
- if record_button == translations["start_record"]:
- gr_info(translations["starting_record"])
-
- if not record_audio_path:
- record_audio_path = os.path.join(configs["audios_path"], "record_audio.wav")
-
- callbacks.vc.record_audio = True
- callbacks.vc.record_audio_path = record_audio_path
- callbacks.vc.export_format = export_format
- callbacks.vc.setup_soundfile_record()
-
- return translations["stop_record"], None
- else:
- gr_info(translations["stopping_record"])
-
- callbacks.vc.record_audio = False
- callbacks.vc.record_audio_path = None
- callbacks.vc.soundfile = None
-
- return translations["start_record"], record_audio_path
-
- gr_warning(translations["realtime_not_found"])
- return translations["start_record"], None
\ No newline at end of file
diff --git a/main/app/core/restart.py b/main/app/core/restart.py
deleted file mode 100644
index 157fd096b3afa3b3bb4903808c04fac5ca9ee860..0000000000000000000000000000000000000000
--- a/main/app/core/restart.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import os
-import sys
-import json
-import platform
-import subprocess
-
-sys.path.append(os.getcwd())
-
-from main.app.core.ui import gr_info
-from main.app.variables import python, translations, configs_json
-
-def restart_app(app):
- gr_info(translations["restart"])
- os.system("cls" if platform.system() == "Windows" else "clear")
-
- app.close()
- subprocess.run([
- python,
- os.path.join("main", "app", "app.py")
- ] + [arg for arg in sys.argv[1:] if arg != "--open"])
-
-def restart(lang, theme, font, app):
- configs = json.load(open(configs_json, "r"))
-
- if lang != configs["language"]:
- configs["language"] = lang
-
- with open(configs_json, "w") as f:
- json.dump(configs, f, indent=4)
-
- if theme != configs["theme"]:
- configs["theme"] = theme
-
- with open(configs_json, "w") as f:
- json.dump(configs, f, indent=4)
-
- if font != configs["font"]:
- configs["font"] = font
-
- with open(configs_json, "w") as f:
- json.dump(configs, f, indent=4)
-
- restart_app(app)
\ No newline at end of file
diff --git a/main/app/core/separate.py b/main/app/core/separate.py
deleted file mode 100644
index b4c2e0fd4ac5a0bd2f1692e0e74027e4a5f7ee3f..0000000000000000000000000000000000000000
--- a/main/app/core/separate.py
+++ /dev/null
@@ -1,96 +0,0 @@
-import os
-import sys
-import subprocess
-
-sys.path.append(os.getcwd())
-
-from main.app.core.ui import gr_info, gr_warning
-from main.app.variables import python, translations, configs
-
-def separate_music(
- input_path,
- output_dirs,
- export_format,
- model_name,
- karaoke_model,
- reverb_model,
- denoise_model,
- sample_rate,
- shifts,
- batch_size,
- overlap,
- aggression,
- hop_length,
- window_size,
- segments_size,
- post_process_threshold,
- enable_tta,
- enable_denoise,
- high_end_process,
- enable_post_process,
- separate_backing,
- separate_reverb
-):
- output_dirs = os.path.dirname(output_dirs) or output_dirs
-
- if not input_path or not os.path.exists(input_path) or os.path.isdir(input_path):
- gr_warning(translations["input_not_valid"])
- return [None]*4
-
- if not os.path.exists(output_dirs):
- gr_warning(translations["output_not_valid"])
- return [None]*4
-
- if not os.path.exists(output_dirs): os.makedirs(output_dirs)
- gr_info(translations["start"].format(start=translations["separator_music"]))
-
- subprocess.run([
- python,
- configs["separate_path"],
- "--input_path", input_path,
- "--output_dirs", output_dirs,
- "--export_format", export_format,
- "--model_name", model_name,
- "--karaoke_model", karaoke_model,
- "--reverb_model", reverb_model,
- "--denoise_model", denoise_model,
- "--sample_rate", str(sample_rate),
- "--shifts", str(shifts),
- "--batch_size", str(batch_size),
- "--overlap", str(overlap),
- "--aggression", str(aggression),
- "--hop_length", str(hop_length),
- "--window_size", str(window_size),
- "--segments_size", str(segments_size),
- "--post_process_threshold", str(post_process_threshold),
- "--enable_tta", str(enable_tta),
- "--enable_denoise", str(enable_denoise),
- "--high_end_process", str(high_end_process),
- "--enable_post_process", str(enable_post_process),
- "--separate_backing", str(separate_backing),
- "--separate_reverb", str(separate_reverb),
- ])
-
- gr_info(translations["success"])
-
- filename, _ = os.path.splitext(os.path.basename(input_path))
- output_dirs = os.path.join(output_dirs, filename)
-
- return [
- os.path.join(
- output_dirs,
- f"Original_Vocals_No_Reverb.{export_format}" if separate_reverb else f"Original_Vocals.{export_format}"
- ),
- os.path.join(
- output_dirs,
- f"Instruments.{export_format}"
- ),
- os.path.join(
- output_dirs,
- f"Main_Vocals_No_Reverb.{export_format}" if separate_reverb else f"Main_Vocals.{export_format}"
- ) if separate_backing else None,
- os.path.join(
- output_dirs,
- f"Backing_Vocals.{export_format}"
- ) if separate_backing else None
- ] if os.path.isfile(input_path) else [None]*4
\ No newline at end of file
diff --git a/main/app/core/training.py b/main/app/core/training.py
deleted file mode 100644
index d4f5718708e65d7304ef5e04160c1159a1df7f62..0000000000000000000000000000000000000000
--- a/main/app/core/training.py
+++ /dev/null
@@ -1,590 +0,0 @@
-import os
-import sys
-import time
-import shutil
-import codecs
-import datetime
-import threading
-import subprocess
-
-sys.path.append(os.getcwd())
-
-from main.tools import huggingface
-from main.app.core.ui import gr_info, gr_warning
-from main.app.variables import python, translations, configs, file_types, logger
-
-def getname(path):
- return os.path.basename(path).replace(".py", "")
-
-def if_done(done, p):
- while 1:
- if p.poll() is None: time.sleep(0.5)
- else: break
-
- done[0] = True
-
-def log_read(done, name, start_time):
- log_file = os.path.join(configs["logs_path"], "app.log")
-
- def read_logs():
- logs = []
-
- with open(log_file, "r", encoding="utf-8") as f:
- for line in f:
- try:
- if ("DEBUG" in line or name not in line or line.strip() == ""): continue
- timestamp = datetime.datetime.strptime(line.split("|")[0].strip(), "%Y-%m-%d %H:%M:%S.%f")
- if timestamp >= start_time: logs.append(line)
- except ValueError:
- continue
- return "".join(logs)
-
- while 1:
- yield read_logs()
-
- time.sleep(1)
-
- if done[0]:
- break
-
- yield read_logs()
-
-def create_dataset(
- input_data,
- output_dirs,
- skip_seconds,
- skip_start_audios,
- skip_end_audios,
- separate,
- model_name,
- reverb_model,
- denoise_model,
- sample_rate,
- shifts,
- batch_size,
- overlap,
- aggression,
- hop_length,
- window_size,
- segments_size,
- post_process_threshold,
- enable_tta,
- enable_denoise,
- high_end_process,
- enable_post_process,
- separate_reverb,
- clean_dataset,
- clean_strength
-):
- gr_info(translations["start"].format(start=translations["create"]))
- start_time = datetime.datetime.now()
-
- p = subprocess.Popen([
- python,
- configs["create_dataset_path"],
- "--input_data", input_data,
- "--output_dirs", output_dirs,
- "--skip_seconds", str(skip_seconds),
- "--skip_start_audios", str(skip_start_audios),
- "--skip_end_audios", str(skip_end_audios),
- "--separate", str(separate),
- "--model_name", model_name,
- "--reverb_model", reverb_model,
- "--denoise_model", denoise_model,
- "--sample_rate", str(sample_rate),
- "--shifts", str(shifts),
- "--batch_size", str(batch_size),
- "--overlap", str(overlap),
- "--aggression", str(aggression),
- "--hop_length", str(hop_length),
- "--window_size", str(window_size),
- "--segments_size", str(segments_size),
- "--post_process_threshold", str(post_process_threshold),
- "--enable_tta", str(enable_tta),
- "--enable_denoise", str(enable_denoise),
- "--high_end_process", str(high_end_process),
- "--enable_post_process", str(enable_post_process),
- "--separate_reverb", str(separate_reverb),
- "--clean_dataset", str(clean_dataset),
- "--clean_strength", str(clean_strength),
- ])
-
- done = [False]
-
- threading.Thread(target=if_done, args=(done, p)).start()
-
- for log in log_read(done, getname(configs["create_dataset_path"]), start_time):
- yield log
-
-def create_reference(
- audio_path,
- reference_name,
- pitch_guidance,
- use_energy,
- version,
- embedder_model,
- embedders_mode,
- f0_method,
- predictor_onnx,
- f0_up_key,
- filter_radius,
- f0_autotune,
- f0_autotune_strength,
- proposal_pitch,
- proposal_pitch_threshold,
- alpha=0.5,
- embedders_mix = False,
- embedders_mix_layers = 9,
- embedders_mix_ratio = 0.5
-):
- gr_info(translations["start"].format(start=translations["create_reference"]))
- start_time = datetime.datetime.now()
-
- p = subprocess.Popen([
- python,
- configs["create_reference_path"],
- "--audio_path", audio_path,
- "--reference_name", reference_name,
- "--pitch_guidance", str(pitch_guidance),
- "--use_energy", str(use_energy),
- "--version", version,
- "--embedder_model", embedder_model,
- "--embedders_mode", embedders_mode,
- "--f0_method", f0_method,
- "--predictor_onnx", str(predictor_onnx),
- "--f0_up_key", str(f0_up_key),
- "--filter_radius", str(filter_radius),
- "--f0_autotune", str(f0_autotune),
- "--f0_autotune_strength", str(f0_autotune_strength),
- "--proposal_pitch", str(proposal_pitch),
- "--proposal_pitch_threshold", str(proposal_pitch_threshold),
- "--alpha", str(alpha),
- "--embedders_mix", str(embedders_mix),
- "--embedders_mix_layers", str(embedders_mix_layers),
- "--embedders_mix_ratio", str(embedders_mix_ratio)
- ])
-
- done = [False]
-
- threading.Thread(target=if_done, args=(done, p)).start()
-
- for log in log_read(done, getname(configs["create_reference_path"]), start_time):
- yield log
-
-def preprocess(
- model_name,
- sample_rate,
- cpu_core,
- cut_preprocess,
- process_effects,
- dataset,
- clean_dataset,
- clean_strength,
- chunk_len=3.0,
- overlap_len=0.3,
- normalization_mode="none",
- architecture="RVC"
-):
- sr = int(float(sample_rate.rstrip("k")) * 1000)
-
- if not model_name: return gr_warning(translations["provide_name"])
-
- if configs.get("check_data", False):
- try:
- found = False
- if os.path.exists(dataset):
- for root, _, files in os.walk(dataset):
- for f in files:
- if f.lower().endswith(tuple(file_types)) and os.path.getsize(os.path.join(root, f)) > 0:
- found = True
- break
-
- if found: break
- if not found: return gr_warning(translations["not_found_data"])
- except Exception:
- return gr_warning(translations["not_found_data"])
-
- start_time = datetime.datetime.now()
- model_dir = os.path.join(configs["logs_path"], model_name)
- if os.path.exists(model_dir): shutil.rmtree(model_dir, ignore_errors=True)
-
- p = subprocess.Popen([
- python,
- configs["preprocess_path"],
- "--model_name", model_name,
- "--dataset_path", dataset,
- "--sample_rate", str(sr),
- "--cpu_cores", str(cpu_core),
- "--cut_preprocess", cut_preprocess,
- "--process_effects", str(process_effects),
- "--clean_dataset", str(clean_dataset),
- "--clean_strength", str(clean_strength),
- "--chunk_len", str(chunk_len),
- "--overlap_len", str(overlap_len),
- "--normalization_mode", normalization_mode,
- "--architecture", architecture
- ])
-
- done = [False]
-
- threading.Thread(target=if_done, args=(done, p)).start()
- os.makedirs(model_dir, exist_ok=True)
-
- for log in log_read(done, getname(configs["preprocess_path"]), start_time):
- yield log
-
-def extract(
- model_name,
- version,
- method,
- pitch_guidance,
- hop_length,
- cpu_cores,
- gpu,
- sample_rate,
- embedders,
- custom_embedders,
- predictor_onnx,
- embedders_mode,
- f0_autotune,
- f0_autotune_strength,
- hybrid_method,
- rms_extract,
- alpha=0.5,
- include_mutes=2,
- embedders_mix = False,
- embedders_mix_layers = 9,
- embedders_mix_ratio = 0.5,
- architecture = "RVC"
-):
- f0_method, embedder_model = (
- method if method != "hybrid" else hybrid_method,
- embedders if embedders != "custom" else custom_embedders
- )
-
- sr = int(float(sample_rate.rstrip("k")) * 1000)
-
- if not model_name: return gr_warning(translations["provide_name"])
- model_dir = os.path.join(configs["logs_path"], model_name)
-
- if configs.get("check_data", False):
- try:
- if not any(
- os.path.isfile(os.path.join(model_dir, "sliced_audios", f))
- for f in os.listdir(os.path.join(model_dir, "sliced_audios"))
- ) or not any(
- os.path.isfile(os.path.join(model_dir, "sliced_audios_16k", f))
- for f in os.listdir(os.path.join(model_dir, "sliced_audios_16k"))
- ):
- return gr_warning(translations["not_found_data_preprocess"])
- except:
- return gr_warning(translations["not_found_data_preprocess"])
-
- start_time = datetime.datetime.now()
-
- p = subprocess.Popen([
- python,
- configs["extract_path"],
- "--model_name", model_name,
- "--rvc_version", version,
- "--f0_method", f0_method,
- "--pitch_guidance", str(pitch_guidance),
- "--hop_length", str(hop_length),
- "--cpu_cores", str(cpu_cores),
- "--gpu", str(gpu),
- "--sample_rate", str(sr),
- "--embedder_model", embedder_model,
- "--predictor_onnx", str(predictor_onnx),
- "--embedders_mode", embedders_mode,
- "--f0_autotune", str(f0_autotune),
- "--f0_autotune_strength", str(f0_autotune_strength),
- "--rms_extract", str(rms_extract),
- "--alpha", str(alpha),
- "--include_mutes", str(include_mutes),
- "--embedders_mix", str(embedders_mix),
- "--embedders_mix_layers", str(embedders_mix_layers),
- "--embedders_mix_ratio", str(embedders_mix_ratio),
- "--architecture", architecture
- ])
-
- done = [False]
-
- threading.Thread(target=if_done, args=(done, p)).start()
- os.makedirs(model_dir, exist_ok=True)
-
- for log in log_read(done, getname(configs["extract_path"]), start_time):
- yield log
-
-def create_index(
- model_name,
- rvc_version,
- index_algorithm,
- nprobe=1
-):
- if not model_name: return gr_warning(translations["provide_name"])
- model_dir = os.path.join(configs["logs_path"], model_name)
-
- if configs.get("check_data", False):
- try:
- if not any(
- os.path.isfile(os.path.join(model_dir, f"{rvc_version}_extracted", f))
- for f in os.listdir(os.path.join(model_dir, f"{rvc_version}_extracted"))
- ):
- return gr_warning(translations["not_found_data_extract"])
- except:
- return gr_warning(translations["not_found_data_extract"])
-
- start_time = datetime.datetime.now()
-
- p = subprocess.Popen([
- python,
- configs["create_index_path"],
- "--model_name", model_name,
- "--rvc_version", rvc_version,
- "--index_algorithm", index_algorithm,
- "--nprobe", str(nprobe)
- ])
-
- done = [False]
-
- threading.Thread(target=if_done, args=(done, p)).start()
- os.makedirs(model_dir, exist_ok=True)
-
- for log in log_read(done, getname(configs["create_index_path"]), start_time):
- yield log
-
-def training(
- model_name,
- rvc_version,
- save_every_epoch,
- save_only_latest,
- save_every_weights,
- total_epoch,
- sample_rate,
- batch_size,
- gpu,
- pitch_guidance,
- not_pretrain,
- custom_pretrained,
- pretrain_g,
- pretrain_d,
- detector,
- threshold,
- clean_up,
- cache,
- model_author,
- vocoder,
- checkpointing,
- deterministic,
- benchmark,
- optimizer,
- energy_use,
- custom_reference=False,
- reference_name="",
- multiscale_mel_loss=False,
- embedders="hubert_base",
- custom_embedders=None,
- cosine_annealing_lr=False,
- architecture="RVC"
-):
- if architecture == "SVC":
- pitch_guidance = True
- energy_use = False
-
- sr = int(float(sample_rate.rstrip("k")) * 1000)
- if not model_name: return gr_warning(translations["provide_name"])
-
- model_dir = os.path.join(configs["logs_path"], model_name)
- if os.path.exists(os.path.join(model_dir, "train_pid.txt")):
- os.remove(os.path.join(model_dir, "train_pid.txt"))
-
- if configs.get("check_data", False):
- try:
- if not any(
- os.path.isfile(os.path.join(model_dir, f"{rvc_version}_extracted", f))
- for f in os.listdir(os.path.join(model_dir, f"{rvc_version}_extracted"))
- ):
- return gr_warning(translations["not_found_data_extract"])
- except:
- return gr_warning(translations["not_found_data_extract"])
-
- if not not_pretrain:
- if not custom_pretrained:
- pretrain_dir = (
- configs["pretrained_v2_path"]
- if rvc_version == 'v2' else
- configs["pretrained_v1_path"]
- )
-
- download_version = codecs.decode(
- f"uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/cergenvarq_",
- "rot13"
- ) + f"{rvc_version}/"
-
- pretrained_selector = {
- True: {
- 24000: ("f0G24k.pth", "f0D24k.pth"),
- 32000: ("f0G32k.pth", "f0D32k.pth"),
- 40000: ("f0G40k.pth", "f0D40k.pth"),
- 44100: ("f0G44k.pth", "f0D44k.pth"),
- 48000: ("f0G48k.pth", "f0D48k.pth")
- },
- False: {
- 24000: ("G24k.pth", "D24k.pth"),
- 32000: ("G32k.pth", "D32k.pth"),
- 40000: ("G40k.pth", "D40k.pth"),
- 44100: ("G44k.pth", "D44k.pth"),
- 48000: ("G48k.pth", "D48k.pth")
- }
- }
-
- pg2, pd2 = "", ""
- pg, pd = pretrained_selector[pitch_guidance][sr]
-
- if energy_use: pg2, pd2 = pg2 + "ENERGY_", pd2 + "ENERGY_"
- if vocoder != 'Default': pg2, pd2 = pg2 + vocoder + "_", pd2 + vocoder + "_"
- if embedders not in ["hubert_base", "contentvec_base"]: pg2, pd2 = pg2 + embedders + "_", pd2 + embedders + "_"
- if architecture != "RVC": pg2, pd2 = architecture + "_" + pg2, architecture + "_" + pd2
-
- pg2, pd2 = pg2 + pg, pd2 + pd
- logger.debug("PG: " + pg2 + " PD: " + pd2)
-
- pretrained_G, pretrained_D = (
- os.path.join(
- pretrain_dir,
- pg2
- ),
- os.path.join(
- pretrain_dir,
- pd2
- )
- )
-
- try:
- if not os.path.exists(pretrained_G):
- gr_info(translations["download_pretrained"].format(dg="G", rvc_version=rvc_version))
- huggingface.HF_download_file(
- "".join(
- [
- download_version,
- pg2
- ]
- ),
- os.path.join(
- pretrain_dir,
- pg2
- )
- )
-
- if not os.path.exists(pretrained_D):
- gr_info(translations["download_pretrained"].format(dg="D", rvc_version=rvc_version))
- huggingface.HF_download_file(
- "".join(
- [
- download_version,
- pd2
- ]
- ),
- os.path.join(
- pretrain_dir,
- pd2
- )
- )
- except:
- gr_warning(translations["not_use_pretrain_error_download"])
- pretrained_G = pretrained_D = None
- else:
- if not pretrain_g:
- return gr_warning(translations["provide_pretrained"].format(dg="G"))
-
- if not pretrain_d:
- return gr_warning(translations["provide_pretrained"].format(dg="D"))
-
- pg2, pd2 = pretrain_g, pretrain_d
- pretrained_G, pretrained_D = (
- os.path.join(configs["pretrained_custom_path"], pg2) if not os.path.exists(pg2) else pg2,
- os.path.join(configs["pretrained_custom_path"], pd2) if not os.path.exists(pd2) else pd2
- )
-
- if not os.path.exists(pretrained_G):
- return gr_warning(translations["not_found_pretrain"].format(dg="G"))
-
- if not os.path.exists(pretrained_D):
- return gr_warning(translations["not_found_pretrain"].format(dg="D"))
- else:
- pretrained_G = pretrained_D = None
- gr_warning(translations["not_use_pretrain"])
-
- if custom_reference:
- embedder_model = embedders if embedders != "custom" else custom_embedders
-
- reference_path = os.path.join(
- configs["reference_path"],
- "".join([
- reference_name,
- "_",
- rvc_version,
- "_",
- embedder_model,
- "_",
- str(pitch_guidance),
- "_",
- str(energy_use)
- ])
- )
-
- if not os.path.exists(reference_path):
- gr_warning(translations["not_found_reference"])
-
- custom_reference = False
- reference_path = None
- else: reference_path = None
-
- start_time = datetime.datetime.now()
-
- p = subprocess.Popen([
- python,
- configs["train_path"],
- "--model_name", model_name,
- "--rvc_version", rvc_version,
- "--save_every_epoch", str(save_every_epoch),
- "--save_only_latest", str(save_only_latest),
- "--save_every_weights", str(save_every_weights),
- "--total_epoch", str(total_epoch),
- "--batch_size", str(batch_size),
- "--gpu", str(gpu),
- "--pitch_guidance", str(pitch_guidance),
- "--overtraining_detector", str(detector),
- "--overtraining_threshold", str(threshold),
- "--cleanup", str(clean_up),
- "--cache_data_in_gpu", str(cache),
- "--g_pretrained_path", str(pretrained_G),
- "--d_pretrained_path", str(pretrained_D),
- "--model_author", model_author,
- "--vocoder", vocoder,
- "--checkpointing", str(checkpointing),
- "--deterministic", str(deterministic),
- "--benchmark", str(benchmark),
- "--optimizer", optimizer,
- "--energy_use", str(energy_use),
- "--use_custom_reference", str(custom_reference),
- "--reference_path", str(reference_path),
- "--multiscale_mel_loss", str(multiscale_mel_loss),
- "--use_cosine_annealing_lr", str(cosine_annealing_lr),
- "--architecture", architecture
- ])
-
- done = [False]
-
- with open(os.path.join(model_dir, "train_pid.txt"), "w") as pid_file:
- pid_file.write(str(p.pid))
-
- threading.Thread(target=if_done, args=(done, p)).start()
-
- for log in log_read(done, getname(configs["train_path"]), start_time):
- lines = log.splitlines()
-
- if len(lines) > 50:
- log = "\n".join(lines[-50:])
-
- yield log
\ No newline at end of file
diff --git a/main/app/core/tts.py b/main/app/core/tts.py
deleted file mode 100644
index 7ea4d78100dd44adf6e591cc806a30b20a5f7a99..0000000000000000000000000000000000000000
--- a/main/app/core/tts.py
+++ /dev/null
@@ -1,203 +0,0 @@
-import os
-import sys
-import pysrt
-import codecs
-import asyncio
-import requests
-import tempfile
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import translations
-from main.app.core.ui import gr_info, gr_warning, gr_error
-
-def synthesize_tts(
- prompt,
- voice,
- speed,
- output,
- pitch,
- google
-):
- if not google:
- from edge_tts import Communicate
-
- asyncio.run(
- Communicate(
- text=prompt,
- voice=voice,
- rate=f"+{speed}%" if speed >= 0 else f"{speed}%",
- pitch=f"+{pitch}Hz" if pitch >= 0 else f"{pitch}Hz"
- ).save(output)
- )
- else:
- response = requests.get(
- codecs.decode(
- "uggcf://genafyngr.tbbtyr.pbz/genafyngr_ggf",
- "rot13"
- ),
- params={
- "ie": "UTF-8",
- "q": prompt,
- "tl": voice,
- "ttsspeed": max(0.24, min(4.0, 1 + speed / 100)),
- "client": "tw-ob"
- },
- headers={
- "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36"
- },
- timeout=15
- )
-
- if response.status_code == 200:
- with open(output, "wb") as f:
- f.write(response.content)
-
- if pitch != 0 or speed != 0:
- import librosa
- import soundfile as sf
-
- y, sr = librosa.load(output, sr=None)
-
- if pitch != 0:
- y = librosa.effects.pitch_shift(
- y,
- sr=sr,
- n_steps=pitch
- )
-
- rate = max(0.01, 1 + speed / 100)
- if rate != 1.0:
- y = librosa.effects.time_stretch(
- y,
- rate=rate
- )
-
- sf.write(
- file=output,
- data=y,
- samplerate=sr,
- format=os.path.splitext(
- os.path.basename(output)
- )[-1].lower().replace('.', '')
- )
- else: gr_error(f"{response.status_code}, {response.text}")
-
-def srt_tts(
- srt_file,
- out_file,
- voice,
- rate = 0,
- sr = 24000,
- google = False
-):
- import librosa
- import numpy as np
- import soundfile as sf
-
- def time_stretch(y, sr, target_duration):
- rate = (len(y) / sr) / target_duration
-
- if rate != 1.0:
- y = librosa.effects.time_stretch(
- y=y.astype(np.float32),
- rate=rate
- )
-
- n_target = int(round(target_duration * sr))
- return np.pad(y, (0, n_target - len(y))) if len(y) < n_target else y[:n_target]
-
- def pysrttime_to_seconds(t):
- return (t.hours * 60 + t.minutes) * 60 + t.seconds + t.milliseconds / 1000
-
- subs = pysrt.open(srt_file)
- if not subs: raise ValueError(translations["srt"])
-
- final_audio = np.zeros(
- int(round(pysrttime_to_seconds(subs[-1].end) * sr)),
- dtype=np.float32
- )
-
- with tempfile.TemporaryDirectory() as tempdir:
- for idx, seg in enumerate(subs):
- wav_path = os.path.join(tempdir, f"seg_{idx}.wav")
-
- synthesize_tts(
- " ".join(seg.text.splitlines()),
- voice,
- 0,
- wav_path,
- rate,
- google
- )
-
- audio, file_sr = sf.read(wav_path, dtype=np.float32)
- if file_sr != sr: audio = librosa.resample(audio, orig_sr=file_sr, target_sr=sr, res_type="soxr_vhq")
-
- adjusted = time_stretch(
- audio,
- sr,
- pysrttime_to_seconds(seg.duration)
- )
-
- start_sample = int(round(pysrttime_to_seconds(seg.start) * sr))
- end_sample = start_sample + adjusted.shape[0]
-
- if end_sample > final_audio.shape[0]:
- adjusted = adjusted[: final_audio.shape[0] - start_sample]
- end_sample = final_audio.shape[0]
-
- final_audio[start_sample:end_sample] += adjusted
-
- sf.write(out_file, final_audio, sr)
-
-def TTS(
- prompt,
- voice,
- speed,
- output,
- pitch,
- google,
- srt_input
-):
- if not srt_input: srt_input = ""
-
- if not prompt and not srt_input.endswith(".srt"):
- gr_warning(translations["enter_the_text"])
- return None
-
- if not voice:
- gr_warning(translations["choose_voice"])
- return None
-
- if not output:
- gr_warning(translations["output_not_valid"])
- return None
-
- if os.path.isdir(output): output = os.path.join(output, f"tts.wav")
- gr_info(translations["convert"].format(name=translations["text"]))
-
- output_dir = os.path.dirname(output) or output
- if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True)
-
- if srt_input.endswith(".srt"):
- srt_tts(
- srt_input,
- output,
- voice,
- 0,
- 24000,
- google
- )
- else:
- synthesize_tts(
- prompt,
- voice,
- speed,
- output,
- pitch,
- google
- )
-
- gr_info(translations["success"])
- return output
\ No newline at end of file
diff --git a/main/app/core/ui.py b/main/app/core/ui.py
deleted file mode 100644
index 5bc8b5a25e25120e639c241cd6f5b7f42b8946d1..0000000000000000000000000000000000000000
--- a/main/app/core/ui.py
+++ /dev/null
@@ -1,814 +0,0 @@
-import os
-import re
-import sys
-import json
-import torch
-import shutil
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-import main.library.audio.sounddevice as sd
-
-from main.library.backends import directml, opencl
-from main.inference.realtime.audio import audio_device
-
-from main.app.variables import (
- logger,
- config,
- configs,
- edgetts,
- method_f0,
- vr_models,
- mdx_models,
- file_types,
- configs_json,
- translations,
- whisper_model,
- demucs_models,
- method_f0_full,
- gradio_version,
- embedders_model,
- google_tts_voice
-)
-
-input_channels_map, output_channels_map = audio_device()
-
-def gr_info(message):
- gr.Info(message, duration=2)
- logger.info(message)
-
-def gr_warning(message):
- gr.Warning(message, duration=2)
- logger.warning(message)
-
-def gr_error(message):
- gr.Error(message=message, duration=6)
- logger.error(message)
-
-def get_gpu_info():
- ngpu = torch.cuda.device_count()
- gpu_infos = [
- (
- f"{i}: {torch.cuda.get_device_name(i)} " +
- f"({int(torch.cuda.get_device_properties(i).total_memory / (1024**3) + 0.4)} GB)"
- )
- for i in range(ngpu)
- if config.device.startswith("cuda") or ngpu != 0
- ]
-
- if len(gpu_infos) == 0 and config.device.startswith("xpu"):
- ngpu = torch.xpu.device_count()
- gpu_infos = [
- (
- f"{i}: {torch.xpu.get_device_name(i)} " +
- f"({int(torch.xpu.get_device_properties(i).total_memory / (1024**3) + 0.4)} GB)"
- )
- for i in range(ngpu)
- if config.device.startswith("xpu") or ngpu != 0
- ]
-
- if len(gpu_infos) == 0:
- if config.device.startswith("privateuseone"):
- ngpu = directml.device_count()
-
- gpu_infos = [
- f"{i}: {directml.device_name(i)}"
- for i in range(ngpu)
- if config.device.startswith("privateuseone") or ngpu != 0
- ]
- elif config.device.startswith("ocl"):
- ngpu = opencl.device_count()
-
- gpu_infos = [
- f"{i}: {opencl.device_name(i)}"
- for i in range(ngpu)
- if config.device.startswith("ocl") or ngpu != 0
- ]
- else:
- ngpu = 0
- gpu_infos = []
-
- return (
- (
- "\n".join(gpu_infos)
- if len(gpu_infos) > 0 and not config.cpu_mode else
- translations["no_support_gpu"]
- ),
- ngpu
- )
-
-def gpu_number_str():
- if config.cpu_mode: return "-"
- ngpu = torch.cuda.device_count()
-
- if ngpu == 0 and config.device.startswith("xpu"):
- ngpu = torch.xpu.device_count()
- if ngpu != 0: return "0"
-
- if ngpu == 0:
- ngpu = (
- directml.device_count()
- if config.device.startswith("privateuseone") else
- opencl.device_count()
- )
- if ngpu != 0: return "0"
-
- return str("-".join(map(str, range(ngpu))) if config.device.startswith(("cuda", "xpu", "privateuseone", "ocl")) else "-")
-
-def change_f0_choices():
- f0_file = sorted([
- os.path.abspath(os.path.join(root, f))
- for root, _, files in os.walk(configs["f0_path"])
- for f in files
- if f.endswith(".txt")
- ])
-
- return {
- "value": f0_file[0] if len(f0_file) >= 1 else "",
- "choices": f0_file,
- "__type__": "update"
- }
-
-def change_audios_choices(input_audio):
- audios = sorted([
- os.path.abspath(os.path.join(root, f))
- for root, _, files in os.walk(configs["audios_path"])
- for f in files if os.path.splitext(f)[1].lower() in file_types and not f.startswith(("Convert", "output"))
- ])
-
- return {
- "value": input_audio if input_audio != "" else (audios[0] if len(audios) >= 1 else ""),
- "choices": audios,
- "__type__": "update"
- }
-
-def change_reference_choices():
- reference = sorted([
- re.sub(r'_v\d+_(?:[A-Za-z0-9_]+?)_(True|False)_(True|False)$', '', name)
- for name in os.listdir(configs["reference_path"])
- if (
- os.path.exists(os.path.join(configs["reference_path"], name)) and
- os.path.isdir(os.path.join(configs["reference_path"], name))
- )
- ])
-
- return {
- "value": reference[0] if len(reference) >= 1 else "",
- "choices": reference,
- "__type__": "update"
- }
-
-def change_models_choices():
- model, index = (
- sorted([
- model
- for model in os.listdir(configs["weights_path"])
- if model.endswith((".pth", ".onnx")) and not model.startswith("G_") and not model.startswith("D_")
- ]),
- sorted([
- os.path.join(root, name)
- for root, _, files in os.walk(configs["logs_path"], topdown=False)
- for name in files if name.endswith(".index") and "trained" not in name
- ])
- )
-
- return [
- {
- "value": model[0] if len(model) >= 1 else "",
- "choices": model,
- "__type__": "update"
- },
- {
- "value": index[0] if len(index) >= 1 else "",
- "choices": index,
- "__type__": "update"
- }
- ]
-
-def change_pretrained_choices():
- pretrainD = sorted([
- model for model in os.listdir(configs["pretrained_custom_path"])
- if model.endswith(".pth") and "D" in model
- ])
-
- pretrainG = sorted([
- model for model in os.listdir(configs["pretrained_custom_path"])
- if model.endswith(".pth") and "G" in model
- ])
-
- return [
- {
- "choices": pretrainD,
- "value": pretrainD[0] if len(pretrainD) >= 1 else "",
- "__type__": "update"
- },
- {
- "choices": pretrainG,
- "value": pretrainG[0] if len(pretrainG) >= 1 else "",
- "__type__": "update"
- }
- ]
-
-def change_preset_choices():
- return {
- "value": "",
- "choices": sorted([
- f for f in os.listdir(configs["presets_path"])
- if f.endswith(".conversion.json")
- ]),
- "__type__": "update"
- }
-
-def change_effect_preset_choices():
- return {
- "value": "",
- "choices": sorted([
- f for f in os.listdir(configs["presets_path"])
- if f.endswith(".effect.json")
- ]),
- "__type__": "update"
- }
-
-def change_realtime_preset_choices():
- return {
- "value": "",
- "choices": sorted([
- f for f in os.listdir(configs["presets_path"])
- if f.endswith(".realtime.json")
- ]),
- "__type__": "update"
- }
-
-def change_tts_voice_choices(google):
- return {
- "choices": google_tts_voice if google else edgetts,
- "value": google_tts_voice[0] if google else edgetts[0],
- "__type__": "update"
- }
-
-def change_backing_choices(
- backing,
- merge
-):
- if backing or merge:
- return {
- "value": False,
- "interactive": False,
- "__type__": "update"
- }
- elif not backing or not merge:
- return {
- "interactive": True,
- "__type__": "update"
- }
- else:
- gr_warning(translations["option_not_valid"])
-
-def change_download_choices(select):
- selects = [False]*10
-
- if select == translations["download_url"]:
- selects[0] = selects[1] = selects[2] = True
- elif select == translations["download_from_csv"]:
- selects[3] = selects[4] = True
- elif select == translations["search_models"]:
- selects[5] = selects[6] = True
- elif select == translations["upload"]:
- selects[9] = True
- else:
- gr_warning(translations["option_not_valid"])
-
- return [
- {
- "visible": selects[i] if gradio_version else (selects[i] or "hidden"),
- "__type__": "update"
- }
- for i in range(len(selects))
- ]
-
-def change_download_pretrained_choices(select):
- selects = [False]*7
-
- if select == translations["download_url"]:
- selects[0] = selects[1] = selects[2] = True
- elif select == translations["list_model"]:
- selects[3] = selects[4] = selects[5] = True
- elif select == translations["upload"]:
- selects[6] = True
- else:
- gr_warning(translations["option_not_valid"])
-
- return [
- {
- "visible": selects[i] if gradio_version else (selects[i] or "hidden"),
- "__type__": "update"
- }
- for i in range(len(selects))
- ]
-
-def get_index(model):
- model = os.path.basename(model).split("_")[0]
-
- return {
- "value": next((
- f for f in [
- os.path.join(root, name)
- for root, _, files in os.walk(configs["logs_path"], topdown=False)
- for name in files
- if name.endswith(".index") and "trained" not in name
- ]
- if model.split(".")[0] in f
- ), ""),
- "__type__": "update"
- } if model else None
-
-def index_strength_show(index):
- index_strength_visible = (
- index != "" and
- index != None and
- os.path.exists(index) and
- os.path.isfile(index)
- )
-
- return [
- {
- "visible": index_strength_visible if gradio_version else (index_strength_visible or "hidden"),
- "value": 0.5,
- "__type__": "update"
- },
- {
- "visible": index_strength_visible if gradio_version else (index_strength_visible or "hidden"),
- "value": 9,
- "__type__": "update"
- }
- ]
-
-def hoplength_show(
- method,
- hybrid_method=None
-):
- visible = False
-
- for m in [
- "mangio-crepe",
- "yin",
- "piptrack",
- "mangio-penn"
- ]:
- if m in method: visible = True
-
- if (
- hybrid_method is not None and
- m in hybrid_method
- ):
- visible = True
-
- if visible: break
- else: visible = False
-
- return {
- "visible": visible if gradio_version else (visible or "hidden"),
- "__type__": "update"
- }
-
-def visible(value):
- return {
- "visible": value if gradio_version else (value or "hidden"),
- "__type__": "update"
- }
-
-def visibleFalse(value):
- return {
- "visible": value if gradio_version else (value or "hidden"),
- "value": False,
- "__type__": "update"
- }
-
-def valueFalse_interactive(value):
- return {
- "value": False,
- "interactive": value,
- "__type__": "update"
- }
-
-def interactive(value):
- return {
- "interactive": value,
- "__type__": "update"
- }
-
-def valueEmpty_visible1(value):
- return {
- "value": "",
- "visible": value if gradio_version else (value or "hidden"),
- "__type__": "update"
- }
-
-def pitch_guidance_lock(vocoders):
- return {
- "value": True,
- "interactive": vocoders == "Default",
- "__type__": "update"
- }
-
-def vocoders_lock(pitch):
- if pitch:
- return gr.update(interactive=True)
-
- return gr.update(
- value="Default",
- interactive=False
- )
-
-def unlock_f0(value):
- return {
- "choices": method_f0_full if value else method_f0,
- "value": "rmvpe",
- "__type__": "update"
- }
-
-def unlock_vocoder(value, vocoder):
- return {
- "value": vocoder if value == "v2" else "Default",
- "interactive": value == "v2",
- "__type__": "update"
- }
-
-def unlock_version(value, vocoder):
- return {
- "value": "v2" if vocoder == "Default" else value,
- "interactive": vocoder == "Default",
- "__type__": "update"
- }
-
-def change_embedders_mode(value):
- if value == "whisper":
- return {
- "value": whisper_model[0],
- "choices": whisper_model,
- "__type__": "update"
- }
- else:
- return {
- "value": embedders_model[0],
- "choices": embedders_model,
- "__type__": "update"
- }
-
-def change_fp(fp, bf16, tf32):
- global config
-
- fp16 = fp == "fp16"
-
- if fp16 and not config.allow_is_half:
- gr_warning(translations["fp16_not_support"])
- return "fp32"
- else:
- gr_info(translations["start_update_precision"])
-
- configs = json.load(open(configs_json, "r"))
- configs["fp16"] = config.is_half = fp16
- configs["brain"] = config.brain = bf16
- configs["tf32"] = config.tf32 = tf32
-
- with open(configs_json, "w") as f:
- json.dump(configs, f, indent=4)
-
- gr_info(translations["success"])
- return "fp16" if fp16 else "fp32"
-
-def process_output(file_path):
- if config.configs.get("delete_exists_file", True):
- if os.path.exists(file_path) and os.path.isfile(file_path): os.remove(file_path)
- return file_path
- else:
- if not os.path.exists(file_path): return file_path
- file = os.path.splitext(os.path.basename(file_path))
-
- index = 1
- while 1:
- file_path = os.path.join(
- os.path.dirname(file_path),
- f"{file[0]}_{index}{file[1]}"
- )
-
- if not os.path.exists(file_path): return file_path
- index += 1
-
-def shutil_move(input_path, output_path):
- output_path = (
- os.path.join(output_path, os.path.basename(input_path))
- if os.path.isdir(output_path) else
- output_path
- )
-
- return (
- shutil.move(input_path, process_output(output_path))
- if os.path.exists(output_path) else
- shutil.move(input_path, output_path)
- )
-
-def separate_change(
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
-):
- model_type = (
- "vr" if model_name in list(vr_models.keys()) else "mdx"
- if model_name in list(mdx_models.keys()) else "demucs"
- if model_name in list(demucs_models.keys()) else ""
- )
-
- karaoke_type = ("vr" if karaoke_model.startswith("VR") else "mdx") if separate_backing else None
- reverb_type = ("vr" if not reverb_model.startswith("MDX") else "mdx") if separate_reverb else None
-
- all_types = {model_type, karaoke_type, reverb_type}
-
- is_vr = "vr" in all_types
- is_mdx = "mdx" in all_types
- is_demucs = "demucs" in all_types
-
- return [
- visible(separate_backing),
- visible(separate_reverb),
- visible(is_mdx or is_demucs),
- visible(is_mdx or is_demucs),
- visible(is_mdx),
- visible(is_mdx or is_vr),
- visible(is_demucs),
- visible(is_vr),
- visible(is_vr),
- visible(is_vr and enable_post_process),
- visible(is_vr and enable_denoise),
- valueFalse_interactive(is_vr),
- valueFalse_interactive(is_vr),
- interactive(is_vr) if is_vr else valueFalse_interactive(is_vr)
- ]
-
-def create_dataset_change(
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
-):
- model_type = (
- "vr" if model_name in list(vr_models.keys()) else "mdx"
- if model_name in list(mdx_models.keys()) else "demucs"
- if model_name in list(demucs_models.keys()) else ""
- )
-
- reverb_type = ("vr" if not reverb_model.startswith("MDX") else "mdx") if separate_reverb else None
- all_types = {model_type, reverb_type}
-
- is_vr = "vr" in all_types
- is_mdx = "mdx" in all_types
- is_demucs = "demucs" in all_types
-
- return [
- visible(separate_reverb),
- visible(is_mdx or is_demucs),
- visible(is_mdx or is_demucs),
- visible(is_mdx),
- visible(is_mdx or is_vr),
- visible(is_demucs),
- visible(is_vr),
- visible(is_vr),
- visible(is_vr and enable_post_process),
- visible(is_vr and enable_denoise),
- valueFalse_interactive(is_vr),
- valueFalse_interactive(is_vr),
- interactive(is_vr) if is_vr else valueFalse_interactive(is_vr)
- ]
-
-def update_audio_device(input_device, output_device, monitor_device, monitor):
- input_is_asio = "ASIO" in input_device if input_device else (False if gradio_version else "hidden")
- output_is_asio = "ASIO" in output_device if output_device else (False if gradio_version else "hidden")
- monitor_is_asio = "ASIO" in monitor_device if monitor_device else (False if gradio_version else "hidden")
-
- if input_is_asio or output_is_asio or monitor_is_asio:
- sd.terminate()
- sd.initialize()
-
- try:
- input_max_ch = input_channels_map.get(input_device, [])[1]
- output_max_ch = output_channels_map.get(output_device, [])[1]
- monitor_max_ch = output_channels_map.get(monitor_device, [])[1] if monitor else 128
- except:
- input_max_ch = output_max_ch = monitor_max_ch = 2
- else: input_max_ch = output_max_ch = monitor_max_ch = 2
-
- return [
- visible(monitor),
- visible(monitor),
- visible(
- input_is_asio or output_is_asio or monitor_is_asio
- ),
- gr.update(
- visible=input_is_asio,
- maximum=input_max_ch - 1
- ),
- gr.update(
- visible=output_is_asio,
- maximum=output_max_ch - 1
- ),
- gr.update(
- visible=monitor_is_asio,
- maximum=monitor_max_ch - 1
- ),
- gr.update(
- value=resolve_sample_rate(input_channels_map[input_device][0]) if input_is_asio else 48000
- ),
- gr.update(
- value=resolve_sample_rate(output_channels_map[output_device][0]) if output_is_asio else 48000
- ),
- gr.update(
- visible=monitor,
- value=resolve_sample_rate(output_channels_map[monitor_device][0]) if monitor_is_asio else 48000
- ),
- gr.update(
- visible=output_is_asio,
- value=True
- ),
- gr.update(
- visible=monitor_is_asio,
- value=True
- ),
- ]
-
-def change_audio_device_choices():
- global input_channels_map, output_channels_map
-
- sd.terminate()
- sd.initialize()
-
- input_channels_map, output_channels_map = audio_device()
- input_channels_map_list, output_channels_map_list = list(input_channels_map.keys()), list(output_channels_map.keys())
-
- return [
- {
- "value": input_channels_map_list[0] if len(input_channels_map_list) >= 1 else "",
- "choices": input_channels_map_list,
- "__type__": "update"
- },
- {
- "value": output_channels_map_list[0] if len(output_channels_map_list) >= 1 else "",
- "choices": output_channels_map_list,
- "__type__": "update"
- },
- {
- "value": output_channels_map_list[0] if len(output_channels_map_list) >= 1 else "",
- "choices": output_channels_map_list,
- "__type__": "update"
- }
- ]
-
-def resolve_sample_rate(input_device_id):
- if configs.get("asio_enabled", False): return 48000
-
- try:
- device = sd.query_devices(input_device_id)
- return int(device["default_samplerate"])
- except Exception:
- return 48000
-
-def replace_punctuation(filename):
- return re.sub(r"_+", "_", re.sub(r"[ \-|]+", "_", filename.translate(str.maketrans("", "", '()[],"\'{}<>?*:/\\')))).strip("_")
-
-def replace_url(url):
- return url.replace("/blob/", "/resolve/").replace("?download=true", "").strip()
-
-def replace_modelname(modelname):
- return replace_punctuation(
- modelname.replace(".onnx", "").replace(".pth", "").replace(".index", "").replace(".zip", "")
- )
-
-def replace_export_format(audio_path, export_format = "wav"):
- export_format = f".{export_format}"
-
- return (
- audio_path
- if audio_path.endswith(export_format) else
- audio_path.replace(f".{os.path.basename(audio_path).split('.')[-1]}", export_format)
- )
-
-def update_dropdowns_from_json(data):
- if not data:
- return [
- gr.update(choices=[], value=None),
- gr.update(choices=[], value=None),
- gr.update(choices=[], value=None)
- ]
-
- inputs = list(data.get("inputs", {}).keys())
- outputs = list(data.get("outputs", {}).keys())
-
- return [
- gr.update(
- choices=inputs,
- value=inputs[0] if len(inputs) > 0 else None
- ),
- gr.update(
- choices=outputs,
- value=outputs[0] if len(outputs) > 0 else None
- ),
- gr.update(
- choices=outputs,
- value=outputs[0] if len(outputs) > 0 else None
- ),
- ]
-
-def update_button_from_json(data):
- if not data:
- return [
- gr.update(interactive=True),
- gr.update(interactive=False)
- ]
-
- return [
- gr.update(interactive=data.get("start_button", True)),
- gr.update(interactive=data.get("stop_button", False))
- ]
-
-def update_value_from_json(data):
- if not data:
- return [
- gr.update(),
- gr.update(value=None)
- ]
-
- return [
- data.get("button", "Start"),
- data.get("path", None),
- ]
-
-def get_speakers_id_and_architecture(model):
- model_path = os.path.join(configs["weights_path"], model) if not os.path.exists(model) else model
-
- if not model or not os.path.exists(model_path) or os.path.isdir(model_path) or not model.endswith((".pth", ".onnx")):
- return [
- {
- "visible": False if gradio_version else "hidden",
- "value": 0,
- "choices": [0],
- "__type__": "update"
- },
- {
- "visible": False if gradio_version else "hidden",
- "value": 0.4,
- "__type__": "update"
- }
- ]
-
- try:
- if model_path.endswith(".pth"):
- model_data = torch.load(model_path, map_location="cpu", weights_only=True)
- else:
- import onnx
-
- model_data = None
- for prop in onnx.load(model_path).metadata_props:
- if prop.key == "model_info":
- model_data = json.loads(prop.value)
- break
-
- speakers_id = model_data.get("speakers_id", 1)
- speakers_id_visible = speakers_id and speakers_id != 1
- noise_scale_visible = model_data.get("architecture", "RVC") == "SVC"
-
- return [
- {
- "visible": speakers_id_visible if gradio_version else (speakers_id_visible or "hidden"),
- "value": 0,
- "choices": list(range(speakers_id)),
- "__type__": "update"
- },
- {
- "visible": noise_scale_visible if gradio_version else (noise_scale_visible or "hidden"),
- "value": 0.4,
- "__type__": "update"
- }
- ]
- except Exception:
- return [
- {
- "visible": False if gradio_version else "hidden",
- "value": 0,
- "choices": [0],
- "__type__": "update"
- },
- {
- "visible": False if gradio_version else "hidden",
- "value": 0.4,
- "__type__": "update"
- }
- ]
-
-def run_commands(cmd):
- os.system(cmd)
\ No newline at end of file
diff --git a/main/app/core/utils.py b/main/app/core/utils.py
deleted file mode 100644
index 4763440ff86136d4c26a73d18f1d6e3bd41081f1..0000000000000000000000000000000000000000
--- a/main/app/core/utils.py
+++ /dev/null
@@ -1,123 +0,0 @@
-import os
-import sys
-import time
-import json
-import signal
-import codecs
-import requests
-import subprocess
-
-sys.path.append(os.getcwd())
-
-from main.app.core.ui import gr_info, gr_warning
-from main.app.variables import translations, configs
-
-def alive(pid):
- try:
- if sys.platform == "win32":
- subprocess.check_output(["tasklist", "/FI", f"PID eq {pid}"], stderr=subprocess.DEVNULL)
- return True
- else:
- os.kill(pid, 0)
- return True
- except:
- return False
-
-def pid_kill(pid):
- if not alive(pid): return True
-
- try:
- if sys.platform == "win32": subprocess.run(["taskkill", "/PID", str(pid), "/T"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
- else: os.kill(pid, signal.SIGINT)
- except:
- pass
-
- for _ in range(15):
- if not alive(pid): return True
- time.sleep(0.1)
-
- try:
- if sys.platform == "win32": subprocess.run(["taskkill", "/PID", str(pid), "/F", "/T"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
- else: os.kill(pid, signal.SIGKILL)
- except:
- pass
-
- for _ in range(10):
- if not alive(pid): return True
- time.sleep(0.1)
-
- return False
-
-def stop_pid(
- pid_file,
- model_name=None,
- train=False
-):
- try:
- pid_file_path = os.path.join(
- "assets", f"{pid_file}.txt"
- ) if model_name is None else os.path.join(
- configs["logs_path"], model_name, f"{pid_file}.txt"
- )
-
- if not os.path.exists(pid_file_path): return gr_warning(translations["not_found_pid"])
- else:
- with open(pid_file_path, "r") as pid_file:
- pids = [int(pid) for pid in pid_file.readlines()]
-
- for pid in pids:
- pid_kill(pid)
-
- if os.path.exists(pid_file_path): os.remove(pid_file_path)
-
- pid_file_path = os.path.join(configs["logs_path"], model_name, "config.json")
-
- if train and os.path.exists(pid_file_path):
- with open(pid_file_path, "r") as pid_file:
- pid_data = json.load(pid_file)
- pids = pid_data.get("process_pids", [])
-
- with open(pid_file_path, "w") as pid_file:
- pid_data.pop("process_pids", None)
-
- json.dump(pid_data, pid_file, indent=4)
-
- for pid in pids:
- pid_kill(pid)
-
- gr_info(translations["end_pid"])
- except:
- pass
-
-def google_translate(text, source='auto', target='vi'):
- if text == "": return gr_warning(translations["prompt_warning"])
-
- try:
- import textwrap
-
- def translate_chunk(chunk):
- response = requests.get(
- codecs.decode("uggcf://genafyngr.tbbtyrncvf.pbz/genafyngr_n/fvatyr", "rot13"),
- params={
- 'client': 'gtx',
- 'sl': source,
- 'tl': target,
- 'dt': 't',
- 'q': chunk
- }
- )
-
- return ''.join([i[0] for i in response.json()[0]]) if response.status_code == 200 else chunk
-
- translated_text = ''
- for chunk in textwrap.wrap(
- text,
- 5000,
- break_long_words=False,
- break_on_hyphens=False
- ):
- translated_text += translate_chunk(chunk)
-
- return translated_text
- except:
- return text
\ No newline at end of file
diff --git a/main/app/install.py b/main/app/install.py
deleted file mode 100644
index 412cfb4559b39c82b236359e5d3dd3c6e815eea1..0000000000000000000000000000000000000000
--- a/main/app/install.py
+++ /dev/null
@@ -1,205 +0,0 @@
-import os
-import sys
-import subprocess
-
-sys.path.append(os.getcwd())
-
-os.makedirs(os.path.join("assets", ".uv"), exist_ok=True)
-os.environ["UV_CACHE_DIR"] = os.path.join("assets", ".uv")
-
-python_dir = os.path.join("runtime", "python.exe")
-
-def run_command(command):
- try:
- subprocess.run(command, shell=True, check=True)
- except subprocess.CalledProcessError as e:
- print(f"Lỗi khi thực thi lệnh: {e}")
-
-def install_dependencies():
- print("Cài đặt các thư viện cơ bản...")
-
- run_command(f"{python_dir} -m pip install uv")
- run_command(f"{python_dir} -m uv pip install six packaging python-dateutil platformdirs pywin32 wget")
-
-def install_ffmpeg():
- if not os.path.exists("ffmpeg.exe"):
- print("Cài đặt ffmpeg...")
- run_command('curl -L -o ffmpeg.exe https://huggingface.co/AnhP/Vietnamese-RVC-Project/resolve/main/ffmpeg/ffmpeg.exe')
-
- if not os.path.exists("ffprobe.exe"):
- print("Cài đặt ffprobe...")
- run_command('curl -L -o ffprobe.exe https://huggingface.co/AnhP/Vietnamese-RVC-Project/resolve/main/ffmpeg/ffprobe.exe')
-
-def remove_onnxruntime():
- if not os.path.exists("requirements.txt"): return
-
- with open("requirements.txt", "r", encoding="utf-8") as f:
- lines = f.readlines()
-
- with open("requirements.txt", "w", encoding="utf-8") as f:
- f.writelines(l for l in lines if "onnxruntime" not in l)
-
-def install_cpu():
- install_dependencies()
- remove_onnxruntime()
-
- print("Cài đặt các gói thư viện cpu...")
-
- run_command(f"{python_dir} -m uv pip install torch torchaudio torchvision --index-url https://download.pytorch.org/whl/cpu")
- run_command(f"{python_dir} -m uv pip install onnxruntime")
- run_command(f"{python_dir} -m uv pip install -r requirements.txt")
-
-def install_cuda(version = "cu118"):
- install_dependencies()
- remove_onnxruntime()
-
- print("Cài đặt các gói thư viện cuda...")
-
- if version in ("cu118", "cu121"): run_command(f"{python_dir} -m uv pip install numpy==1.26.4 numba==0.61.0")
- run_command(f"{python_dir} -m uv pip install torch torchaudio torchvision --index-url https://download.pytorch.org/whl/{version}")
- run_command(f"{python_dir} -m uv pip install onnxruntime-gpu" + ("==1.20.1" if version in ("cu118", "cu121") else ""))
- run_command(f"{python_dir} -m uv pip install -r requirements.txt")
- if version in ("cu128", "cu130"): run_command(f"{python_dir} -m uv pip install faiss-cpu==1.13.2")
-
-def install_directml():
- install_dependencies()
- remove_onnxruntime()
-
- print("Cài đặt các gói thư viện directml...")
-
- run_command(f"{python_dir} -m uv pip install numpy==1.26.4 numba==0.61.0")
- run_command(f"{python_dir} -m uv pip install torch==2.4.1 torchaudio==2.4.1 torchvision")
- run_command(f"{python_dir} -m uv pip install torch-directml==0.2.5.dev240914")
- run_command(f"{python_dir} -m uv pip install onnxruntime-directml")
- run_command(f"{python_dir} -m uv pip install -r requirements.txt")
-
-def install_opencl():
- install_dependencies()
- remove_onnxruntime()
-
- print("Cài đặt các gói thư viện opencl...")
-
- run_command(f"{python_dir} -m uv pip install numpy==1.26.4 numba==0.61.0")
- run_command(f"{python_dir} -m uv pip install torch==2.6.0 torchaudio==2.6.0 torchvision")
- run_command(f"{python_dir} -m uv pip install https://github.com/artyom-beilis/pytorch_dlprim/releases/download/0.2.0/pytorch_ocl-0.2.0+torch2.6-cp311-none-win_amd64.whl")
- run_command(f"{python_dir} -m uv pip install onnxruntime-directml")
- run_command(f"{python_dir} -m uv pip install -r requirements.txt")
-
-def install_xpu(provider = "openvino"):
- install_dependencies()
- remove_onnxruntime()
-
- print("Cài đặt các gói thư viện xpu...")
-
- run_command(f"{python_dir} -m uv pip install torch torchaudio torchvision --index-url https://download.pytorch.org/whl/xpu")
- run_command(f"{python_dir} -m uv pip install openvino==2025.4.1")
- run_command(f"{python_dir} -m uv pip install triton-windows")
- run_command(f"{python_dir} -m uv pip install " + ("onnxruntime-openvino==1.24.1" if provider == "openvino" else "onnxruntime-directml"))
- run_command(f"{python_dir} -m uv pip install -r requirements.txt")
- run_command(f"{python_dir} -m uv pip install faiss-cpu==1.13.2")
-
-def install_requirements():
- print("Các phiên bản Backend: \n - 1. CPU (Đối với CPU) / 2. CUDA (Đối với GPU NVIDIA) / 3. DIRECTML (Đối với GPU NVIDIA / AMD / INTEL) / 4. OPENCL (Đối với GPU AMD) / 5. XPU (Đối với GPU INTEL)")
-
- while 1:
- selected = str(input("Hãy chọn phiên bản Backend (Nhập 1-5): ")).strip().upper()
-
- if selected in ("1", "CPU"):
- print("Cài đặt dành cho CPU...")
- install_cpu()
- break
- elif selected in ("2", "CUDA"):
- print("Cài đặt dành cho CUDA...")
- print("Các phiên bản CUDA: \n Lưu ý: Hãy chọn đúng phiên bản nếu như chọn sai có thể gây ra lỗi suy luận hoặc huấn luyện. \n - 1. Phiên bản 118 dành cho các GPU GTX 10-Series trở lên. \n - 2. Phiên bản 121 dành cho các GPU RTX 20-Series đến 30-Series trở lên. \n - 3. Phiên bản 128 dành cho các GPU RTX 30-Series đến RTX 40-Series trở lên. \n - 4. Phiên bản 130 dành cho các GPU RTX 50-Series trở lên.")
-
- cuda_selected = None
-
- while 1:
- cuda_selected = str(input("Hãy chọn phiên bản CUDA (Nhập 1-4): ")).strip().upper()
-
- if cuda_selected in ("1", "118"):
- install_cuda("cu118")
- break
- elif cuda_selected in ("2", "121"):
- install_cuda("cu121")
- break
- elif cuda_selected in ("3", "128"):
- install_cuda("cu128")
- break
- elif cuda_selected in ("4", "130"):
- install_cuda("cu130")
- break
- else:
- print("Vui lòng chọn phiên bản CUDA hợp lệ!")
-
- if cuda_selected in ("cu128", "cu130"):
- print("Cài đặt gói phụ thuộc TensorRT (Cực Kỳ Không Khuyên Dùng)")
-
- while 1:
- tensorrt_selected = str(input("Bạn có muốn sử dụng TensorRT không (Y/N): ")).strip().upper()
-
- if tensorrt_selected in ("Y", "YES"):
- run_command(f"{python_dir} -m uv pip install tensorrt")
- break
- elif tensorrt_selected in ("N", "NO"):
- break
- else:
- print("Vui lòng chọn giá trị hợp lệ!")
-
- print("Cài đặt gói phụ thuộc Triton (Không Khuyên Dùng)")
-
- while 1:
- triton_selected = str(input("Bạn có muốn sử dụng Triton không (Y/N): ")).strip().upper()
-
- if triton_selected in ("Y", "YES"):
- run_command(f"{python_dir} -m uv pip install triton-windows")
- break
- elif triton_selected in ("N", "NO"):
- break
- else:
- print("Vui lòng chọn giá trị hợp lệ!")
-
- break
- elif selected in ("3", "DIRECTML"):
- print("Cài đặt dành cho DIRECTML...")
- install_directml()
- break
- elif selected in ("4", "OPENCL"):
- print("Cài đặt dành cho OPENCL...")
- install_opencl()
- break
- elif selected in ("5", "XPU"):
- print("Cài đặt dành cho XPU...")
- print("Phiên bản ONNXRUNTIME: 1. DIRECTML (Sử dụng trên mọi GPU) / 2. OPENVINO (Chỉ Intel GPU và tối ưu nhất)")
-
- while 1:
- provider_selected = str(input("Hãy chọn phiên bản ONNXRUNTIME (1-2): ")).strip().upper()
-
- if provider_selected in ("1", "DIRECTML"):
- install_xpu("directml")
- break
- elif provider_selected in ("2", "OPENVINO"):
- install_xpu("openvino")
- break
- else:
- print("Vui lòng chọn giá trị hợp lệ!")
-
- break
- else:
- print("Vui lòng chọn phiên bản hợp lệ!")
-
- print("Hoàn tất quá trình cài đặt thư viện!")
-
-if __name__ == "__main__":
- if not os.path.exists(python_dir):
- print("Không tìm thấy thời gian chạy python!")
- sys.exit()
-
- if sys.platform != "win32":
- print("Chỉ hỗ trợ trên Windows!")
- sys.exit()
-
- print("Lưu Ý: Hãy cài các phần phụ trợ bên ngoài được đề cập trong phần README.md trước khi tiếp tục!")
-
- install_requirements()
- install_ffmpeg()
\ No newline at end of file
diff --git a/main/app/parser.py b/main/app/parser.py
deleted file mode 100644
index 368894e3bccaa6ef53fa03e091d28eac799795f2..0000000000000000000000000000000000000000
--- a/main/app/parser.py
+++ /dev/null
@@ -1,407 +0,0 @@
-import os
-import sys
-
-sys.path.append(os.getcwd())
-
-try:
- argv = sys.argv[1]
-except IndexError:
- argv = None
-
-argv_help_is_allows = [
- "--help_audio_effects",
- "--help_convert",
- "--help_create_dataset",
- "--help_create_index",
- "--help_extract",
- "--help_preprocess",
- "--help_separate_music",
- "--help_train",
- "--help_create_reference",
- "--help"
-]
-
-COMMANDS = {
- "--audio_effects": "main.inference.audio_effects",
- "--convert": "main.inference.conversion.convert",
- "--create_dataset": "main.inference.create_dataset",
- "--create_index": "main.inference.create_index",
- "--extract": "main.inference.extracting.extract",
- "--preprocess": "main.inference.preprocess.preprocess",
- "--separate_music": "main.inference.separate_music",
- "--train": "main.inference.training.train",
- "--create_reference": "main.inference.create_reference",
-}
-
-if argv is None or argv not in list(COMMANDS) and "--help" not in argv:
- print("Cú pháp không hợp lệ! Sử dụng --help để biết thêm")
- sys.exit()
-
-if argv_help_is_allows[0] == argv:
- print("""Các tham số của `--audio_effects`:
- 1. Đường dẫn tệp:
- - `--input_path` (bắt buộc): Đường dẫn đến tệp âm thanh đầu vào.
- - `--output_path` (mặc định: `./audios/apply_effects.wav`): Đường dẫn lưu tệp đầu ra.
- - `--export_format` (mặc định: `wav`): Định dạng xuất tệp (`wav`, `mp3`, ...).
-
- 2. Lấy mẫu lại:
- - `--resample` (mặc định: `False`): Có lấy mẫu lại hay không.
- - `--resample_sr` (mặc định: `0`): Tần số lấy mẫu mới (Hz).
-
- 3. Chorus:
- - `--chorus`: Bật/tắt chorus.
- - `--chorus_depth`, `--chorus_rate`, `--chorus_mix`, `--chorus_delay`, `--chorus_feedback`: Các thông số điều chỉnh chorus.
-
- 4. Distortion:
- - `--distortion`: Bật/tắt distortion.
- - `--drive_db`: Mức độ méo âm thanh.
-
- 5. Reverb:
- - `--reverb`: Bật/tắt hồi âm.
- - `--reverb_room_size`, `--reverb_damping`, `--reverb_wet_level`, `--reverb_dry_level`, `--reverb_width`, `--reverb_freeze_mode`: Điều chỉnh hồi âm.
-
- 6. Pitchshift:
- - `--pitchshift`: Bật/tắt thay đổi cao độ.
- - `--pitch_shift`: Giá trị dịch cao độ.
-
- 7. Delay:
- - `--delay`: Bật/tắt delay.
- - `--delay_seconds`, `--delay_feedback`, `--delay_mix`: Điều chỉnh thời gian trễ, phản hồi và hòa trộn.
-
- 8. Compressor:
- - `--compressor`: Bật/tắt compressor.
- - `--compressor_threshold`, `--compressor_ratio`, `--compressor_attack_ms`, `--compressor_release_ms`: Các thông số nén.
-
- 9. Limiter:
- - `--limiter`: Bật/tắt giới hạn mức âm thanh.
- - `--limiter_threshold`, `--limiter_release`: Ngưỡng giới hạn và thời gian nhả.
-
- 10. Gain (Khuếch đại):
- - `--gain`: Bật/tắt gain.
- - `--gain_db`: Mức gain (dB).
-
- 11. Bitcrush:
- - `--bitcrush`: Bật/tắt hiệu ứng giảm độ phân giải.
- - `--bitcrush_bit_depth`: Số bit của bitcrush.
-
- 12. Clipping:
- - `--clipping`: Bật/tắt cắt âm thanh.
- - `--clipping_threshold`: Ngưỡng clipping.
-
- 13. Phaser:
- - `--phaser`: Bật/tắt hiệu ứng phaser.
- - `--phaser_rate_hz`, `--phaser_depth`, `--phaser_centre_frequency_hz`, `--phaser_feedback`, `--phaser_mix`: Điều chỉnh hiệu ứng phaser.
-
- 14. Boost bass & treble:
- - `--treble_bass_boost`: Bật/tắt tăng cường âm bass và treble.
- - `--bass_boost_db`, `--bass_boost_frequency`, `--treble_boost_db`, `--treble_boost_frequency`: Các thông số tăng bass và treble.
-
- 15. Fade in & fade out:
- - `--fade_in_out`: Bật/tắt hiệu ứng fade.
- - `--fade_in_duration`, `--fade_out_duration`: Thời gian fade vào/ra.
-
- 16. Kết hợp âm thanh:
- - `--audio_combination`: Bật/tắt ghép nhiều tệp âm thanh.
- - `--audio_combination_input`: Đường dẫn tệp âm thanh bổ sung.
- - `--main_volume`: Âm lượng của âm thanh chính.
- - `--combination_volume`:: Âm lượng của âm thanh cần kết hợp.
- """)
- sys.exit()
-elif argv_help_is_allows[1] == argv:
- print("""Các tham số của --convert:
- 1. Cấu hình xử lí giọng nói:
- - `--pitch` (mặc định: `0`): Điều chỉnh cao độ.
- - `--filter_radius` (mặc định: `3`): Độ mượt của đường F0.
- - `--index_rate` (mặc định: `0.5`): Tỷ lệ sử dụng chỉ mục giọng nói.
- - `--rms_mix_rate` (mặc định: `1`): Hệ số điều chỉnh biên độ âm lượng.
- - `--protect` (mặc định: `0.33`): Bảo vệ phụ âm.
- - `--hop_length` (mặc định: `64`): Bước nhảy khi xử lí âm thanh.
- - `--sid` (mặc định: `0`): Mã số nhận dạng giọng nói đối với mô hình đa giọng.
- - `--noise_scale` (mặc định: `0.35`): Tùy chỉnh đặc biệt cho mô hình SVC gây ảnh hưởng trực tiếp đến chất lượng của âm thanh, bạn không nên điều chỉnh nó.
-
- 2. Cấu hình F0:
- - `--f0_method` (mặc định: `rmvpe`): Phương pháp dự đoán F0 (`pm-ac`, `pm-cc`, `pm-shs`, `dio`, `dio-stonemask`, `mangio-crepe-tiny`, `mangio-crepe-small`, `mangio-crepe-medium`, `mangio-crepe-large`, `mangio-crepe-full`, `crepe-tiny`, `crepe-small`, `crepe-medium`, `crepe-large`, `crepe-full`, `fcpe`, `fcpe-legacy`, `fcpe-previous`, `rmvpe`, `rmvpe-medfilt`, `rmvpe-mix`, `rmvpe-mix-medfilt`, `hpa-rmvpe`, `hpa-rmvpe-medfilt`, `hpa-rmvpe-previous`, `hpa-rmvpe-previous-medfilt`, `harvest`, `harvest-stonemask`, `yin`, `pyin`, `swipe`, `swipe-stonemask`, `piptrack`, `penn`, `mangio-penn`, `djcm`, `djcm-medfilt`, `djcm-svs`, `djcm-svs-medfilt`, `swift`, `pesto`).
- - `--f0_autotune` (mặc định: `False`): Có tự động điều chỉnh F0 hay không.
- - `--f0_autotune_strength` (mặc định: `1`): Cường độ hiệu chỉnh tự động F0.
- - `--f0_file` (mặc định: ``): Đường dẫn tệp F0 có sẵn.
- - `--predictor_onnx` (mặc định: `False`): Có sử dụng chế độ tăng tốc bằng ONNX của trích xuất cao độ hay không.
- - `--proposal_pitch` (mặc định: `False`): Đề xuất cao độ thay vì điều chỉnh thủ công.
- - `--proposal_pitch_threshold` (mặc định: `0.0`): Ngưỡng tần số ước tính cao độ.
- - `--alpha` (mặc định: `0.5`): Ngưỡng trộn cao độ khi ước tính cao độ hybrid.
-
- 3. Mô hình nhúng:
- - `--embedder_model` (mặc định: `hubert_base`): Mô hình nhúng sử dụng.
- - `--embedders_mode` (mặc định: `fairseq`): Chế độ nhúng (`fairseq`, `transformers`, `onnx`, `whisper`).
- - `--embedders_mix` (mặc định: `False`): Hòa trộn tầng.
- - `--embedders_mix_layers` (mặc định: `9`): Tầng hòa trộn.
- - `--embedders_mix_ratio` (mặc định: `0.5`): Tỉ lệ hòa trộn.
-
- 4. Đường dẫn tệp:
- - `--input_path` (bắt buộc): Đường dẫn tệp âm thanh đầu vào.
- - `--output_path` (mặc định: `./audios/output.wav`): Đường dẫn lưu tệp đầu ra.
- - `--export_format` (mặc định: `wav`): Định dạng xuất tệp.
- - `--pth_path` (bắt buộc): Đường dẫn đến tệp mô hình `.pth`.
- - `--index_path` (mặc định: `None`): Đường dẫn tệp chỉ mục (nếu có).
-
- 5. Làm sạch âm thanh:
- - `--clean_audio` (mặc định: `False`): Có áp dụng làm sạch âm thanh không.
- - `--clean_strength` (mặc định: `0.7`): Mức độ làm sạch.
-
- 6. Resampling & chia nhỏ âm thanh:
- - `--resample_sr` (mặc định: `0`): Tần số lấy mẫu mới (0 nghĩa là giữ nguyên).
- - `--split_audio` (mặc định: `False`): Có chia nhỏ audio trước khi xử lí không.
-
- 7. Kiểm tra & tối ưu hóa:
- - `--checkpointing` (mặc định: `False`): Bật/tắt checkpointing để tiết kiệm RAM.
-
- 8. Dịch formant:
- - `--formant_shifting` (mặc định: `False`): Có bật hiệu ứng dịch formant không.
- - `--formant_qfrency` (mặc định: `0.8`): Hệ số dịch formant theo tần số.
- - `--formant_timbre` (mặc định: `0.8`): Hệ số thay đổi màu sắc giọng.
- """)
- sys.exit()
-elif argv_help_is_allows[2] == argv:
- print("""Các tham số của --create_dataset:
- 1. Đường dẫn & cấu hình dataset:
- - `--input_data` (bắt buộc): Đường dẫn liên kết đến âm thanh (Liên kết Youtube, có thể dùng dấu `,` để dùng nhiều liên kết).
- - `--output_dirs` (mặc định: `./dataset`): Thư mục xuất dữ liệu đầu ra.
- - `--sample_rate` (mặc định: `48000`): Tần số lấy mẫu cho âm thanh.
-
- 2. Làm sạch dữ liệu:
- - `--clean_dataset` (mặc định: `False`): Có áp dụng làm sạch dữ liệu hay không.
- - `--clean_strength` (mặc định: `0.7`): Mức độ làm sạch dữ liệu.
-
- 3. Tách giọng & hiệu ứng:
- - `--separate` (mặc định: `True`): có tách nhạc hay không.
- - `--separator_reverb` (mặc định: `False`): Có tách vang giọng không.
- - `--model_name` (mặc định: `MDXNET_Main`): Mô hình tách nhạc ('Main_340', 'Main_390', 'Main_406', 'Main_427', 'Main_438', 'Inst_full_292', 'Inst_HQ_1', 'Inst_HQ_2', 'Inst_HQ_3', 'Inst_HQ_4', 'Inst_HQ_5', 'Kim_Vocal_1', 'Kim_Vocal_2', 'Kim_Inst', 'Inst_187_beta', 'Inst_82_beta', 'Inst_90_beta', 'Voc_FT', 'Crowd_HQ', 'MDXNET_9482', 'Inst_1', 'Inst_2', 'Inst_3', 'MDXNET_1_9703', 'MDXNET_2_9682', 'MDXNET_3_9662', 'Inst_Main', 'MDXNET_Main', 'HT-Tuned', 'HT-Normal', 'HD_MMI', 'HT_6S', 'HP-1', 'HP-2', 'HP-Vocal-1', 'HP-Vocal-2', 'HP2-1', 'HP2-2', 'HP2-3', 'SP-2B-1', 'SP-2B-2', 'SP-3B-1', 'SP-4B-1', 'SP-4B-2', 'SP-MID-1', 'SP-MID-2').
- - `--reverb_model` (mặc định: `MDX-Reverb`): Mô hình tách nhạc ("MDX-Reverb", 'VR-Reverb', 'Echo-Aggressive', 'Echo-Normal').
- - `--denoise_model` (mặc định: `Normal`): Mô hình tách nhạc ('Lite', 'Normal').
-
- 4. Cấu hình xử lí âm thanh:
- - `--shifts` (mặc định: `2`): Số lượng dự đoán.
- - `--batch_size` (mặc định: `1`): Kích thước lô.
- - `--overlap` (mặc định: `0.25`): Mức độ chồng lấn giữa các đoạn.
- - `--aggression` (mặc định: `5`): Cường độ chiết xuất thân chính.
- - `--hop_length` (mặc định: `1024`): Bước nhảy MDX khi xử lí.
- - `--window_size` (mặc định: `512`): Kích thước cửa sổ.
- - `--segments_size` (mặc định: `256`): Kích thước phân đoạn âm thanh.
- - `--post_process_threshold` (mặc định: `0.2`): Mức độ xử lí hậu kỳ sau khi tách nhạc.
-
- 5. Cấu hình xử lí âm thanh khác:
- - `--enable_tta` (mặc định: `False`): Tăng cường suy luận.
- - `--enable_denoise` (mặc định: `False`): Khữ tách nhạc.
- - `--high_end_process` (mặc định: `False`): Xử lí dải cao.
- - `--enable_post_process` (mặc định: `False`): Hậu xử lí.
-
- 6. Bỏ qua phần âm thanh:
- - `--skip_seconds` (mặc định: `False`): Có bỏ qua giây âm thanh nào không.
- - `--skip_start_audios` (mặc định: `0`): Thời gian (giây) cần bỏ qua ở đầu audio.
- - `--skip_end_audios` (mặc định: `0`): Thời gian (giây) cần bỏ qua ở cuối audio.
- """)
- sys.exit()
-elif argv_help_is_allows[3] == argv:
- print("""Các tham số của --create_index:
- 1. Thông tin mô hình:
- - `--model_name` (bắt buộc): Tên mô hình.
- - `--rvc_version` (mặc định: `v2`): Phiên bản (`v1`, `v2`).
- - `--index_algorithm` (mặc định: `Auto`): Thuật toán index sử dụng (`Auto`, `Faiss`, `KMeans`).
- """)
- sys.exit()
-elif argv_help_is_allows[4] == argv:
- print("""Các tham số của --extract:
- 1. Thông tin mô hình:
- - `--model_name` (bắt buộc): Tên mô hình.
- - `--rvc_version` (mặc định: `v2`): Phiên bản mô hình (`v1`, `v2`).
-
- 2. Cấu hình F0:
- - `--f0_method` (mặc định: `rmvpe`): Phương pháp dự đoán F0 (`pm-ac`, `pm-cc`, `pm-shs`, `dio`, `dio-stonemask`, `mangio-crepe-tiny`, `mangio-crepe-small`, `mangio-crepe-medium`, `mangio-crepe-large`, `mangio-crepe-full`, `crepe-tiny`, `crepe-small`, `crepe-medium`, `crepe-large`, `crepe-full`, `fcpe`, `fcpe-legacy`, `fcpe-previous`, `rmvpe`, `rmvpe-medfilt`, `rmvpe-mix`, `rmvpe-mix-medfilt`, `hpa-rmvpe`, `hpa-rmvpe-medfilt`, `hpa-rmvpe-previous`, `hpa-rmvpe-previous-medfilt`, `harvest`, `harvest-stonemask`, `yin`, `pyin`, `swipe`, `swipe-stonemask`, `piptrack`, `penn`, `mangio-penn`, `djcm`, `djcm-medfilt`, `djcm-svs`, `djcm-svs-medfilt`, `swift`, `pesto`).
- - `--predictor_onnx` (mặc định: `False`): Có sử dụng chế độ tăng tốc bằng ONNX của trích xuất cao độ hay không.
- - `--pitch_guidance` (mặc định: `True`): Có sử dụng hướng dẫn cao độ hay không.
- - `--f0_autotune` (mặc định: `False`): Có tự động điều chỉnh F0 hay không.
- - `--f0_autotune_strength` (mặc định: `1`): Cường độ hiệu chỉnh tự động F0.
- - `--alpha` (mặc định: `0.5`): Ngưỡng trộn cao độ khi ước tính cao độ hybrid.
-
- 3. Cấu hình xử lí:
- - `--hop_length` (mặc định: `128`): Độ dài bước nhảy trong quá trình xử lí.
- - `--cpu_cores` (mặc định: `2`): Số lượng luồng CPU sử dụng.
- - `--gpu` (mặc định: `-`): Chỉ định GPU sử dụng (ví dụ: `0` cho GPU đầu tiên, `-` để tắt GPU).
- - `--sample_rate` (bắt buộc): Tần số lấy mẫu của âm thanh đầu vào.
- - `--include_mutes` (mặc định: `2`): Số lượng tệp im lặng được sử dụng huấn luyện.
-
- 4. Cấu hình nhúng:
- - `--embedder_model` (mặc định: `hubert_base`): Tên mô hình nhúng.
- - `--embedders_mode` (mặc định: `fairseq`): Chế độ nhúng (`fairseq`, `transformers`, `onnx`, `whisper`).
- - `--embedders_mix` (mặc định: `False`): Hòa trộn tầng.
- - `--embedders_mix_layers` (mặc định: `9`): Tầng hòa trộn.
- - `--embedders_mix_ratio` (mặc định: `0.5`): Tỉ lệ hòa trộn.
-
- 4. RMS:
- - `--rms_extract` (mặc định: False): Trích xuất thêm năng lượng rms.
- """)
- sys.exit()
-elif argv_help_is_allows[5] == argv:
- print("""Các tham số của --preprocess:
- 1. Thông tin mô hình:
- - `--model_name` (bắt buộc): Tên mô hình.
-
- 2. Cấu hình dữ liệu:
- - `--dataset_path` (mặc định: `./dataset`): Đường dẫn thư mục chứa tệp dữ liệu.
- - `--sample_rate` (bắt buộc): Tần số lấy mẫu của dữ liệu âm thanh.
-
- 3. Cấu hình xử lí:
- - `--cpu_cores` (mặc định: `2`): Số lượng luồng CPU sử dụng.
- - `--cut_preprocess` (mặc định: `Automatic`): Cách cắt dữ liệu tiền xử lí (`Automatic`, `Simple`, `Skip`).
- - `--process_effects` (mặc định: `False`): Có áp dụng tiền xử lí hay không.
- - `--clean_dataset` (mặc định: `False`): Có làm sạch tệp dữ liệu hay không.
- - `--clean_strength` (mặc định: `0.7`): Độ mạnh của quá trình làm sạch dữ liệu.
-
- 4. Cấu hình khác:
- - `--chunk_len` (mặc định: `3.0`): Độ dài của đoạn âm thanh cho phương pháp 'Simple'.
- - `--overlap_len` (mặc định: `0.3`): Độ dài của phần chồng chéo giữa các lát cắt đối với phương pháp 'Simple'.
- - `--normalization_mode` (mặc định: `none`): Có xử lí chuẩn hóa âm thanh không (`none`, `pre`, `post`)
- """)
- sys.exit()
-elif argv_help_is_allows[6] == argv:
- print("""Các tham số của --separate_music:
- 1. Cấu hình đầu vào, đầu ra:
- - `--input_path` (bắt buộc): Đường dẫn tệp âm thanh đầu vào.
- - `--output_dirs` (mặc định: `./audios`): Thư mục lưu tệp đầu ra.
- - `--export_format` (mặc định: `wav`): Định dạng xuất tệp (`wav`, `mp3`,...).
- - `--sample_rate` (mặc định: `44100`): Tần số lấy mẫu của âm thanh đầu ra.
-
- 2. Cấu hình mô hình:
- - `--model_name` (mặc định: `MDXNET_Main`): Mô hình tách nhạc ('Main_340', 'Main_390', 'Main_406', 'Main_427', 'Main_438', 'Inst_full_292', 'Inst_HQ_1', 'Inst_HQ_2', 'Inst_HQ_3', 'Inst_HQ_4', 'Inst_HQ_5', 'Kim_Vocal_1', 'Kim_Vocal_2', 'Kim_Inst', 'Inst_187_beta', 'Inst_82_beta', 'Inst_90_beta', 'Voc_FT', 'Crowd_HQ', 'MDXNET_9482', 'Inst_1', 'Inst_2', 'Inst_3', 'MDXNET_1_9703', 'MDXNET_2_9682', 'MDXNET_3_9662', 'Inst_Main', 'MDXNET_Main', 'HT-Tuned', 'HT-Normal', 'HD_MMI', 'HT_6S', 'HP-1', 'HP-2', 'HP-Vocal-1', 'HP-Vocal-2', 'HP2-1', 'HP2-2', 'HP2-3', 'SP-2B-1', 'SP-2B-2', 'SP-3B-1', 'SP-4B-1', 'SP-4B-2', 'SP-MID-1', 'SP-MID-2').
- - `--karaoke_model` (mặc định: `MDX-Version-1`): Mô hình tách nhạc ('MDX-Version-1', 'MDX-Version-2', 'VR-Version-1', 'VR-Version-2').
- - `--reverb_model` (mặc định: `MDX-Reverb`): Mô hình tách nhạc ("MDX-Reverb", 'VR-Reverb', 'Echo-Aggressive', 'Echo-Normal').
- - `--denoise_model` (mặc định: `Normal`): Mô hình tách nhạc ('Lite', 'Normal').
-
- 3. Cấu hình xử lí âm thanh:
- - `--shifts` (mặc định: `2`): Số lượng dự đoán.
- - `--batch_size` (mặc định: `1`): Kích thước lô.
- - `--overlap` (mặc định: `0.25`): Mức độ chồng lấn giữa các đoạn.
- - `--aggression` (mặc định: `5`): Cường độ chiết xuất thân chính.
- - `--hop_length` (mặc định: `1024`): Bước nhảy MDX khi xử lí.
- - `--window_size` (mặc định: `512`): Kích thước cửa sổ.
- - `--segments_size` (mặc định: `256`): Kích thước phân đoạn âm thanh.
- - `--post_process_threshold` (mặc định: `0.2`): Mức độ xử lí hậu kỳ sau khi tách nhạc.
-
- 4. Cấu hình xử lí âm thanh khác:
- - `--enable_tta` (mặc định: `False`): Tăng cường suy luận.
- - `--enable_denoise` (mặc định: `False`): Khữ tách nhạc.
- - `--high_end_process` (mặc định: `False`): Xử lí dải cao.
- - `--enable_post_process` (mặc định: `False`): Hậu xử lí.
- - `--separate_backing` (mặc định: `False`): Tách bè giọng.
- - `--separate_reverb` (mặc định: `False`): Tách vang giọng.
- """)
- sys.exit()
-elif argv_help_is_allows[7] == argv:
- print("""Các tham số của --train:
- 1. Cấu hình mô hình:
- - `--model_name` (bắt buộc): Tên mô hình.
- - `--rvc_version` (mặc định: `v2`): Phiên bản mô hình (`v1`, `v2`).
- - `--model_author` (tùy chọn): Tác giả của mô hình.
-
- 2. Cấu hình lưu:
- - `--save_every_epoch` (bắt buộc): Số kỷ nguyên giữa mỗi lần lưu.
- - `--save_only_latest` (mặc định: `True`): Chỉ lưu điểm mới nhất.
- - `--save_every_weights` (mặc định: `True`): Lưu tất cả trọng số của mô hình.
-
- 3. Cấu hình huấn luyện:
- - `--total_epoch` (mặc định: `300`): Tổng số kỷ nguyên huấn luyện.
- - `--batch_size` (mặc định: `8`): Kích thước lô trong quá trình huấn luyện.
-
- 4. Cấu hình thiết bị:
- - `--gpu` (mặc định: `0`): Chỉ định GPU để sử dụng (số hoặc `-` nếu không dùng GPU).
- - `--cache_data_in_gpu` (mặc định: `False`): Lưu dữ liệu vào GPU để tăng tốc.
-
- 5. Cấu hình huấn luyện nâng cao:
- - `--pitch_guidance` (mặc định: `True`): Sử dụng hướng dẫn cao độ.
- - `--g_pretrained_path` (mặc định: ``): Đường dẫn đến trọng số G đã huấn luyện trước.
- - `--d_pretrained_path` (mặc định: ``): Đường dẫn đến trọng số D đã huấn luyện trước.
- - `--vocoder` (mặc định: `Default`): Bộ mã hóa được sử dụng (`Default`, `MRF-HiFi-GAN`, `RefineGAN`).
- - `--energy_use` (mặc định: `False`): Sử dụng năng lượng rms.
- - `--architecture` (mặc định: `RVC`): Kiến trúc của mô hình giọng nói (`RVC`, `SVC`).
-
- 6. Phát hiện huấn luyện quá mức:
- - `--overtraining_detector` (mặc định: `False`): Bật/tắt chế độ phát hiện huấn luyện quá mức.
- - `--overtraining_threshold` (mặc định: `50`): Ngưỡng để xác định huấn luyện quá mức.
-
- 7. Xử lí dữ liệu:
- - `--cleanup` (mặc định: `False`): Dọn dẹp tệp huấn luyện cũ để tiến hành huấn luyện lại từ đầu.
-
- 8. Tối ưu:
- - `--checkpointing` (mặc định: `False`): Bật/tắt checkpointing để tiết kiệm RAM.
- - `--deterministic` (mặc định: `False`): Khi bật sẽ sử dụng các thuật toán có tính xác định cao, đảm bảo rằng mỗi lần chạy cùng một dữ liệu đầu vào sẽ cho kết quả giống nhau.
- - `--benchmark` (mặc định: `False`): Khi bật sẽ thử nghiệm và chọn thuật toán tối ưu nhất cho phần cứng và kích thước cụ thể.
- - `--optimizer` (mặc định: `AdamW`): Trình tối ưu hóa được sử dụng (`AdamW`, `RAdam`, `AnyPrecisionAdamW`, `AdaBelief`, `AdaBeliefV2`).
- - `--multiscale_mel_loss` (mặc định: `False`): So sánh phổ Mel của âm thanh thật và âm thanh giả ở nhiều thang độ khác nhau. Giúp mô hình học được chi tiết âm sắc, độ sáng và cấu trúc tần số tốt hơn, từ đó cải thiện chất lượng và độ tự nhiên của giọng nói đầu ra.
- - `--use_cosine_annealing_lr` (mặc định: `False`): Sử dụng phương pháp giảm LR bằng Cosine Annealing có thể giúp cải thiện chất lượng phát âm.
-
- 9. Bộ tham chiếu:
- - `--use_custom_reference` (mặc định: `False`): Có tùy chỉnh bộ tham chiếu hay không.
- - `--reference_path` (mặc định: `False`): Đường dẫn đến bộ tham chiếu.
- """)
- sys.exit()
-elif argv_help_is_allows[8] == argv:
- print("""Các tham số của --create_reference:
- 1. Đường dẫn tệp:
- - `--audio_path` (bắt buộc): Đường dẫn tệp âm thanh đầu vào.
- - `--reference_name` (mặc định: `reference`): Đường dẫn lưu bộ tham chiếu đầu ra.
-
- 2. Cấu hình bộ tham chiếu:
- - `--pitch_guidance` (mặc định: `True`): Sử dụng hướng dẫn cao độ.
- - `--energy_use` (mặc định: `False`): Sử dụng năng lượng rms.
- - `--version` (mặc định: `v2`): Phiên bản mô hình (`v1`, `v2`).
-
- 3. Cấu hình nhúng:
- - `--embedder_model` (mặc định: `hubert_base`): Tên mô hình nhúng.
- - `--embedders_mode` (mặc định: `fairseq`): Chế độ nhúng (`fairseq`, `transformers`, `onnx`, `whisper`).
- - `--embedders_mix` (mặc định: `False`): Hòa trộn tầng.
- - `--embedders_mix_layers` (mặc định: `9`): Tầng hòa trộn.
- - `--embedders_mix_ratio` (mặc định: `0.5`): Tỉ lệ hòa trộn.
-
- 4. Cấu hình F0:
- - `--f0_method` (mặc định: `rmvpe`): Phương pháp dự đoán F0 (`pm-ac`, `pm-cc`, `pm-shs`, `dio`, `dio-stonemask`, `mangio-crepe-tiny`, `mangio-crepe-small`, `mangio-crepe-medium`, `mangio-crepe-large`, `mangio-crepe-full`, `crepe-tiny`, `crepe-small`, `crepe-medium`, `crepe-large`, `crepe-full`, `fcpe`, `fcpe-legacy`, `fcpe-previous`, `rmvpe`, `rmvpe-medfilt`, `rmvpe-mix`, `rmvpe-mix-medfilt`, `hpa-rmvpe`, `hpa-rmvpe-medfilt`, `hpa-rmvpe-previous`, `hpa-rmvpe-previous-medfilt`, `harvest`, `harvest-stonemask`, `yin`, `pyin`, `swipe`, `swipe-stonemask`, `piptrack`, `penn`, `mangio-penn`, `djcm`, `djcm-medfilt`, `djcm-svs`, `djcm-svs-medfilt`, `swift`, `pesto`).
- - `--predictor_onnx` (mặc định: `False`): Có sử dụng chế độ tăng tốc bằng ONNX của trích xuất cao độ hay không.
- - `--f0_up_key` (mặc định: `0`): Điều chỉnh cao độ.
- - `--filter_radius` (mặc định: `3`): Độ mượt của đường F0.
- - `--f0_autotune` (mặc định: `False`): Có tự động điều chỉnh F0 hay không.
- - `--f0_autotune_strength` (mặc định: `1`): Cường độ hiệu chỉnh tự động F0.
- - `--f0_file` (mặc định: ``): Đường dẫn tệp F0 có sẵn.
- - `--proposal_pitch` (mặc định: `False`): Đề xuất cao độ thay vì điều chỉnh thủ công.
- - `--proposal_pitch_threshold` (mặc định: `0.0`): Ngưỡng tần số ước tính cao độ.
- - `--alpha` (mặc định: `0.5`): Ngưỡng trộn cao độ khi ước tính cao độ hybrid.
- """)
- sys.exit()
-elif argv_help_is_allows[9] == argv:
- print("""Sử dụng:
- 1. `--help_audio_effects`: Trợ giúp về phần thêm hiệu ứng âm thanh.
- 2. `--help_convert`: Trợ giúp về chuyển đổi âm thanh.
- 3. `--help_create_dataset`: Trợ giúp về tạo dữ liệu huấn luyện.
- 4. `--help_create_index`: Trợ giúp về tạo chỉ mục.
- 5. `--help_extract`: Trợ giúp về trích xuất dữ liệu huấn luyện.
- 6. `--help_preprocess`: Trợ giúp về xử lí trước dữ liệu.
- 7. `--help_separate_music`: Trợ giúp về tách nhạc.
- 8. `--help_train`: Trợ giúp về huấn luyện mô hình.
- 9. `--help_create_reference`: Trợ giúp về tạo bộ tham chiếu.
- """)
- sys.exit()
-elif argv in COMMANDS:
- import importlib
-
- module = importlib.import_module(COMMANDS[argv])
- main = module.main
-else:
- main = lambda: print("Cú pháp không hợp lệ!"); sys.exit()
-
-if __name__ == "__main__":
- import torch.multiprocessing as mp
-
- try:
- if "--train" in argv: mp.set_start_method("spawn")
- if "--preprocess" in argv or "--extract" in argv: mp.set_start_method("spawn", force=True)
- except:
- pass
-
- main()
\ No newline at end of file
diff --git a/main/app/run_tensorboard.py b/main/app/run_tensorboard.py
deleted file mode 100644
index 1cc07da8d6002b535d7c9c1b600d80aeb798fd4f..0000000000000000000000000000000000000000
--- a/main/app/run_tensorboard.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import os
-import sys
-import time
-import logging
-import warnings
-import webbrowser
-
-from tensorboard import program
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import config, translations, logger
-
-def launch_tensorboard():
- if not config.debug_mode:
- warnings.filterwarnings("ignore")
- for l in ["root", "tensorboard"]:
- logging.getLogger(l).setLevel(logging.ERROR)
-
- tb = program.TensorBoard()
- tb.configure(
- argv=[
- None,
- "--logdir", config.configs["logs_path"],
- f"--port={config.configs['tensorboard_port']}"
- ]
- )
- url = tb.launch()
-
- logger.info(f"{translations['tensorboard_url']}: {url}")
- if "--open" in sys.argv: webbrowser.open(url)
-
- return url
-
-if __name__ == "__main__":
- launch_tensorboard()
-
- while 1:
- time.sleep(5)
\ No newline at end of file
diff --git a/main/app/tabs/downloads/downloads.py b/main/app/tabs/downloads/downloads.py
deleted file mode 100644
index 4e6db4b3357f894901e3c9a37086e6997c2f1efd..0000000000000000000000000000000000000000
--- a/main/app/tabs/downloads/downloads.py
+++ /dev/null
@@ -1,330 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import (
- models,
- configs,
- translations,
- model_options
-)
-
-from main.app.core.downloads import (
- search_models,
- download_model,
- download_pretrained_model
-)
-
-from main.app.core.ui import (
- shutil_move,
- change_download_choices,
- change_download_pretrained_choices
-)
-
-from main.app.core.process import (
- save_drop_model,
- fetch_pretrained_data,
- update_sample_rate_dropdown
-)
-
-def download_tab():
- with gr.TabItem(
- translations["downloads"]
- ):
- gr.Markdown(translations["download_markdown"])
- with gr.Row():
- gr.Markdown(translations["download_markdown_2"])
- with gr.Row():
- with gr.Accordion(
- translations["model_download"],
- open=True
- ):
- with gr.Row():
- download_method = gr.Radio(
- label=translations["model_download_select"],
- choices=[
- translations["download_url"],
- translations["download_from_csv"],
- translations["search_models"],
- translations["upload"]
- ],
- interactive=True,
- value=translations["download_url"]
- )
- with gr.Row():
- gr.Markdown("___")
- with gr.Column():
- with gr.Row():
- download_model_url = gr.Textbox(
- label=translations["model_url"],
- value="",
- placeholder="https://...",
- scale=6
- )
- download_model_name = gr.Textbox(
- label=translations["modelname"],
- value="",
- placeholder=translations["modelname"],
- scale=2
- )
- download_url_button = gr.Button(
- value=translations["downloads"],
- scale=2
- )
- with gr.Column():
- download_csv_model = gr.Dropdown(
- choices=models.keys(),
- label=translations["model_warehouse"],
- scale=8,
- allow_custom_value=True,
- visible=False
- )
- download_csv_button = gr.Button(
- value=translations["get_model"],
- scale=2,
- variant="primary",
- visible=False
- )
- with gr.Column():
- search_model_name = gr.Textbox(
- label=translations["name_to_search"],
- placeholder=translations["modelname"],
- interactive=True,
- scale=8,
- visible=False
- )
- search_button = gr.Button(
- translations["search_2"],
- scale=2,
- visible=False
- )
- search_dropdown = gr.Dropdown(
- label=translations["select_download_model"],
- value="",
- choices=[],
- allow_custom_value=True,
- interactive=False,
- visible=False
- )
- search_download_model = gr.Button(
- translations["downloads"],
- variant="primary",
- visible=False
- )
- with gr.Column():
- upload_model_files = gr.Files(
- label=translations["drop_model"],
- file_types=[".pth", ".onnx", ".index", ".zip"],
- visible=False
- )
- with gr.Row():
- with gr.Accordion(
- translations["download_pretrained_2"],
- open=True
- ):
- with gr.Row():
- download_pretrain_method = gr.Radio(
- label=translations["model_download_select"],
- choices=[
- translations["download_url"],
- translations["list_model"],
- translations["upload"]
- ],
- value=translations["download_url"],
- interactive=True
- )
- with gr.Row():
- gr.Markdown("___")
- with gr.Column():
- with gr.Row():
- download_pretrain_disc_url = gr.Textbox(
- label=translations["pretrained_url"].format(dg="D"),
- value="",
- placeholder="https://...",
- interactive=True,
- scale=4
- )
- download_pretrain_gen_url = gr.Textbox(
- label=translations["pretrained_url"].format(dg="G"),
- value="",
- placeholder="https://...",
- interactive=True,
- scale=4
- )
- download_pretrain_button = gr.Button(
- translations["downloads"],
- scale=2,
- visible=True
- )
- with gr.Column():
- with gr.Row():
- download_pretrain_choices = gr.Dropdown(
- label=translations["select_pretrain"],
- info=translations["select_pretrain_info"],
- choices=list(fetch_pretrained_data().keys()),
- value="Titan_Medium",
- allow_custom_value=True,
- interactive=True,
- scale=6,
- visible=False
- )
- download_pretrain_sample_rate = gr.Dropdown(
- label=translations["pretrain_sr"],
- info=translations["pretrain_sr"],
- choices=["48k", "40k", "32k"],
- value="48k",
- interactive=True,
- visible=False
- )
- download_pretrain_choices_button = gr.Button(
- translations["downloads"],
- scale=2,
- variant="primary",
- visible=False
- )
- with gr.Row():
- upload_pretrains = gr.Files(
- label=translations["drop_pretrain"].format(dg="G, D"),
- file_types=[".pth"],
- visible=False
- )
- with gr.Row():
- download_url_button.click(
- fn=download_model,
- inputs=[
- download_model_url,
- download_model_name
- ],
- outputs=[download_model_url],
- api_name="download_model"
- )
- download_csv_button.click(
- fn=lambda model: download_model(
- models[model],
- model
- ),
- inputs=[
- download_csv_model
- ],
- outputs=[
- download_csv_model
- ],
- api_name="download_browser"
- )
- with gr.Row():
- download_method.change(
- fn=change_download_choices,
- inputs=[
- download_method
- ],
- outputs=[
- download_model_url,
- download_model_name,
- download_url_button,
- download_csv_model,
- download_csv_button,
- search_model_name,
- search_button,
- search_dropdown,
- search_download_model,
- upload_model_files
- ]
- )
- search_button.click(
- fn=search_models,
- inputs=[
- search_model_name
- ],
- outputs=[
- search_dropdown,
- search_download_model
- ]
- )
- with gr.Row():
- upload_model_files.upload(
- fn=save_drop_model,
- inputs=[
- upload_model_files
- ],
- outputs=[
- upload_model_files
- ]
- )
- search_download_model.click(
- fn=lambda model: download_model(
- model_options[model],
- model
- ),
- inputs=[
- search_dropdown
- ],
- outputs=[
- search_dropdown
- ],
- api_name="search_models"
- )
- with gr.Row():
- download_pretrain_method.change(
- fn=change_download_pretrained_choices,
- inputs=[
- download_pretrain_method
- ],
- outputs=[
- download_pretrain_disc_url,
- download_pretrain_gen_url,
- download_pretrain_button,
- download_pretrain_choices,
- download_pretrain_sample_rate,
- download_pretrain_choices_button,
- upload_pretrains
- ]
- )
- download_pretrain_choices.change(
- fn=update_sample_rate_dropdown,
- inputs=[
- download_pretrain_choices
- ],
- outputs=[
- download_pretrain_sample_rate
- ]
- )
- with gr.Row():
- download_pretrain_button.click(
- fn=download_pretrained_model,
- inputs=[
- download_pretrain_method,
- download_pretrain_disc_url,
- download_pretrain_gen_url
- ],
- outputs=[
- download_pretrain_disc_url,
- download_pretrain_gen_url
- ],
- api_name="download_pretrain_link"
- )
- download_pretrain_choices_button.click(
- fn=download_pretrained_model,
- inputs=[
- download_pretrain_method,
- download_pretrain_choices,
- download_pretrain_sample_rate
- ],
- outputs=[
- download_pretrain_choices
- ],
- api_name="download_pretrain_choices"
- )
- upload_pretrains.upload(
- fn=lambda upload_pretrains: [
- shutil_move(pretrain.name, configs["pretrained_custom_path"])
- for pretrain in upload_pretrains
- ],
- inputs=[
- upload_pretrains
- ],
- outputs=[],
- api_name="upload_pretrain"
- )
\ No newline at end of file
diff --git a/main/app/tabs/editing/child/audio_effects.py b/main/app/tabs/editing/child/audio_effects.py
deleted file mode 100644
index 050ca6947c5f674dbc6cd6dfdcc9df3b4237eb1d..0000000000000000000000000000000000000000
--- a/main/app/tabs/editing/child/audio_effects.py
+++ /dev/null
@@ -1,1165 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.editing import audio_effects
-
-from main.app.core.presets import (
- audio_effect_load_presets,
- audio_effect_save_presets
-)
-
-from main.app.core.ui import (
- visible,
- shutil_move,
- change_audios_choices,
- change_effect_preset_choices
-)
-
-from main.app.variables import (
- configs,
- file_types,
- translations,
- audio_params,
- paths_for_files,
- sample_rate_choice,
- export_format_choices,
- audio_effect_presets_file
-)
-
-def audio_effects_tab():
- with gr.Row():
- gr.Markdown(translations["audio_effects_edit"])
- with gr.Row():
- with gr.Column():
- with gr.Row():
- reverb_check_box = gr.Checkbox(
- label=translations["reverb"],
- value=False,
- interactive=True
- )
- chorus_check_box = gr.Checkbox(
- label=translations["chorus"],
- value=False,
- interactive=True
- )
- delay_check_box = gr.Checkbox(
- label=translations["delay"],
- value=False,
- interactive=True
- )
- phaser_check_box = gr.Checkbox(
- label=translations["phaser"],
- value=False,
- interactive=True
- )
- compressor_check_box = gr.Checkbox(
- label=translations["compressor"],
- value=False,
- interactive=True
- )
- more_options = gr.Checkbox(
- label=translations["more_option"],
- value=False,
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["input_output"],
- open=False
- ):
- with gr.Row():
- upload_audio_files = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- with gr.Row():
- audio_in_path = gr.Dropdown(
- label=translations["input_audio"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- interactive=True,
- allow_custom_value=True
- )
- audio_out_path = gr.Textbox(
- label=translations["output_audio"],
- value="audios/audio_effects.wav",
- placeholder="audios/audio_effects.wav",
- info=translations["provide_output"],
- interactive=True
- )
- with gr.Row():
- with gr.Column():
- audio_combination = gr.Checkbox(
- label=translations["merge_instruments"],
- value=False,
- interactive=True
- )
- audio_combination_input = gr.Dropdown(
- label=translations["input_audio"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- interactive=True,
- allow_custom_value=True,
- visible=False
- )
- with gr.Row():
- main_volume = gr.Slider(
- minimum=-80,
- maximum=80,
- label=translations["main_volume"],
- info=translations["main_volume_info"],
- value=-4,
- step=1,
- interactive=True,
- visible=False
- )
- combine_volume = gr.Slider(
- minimum=-80,
- maximum=80,
- label=translations["combination_volume"],
- info=translations["combination_volume_info"],
- value=-7,
- step=1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- audio_effects_refresh = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- audio_output_format = gr.Radio(
- label=translations["export_format"],
- info=translations["export_info"],
- choices=export_format_choices,
- value="wav",
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["use_presets"],
- open=False
- ):
- with gr.Row():
- presets_name = gr.Dropdown(
- label=translations["file_preset"],
- choices=audio_effect_presets_file,
- value=(
- audio_effect_presets_file[0]
- ) if len(audio_effect_presets_file) > 0 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- load_preset_button = gr.Button(
- translations["load_file"],
- variant="primary"
- )
- refresh_preset_button = gr.Button(
- translations["refresh"]
- )
- with gr.Accordion(
- translations["export_file"],
- open=False
- ):
- with gr.Row():
- with gr.Column():
- name_to_save_file = gr.Textbox(
- label=translations["filename_to_save"]
- )
- save_file_button = gr.Button(
- translations["export_file"]
- )
- with gr.Row():
- upload_presets = gr.Files(
- label=translations["upload_presets"],
- file_types=[".effect.json"]
- )
- with gr.Row():
- apply_effects_button = gr.Button(
- translations["apply"],
- variant="primary",
- scale=2
- )
- with gr.Accordion(translations["audio_effects"], visible=False) as accordion:
- with gr.Row():
- with gr.Accordion(
- translations["reverb"],
- open=True,
- visible=False
- ) as reverb_accordion:
- reverb_freeze_mode = gr.Checkbox(
- label=translations["reverb_freeze"],
- info=translations["reverb_freeze_info"],
- value=False,
- interactive=True
- )
- reverb_room_size = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.15,
- label=translations["room_size"],
- info=translations["room_size_info"],
- interactive=True
- )
- reverb_damping = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.7,
- label=translations["damping"],
- info=translations["damping_info"],
- interactive=True
- )
- reverb_wet_level = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.2,
- label=translations["wet_level"],
- info=translations["wet_level_info"],
- interactive=True
- )
- reverb_dry_level = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.8,
- label=translations["dry_level"],
- info=translations["dry_level_info"],
- interactive=True
- )
- reverb_width = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=1,
- label=translations["width"],
- info=translations["width_info"],
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["chorus"],
- open=True,
- visible=False
- ) as chorus_accordion:
- chorus_depth = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["chorus_depth"],
- info=translations["chorus_depth_info"],
- interactive=True
- )
- chorus_rate_hz = gr.Slider(
- minimum=0.1,
- maximum=10,
- step=0.1,
- value=1.5,
- label=translations["chorus_rate_hz"],
- info=translations["chorus_rate_hz_info"],
- interactive=True
- )
- chorus_mix = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["chorus_mix"],
- info=translations["chorus_mix_info"],
- interactive=True
- )
- chorus_center_delay_ms = gr.Slider(
- minimum=0,
- maximum=50,
- step=1,
- value=10,
- label=translations["chorus_center_delay_ms"],
- info=translations["chorus_center_delay_ms_info"],
- interactive=True
- )
- chorus_feedback = gr.Slider(
- minimum=-1,
- maximum=1,
- step=0.01,
- value=0,
- label=translations["chorus_feedback"],
- info=translations["chorus_feedback_info"],
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["delay"],
- open=True,
- visible=False
- ) as delay_accordion:
- delay_second = gr.Slider(
- minimum=0,
- maximum=5,
- step=0.01,
- value=0.5,
- label=translations["delay_seconds"],
- info=translations["delay_seconds_info"],
- interactive=True
- )
- delay_feedback = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["delay_feedback"],
- info=translations["delay_feedback_info"],
- interactive=True
- )
- delay_mix = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["delay_mix"],
- info=translations["delay_mix_info"],
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["phaser"],
- open=True,
- visible=False
- ) as phaser_accordion:
- phaser_depth = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["phaser_depth"],
- info=translations["phaser_depth_info"],
- interactive=True
- )
- phaser_rate_hz = gr.Slider(
- minimum=0.1,
- maximum=10,
- step=0.1,
- value=1,
- label=translations["phaser_rate_hz"],
- info=translations["phaser_rate_hz_info"],
- interactive=True
- )
- phaser_mix = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["phaser_mix"],
- info=translations["phaser_mix_info"],
- interactive=True
- )
- phaser_centre_frequency_hz = gr.Slider(
- minimum=50,
- maximum=5000,
- step=10,
- value=1000,
- label=translations["phaser_centre_frequency_hz"],
- info=translations["phaser_centre_frequency_hz_info"],
- interactive=True
- )
- phaser_feedback = gr.Slider(
- minimum=-1,
- maximum=1,
- step=0.01,
- value=0,
- label=translations["phaser_feedback"],
- info=translations["phaser_feedback_info"],
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["compressor"],
- open=True,
- visible=False
- ) as compressor_accordion:
- compressor_threshold_db = gr.Slider(
- minimum=-60,
- maximum=0,
- step=1,
- value=-20,
- label=translations["compressor_threshold_db"],
- info=translations["compressor_threshold_db_info"],
- interactive=True
- )
- compressor_ratio = gr.Slider(
- minimum=1,
- maximum=20,
- step=0.1,
- value=1,
- label=translations["compressor_ratio"],
- info=translations["compressor_ratio_info"],
- interactive=True
- )
- compressor_attack_ms = gr.Slider(
- minimum=0.1,
- maximum=100,
- step=0.1,
- value=10,
- label=translations["compressor_attack_ms"],
- info=translations["compressor_attack_ms_info"],
- interactive=True
- )
- compressor_release_ms = gr.Slider(
- minimum=10,
- maximum=1000,
- step=1,
- value=100,
- label=translations["compressor_release_ms"],
- info=translations["compressor_release_ms_info"],
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["more_option"],
- open=True,
- visible=False
- ) as more_accordion:
- with gr.Row():
- fade = gr.Checkbox(
- label=translations["fade"],
- value=False,
- interactive=True
- )
- bass_or_treble = gr.Checkbox(
- label=translations["bass_or_treble"],
- value=False,
- interactive=True
- )
- limiter = gr.Checkbox(
- label=translations["limiter"],
- value=False,
- interactive=True
- )
- resample_checkbox = gr.Checkbox(
- label=translations["resample"],
- value=False,
- interactive=True
- )
- with gr.Row():
- distortion_checkbox = gr.Checkbox(
- label=translations["distortion"],
- value=False,
- interactive=True
- )
- gain_checkbox = gr.Checkbox(
- label=translations["gain"],
- value=False,
- interactive=True
- )
- bitcrush_checkbox = gr.Checkbox(
- label=translations["bitcrush"],
- value=False,
- interactive=True
- )
- clipping_checkbox = gr.Checkbox(
- label=translations["clipping"],
- value=False,
- interactive=True
- )
- with gr.Accordion(
- translations["fade"],
- open=True,
- visible=False
- ) as fade_accordion:
- with gr.Row():
- fade_in = gr.Slider(
- minimum=0,
- maximum=10000,
- step=100,
- value=0,
- label=translations["fade_in"],
- info=translations["fade_in_info"],
- interactive=True
- )
- fade_out = gr.Slider(
- minimum=0,
- maximum=10000,
- step=100,
- value=0,
- label=translations["fade_out"],
- info=translations["fade_out_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["bass_or_treble"],
- open=True,
- visible=False
- ) as bass_treble_accordion:
- with gr.Row():
- bass_boost = gr.Slider(
- minimum=0,
- maximum=20,
- step=1,
- value=0,
- label=translations["bass_boost"],
- info=translations["bass_boost_info"],
- interactive=True
- )
- bass_frequency = gr.Slider(
- minimum=20,
- maximum=200,
- step=10,
- value=100,
- label=translations["bass_frequency"],
- info=translations["bass_frequency_info"],
- interactive=True
- )
- with gr.Row():
- treble_boost = gr.Slider(
- minimum=0,
- maximum=20,
- step=1,
- value=0,
- label=translations["treble_boost"],
- info=translations["treble_boost_info"],
- interactive=True
- )
- treble_frequency = gr.Slider(
- minimum=1000,
- maximum=10000,
- step=500,
- value=3000,
- label=translations["treble_frequency"],
- info=translations["treble_frequency_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["limiter"],
- open=True,
- visible=False
- ) as limiter_accordion:
- with gr.Row():
- limiter_threshold_db = gr.Slider(
- minimum=-60,
- maximum=0,
- step=1,
- value=-1,
- label=translations["limiter_threshold_db"],
- info=translations["limiter_threshold_db_info"],
- interactive=True
- )
- limiter_release_ms = gr.Slider(
- minimum=10,
- maximum=1000,
- step=1,
- value=100,
- label=translations["limiter_release_ms"],
- info=translations["limiter_release_ms_info"],
- interactive=True
- )
- with gr.Column():
- pitch_shift_semitones = gr.Slider(
- minimum=-20,
- maximum=20,
- step=1,
- value=0,
- label=translations["pitch"],
- info=translations["pitch_info"],
- interactive=True
- )
- audio_effect_resample_sr = gr.Radio(
- choices=[0]+sample_rate_choice,
- value=0,
- label=translations["resample"],
- info=translations["resample_info"],
- interactive=True,
- visible=False
- )
- distortion_drive_db = gr.Slider(
- minimum=0,
- maximum=50,
- step=1,
- value=20,
- label=translations["distortion"],
- info=translations["distortion_info"],
- interactive=True,
- visible=False
- )
- gain_db = gr.Slider(
- minimum=-60,
- maximum=60,
- step=1,
- value=0,
- label=translations["gain"],
- info=translations["gain_info"],
- interactive=True,
- visible=False
- )
- clipping_threshold_db = gr.Slider(
- minimum=-60,
- maximum=0,
- step=1,
- value=-1,
- label=translations["clipping_threshold_db"],
- info=translations["clipping_threshold_db_info"],
- interactive=True,
- visible=False
- )
- bitcrush_bit_depth = gr.Slider(
- minimum=1,
- maximum=24,
- step=1,
- value=16,
- label=translations["bitcrush_bit_depth"],
- info=translations["bitcrush_bit_depth_info"],
- interactive=True,
- visible=False
- )
- with gr.Row():
- gr.Markdown(translations["output_audio"])
- with gr.Row():
- audio_play_input = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- audio_play_output = gr.Audio(
- interactive=False,
- label=translations["output_audio"],
- **audio_params
- )
- with gr.Row():
- reverb_check_box.change(
- fn=visible,
- inputs=[
- reverb_check_box
- ],
- outputs=[
- reverb_accordion
- ]
- )
- chorus_check_box.change(
- fn=visible,
- inputs=[
- chorus_check_box
- ],
- outputs=[
- chorus_accordion
- ]
- )
- delay_check_box.change(
- fn=visible,
- inputs=[
- delay_check_box
- ],
- outputs=[
- delay_accordion
- ]
- )
- with gr.Row():
- compressor_check_box.change(
- fn=visible,
- inputs=[
- compressor_check_box
- ],
- outputs=[
- compressor_accordion
- ]
- )
- phaser_check_box.change(
- fn=visible,
- inputs=[
- phaser_check_box
- ],
- outputs=[
- phaser_accordion
- ]
- )
- more_options.change(
- fn=visible,
- inputs=[
- more_options
- ],
- outputs=[
- more_accordion
- ]
- )
- with gr.Row():
- fade.change(
- fn=visible,
- inputs=[
- fade
- ],
- outputs=[
- fade_accordion
- ]
- )
- bass_or_treble.change(
- fn=visible,
- inputs=[
- bass_or_treble
- ],
- outputs=[
- bass_treble_accordion
- ]
- )
- limiter.change(
- fn=visible,
- inputs=[
- limiter
- ],
- outputs=[
- limiter_accordion
- ]
- )
- resample_checkbox.change(
- fn=visible,
- inputs=[
- resample_checkbox
- ],
- outputs=[
- audio_effect_resample_sr
- ]
- )
- with gr.Row():
- distortion_checkbox.change(
- fn=visible,
- inputs=[
- distortion_checkbox
- ],
- outputs=[
- distortion_drive_db
- ]
- )
- gain_checkbox.change(
- fn=visible,
- inputs=[
- gain_checkbox
- ],
- outputs=[
- gain_db
- ]
- )
- clipping_checkbox.change(
- fn=visible,
- inputs=[
- clipping_checkbox
- ],
- outputs=[
- clipping_threshold_db
- ]
- )
- with gr.Row():
- bitcrush_checkbox.change(
- fn=visible,
- inputs=[
- bitcrush_checkbox
- ],
- outputs=[
- bitcrush_bit_depth
- ]
- )
- upload_audio_files.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- upload_audio_files
- ],
- outputs=[
- audio_in_path
- ]
- )
- audio_in_path.change(
- fn=lambda audio: audio if audio else None,
- inputs=[
- audio_in_path
- ],
- outputs=[
- audio_play_input
- ]
- )
- with gr.Row():
- audio_effects_refresh.click(
- fn=lambda a, b: [
- change_audios_choices(a),
- change_audios_choices(b)
- ],
- inputs=[
- audio_in_path,
- audio_combination_input
- ],
- outputs=[
- audio_in_path,
- audio_combination_input
- ]
- )
- audio_combination.change(
- fn=visible,
- inputs=[
- audio_combination
- ],
- outputs=[
- audio_combination_input
- ]
- )
- audio_combination.change(
- fn=lambda a: [
- visible(a)
- for _ in range(2)
- ],
- inputs=[
- audio_combination
- ],
- outputs=[
- main_volume,
- combine_volume
- ]
- )
- with gr.Row():
- more_options.change(
- fn=lambda: [False]*8,
- inputs=[],
- outputs=[
- fade,
- bass_or_treble,
- limiter,
- resample_checkbox,
- distortion_checkbox,
- gain_checkbox,
- clipping_checkbox,
- bitcrush_checkbox
- ]
- )
- upload_presets.upload(
- fn=lambda presets_in: [
- shutil_move(preset.name, configs["presets_path"])
- for preset in presets_in
- ][0],
- inputs=[
- upload_presets
- ],
- outputs=[
- presets_name
- ]
- )
- refresh_preset_button.click(
- fn=change_effect_preset_choices,
- inputs=[],
- outputs=[
- presets_name
- ]
- )
- with gr.Row():
- reverb_check_box.change(
- fn=lambda a, b, c, d, e, f: visible(max([a, b, c, d, e, f])),
- inputs=[
- reverb_check_box,
- chorus_check_box,
- delay_check_box,
- phaser_check_box,
- compressor_check_box,
- more_options
- ],
- outputs=[accordion]
- )
- chorus_check_box.change(
- fn=lambda a, b, c, d, e, f: visible(max([a, b, c, d, e, f])),
- inputs=[
- reverb_check_box,
- chorus_check_box,
- delay_check_box,
- phaser_check_box,
- compressor_check_box,
- more_options
- ],
- outputs=[accordion]
- )
- delay_check_box.change(
- fn=lambda a, b, c, d, e, f: visible(max([a, b, c, d, e, f])),
- inputs=[
- reverb_check_box,
- chorus_check_box,
- delay_check_box,
- phaser_check_box,
- compressor_check_box,
- more_options
- ],
- outputs=[accordion]
- )
- with gr.Row():
- phaser_check_box.change(
- fn=lambda a, b, c, d, e, f: visible(max([a, b, c, d, e, f])),
- inputs=[
- reverb_check_box,
- chorus_check_box,
- delay_check_box,
- phaser_check_box,
- compressor_check_box,
- more_options
- ],
- outputs=[accordion]
- )
- compressor_check_box.change(
- fn=lambda a, b, c, d, e, f: visible(max([a, b, c, d, e, f])),
- inputs=[
- reverb_check_box,
- chorus_check_box,
- delay_check_box,
- phaser_check_box,
- compressor_check_box,
- more_options
- ],
- outputs=[accordion]
- )
- more_options.change(
- fn=lambda a, b, c, d, e, f: visible(max([a, b, c, d, e, f])),
- inputs=[
- reverb_check_box,
- chorus_check_box,
- delay_check_box,
- phaser_check_box,
- compressor_check_box,
- more_options
- ],
- outputs=[accordion]
- )
- with gr.Row():
- load_preset_button.click(
- fn=audio_effect_load_presets,
- inputs=[
- presets_name,
- resample_checkbox,
- audio_effect_resample_sr,
- chorus_depth,
- chorus_rate_hz,
- chorus_mix,
- chorus_center_delay_ms,
- chorus_feedback,
- distortion_drive_db,
- reverb_room_size,
- reverb_damping,
- reverb_wet_level,
- reverb_dry_level,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_second,
- delay_feedback,
- delay_mix,
- compressor_threshold_db,
- compressor_ratio,
- compressor_attack_ms,
- compressor_release_ms,
- limiter_threshold_db,
- limiter_release_ms,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold_db,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- bass_boost,
- bass_frequency,
- treble_boost,
- treble_frequency,
- fade_in,
- fade_out,
- chorus_check_box,
- distortion_checkbox,
- reverb_check_box,
- delay_check_box,
- compressor_check_box,
- limiter,
- gain_checkbox,
- bitcrush_checkbox,
- clipping_checkbox,
- phaser_check_box,
- bass_or_treble,
- fade
- ],
- outputs=[
- resample_checkbox,
- audio_effect_resample_sr,
- chorus_depth,
- chorus_rate_hz,
- chorus_mix,
- chorus_center_delay_ms,
- chorus_feedback,
- distortion_drive_db,
- reverb_room_size,
- reverb_damping,
- reverb_wet_level,
- reverb_dry_level,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_second,
- delay_feedback,
- delay_mix,
- compressor_threshold_db,
- compressor_ratio,
- compressor_attack_ms,
- compressor_release_ms,
- limiter_threshold_db,
- limiter_release_ms,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold_db,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- bass_boost,
- bass_frequency,
- treble_boost,
- treble_frequency,
- fade_in,
- fade_out,
- chorus_check_box,
- distortion_checkbox,
- reverb_check_box,
- delay_check_box,
- compressor_check_box,
- limiter,
- gain_checkbox,
- bitcrush_checkbox,
- clipping_checkbox,
- phaser_check_box,
- bass_or_treble,
- fade
- ],
- )
- save_file_button.click(
- fn=audio_effect_save_presets,
- inputs=[
- name_to_save_file,
- resample_checkbox,
- audio_effect_resample_sr,
- chorus_depth,
- chorus_rate_hz,
- chorus_mix,
- chorus_center_delay_ms,
- chorus_feedback,
- distortion_drive_db,
- reverb_room_size,
- reverb_damping,
- reverb_wet_level,
- reverb_dry_level,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_second,
- delay_feedback,
- delay_mix,
- compressor_threshold_db,
- compressor_ratio,
- compressor_attack_ms,
- compressor_release_ms,
- limiter_threshold_db,
- limiter_release_ms,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold_db,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- bass_boost,
- bass_frequency,
- treble_boost,
- treble_frequency,
- fade_in,
- fade_out,
- chorus_check_box,
- distortion_checkbox,
- reverb_check_box,
- delay_check_box,
- compressor_check_box,
- limiter,
- gain_checkbox,
- bitcrush_checkbox,
- clipping_checkbox,
- phaser_check_box,
- bass_or_treble,
- fade
- ],
- outputs=[
- presets_name
- ]
- )
- apply_effects_button.click(
- fn=audio_effects,
- inputs=[
- audio_in_path,
- audio_out_path,
- resample_checkbox,
- audio_effect_resample_sr,
- chorus_depth,
- chorus_rate_hz,
- chorus_mix,
- chorus_center_delay_ms,
- chorus_feedback,
- distortion_drive_db,
- reverb_room_size,
- reverb_damping,
- reverb_wet_level,
- reverb_dry_level,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_second,
- delay_feedback,
- delay_mix,
- compressor_threshold_db,
- compressor_ratio,
- compressor_attack_ms,
- compressor_release_ms,
- limiter_threshold_db,
- limiter_release_ms,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold_db,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- bass_boost,
- bass_frequency,
- treble_boost,
- treble_frequency,
- fade_in,
- fade_out,
- audio_output_format,
- chorus_check_box,
- distortion_checkbox,
- reverb_check_box,
- delay_check_box,
- compressor_check_box,
- limiter,
- gain_checkbox,
- bitcrush_checkbox,
- clipping_checkbox,
- phaser_check_box,
- bass_or_treble,
- fade,
- audio_combination,
- audio_combination_input,
- main_volume,
- combine_volume
- ],
- outputs=[
- audio_play_output
- ],
- api_name="audio_effects"
- )
\ No newline at end of file
diff --git a/main/app/tabs/editing/child/quirk.py b/main/app/tabs/editing/child/quirk.py
deleted file mode 100644
index d010d8fb9dfc74ca2a244e711623a238985fdf11..0000000000000000000000000000000000000000
--- a/main/app/tabs/editing/child/quirk.py
+++ /dev/null
@@ -1,130 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.editing import apply_voice_quirk
-
-from main.app.core.ui import (
- shutil_move,
- change_audios_choices
-)
-
-from main.app.variables import (
- configs,
- file_types,
- audio_params,
- translations,
- paths_for_files,
- export_format_choices
-)
-
-def quirk_tab():
- with gr.Row():
- gr.Markdown(translations["quirk_markdown"])
- with gr.Row():
- input_audio_play = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- with gr.Row():
- quirk_choice = gr.Radio(
- label=translations["quirk_label"],
- info=translations["quirk_label_info"],
- choices=list(translations["quirk_choice"].keys()),
- interactive=True,
- value=list(translations["quirk_choice"].keys())[0]
- )
- with gr.Row():
- apply_quirk_button = gr.Button(
- translations["apply"],
- variant="primary"
- )
- with gr.Row():
- with gr.Accordion(translations["input_output"], open=False):
- with gr.Row():
- quirk_upload_audio = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- with gr.Column():
- quirk_export_format = gr.Radio(
- label=translations["export_format"],
- info=translations["export_info"],
- choices=export_format_choices,
- value="wav",
- interactive=True
- )
- quirk_input_path = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- allow_custom_value=True,
- interactive=True
- )
- quirk_output_path = gr.Textbox(
- label=translations["output_path"],
- value="audios/output.wav",
- placeholder="audios/output.wav",
- info=translations["output_path_info"],
- interactive=True
- )
- with gr.Column():
- quirk_refresh = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- output_audio_play = gr.Audio(
- interactive=False,
- label=translations["output_audio"],
- **audio_params
- )
- with gr.Row():
- quirk_upload_audio.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- quirk_upload_audio
- ],
- outputs=[
- quirk_input_path
- ]
- )
- quirk_input_path.change(
- fn=lambda audio: audio if audio else None,
- inputs=[
- quirk_input_path
- ],
- outputs=[
- input_audio_play
- ]
- )
- quirk_refresh.click(
- fn=change_audios_choices,
- inputs=[
- quirk_input_path
- ],
- outputs=[
- quirk_input_path
- ]
- )
- with gr.Row():
- apply_quirk_button.click(
- fn=apply_voice_quirk,
- inputs=[
- quirk_input_path,
- quirk_choice,
- quirk_output_path,
- quirk_export_format
- ],
- outputs=[
- output_audio_play
- ],
- api_name="quirk"
- )
\ No newline at end of file
diff --git a/main/app/tabs/editing/editing.py b/main/app/tabs/editing/editing.py
deleted file mode 100644
index bb631732c7be16d6b2875ceb3d2e2aa8d69af4d4..0000000000000000000000000000000000000000
--- a/main/app/tabs/editing/editing.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import (
- configs,
- translations
-)
-
-def editing_tab():
- with gr.TabItem(translations["editing"]):
- if configs.get("effects_tab", True):
- from main.app.tabs.editing.child.audio_effects import audio_effects_tab
-
- with gr.TabItem(translations["audio_effects"]):
- gr.Markdown(translations["apply_audio_effects"])
- audio_effects_tab()
-
- if configs.get("quirk_tab", True):
- from main.app.tabs.editing.child.quirk import quirk_tab
-
- with gr.TabItem(translations["quirk"]):
- gr.Markdown(translations["quirk_info"])
- quirk_tab()
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/analyzer.py b/main/app/tabs/extra/child/analyzer.py
deleted file mode 100644
index e7b851dc2a4c9f92c6b81b3a6f64056fb7dd4c4a..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/analyzer.py
+++ /dev/null
@@ -1,94 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.tools.analyzer import analyze_audio
-from main.app.core.ui import change_audios_choices, shutil_move
-from main.app.variables import translations, paths_for_files, audio_params, file_types, configs
-
-def analyzer_tab():
- with gr.Row():
- gr.Markdown(translations["analyzer_markdown_2"])
- with gr.Row():
- with gr.Accordion(
- translations["input_output"],
- open=False
- ):
- input_audio = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- allow_custom_value=True,
- interactive=True
- )
- upload_audio_file = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- with gr.Row():
- play_audio = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- with gr.Row():
- refresh_audio = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- get_info_button = gr.Button(
- value=translations["read_audio"],
- variant="primary"
- )
- with gr.Row():
- output_info = gr.Textbox(
- label=translations["output_information"],
- value="",
- max_lines=8,
- interactive=False,
- )
- with gr.Row():
- image_output = gr.Image(
- interactive=False
- )
- with gr.Row():
- get_info_button.click(
- fn=analyze_audio,
- inputs=[input_audio],
- outputs=[output_info, image_output],
- )
- input_audio.change(
- fn=lambda audio: audio if os.path.isfile(audio) else None,
- inputs=[
- input_audio
- ],
- outputs=[
- play_audio
- ]
- )
- refresh_audio.click(
- fn=change_audios_choices,
- inputs=[
- input_audio
- ],
- outputs=[
- input_audio
- ]
- )
- with gr.Row():
- upload_audio_file.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- upload_audio_file
- ],
- outputs=[
- input_audio
- ]
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/convert_model_onnx.py b/main/app/tabs/extra/child/convert_model_onnx.py
deleted file mode 100644
index b49f49180aa53defd1f3f95048dcaffbff2e1572..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/convert_model_onnx.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.model_utils import onnx_export
-
-from main.app.core.ui import (
- visible,
- shutil_move,
- change_models_choices
-)
-
-from main.app.variables import (
- configs,
- model_name,
- translations
-)
-
-def convert_onnx_model_tab():
- with gr.Row():
- gr.Markdown(translations["pytorch2onnx_markdown"])
- with gr.Row():
- model_pth_upload = gr.File(
- label=translations["drop_model"],
- file_types=[".pth"]
- )
- with gr.Accordion(
- label=translations["model_name"],
- open=True
- ):
- with gr.Row():
- model_pth_path = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh_model = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- convert_onnx_button = gr.Button(
- translations["convert_model"],
- variant="primary",
- scale=2
- )
- with gr.Row():
- output_model_file = gr.File(
- label=translations["output_model_path"],
- file_types=[".onnx"],
- interactive=False,
- visible=False
- )
- with gr.Row():
- model_pth_upload.upload(
- fn=lambda model_pth_upload: shutil_move(model_pth_upload.name, configs["weights_path"]),
- inputs=[
- model_pth_upload
- ],
- outputs=[
- model_pth_path
- ]
- )
- refresh_model.click(
- fn=lambda: change_models_choices()[0],
- inputs=[],
- outputs=[
- model_pth_path
- ]
- )
- with gr.Row():
- convert_onnx_button.click(
- fn=onnx_export,
- inputs=[
- model_pth_path
- ],
- outputs=[
- output_model_file
- ],
- api_name="model_onnx_export"
- )
- convert_onnx_button.click(
- fn=lambda: visible(True),
- inputs=[],
- outputs=[
- output_model_file
- ]
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/convert_model_svc.py b/main/app/tabs/extra/child/convert_model_svc.py
deleted file mode 100644
index b405affbf565df8acf8ce554a0dc14762804e58c..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/convert_model_svc.py
+++ /dev/null
@@ -1,128 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.model_utils import svc_export
-
-from main.app.core.ui import (
- visible,
- shutil_move,
- change_models_choices
-)
-
-from main.app.variables import (
- configs,
- model_name,
- translations
-)
-
-def convert_svc_model_tab():
- with gr.Row():
- gr.Markdown(translations["convert_model_svc_markdown_2"])
- with gr.Row():
- delete_when_success = gr.Checkbox(
- label=translations["delete_when_success"],
- value=True,
- interactive=True
- )
- with gr.Row():
- model_pth_upload = gr.File(
- label=translations["drop_model"],
- file_types=[".pth"]
- )
- config_upload = gr.File(
- label=translations["drop_json"],
- file_types=[".json"]
- )
- with gr.Accordion(
- label=translations["model_name"],
- open=True
- ):
- with gr.Row():
- model_pth_path = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- config_path = gr.Textbox(
- label=translations["config_path"],
- value="",
- placeholder="config.json",
- interactive=True
- )
- with gr.Row():
- modelname = gr.Textbox(
- label=translations["modelname"],
- value="",
- placeholder=translations["modelname"],
- interactive=True
- )
- with gr.Row():
- refresh_model = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- convert_svc_button = gr.Button(
- translations["convert_model_svc"],
- variant="primary",
- scale=2
- )
- with gr.Row():
- output_model_file = gr.File(
- label=translations["output_model_path"],
- file_types=[".pth", ".onnx"],
- interactive=False,
- visible=False
- )
- with gr.Row():
- model_pth_upload.upload(
- fn=lambda model_pth_upload: shutil_move(model_pth_upload.name, configs["weights_path"]),
- inputs=[
- model_pth_upload
- ],
- outputs=[
- model_pth_path
- ]
- )
- config_upload.upload(
- fn=lambda config: shutil_move(config.name, configs["weights_path"]),
- inputs=[
- config_upload
- ],
- outputs=[
- config_path
- ]
- )
- refresh_model.click(
- fn=lambda: change_models_choices()[0],
- inputs=[],
- outputs=[
- model_pth_path
- ]
- )
- with gr.Row():
- convert_svc_button.click(
- fn=svc_export,
- inputs=[
- model_pth_path,
- config_path,
- modelname,
- delete_when_success
- ],
- outputs=[
- output_model_file
- ],
- api_name="model_svc_export"
- )
- convert_svc_button.click(
- fn=lambda: visible(True),
- inputs=[],
- outputs=[
- output_model_file
- ]
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/create_srt.py b/main/app/tabs/extra/child/create_srt.py
deleted file mode 100644
index 550a00566824da035fcb3a8cc015123cd9c74754..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/create_srt.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.csrt import create_srt
-
-from main.app.core.ui import (
- shutil_move,
- change_audios_choices
-)
-
-from main.app.variables import (
- configs,
- file_types,
- translations,
- audio_params,
- whisper_model,
- paths_for_files,
- whisper_languages
-)
-
-def create_srt_tab():
- with gr.Row():
- gr.Markdown(translations["create_srt_markdown_2"])
- with gr.Row():
- with gr.Column():
- srt_content = gr.Textbox(
- label=translations["srt_content"],
- value="",
- lines=11,
- max_lines=11,
- interactive=False
- )
- with gr.Column():
- with gr.Group():
- language = gr.Dropdown(
- label=translations["whisper_languages"],
- value="vi",
- choices=whisper_languages,
- info=translations["whisper_languages_info"],
- interactive=True
- )
- model_size = gr.Radio(
- label=translations["model_size"],
- info=translations["model_size_info"],
- choices=whisper_model,
- value=whisper_model[0],
- interactive=True
- )
- with gr.Row():
- convert_button = gr.Button(
- translations["convert_audio"],
- variant="primary"
- )
- with gr.Row():
- with gr.Accordion(
- translations["input_output"],
- open=False
- ):
- with gr.Column():
- input_audio = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- allow_custom_value=True,
- interactive=True
- )
- output_file = gr.Textbox(
- label=translations["srt_path_output_file"],
- value="srt/output.srt",
- placeholder="srt/output.srt",
- interactive=True
- )
- with gr.Column():
- refresh = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- upload_audio_files = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- with gr.Row():
- play_audio = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- with gr.Row():
- output_srt = gr.File(
- label=translations["srt_output_file"],
- file_types=[".srt"],
- interactive=False,
- visible=False
- )
- with gr.Row():
- upload_audio_files.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- upload_audio_files
- ],
- outputs=[
- input_audio
- ]
- )
- input_audio.change(
- fn=lambda audio: audio if os.path.isfile(audio) else None,
- inputs=[
- input_audio
- ],
- outputs=[
- play_audio
- ]
- )
- refresh.click(
- fn=change_audios_choices,
- inputs=[
- input_audio
- ],
- outputs=[
- input_audio
- ]
- )
- with gr.Row():
- convert_button.click(
- fn=create_srt,
- inputs=[
- model_size,
- input_audio,
- output_file,
- language
- ],
- outputs=[
- output_srt,
- srt_content
- ],
- api_name="create_srt"
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/f0_extract.py b/main/app/tabs/extra/child/f0_extract.py
deleted file mode 100644
index 7cfa1307d40f30c362c95d077091479b25cd832e..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/f0_extract.py
+++ /dev/null
@@ -1,225 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.f0_extract import f0_extract
-
-from main.app.core.ui import (
- visible,
- unlock_f0,
- shutil_move,
- change_audios_choices
-)
-
-from main.app.variables import (
- configs,
- method_f0,
- file_types,
- audio_params,
- translations,
- paths_for_files
-)
-
-def f0_extract_tab():
- with gr.Row():
- gr.Markdown(translations["f0_extractor_markdown_2"])
- with gr.Row():
- extractor_button = gr.Button(
- translations["extract_button"].replace("2. ", ""),
- variant="primary"
- )
- with gr.Row():
- with gr.Column():
- upload_audio_file = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- audioplay = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- with gr.Column():
- with gr.Accordion(
- translations["f0_method"],
- open=False
- ):
- with gr.Group():
- with gr.Row():
- predictor_onnx = gr.Checkbox(
- label=translations["predictor_onnx"],
- value=False,
- interactive=True
- )
- unlock_full_method = gr.Checkbox(
- label=translations["f0_unlock"],
- value=False,
- interactive=True
- )
- autotune = gr.Checkbox(
- label=translations["autotune"],
- value=False,
- interactive=True
- )
- proposal_pitch = gr.Checkbox(
- label=translations["proposal_pitch"],
- value=False,
- interactive=True
- )
- f0_method_extract = gr.Radio(
- label=translations["f0_method"],
- info=translations["f0_method_info"],
- choices=[m for m in method_f0 if m != "hybrid"],
- value="rmvpe",
- interactive=True
- )
- pitch = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- f0_autotune_strength = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["autotune_rate"],
- info=translations["autotune_rate_info"],
- value=1,
- step=0.1,
- interactive=True,
- visible=False
- )
- proposal_pitch_threshold = gr.Slider(
- minimum=50.0,
- maximum=1200.0,
- label=translations["proposal_pitch_threshold"],
- info=translations["proposal_pitch_threshold_info"],
- value=255.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- filter_radius = gr.Slider(
- minimum=0,
- maximum=7,
- label=translations["filter_radius"],
- info=translations["filter_radius_info"],
- value=3,
- step=1,
- interactive=True
- )
- with gr.Accordion(
- translations["audio_path"],
- open=True
- ):
- input_audio_path = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- allow_custom_value=True,
- interactive=True
- )
- refresh_audio_button = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- gr.Markdown("___")
- with gr.Row():
- file_output = gr.File(
- label="",
- file_types=[".txt"],
- interactive=False
- )
- image_output = gr.Image(
- label="",
- interactive=False
- )
- with gr.Row():
- upload_audio_file.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- upload_audio_file
- ],
- outputs=[
- input_audio_path
- ]
- )
- input_audio_path.change(
- fn=lambda audio: audio if os.path.isfile(audio) else None,
- inputs=[
- input_audio_path
- ],
- outputs=[
- audioplay
- ]
- )
- refresh_audio_button.click(
- fn=change_audios_choices,
- inputs=[
- input_audio_path
- ],
- outputs=[
- input_audio_path
- ]
- )
- with gr.Row():
- autotune.change(
- fn=visible,
- inputs=[
- autotune
- ],
- outputs=[
- f0_autotune_strength
- ]
- )
- proposal_pitch.change(
- fn=visible,
- inputs=[
- proposal_pitch
- ],
- outputs=[
- proposal_pitch_threshold
- ]
- )
- with gr.Row():
- unlock_full_method.change(
- fn=lambda method: {
- "choices": [m for m in unlock_f0(method)["choices"] if m != "hybrid"],
- "value": "rmvpe",
- "__type__": "update"
- },
- inputs=[
- unlock_full_method
- ],
- outputs=[
- f0_method_extract
- ]
- )
- extractor_button.click(
- fn=f0_extract,
- inputs=[
- input_audio_path,
- f0_method_extract,
- predictor_onnx,
- pitch,
- filter_radius,
- autotune,
- f0_autotune_strength,
- proposal_pitch,
- proposal_pitch_threshold
- ],
- outputs=[
- file_output,
- image_output
- ],
- api_name="f0_extract"
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/fushion.py b/main/app/tabs/extra/child/fushion.py
deleted file mode 100644
index 1585930b4e220edb71e3c2bc58eb87b6ffd5951b..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/fushion.py
+++ /dev/null
@@ -1,132 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.model_utils import fushion_model
-
-from main.app.core.ui import (
- visible,
- shutil_move,
- change_models_choices
-)
-
-from main.app.variables import (
- configs,
- model_name,
- translations
-)
-
-def fushion_tab():
- with gr.Row():
- gr.Markdown(translations["fushion_markdown_2"])
- with gr.Row():
- modelname = gr.Textbox(
- label=translations["modelname"],
- placeholder="Model.pth",
- value="",
- max_lines=2,
- interactive=True
- )
- with gr.Row():
- fushion_button = gr.Button(
- translations["fushion"],
- variant="primary",
- scale=4
- )
- with gr.Column():
- with gr.Row():
- upload_model_1 = gr.File(
- label=f"{translations['model_name']} 1",
- file_types=[".pth"]
- )
- upload_model_2 = gr.File(
- label=f"{translations['model_name']} 2",
- file_types=[".pth"]
- )
- with gr.Row():
- model_path_1 = gr.Dropdown(
- label=translations["model_name"] + " 1",
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- model_path_2 = gr.Dropdown(
- label=translations["model_name"] + " 2",
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh_model = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- ratio = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["model_ratio"],
- info=translations["model_ratio_info"],
- value=0.5,
- interactive=True
- )
- with gr.Row():
- output_model = gr.File(
- label=translations["output_model_path"],
- file_types=[".pth", ".onnx"],
- interactive=False,
- visible=False
- )
- with gr.Row():
- upload_model_1.upload(
- fn=lambda model: shutil_move(model.name, configs["weights_path"]),
- inputs=[
- upload_model_1
- ],
- outputs=[
- model_path_1
- ]
- )
- upload_model_2.upload(
- fn=lambda model: shutil_move(model.name, configs["weights_path"]),
- inputs=[
- upload_model_2
- ],
- outputs=[
- model_path_2
- ]
- )
- refresh_model.click(
- fn=lambda: [change_models_choices()[0] for _ in range(2)],
- inputs=[],
- outputs=[
- model_path_1,
- model_path_2
- ]
- )
- with gr.Row():
- fushion_button.click(
- fn=fushion_model,
- inputs=[
- modelname,
- model_path_1,
- model_path_2,
- ratio
- ],
- outputs=[
- modelname,
- output_model
- ],
- api_name="fushion_model"
- )
- fushion_button.click(
- fn=lambda: visible(True),
- inputs=[],
- outputs=[
- output_model
- ]
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/read_model.py b/main/app/tabs/extra/child/read_model.py
deleted file mode 100644
index 4a9a298c3c1ad33e7db9d7182f2b9d6fdeb0ff8c..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/read_model.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.model_utils import model_info
-
-from main.app.core.ui import (
- shutil_move,
- change_models_choices
-)
-
-from main.app.variables import (
- configs,
- model_name,
- translations,
-)
-
-def read_model_tab():
- with gr.Row():
- gr.Markdown(translations["read_model_markdown_2"])
- with gr.Row():
- model = gr.File(
- label=translations["drop_model"],
- file_types=[".pth", ".onnx"]
- )
- with gr.Accordion(
- label=translations["model_name"],
- open=True
- ):
- model_path = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh_model = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- read_button = gr.Button(
- translations["readmodel"],
- variant="primary",
- scale=2
- )
- with gr.Row():
- output_info = gr.Textbox(
- label=translations["modelinfo"],
- value="",
- interactive=False,
- lines=10
- )
- with gr.Row():
- model.upload(
- fn=lambda model: shutil_move(model.name, configs["weights_path"]),
- inputs=[
- model
- ],
- outputs=[
- model_path
- ]
- )
- read_button.click(
- fn=model_info,
- inputs=[
- model_path
- ],
- outputs=[
- output_info
- ],
- api_name="read_model"
- )
- refresh_model.click(
- fn=lambda: change_models_choices()[0],
- inputs=[],
- outputs=[
- model_path
- ]
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/child/settings.py b/main/app/tabs/extra/child/settings.py
deleted file mode 100644
index 64b845734ed9f310bcd466410eb1100c935091a6..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/child/settings.py
+++ /dev/null
@@ -1,217 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.utils import stop_pid
-from main.app.core.ui import change_fp, run_commands
-
-from main.app.core.restart import restart
-
-from main.app.variables import (
- font,
- theme,
- config,
- configs,
- language,
- translations
-)
-
-reload_js = """
-() => {
- function Checking() {
- fetch(window.location.origin)
- .then(response => {
- if (response.ok) {
- location.reload();
- } else {
- setTimeout(Checking, 3000);
- }
- })
- .catch(err => {
- setTimeout(Checking, 3000);
- });
- }
- setTimeout(Checking, 10000);
-}
-"""
-
-def settings_tab(app):
- with gr.Row():
- gr.Markdown(translations["settings_markdown_2"])
- with gr.Row():
- toggle_button = gr.Button(
- translations["change_light_dark"],
- variant="secondary",
- scale=2
- )
- with gr.Row():
- with gr.Column():
- language_dropdown = gr.Dropdown(
- label=translations["lang"],
- interactive=True,
- info=translations["lang_restart"],
- choices=configs.get("support_language", "vi-VN"),
- value=language
- )
- with gr.Column():
- theme_dropdown = gr.Dropdown(
- label=translations["theme"],
- interactive=True,
- info=translations["theme_restart"],
- choices=configs.get("themes", theme),
- value=theme,
- allow_custom_value=True
- )
- with gr.Column():
- font_choice = gr.Textbox(
- label=translations["font"],
- info=translations["font_info"],
- value=font,
- interactive=True
- )
- with gr.Row():
- restart_button = gr.Button(
- translations["restart_button"]
- )
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- bf16_checkbox = gr.Checkbox(
- label=translations["bf16"],
- value=False,
- interactive=config.device.startswith(("cuda", "xpu")) and config.bf16_support
- )
- tf32_checkbox = gr.Checkbox(
- label=translations["tf32"],
- value=False,
- interactive=config.device.startswith("cuda") and config.tf32_support
- )
- fp_choice = gr.Radio(
- choices=["fp16","fp32"],
- value="fp16" if configs.get("fp16", False) else "fp32",
- label=translations["precision"],
- info=translations["precision_info"],
- interactive=config.allow_is_half
- )
- fp_button = gr.Button(
- translations["update_precision"],
- variant="primary",
- scale=2
- )
- with gr.Row():
- commands = gr.Textbox(
- label=translations["commands"],
- info=translations["commands_info"],
- value="",
- interactive=True
- )
- with gr.Row():
- run_commands_button = gr.Button(
- translations["run_commands"]
- )
- with gr.Row():
- with gr.Column():
- with gr.Accordion(translations["stop"], open=False, visible=True):
- separate_stop = gr.Button(
- translations["stop_separate"]
- )
- convert_stop = gr.Button(
- translations["stop_convert"]
- )
- create_dataset_stop = gr.Button(
- translations["stop_create_dataset"]
- )
- with gr.Accordion(translations["stop_training"], open=False):
- model_name_stop = gr.Textbox(
- label=translations["modelname"],
- info=translations["training_model_name"],
- value="",
- placeholder=translations["modelname"],
- interactive=True
- )
- preprocess_stop = gr.Button(
- translations["stop_preprocess"]
- )
- extract_stop = gr.Button(
- translations["stop_extract"]
- )
- train_stop = gr.Button(
- translations["stop_training"]
- )
- with gr.Row():
- toggle_button.click(
- fn=None,
- js="() => {document.body.classList.toggle('dark')}"
- )
- fp_button.click(
- fn=change_fp,
- inputs=[
- fp_choice,
- bf16_checkbox,
- tf32_checkbox
- ],
- outputs=[
- fp_choice
- ]
- )
- run_commands_button.click(
- fn=run_commands,
- inputs=[
- commands
- ],
- outputs=[]
- )
- with gr.Row():
- restart_button.click(
- fn=lambda lang, theme, font: restart(lang, theme, font, app),
- inputs=[language_dropdown, theme_dropdown, font_choice],
- outputs=[]
- )
- restart_button.click(
- fn=None,
- js=reload_js,
- inputs=[],
- outputs=[]
- )
- with gr.Row():
- separate_stop.click(
- fn=lambda: stop_pid("separate_pid", None, False),
- inputs=[],
- outputs=[]
- )
- convert_stop.click(
- fn=lambda: stop_pid("convert_pid", None, False),
- inputs=[],
- outputs=[]
- )
- create_dataset_stop.click(
- fn=lambda: stop_pid("create_dataset_pid", None, False),
- inputs=[],
- outputs=[]
- )
- with gr.Row():
- preprocess_stop.click(
- fn=lambda model_name_stop: stop_pid("preprocess_pid", model_name_stop, False),
- inputs=[
- model_name_stop
- ],
- outputs=[]
- )
- extract_stop.click(
- fn=lambda model_name_stop: stop_pid("extract_pid", model_name_stop, False),
- inputs=[
- model_name_stop
- ],
- outputs=[]
- )
- train_stop.click(
- fn=lambda model_name_stop: stop_pid("train_pid", model_name_stop, True),
- inputs=[
- model_name_stop
- ],
- outputs=[]
- )
\ No newline at end of file
diff --git a/main/app/tabs/extra/extra.py b/main/app/tabs/extra/extra.py
deleted file mode 100644
index fd2b90542e3cf7df83795233f569c441b534482d..0000000000000000000000000000000000000000
--- a/main/app/tabs/extra/extra.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import (
- configs,
- translations
-)
-
-from main.app.tabs.extra.child.fushion import fushion_tab
-from main.app.tabs.extra.child.analyzer import analyzer_tab
-from main.app.tabs.extra.child.settings import settings_tab
-from main.app.tabs.extra.child.read_model import read_model_tab
-from main.app.tabs.extra.child.f0_extract import f0_extract_tab
-from main.app.tabs.extra.child.create_srt import create_srt_tab
-from main.app.tabs.extra.child.convert_model_svc import convert_svc_model_tab
-from main.app.tabs.extra.child.convert_model_onnx import convert_onnx_model_tab
-
-def extra_tab(app):
- with gr.TabItem(translations["extra"]):
- if configs.get("fushion_tab", True):
- with gr.TabItem(translations["fushion"]):
- gr.Markdown(translations["fushion_markdown"])
- fushion_tab()
-
- if configs.get("read_tab", True):
- with gr.TabItem(translations["read_model"]):
- gr.Markdown(translations["read_model_markdown"])
- read_model_tab()
-
- if configs.get("onnx_tab", True):
- with gr.TabItem(translations["convert_model"]):
- gr.Markdown(translations["pytorch2onnx"])
- convert_onnx_model_tab()
-
- if configs.get("svc_tab", True):
- with gr.TabItem(translations["convert_model_svc"]):
- gr.Markdown(translations["convert_model_svc_markdown"])
- convert_svc_model_tab()
-
- if configs.get("f0_extractor_tab", True):
- with gr.TabItem(translations["f0_extractor_tab"]):
- gr.Markdown(translations["f0_extractor_markdown"])
- f0_extract_tab()
-
- if configs.get("create_srt_tab", True):
- with gr.TabItem(translations["create_srt_tab"]):
- gr.Markdown(translations["create_srt_markdown"])
- create_srt_tab()
-
- if configs.get("analyzer_tab", True):
- with gr.TabItem(translations["analyzer_tab"]):
- gr.Markdown(translations["analyzer_markdown"])
- analyzer_tab()
-
- if configs.get("settings_tab", True):
- with gr.TabItem(translations["settings"]):
- gr.Markdown(translations["settings_markdown"])
- settings_tab(app)
\ No newline at end of file
diff --git a/main/app/tabs/inference/child/convert.py b/main/app/tabs/inference/child/convert.py
deleted file mode 100644
index 0f9163e74a89675d80d952a1b6e2d02b5a12a065..0000000000000000000000000000000000000000
--- a/main/app/tabs/inference/child/convert.py
+++ /dev/null
@@ -1,1142 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.presets import (
- load_presets,
- save_presets
-)
-
-from main.app.core.inference import (
- convert_audio,
- convert_selection
-)
-
-from main.app.variables import (
- configs,
- f0_file,
- method_f0,
- file_types,
- model_name,
- index_path,
- audio_params,
- presets_file,
- translations,
- embedders_mode,
- embedders_model,
- paths_for_files,
- sample_rate_choice,
- hybrid_f0_method,
- export_format_choices,
-)
-
-from main.app.core.ui import (
- visible,
- unlock_f0,
- get_index,
- shutil_move,
- hoplength_show,
- change_f0_choices,
- index_strength_show,
- change_embedders_mode,
- change_models_choices,
- change_preset_choices,
- change_audios_choices,
- valueFalse_interactive,
- change_backing_choices,
- get_speakers_id_and_architecture
-)
-
-def convert_tab():
- with gr.Row():
- gr.Markdown(translations["convert_info"])
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- cleaner = gr.Checkbox(
- label=translations["clear_audio"],
- value=False,
- interactive=True
- )
- autotune = gr.Checkbox(
- label=translations["autotune"],
- value=False,
- interactive=True
- )
- use_audio = gr.Checkbox(
- label=translations["use_audio"],
- value=False,
- interactive=True
- )
- checkpointing = gr.Checkbox(
- label=translations["memory_efficient_training"],
- value=False,
- interactive=True
- )
- with gr.Row():
- use_original = gr.Checkbox(
- label=translations["convert_original"],
- value=False,
- interactive=True,
- visible=False
- )
- convert_backing = gr.Checkbox(
- label=translations["convert_backing"],
- value=False,
- interactive=True,
- visible=False
- )
- not_merge_backing = gr.Checkbox(
- label=translations["not_merge_backing"],
- value=False,
- interactive=True,
- visible=False
- )
- merge_instrument = gr.Checkbox(
- label=translations["merge_instruments"],
- value=False,
- interactive=True,
- visible=False
- )
- with gr.Row():
- pitch = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- clean_strength = gr.Slider(
- label=translations["clean_strength"],
- info=translations["clean_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- with gr.Column():
- convert_select_audio = gr.Dropdown(
- label=translations["select_separate"],
- choices=[],
- value="",
- interactive=True,
- allow_custom_value=True,
- visible=False
- )
- convert_select_audio_button = gr.Button(
- translations["convert_audio"],
- visible=False
- )
- with gr.Row():
- with gr.Column():
- convert_audio_button = gr.Button(
- translations["convert_audio"],
- variant="primary"
- )
- with gr.Row():
- with gr.Column():
- drop_audio_file = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- play_audio = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- with gr.Column():
- with gr.Accordion(
- translations["model_accordion"],
- open=True
- ):
- with gr.Row():
- model_pth = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- model_index = gr.Dropdown(
- label=translations["index_path"],
- choices=index_path,
- value=index_path[0] if len(index_path) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh_model = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- index_strength = gr.Slider(
- label=translations["index_strength"],
- info=translations["index_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.01,
- interactive=True,
- visible=True
- )
- nprobe = gr.Slider(
- label=translations["nprobe"],
- info=translations["nprobe_info"],
- minimum=1,
- maximum=64,
- value=9,
- step=1,
- interactive=True,
- visible=True
- )
- with gr.Row():
- sid_dict, architecture_dict = get_speakers_id_and_architecture(model_pth.value)
- if sid_dict["visible"] == "hidden": sid_dict["visible"] = False
- if architecture_dict["visible"] == "hidden": architecture_dict["visible"] = False
-
- sids = gr.Dropdown(
- label=translations["sids_label"],
- info=translations["sids_info"],
- choices=sid_dict["choices"],
- value=sid_dict["value"],
- visible=sid_dict["visible"],
- interactive=True
- )
- with gr.Accordion(
- translations["input_output"],
- open=False
- ):
- with gr.Column():
- export_format = gr.Radio(
- label=translations["export_format"],
- info=translations["export_info"],
- choices=export_format_choices,
- value="wav",
- interactive=True
- )
- input_audio = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- allow_custom_value=True,
- interactive=True
- )
- output_audio = gr.Textbox(
- label=translations["output_path"],
- value="audios/output.wav",
- placeholder="audios/output.wav",
- info=translations["output_path_info"],
- interactive=True
- )
- with gr.Column():
- refresh_audio = gr.Button(
- translations["refresh"]
- )
- with gr.Accordion(
- translations["setting"],
- open=False
- ):
- with gr.Accordion(
- translations["f0_method"],
- open=False
- ):
- with gr.Group():
- with gr.Row():
- predictor_onnx = gr.Checkbox(
- label=translations["predictor_onnx"],
- info=translations["predictor_onnx_info"],
- value=False,
- interactive=True
- )
- unlock_full_method = gr.Checkbox(
- label=translations["f0_unlock"],
- info=translations["f0_unlock_info"],
- value=False,
- interactive=True
- )
- f0_method = gr.Radio(
- label=translations["f0_method"],
- info=translations["f0_method_info"],
- choices=method_f0,
- value="rmvpe",
- interactive=True
- )
- hybrid_method = gr.Dropdown(
- label=translations["f0_method_hybrid"],
- info=translations["f0_method_hybrid_info"],
- choices=hybrid_f0_method,
- value=hybrid_f0_method[0],
- interactive=True,
- allow_custom_value=True,
- visible=False
- )
- hop_length = gr.Slider(
- label=translations['hop_length'],
- info=translations["hop_length_info"],
- minimum=64,
- maximum=512,
- value=160,
- step=1,
- interactive=True,
- visible=False
- )
- alpha = gr.Slider(
- label=translations["alpha_label"],
- info=translations["alpha_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Accordion(
- translations["f0_file"],
- open=False
- ):
- upload_f0_file = gr.File(
- label=translations["upload_f0"],
- file_types=[".txt"]
- )
- f0_file_dropdown = gr.Dropdown(
- label=translations["f0_file_2"],
- value="",
- choices=f0_file,
- allow_custom_value=True,
- interactive=True
- )
- refresh_f0_file = gr.Button(
- translations["refresh"]
- )
- with gr.Accordion(
- translations["hubert_model"],
- open=False
- ):
- embedders_mix = gr.Checkbox(
- label=translations["embedders_mix"],
- info=translations["embedders_mix_info"],
- value=False,
- interactive=True
- )
- embedder_mode = gr.Radio(
- label=translations["embed_mode"],
- info=translations["embed_mode_info"],
- value="fairseq",
- choices=embedders_mode,
- interactive=True,
- visible=True
- )
- embedders = gr.Radio(
- label=translations["hubert_model"],
- info=translations["hubert_info"],
- choices=embedders_model,
- value="hubert_base",
- interactive=True
- )
- custom_embedders = gr.Textbox(
- label=translations["modelname"],
- info=translations["modelname_info"],
- value="",
- placeholder="hubert_base",
- interactive=True,
- visible=False
- )
- with gr.Column(visible=False) as embedders_mix_column:
- embedders_mix_layers = gr.Slider(
- label=translations["embedders_mix_layers"],
- info=translations["embedders_mix_layers_info"],
- minimum=1,
- maximum=12,
- value=9,
- step=1,
- interactive=True
- )
- embedders_mix_ratio = gr.Slider(
- label=translations["embedders_mix_ratio"],
- info=translations["embedders_mix_ratio_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True
- )
- with gr.Accordion(
- translations["use_presets"],
- open=False
- ):
- with gr.Row():
- presets_name = gr.Dropdown(
- label=translations["file_preset"],
- choices=presets_file,
- value=presets_file[0] if len(presets_file) > 0 else '',
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- load_preset_button = gr.Button(
- translations["load_file"],
- variant="primary"
- )
- refresh_preset_button = gr.Button(
- translations["refresh"]
- )
- with gr.Accordion(
- translations["export_file"],
- open=False
- ):
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- cleaner_checkbox = gr.Checkbox(
- label=translations["save_clean"],
- value=True,
- interactive=True
- )
- autotune_checkbox = gr.Checkbox(
- label=translations["save_autotune"],
- value=True,
- interactive=True
- )
- pitch_checkbox = gr.Checkbox(
- label=translations["save_pitch"],
- value=True,
- interactive=True
- )
- index_strength_checkbox = gr.Checkbox(
- label=translations["save_index_2"],
- value=True,
- interactive=True
- )
- resample_sr_checkbox = gr.Checkbox(
- label=translations["save_resample"],
- value=True,
- interactive=True
- )
- filter_radius_checkbox = gr.Checkbox(
- label=translations["save_filter"],
- value=True,
- interactive=True
- )
- rms_mix_rate_checkbox = gr.Checkbox(
- label=translations["save_envelope"],
- value=True,
- interactive=True
- )
- protect_checkbox = gr.Checkbox(
- label=translations["save_protect"],
- value=True,
- interactive=True
- )
- split_audio_checkbox = gr.Checkbox(
- label=translations["save_split"],
- value=True,
- interactive=True
- )
- formant_shifting_checkbox = gr.Checkbox(
- label=translations["formantshift"],
- value=True,
- interactive=True
- )
- with gr.Row():
- with gr.Column():
- name_to_save_file = gr.Textbox(
- label=translations["filename_to_save"]
- )
- save_file_button = gr.Button(
- translations["export_file"]
- )
- with gr.Row():
- upload_presets = gr.Files(
- label=translations["upload_presets"],
- file_types=[".conversion.json"]
- )
- with gr.Column():
- with gr.Group():
- with gr.Row():
- split_audio = gr.Checkbox(
- label=translations["split_audio"],
- value=False,
- interactive=True
- )
- formant_shifting = gr.Checkbox(
- label=translations["formantshift"],
- value=False,
- interactive=True
- )
- with gr.Row():
- proposal_pitch = gr.Checkbox(
- label=translations["proposal_pitch"],
- value=False,
- interactive=True
- )
- audio_processing = gr.Checkbox(
- label=translations["audio_processing"],
- value=False,
- interactive=True
- )
- with gr.Row():
- audio_upscaler = gr.Checkbox(
- label=translations["audio_upscaler"],
- info=translations["audio_upscaler_info"],
- value=False,
- interactive=True
- )
- resample_sr = gr.Radio(
- choices=[0]+sample_rate_choice,
- label=translations["resample"],
- info=translations["resample_info"],
- value=0,
- interactive=True
- )
- proposal_pitch_threshold = gr.Slider(
- minimum=50.0,
- maximum=1200.0,
- label=translations["proposal_pitch_threshold"],
- info=translations["proposal_pitch_threshold_info"],
- value=255.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- f0_autotune_strength = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["autotune_rate"],
- info=translations["autotune_rate_info"],
- value=1,
- step=0.1,
- interactive=True,
- visible=False
- )
- filter_radius = gr.Slider(
- minimum=0,
- maximum=7,
- label=translations["filter_radius"],
- info=translations["filter_radius_info"],
- value=3,
- step=1,
- interactive=True
- )
- rms_mix_rate = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["rms_mix_rate"],
- info=translations["rms_mix_rate_info"],
- value=1,
- step=0.1,
- interactive=True
- )
- protect = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["protect"],
- info=translations["protect_info"],
- value=0.5,
- step=0.01,
- interactive=True
- )
- noise_scale = gr.Slider(
- minimum=0.1,
- maximum=1.0,
- label=translations["noise_scale"],
- info=translations["noise_scale_info"],
- value=0.4,
- step=0.01,
- interactive=True,
- visible=architecture_dict["visible"]
- )
- with gr.Row():
- formant_qfrency = gr.Slider(
- value=1.0,
- label=translations["formant_qfrency"],
- info=translations["formant_qfrency"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- formant_timbre = gr.Slider(
- value=1.0,
- label=translations["formant_timbre"],
- info=translations["formant_timbre"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- gr.Markdown(translations["output_convert"])
- with gr.Row():
- main_convert = gr.Audio(
- interactive=False,
- label=translations["main_convert"],
- visible=True,
- **audio_params
- )
- backing_convert = gr.Audio(
- interactive=False,
- label=translations["convert_backing"],
- visible=False,
- **audio_params
- )
- main_backing = gr.Audio(
- interactive=False,
- label=translations["main_or_backing"],
- visible=False,
- **audio_params
- )
- with gr.Row():
- original_convert = gr.Audio(
- interactive=False,
- label=translations["convert_original"],
- visible=False,
- **audio_params
- )
- vocal_instrument = gr.Audio(
- interactive=False,
- label=translations["voice_or_instruments"],
- visible=False,
- **audio_params
- )
- with gr.Row():
- upload_f0_file.upload(
- fn=lambda inp: shutil_move(inp.name, configs["f0_path"]),
- inputs=[
- upload_f0_file
- ],
- outputs=[
- f0_file_dropdown
- ]
- )
- refresh_f0_file.click(
- fn=change_f0_choices,
- inputs=[],
- outputs=[
- f0_file_dropdown
- ]
- )
- unlock_full_method.change(
- fn=unlock_f0,
- inputs=[
- unlock_full_method
- ],
- outputs=[
- f0_method
- ]
- )
- with gr.Row():
- load_preset_button.click(
- fn=load_presets,
- inputs=[
- presets_name,
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
- ],
- outputs=[
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
- ]
- )
- refresh_preset_button.click(
- fn=change_preset_choices,
- inputs=[],
- outputs=[
- presets_name
- ]
- )
- save_file_button.click(
- fn=save_presets,
- inputs=[
- name_to_save_file,
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- cleaner_checkbox,
- autotune_checkbox,
- pitch_checkbox,
- index_strength_checkbox,
- resample_sr_checkbox,
- filter_radius_checkbox,
- rms_mix_rate_checkbox,
- protect_checkbox,
- split_audio_checkbox,
- formant_shifting_checkbox,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
- ],
- outputs=[
- presets_name
- ]
- )
- with gr.Row():
- upload_presets.upload(
- fn=lambda presets_in: [
- shutil_move(preset.name, configs["presets_path"])
- for preset in presets_in
- ][0],
- inputs=[
- upload_presets
- ],
- outputs=[
- presets_name
- ]
- )
- autotune.change(
- fn=visible,
- inputs=[
- autotune
- ],
- outputs=[
- f0_autotune_strength
- ]
- )
- use_audio.change(
- fn=lambda a: [
- visible(a),
- visible(a),
- visible(a),
- visible(a),
- visible(a),
- valueFalse_interactive(a),
- valueFalse_interactive(a),
- valueFalse_interactive(a),
- valueFalse_interactive(a),
- visible(not a),
- visible(not a),
- visible(not a),
- visible(not a)
- ],
- inputs=[
- use_audio
- ],
- outputs=[
- main_backing,
- use_original,
- convert_backing,
- not_merge_backing,
- merge_instrument,
- use_original,
- convert_backing,
- not_merge_backing,
- merge_instrument,
- input_audio,
- output_audio,
- drop_audio_file,
- play_audio
- ]
- )
- with gr.Row():
- convert_backing.change(
- fn=lambda a,b: [
- change_backing_choices(a, b),
- visible(a)
- ],
- inputs=[
- convert_backing,
- not_merge_backing
- ],
- outputs=[
- use_original,
- backing_convert
- ]
- )
- use_original.change(
- fn=lambda audio, original: [
- visible(original),
- visible(not original),
- visible(audio and not original),
- valueFalse_interactive(not original),
- valueFalse_interactive(not original)
- ],
- inputs=[
- use_audio,
- use_original
- ],
- outputs=[
- original_convert,
- main_convert,
- main_backing,
- convert_backing,
- not_merge_backing
- ]
- )
- cleaner.change(
- fn=visible,
- inputs=[
- cleaner
- ],
- outputs=[
- clean_strength
- ]
- )
- with gr.Row():
- merge_instrument.change(
- fn=visible,
- inputs=[
- merge_instrument
- ],
- outputs=[
- vocal_instrument
- ]
- )
- not_merge_backing.change(
- fn=lambda audio, merge, cvb: [
- visible(audio and not merge),
- change_backing_choices(cvb, merge)
- ],
- inputs=[
- use_audio,
- not_merge_backing,
- convert_backing
- ],
- outputs=[
- main_backing,
- use_original
- ]
- )
- f0_method.change(
- fn=lambda f0_method, hybrid: [
- visible(f0_method == "hybrid"),
- visible(f0_method == "hybrid"),
- hoplength_show(f0_method, hybrid)
- ],
- inputs=[
- f0_method,
- hybrid_method
- ],
- outputs=[
- hybrid_method,
- alpha,
- hop_length
- ]
- )
- with gr.Row():
- hybrid_method.change(
- fn=hoplength_show,
- inputs=[
- f0_method,
- hybrid_method
- ],
- outputs=[
- hop_length
- ]
- )
- refresh_model.click(
- fn=change_models_choices,
- inputs=[],
- outputs=[
- model_pth,
- model_index
- ]
- )
- model_pth.change(
- fn=get_index,
- inputs=[
- model_pth
- ],
- outputs=[
- model_index
- ]
- )
- with gr.Row():
- drop_audio_file.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- drop_audio_file
- ],
- outputs=[
- input_audio
- ]
- )
- input_audio.change(
- fn=lambda audio: audio if os.path.isfile(audio) else None,
- inputs=[
- input_audio
- ],
- outputs=[
- play_audio
- ]
- )
- formant_shifting.change(
- fn=lambda a: [
- visible(a)
- for _ in range(2)
- ],
- inputs=[
- formant_shifting
- ],
- outputs=[
- formant_qfrency,
- formant_timbre
- ]
- )
- with gr.Row():
- embedders.change(
- fn=lambda embedders: visible(embedders == "custom"),
- inputs=[
- embedders
- ],
- outputs=[
- custom_embedders
- ]
- )
- refresh_audio.click(
- fn=change_audios_choices,
- inputs=[
- input_audio
- ],
- outputs=[
- input_audio
- ]
- )
- model_index.change(
- fn=index_strength_show,
- inputs=[
- model_index
- ],
- outputs=[
- index_strength,
- nprobe
- ]
- )
- with gr.Row():
- convert_audio_button.click(
- fn=lambda: visible(False),
- inputs=[],
- outputs=[
- convert_audio_button
- ]
- )
- convert_select_audio_button.click(
- fn=lambda: [
- visible(False)
- for _ in range(2)
- ],
- inputs=[],
- outputs=[
- convert_select_audio,
- convert_select_audio_button
- ]
- )
- with gr.Row():
- proposal_pitch.change(
- fn=visible,
- inputs=[
- proposal_pitch
- ],
- outputs=[
- proposal_pitch_threshold
- ]
- )
- embedder_mode.change(
- fn=change_embedders_mode,
- inputs=[
- embedder_mode
- ],
- outputs=[
- embedders
- ]
- )
- model_pth.change(
- fn=get_speakers_id_and_architecture,
- inputs=[
- model_pth
- ],
- outputs=[
- sids,
- noise_scale
- ]
- )
- with gr.Row():
- embedders_mix.change(
- fn=visible,
- inputs=[
- embedders_mix
- ],
- outputs=[
- embedders_mix_column
- ]
- )
- convert_audio_button.click(
- fn=convert_selection,
- inputs=[
- cleaner,
- autotune,
- use_audio,
- use_original,
- convert_backing,
- not_merge_backing,
- merge_instrument,
- pitch,
- clean_strength,
- model_pth,
- model_index,
- index_strength,
- input_audio,
- output_audio,
- export_format,
- f0_method,
- hybrid_method,
- hop_length,
- embedders,
- custom_embedders,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- checkpointing,
- predictor_onnx,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- f0_file_dropdown,
- embedder_mode,
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sids,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale,
- nprobe,
- audio_upscaler
- ],
- outputs=[
- convert_select_audio,
- main_convert,
- backing_convert,
- main_backing,
- original_convert,
- vocal_instrument,
- convert_audio_button,
- convert_select_audio_button
- ],
- api_name="convert_selection"
- )
- convert_select_audio_button.click(
- fn=convert_audio,
- inputs=[
- cleaner,
- autotune,
- use_audio,
- use_original,
- convert_backing,
- not_merge_backing,
- merge_instrument,
- pitch,
- clean_strength,
- model_pth,
- model_index,
- index_strength,
- input_audio,
- output_audio,
- export_format,
- f0_method,
- hybrid_method,
- hop_length,
- embedders,
- custom_embedders,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- convert_select_audio,
- checkpointing,
- predictor_onnx,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- f0_file_dropdown,
- embedder_mode,
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sids,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale,
- nprobe,
- audio_upscaler
- ],
- outputs=[
- main_convert,
- backing_convert,
- main_backing,
- original_convert,
- vocal_instrument,
- convert_audio_button
- ],
- api_name="convert_audio"
- )
\ No newline at end of file
diff --git a/main/app/tabs/inference/child/convert_tts.py b/main/app/tabs/inference/child/convert_tts.py
deleted file mode 100644
index c9fafc7ce527859aa4fe95cb26c42c917a5678bd..0000000000000000000000000000000000000000
--- a/main/app/tabs/inference/child/convert_tts.py
+++ /dev/null
@@ -1,979 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.tts import TTS
-from main.app.core.process import process_input
-from main.app.core.inference import convert_tts
-from main.app.core.utils import google_translate
-
-from main.app.core.presets import (
- save_presets,
- load_presets
-)
-
-from main.app.variables import (
- configs,
- edgetts,
- f0_file,
- method_f0,
- model_name,
- index_path,
- presets_file,
- translations,
- audio_params,
- embedders_mode,
- embedders_model,
- google_tts_voice,
- hybrid_f0_method,
- sample_rate_choice,
- export_format_choices
-)
-
-from main.app.core.ui import (
- visible,
- unlock_f0,
- get_index,
- shutil_move,
- hoplength_show,
- change_f0_choices,
- index_strength_show,
- change_models_choices,
- change_preset_choices,
- change_embedders_mode,
- change_tts_voice_choices,
- get_speakers_id_and_architecture
-)
-
-def convert_tts_tab():
- with gr.Row():
- gr.Markdown(translations["convert_text_markdown_2"])
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- use_txt = gr.Checkbox(
- label=translations["input_txt"],
- value=False,
- interactive=True
- )
- google_tts_check_box = gr.Checkbox(
- label=translations["googletts"],
- value=False,
- interactive=True
- )
- prompt = gr.Textbox(
- label=translations["text_to_speech"],
- value="",
- placeholder="Hello Words",
- lines=5,
- max_lines=5
- )
- with gr.Column():
- speed = gr.Slider(
- label=translations["voice_speed"],
- info=translations["voice_speed_info"],
- minimum=-100,
- maximum=100,
- value=0,
- step=1
- )
- pitch = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- with gr.Row():
- tts_button = gr.Button(
- translations["tts_1"],
- variant="primary",
- scale=2
- )
- convert_button = gr.Button(
- translations["tts_2"],
- variant="secondary",
- scale=2
- )
- with gr.Row():
- with gr.Column():
- txt_input = gr.File(
- label=translations["drop_text"],
- file_types=[".txt", ".srt", ".docx"],
- visible=False
- )
- tts_voice = gr.Dropdown(
- label=translations["voice"],
- choices=edgetts,
- interactive=True,
- value="vi-VN-NamMinhNeural"
- )
- tts_pitch = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info_2"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- with gr.Accordion(
- translations["translate"],
- open=False
- ):
- with gr.Row():
- source_lang = gr.Dropdown(
- label=translations["source_lang"],
- choices=["auto"]+google_tts_voice,
- interactive=True,
- value="auto"
- )
- target_lang = gr.Dropdown(
- label=translations["target_lang"],
- choices=google_tts_voice,
- interactive=True,
- value="en"
- )
- translate_button = gr.Button(
- translations["translate"]
- )
- with gr.Column():
- with gr.Accordion(
- translations["model_accordion"],
- open=True
- ):
- with gr.Row():
- model_pth = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- model_index = gr.Dropdown(
- label=translations["index_path"],
- choices=index_path,
- value=index_path[0] if len(index_path) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- index_strength = gr.Slider(
- label=translations["index_strength"],
- info=translations["index_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.01,
- interactive=True,
- visible=True
- )
- nprobe = gr.Slider(
- label=translations["nprobe"],
- info=translations["nprobe_info"],
- minimum=1,
- maximum=64,
- value=9,
- step=1,
- interactive=True,
- visible=True
- )
- with gr.Row():
- sid_dict, architecture_dict = get_speakers_id_and_architecture(model_pth.value)
- if sid_dict["visible"] == "hidden": sid_dict["visible"] = False
- if architecture_dict["visible"] == "hidden": architecture_dict["visible"] = False
-
- sids = gr.Dropdown(
- label=translations["sids_label"],
- info=translations["sids_info"],
- choices=sid_dict["choices"],
- value=sid_dict["value"],
- visible=sid_dict["visible"],
- interactive=True
- )
- with gr.Accordion(
- translations["output_path"],
- open=False
- ):
- export_format = gr.Radio(
- label=translations["export_format"],
- info=translations["export_info"],
- choices=export_format_choices,
- value="wav",
- interactive=True
- )
- output_audio_tts = gr.Textbox(
- label=translations["output_tts"],
- value="audios/tts.wav",
- placeholder="audios/tts.wav",
- info=translations["tts_output"],
- interactive=True
- )
- output_audio = gr.Textbox(
- label=translations["output_tts_convert"],
- value="audios/tts-convert.wav",
- placeholder="audios/tts-convert.wav",
- info=translations["tts_output"],
- interactive=True
- )
- with gr.Accordion(
- translations["setting"],
- open=False
- ):
- with gr.Accordion(
- translations["f0_method"],
- open=False
- ):
- with gr.Group():
- with gr.Row():
- predictor_onnx = gr.Checkbox(
- label=translations["predictor_onnx"],
- info=translations["predictor_onnx_info"],
- value=False,
- interactive=True
- )
- unlock_full_method = gr.Checkbox(
- label=translations["f0_unlock"],
- info=translations["f0_unlock_info"],
- value=False,
- interactive=True
- )
- f0_method = gr.Radio(
- label=translations["f0_method"],
- info=translations["f0_method_info"],
- choices=method_f0,
- value="rmvpe",
- interactive=True
- )
- hybrid_f0method = gr.Dropdown(
- label=translations["f0_method_hybrid"],
- info=translations["f0_method_hybrid_info"],
- choices=hybrid_f0_method,
- value=hybrid_f0_method[0],
- interactive=True,
- allow_custom_value=True,
- visible=False
- )
- hop_length = gr.Slider(
- label=translations['hop_length'],
- info=translations["hop_length_info"],
- minimum=64,
- maximum=512,
- value=160,
- step=1,
- interactive=True,
- visible=False
- )
- alpha = gr.Slider(
- label=translations["alpha_label"],
- info=translations["alpha_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Accordion(
- translations["f0_file"],
- open=False
- ):
- upload_f0_file = gr.File(
- label=translations["upload_f0"],
- file_types=[".txt"]
- )
- f0_file_dropdown = gr.Dropdown(
- label=translations["f0_file_2"],
- value="",
- choices=f0_file,
- allow_custom_value=True,
- interactive=True
- )
- refresh_f0_file = gr.Button(
- translations["refresh"]
- )
- with gr.Accordion(
- translations["hubert_model"],
- open=False
- ):
- embedders_mix = gr.Checkbox(
- label=translations["embedders_mix"],
- info=translations["embedders_mix_info"],
- value=False,
- interactive=True
- )
- embedder_mode = gr.Radio(
- label=translations["embed_mode"],
- info=translations["embed_mode_info"],
- value="fairseq",
- choices=embedders_mode,
- interactive=True,
- visible=True
- )
- embedders = gr.Radio(
- label=translations["hubert_model"],
- info=translations["hubert_info"],
- choices=embedders_model,
- value="hubert_base",
- interactive=True
- )
- custom_embedders = gr.Textbox(
- label=translations["modelname"],
- info=translations["modelname_info"],
- value="",
- placeholder="hubert_base",
- interactive=True,
- visible=False
- )
- with gr.Column(visible=False) as embedders_mix_column:
- embedders_mix_layers = gr.Slider(
- label=translations["embedders_mix_layers"],
- info=translations["embedders_mix_layers_info"],
- minimum=1,
- maximum=12,
- value=9,
- step=1,
- interactive=True
- )
- embedders_mix_ratio = gr.Slider(
- label=translations["embedders_mix_ratio"],
- info=translations["embedders_mix_ratio_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True
- )
- with gr.Accordion(
- translations["use_presets"],
- open=False
- ):
- with gr.Row():
- presets_name = gr.Dropdown(
- label=translations["file_preset"],
- choices=presets_file,
- value=presets_file[0] if len(presets_file) > 0 else '',
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- load_preset_button = gr.Button(
- translations["load_file"],
- variant="primary"
- )
- refresh_preset_button = gr.Button(
- translations["refresh"]
- )
- with gr.Accordion(
- translations["export_file"],
- open=False
- ):
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- cleaner_checkbox = gr.Checkbox(
- label=translations["save_clean"],
- value=True,
- interactive=True
- )
- autotune_checkbox = gr.Checkbox(
- label=translations["save_autotune"],
- value=True,
- interactive=True
- )
- pitch_checkbox = gr.Checkbox(
- label=translations["save_pitch"],
- value=True,
- interactive=True
- )
- index_strength_checkbox = gr.Checkbox(
- label=translations["save_index_2"],
- value=True,
- interactive=True
- )
- resample_sr_checkbox = gr.Checkbox(
- label=translations["save_resample"],
- value=True,
- interactive=True
- )
- filter_radius_checkbox = gr.Checkbox(
- label=translations["save_filter"],
- value=True,
- interactive=True
- )
- rms_mix_rate_checkbox = gr.Checkbox(
- label=translations["save_envelope"],
- value=True,
- interactive=True
- )
- protect_checkbox = gr.Checkbox(
- label=translations["save_protect"],
- value=True,
- interactive=True
- )
- split_audio_checkbox = gr.Checkbox(
- label=translations["save_split"],
- value=True,
- interactive=True
- )
- formant_shifting_checkbox = gr.Checkbox(
- label=translations["formantshift"],
- value=True,
- interactive=True
- )
- with gr.Row():
- with gr.Column():
- name_to_save_file = gr.Textbox(
- label=translations["filename_to_save"]
- )
- save_file_button = gr.Button(
- translations["export_file"]
- )
- with gr.Row():
- upload_presets = gr.Files(
- label=translations["upload_presets"],
- file_types=[".conversion.json"]
- )
- with gr.Group():
- with gr.Row():
- audio_processing = gr.Checkbox(
- label=translations["audio_processing"],
- value=False,
- interactive=True
- )
- with gr.Row():
- formant_shifting = gr.Checkbox(
- label=translations["formantshift"],
- value=False,
- interactive=True
- )
- split_audio = gr.Checkbox(
- label=translations["split_audio"],
- value=False,
- interactive=True
- )
- cleaner = gr.Checkbox(
- label=translations["clear_audio"],
- value=False,
- interactive=True
- )
- with gr.Row():
- autotune = gr.Checkbox(
- label=translations["autotune"],
- value=False,
- interactive=True
- )
- checkpointing = gr.Checkbox(
- label=translations["memory_efficient_training"],
- value=False,
- interactive=True
- )
- proposal_pitch = gr.Checkbox(
- label=translations["proposal_pitch"],
- value=False,
- interactive=True
- )
- with gr.Row():
- audio_upscaler = gr.Checkbox(
- label=translations["audio_upscaler"],
- info=translations["audio_upscaler_info"],
- value=False,
- interactive=True
- )
- with gr.Column():
- resample_sr = gr.Radio(
- choices=[0]+sample_rate_choice,
- label=translations["resample"],
- info=translations["resample_info"],
- value=0,
- interactive=True
- )
- proposal_pitch_threshold = gr.Slider(
- minimum=50.0,
- maximum=1200.0,
- label=translations["proposal_pitch_threshold"],
- info=translations["proposal_pitch_threshold_info"],
- value=255.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- f0_autotune_strength = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["autotune_rate"],
- info=translations["autotune_rate_info"],
- value=1,
- step=0.1,
- interactive=True,
- visible=False
- )
- clean_strength = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["clean_strength"],
- info=translations["clean_strength_info"],
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- filter_radius = gr.Slider(
- minimum=0,
- maximum=7,
- label=translations["filter_radius"],
- info=translations["filter_radius_info"],
- value=3,
- step=1,
- interactive=True
- )
- rms_mix_rate = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["rms_mix_rate"],
- info=translations["rms_mix_rate_info"],
- value=1,
- step=0.1,
- interactive=True
- )
- protect = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["protect"],
- info=translations["protect_info"],
- value=0.5,
- step=0.01,
- interactive=True
- )
- noise_scale = gr.Slider(
- minimum=0.1,
- maximum=1.0,
- label=translations["noise_scale"],
- info=translations["noise_scale_info"],
- value=0.4,
- step=0.01,
- interactive=True,
- visible=architecture_dict["visible"]
- )
- with gr.Row():
- formant_qfrency = gr.Slider(
- value=1.0,
- label=translations["formant_qfrency"],
- info=translations["formant_qfrency"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- formant_timbre = gr.Slider(
- value=1.0,
- label=translations["formant_timbre"],
- info=translations["formant_timbre"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- gr.Markdown(translations["output_tts_markdown"])
- with gr.Row():
- tts_voice_audio = gr.Audio(
- interactive=False,
- label=translations["output_text_to_speech"],
- **audio_params
- )
- tts_voice_convert = gr.Audio(
- interactive=False,
- label=translations["output_file_tts_convert"],
- **audio_params
- )
- with gr.Row():
- load_preset_button.click(
- fn=load_presets,
- inputs=[
- presets_name,
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
- ],
- outputs=[
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
- ]
- )
- save_file_button.click(
- fn=save_presets,
- inputs=[
- name_to_save_file,
- cleaner,
- autotune,
- pitch,
- clean_strength,
- index_strength,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- cleaner_checkbox,
- autotune_checkbox,
- pitch_checkbox,
- index_strength_checkbox,
- resample_sr_checkbox,
- filter_radius_checkbox,
- rms_mix_rate_checkbox,
- protect_checkbox,
- split_audio_checkbox,
- formant_shifting_checkbox,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
- ],
- outputs=[
- presets_name
- ]
- )
- refresh_preset_button.click(
- fn=change_preset_choices,
- inputs=[],
- outputs=[
- presets_name
- ]
- )
- with gr.Row():
- proposal_pitch.change(
- fn=visible,
- inputs=[
- proposal_pitch
- ],
- outputs=[
- proposal_pitch_threshold
- ]
- )
- upload_presets.upload(
- fn=lambda presets_in: [
- shutil_move(preset.name, configs["presets_path"])
- for preset in presets_in
- ][0],
- inputs=[
- upload_presets
- ],
- outputs=[
- presets_name
- ]
- )
- translate_button.click(
- fn=google_translate,
- inputs=[
- prompt,
- source_lang,
- target_lang
- ],
- outputs=[
- prompt
- ],
- api_name="google_translate"
- )
- with gr.Row():
- unlock_full_method.change(
- fn=unlock_f0,
- inputs=[
- unlock_full_method
- ],
- outputs=[
- f0_method
- ]
- )
- upload_f0_file.upload(
- fn=lambda inp: shutil_move(inp.name, configs["f0_path"]),
- inputs=[
- upload_f0_file
- ],
- outputs=[
- f0_file_dropdown
- ]
- )
- refresh_f0_file.click(
- fn=change_f0_choices,
- inputs=[],
- outputs=[
- f0_file_dropdown
- ]
- )
- with gr.Row():
- embedder_mode.change(
- fn=change_embedders_mode,
- inputs=[
- embedder_mode
- ],
- outputs=[
- embedders
- ]
- )
- autotune.change(
- fn=visible,
- inputs=[
- autotune
- ],
- outputs=[
- f0_autotune_strength
- ]
- )
- model_pth.change(
- fn=get_index,
- inputs=[
- model_pth
- ],
- outputs=[
- model_index
- ]
- )
- with gr.Row():
- cleaner.change(
- fn=visible,
- inputs=[
- cleaner
- ],
- outputs=[
- clean_strength
- ]
- )
- f0_method.change(
- fn=lambda method, hybrid: [
- visible(method == "hybrid"),
- visible(method == "hybrid"),
- hoplength_show(method, hybrid)
- ],
- inputs=[
- f0_method,
- hybrid_f0method
- ],
- outputs=[
- hybrid_f0method,
- alpha,
- hop_length
- ]
- )
- hybrid_f0method.change(
- fn=hoplength_show,
- inputs=[
- f0_method,
- hybrid_f0method
- ],
- outputs=[
- hop_length
- ]
- )
- with gr.Row():
- refresh.click(
- fn=change_models_choices,
- inputs=[],
- outputs=[
- model_pth,
- model_index
- ]
- )
- embedders.change(
- fn=lambda embedders: visible(embedders == "custom"),
- inputs=[
- embedders
- ],
- outputs=[
- custom_embedders
- ]
- )
- formant_shifting.change(
- fn=lambda a: [
- visible(a)
- for _ in range(2)
- ],
- inputs=[
- formant_shifting
- ],
- outputs=[
- formant_qfrency,
- formant_timbre
- ]
- )
- with gr.Row():
- model_index.change(
- fn=index_strength_show,
- inputs=[
- model_index
- ],
- outputs=[
- index_strength,
- nprobe
- ]
- )
- txt_input.upload(
- fn=process_input,
- inputs=[
- txt_input
- ],
- outputs=[
- prompt
- ]
- )
- use_txt.change(
- fn=visible,
- inputs=[
- use_txt
- ],
- outputs=[
- txt_input
- ]
- )
- use_txt.change(
- fn=lambda: None,
- inputs=[],
- outputs=[
- txt_input
- ]
- )
- with gr.Row():
- google_tts_check_box.change(
- fn=change_tts_voice_choices,
- inputs=[
- google_tts_check_box
- ],
- outputs=[
- tts_voice
- ]
- )
- model_pth.change(
- fn=get_speakers_id_and_architecture,
- inputs=[
- model_pth
- ],
- outputs=[
- sids,
- noise_scale
- ]
- )
- embedders_mix.change(
- fn=visible,
- inputs=[
- embedders_mix
- ],
- outputs=[
- embedders_mix_column
- ]
- )
- with gr.Row():
- tts_button.click(
- fn=TTS,
- inputs=[
- prompt,
- tts_voice,
- speed,
- output_audio_tts,
- tts_pitch,
- google_tts_check_box,
- txt_input
- ],
- outputs=[
- tts_voice_audio
- ],
- api_name="text-to-speech"
- )
- convert_button.click(
- fn=convert_tts,
- inputs=[
- cleaner,
- autotune,
- pitch,
- clean_strength,
- model_pth,
- model_index,
- index_strength,
- output_audio_tts,
- output_audio,
- export_format,
- f0_method,
- hybrid_f0method,
- hop_length,
- embedders,
- custom_embedders,
- resample_sr,
- filter_radius,
- rms_mix_rate,
- protect,
- split_audio,
- f0_autotune_strength,
- checkpointing,
- predictor_onnx,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- f0_file_dropdown,
- embedder_mode,
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sids,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale,
- nprobe,
- audio_upscaler
- ],
- outputs=[
- tts_voice_convert
- ],
- api_name="convert_tts"
- )
\ No newline at end of file
diff --git a/main/app/tabs/inference/child/convert_with_vad.py b/main/app/tabs/inference/child/convert_with_vad.py
deleted file mode 100644
index 87c08450030215f28dffa9bf6116ed87ca992830..0000000000000000000000000000000000000000
--- a/main/app/tabs/inference/child/convert_with_vad.py
+++ /dev/null
@@ -1,810 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.inference import convert_with_vad
-
-from main.app.core.ui import (
- visible,
- get_index,
- unlock_f0,
- shutil_move,
- hoplength_show,
- index_strength_show,
- change_audios_choices,
- change_models_choices,
- change_embedders_mode,
- get_speakers_id_and_architecture
-)
-
-from main.app.variables import (
- configs,
- method_f0,
- model_name,
- index_path,
- file_types,
- audio_params,
- translations,
- embedders_mode,
- embedders_model,
- paths_for_files,
- hybrid_f0_method,
- sample_rate_choice,
- export_format_choices,
-)
-
-def convert_with_vad_tab():
- with gr.Row():
- gr.Markdown(translations["convert_with_vad_info"])
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- cleaner = gr.Checkbox(
- label=translations["clear_audio"],
- value=False,
- interactive=True
- )
- autotune = gr.Checkbox(
- label=translations["autotune"],
- value=False,
- interactive=True
- )
- checkpointing = gr.Checkbox(
- label=translations["memory_efficient_training"],
- value=False,
- interactive=True
- )
- formant_shifting = gr.Checkbox(
- label=translations["formantshift"],
- value=False,
- interactive=True
- )
- proposal_pitch = gr.Checkbox(
- label=translations["proposal_pitch"],
- value=False,
- interactive=True
- )
- audio_processing = gr.Checkbox(
- label=translations["audio_processing"],
- value=False,
- interactive=True
- )
- with gr.Row():
- num_spk = gr.Slider(
- minimum=2,
- maximum=8,
- step=1,
- info=translations["num_spk_info"],
- label=translations["num_spk"],
- value=2,
- interactive=True
- )
- with gr.Row():
- with gr.Column():
- convert_button = gr.Button(
- translations["convert_audio"],
- variant="primary"
- )
- with gr.Row():
- with gr.Column():
- with gr.Accordion(
- translations["model_accordion"] + " 1",
- open=True
- ):
- with gr.Row():
- model_pth_1 = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- model_index_1 = gr.Dropdown(
- label=translations["index_path"],
- choices=index_path,
- value=index_path[0] if len(index_path) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh_model_1 = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- pitch_1 = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- index_strength_1 = gr.Slider(
- label=translations["index_strength"],
- info=translations["index_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.01,
- interactive=True,
- visible=True
- )
- with gr.Row():
- nprobe_1 = gr.Slider(
- label=translations["nprobe"],
- info=translations["nprobe_info"],
- minimum=1,
- maximum=64,
- value=9,
- step=1,
- interactive=True,
- visible=True
- )
- with gr.Row():
- sid_dict_1, architecture_dict_1 = get_speakers_id_and_architecture(model_pth_1.value)
- if sid_dict_1["visible"] == "hidden": sid_dict_1["visible"] = False
- if architecture_dict_1["visible"] == "hidden": architecture_dict_1["visible"] = False
-
- sids_1 = gr.Dropdown(
- label=translations["sids_label"],
- info=translations["sids_info"],
- choices=sid_dict_1["choices"],
- value=sid_dict_1["value"],
- visible=sid_dict_1["visible"],
- interactive=True
- )
- with gr.Row():
- noise_scale_1 = gr.Slider(
- minimum=0.1,
- maximum=1.0,
- label=translations["noise_scale"],
- info=translations["noise_scale_info"],
- value=0.4,
- step=0.01,
- interactive=True,
- visible=architecture_dict_1["visible"]
- )
- with gr.Accordion(
- translations["input_output"],
- open=False
- ):
- with gr.Column():
- export_format = gr.Radio(
- label=translations["export_format"],
- info=translations["export_info"],
- choices=export_format_choices,
- value="wav",
- interactive=True
- )
- input_audio = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- allow_custom_value=True,
- interactive=True
- )
- output_audio = gr.Textbox(
- label=translations["output_path"],
- value="audios/output.wav",
- placeholder="audios/output.wav",
- info=translations["output_path_info"],
- interactive=True
- )
- with gr.Column():
- refresh_audio = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- drop_audio = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- with gr.Column():
- with gr.Accordion(
- translations["model_accordion"] + " 2",
- open=True
- ):
- with gr.Row():
- model_pth_2 = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- model_index_2 = gr.Dropdown(
- label=translations["index_path"],
- choices=index_path,
- value=index_path[0] if len(index_path) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh_model_2 = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- pitch_2 = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- index_strength_2 = gr.Slider(
- label=translations["index_strength"],
- info=translations["index_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.01,
- interactive=True,
- visible=True
- )
- with gr.Row():
- nprobe_2 = gr.Slider(
- label=translations["nprobe"],
- info=translations["nprobe_info"],
- minimum=1,
- maximum=64,
- value=9,
- step=1,
- interactive=True,
- visible=True
- )
- with gr.Row():
- sid_dict_2, architecture_dict_2 = get_speakers_id_and_architecture(model_pth_2.value)
- if sid_dict_2["visible"] == "hidden": sid_dict_2["visible"] = False
- if architecture_dict_2["visible"] == "hidden": architecture_dict_2["visible"] = False
-
- sids_2 = gr.Dropdown(
- label=translations["sids_label"],
- info=translations["sids_info"],
- choices=sid_dict_2["choices"],
- value=sid_dict_2["value"],
- visible=sid_dict_2["visible"],
- interactive=True
- )
- with gr.Row():
- noise_scale_2 = gr.Slider(
- minimum=0.1,
- maximum=1.0,
- label=translations["noise_scale"],
- info=translations["noise_scale_info"],
- value=0.4,
- step=0.01,
- interactive=True,
- visible=architecture_dict_2["visible"]
- )
- with gr.Accordion(
- translations["setting"],
- open=False
- ):
- with gr.Accordion(
- translations["f0_method"],
- open=False
- ):
- with gr.Group():
- with gr.Row():
- predictor_onnx = gr.Checkbox(
- label=translations["predictor_onnx"],
- info=translations["predictor_onnx_info"],
- value=False,
- interactive=True
- )
- unlock_full_method = gr.Checkbox(
- label=translations["f0_unlock"],
- info=translations["f0_unlock_info"],
- value=False,
- interactive=True
- )
- f0_method = gr.Radio(
- label=translations["f0_method"],
- info=translations["f0_method_info"],
- choices=method_f0,
- value="rmvpe",
- interactive=True
- )
- hybrid_f0method = gr.Dropdown(
- label=translations["f0_method_hybrid"],
- info=translations["f0_method_hybrid_info"],
- choices=hybrid_f0_method,
- value=hybrid_f0_method[0],
- interactive=True,
- allow_custom_value=True,
- visible=False
- )
- hop_length = gr.Slider(
- label=translations['hop_length'],
- info=translations["hop_length_info"],
- minimum=64,
- maximum=512,
- value=160,
- step=1,
- interactive=True,
- visible=False
- )
- alpha = gr.Slider(
- label=translations["alpha_label"],
- info=translations["alpha_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Accordion(
- translations["hubert_model"],
- open=False
- ):
- embedders_mix = gr.Checkbox(
- label=translations["embedders_mix"],
- info=translations["embedders_mix_info"],
- value=False,
- interactive=True
- )
- embedder_mode = gr.Radio(
- label=translations["embed_mode"],
- info=translations["embed_mode_info"],
- value="fairseq",
- choices=embedders_mode,
- interactive=True,
- visible=True
- )
- embedders = gr.Radio(
- label=translations["hubert_model"],
- info=translations["hubert_info"],
- choices=embedders_model,
- value="hubert_base",
- interactive=True
- )
- custom_embedders = gr.Textbox(
- label=translations["modelname"],
- info=translations["modelname_info"],
- value="",
- placeholder="hubert_base",
- interactive=True,
- visible=False
- )
- with gr.Column(visible=False) as embedders_mix_column:
- embedders_mix_layers = gr.Slider(
- label=translations["embedders_mix_layers"],
- info=translations["embedders_mix_layers_info"],
- minimum=1,
- maximum=12,
- value=9,
- step=1,
- interactive=True
- )
- embedders_mix_ratio = gr.Slider(
- label=translations["embedders_mix_ratio"],
- info=translations["embedders_mix_ratio_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True
- )
- with gr.Column():
- resample_sr3 = gr.Radio(
- choices=[0]+sample_rate_choice,
- label=translations["resample"],
- info=translations["resample_info"],
- value=0,
- interactive=True
- )
- proposal_pitch_threshold = gr.Slider(
- minimum=50.0,
- maximum=1200.0,
- label=translations["proposal_pitch_threshold"],
- info=translations["proposal_pitch_threshold_info"],
- value=255.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- clean_strength = gr.Slider(
- label=translations["clean_strength"],
- info=translations["clean_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- f0_autotune_strength = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["autotune_rate"],
- info=translations["autotune_rate_info"],
- value=1,
- step=0.1,
- interactive=True,
- visible=False
- )
- filter_radius = gr.Slider(
- minimum=0,
- maximum=7,
- label=translations["filter_radius"],
- info=translations["filter_radius_info"],
- value=3,
- step=1,
- interactive=True
- )
- rms_mix_rate = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["rms_mix_rate"],
- info=translations["rms_mix_rate_info"],
- value=1,
- step=0.1,
- interactive=True
- )
- protect = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["protect"],
- info=translations["protect_info"],
- value=0.5,
- step=0.01,
- interactive=True
- )
- with gr.Row():
- vad_sensitivity = gr.Slider(
- minimum=0,
- maximum=3,
- label=translations["vad_sensitivity_label"],
- info=translations["vad_sensitivity_info"],
- value=3,
- step=1,
- interactive=True,
- visible=False
- )
- vad_frame_ms = gr.Slider(
- minimum=10,
- maximum=30,
- label=translations["vad_frame_ms_label"],
- info=translations["vad_frame_ms_info"],
- value=30,
- step=10,
- interactive=True,
- visible=False
- )
- with gr.Row():
- formant_qfrency = gr.Slider(
- value=1.0,
- label=translations["formant_qfrency"] + " 1",
- info=translations["formant_qfrency"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- formant_timbre = gr.Slider(
- value=1.0,
- label=translations["formant_timbre"] + " 1",
- info=translations["formant_timbre"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- formant_qfrency = gr.Slider(
- value=1.0,
- label=translations["formant_qfrency"] + " 2",
- info=translations["formant_qfrency"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- formant_timbre = gr.Slider(
- value=1.0,
- label=translations["formant_timbre"] + " 2",
- info=translations["formant_timbre"],
- minimum=0.0,
- maximum=16.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- gr.Markdown(translations["input_output"])
- with gr.Row():
- play_input_audio = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- play_output_audio = gr.Audio(
- interactive=False,
- label=translations["output_file_tts_convert"],
- **audio_params
- )
- with gr.Row():
- autotune.change(
- fn=visible,
- inputs=[
- autotune
- ],
- outputs=[
- f0_autotune_strength
- ]
- )
- cleaner.change(
- fn=visible,
- inputs=[
- cleaner
- ],
- outputs=[
- clean_strength
- ]
- )
- f0_method.change(
- fn=lambda method, hybrid: [
- visible(method == "hybrid"),
- visible(method == "hybrid"),
- hoplength_show(method, hybrid)
- ],
- inputs=[
- f0_method,
- hybrid_f0method
- ],
- outputs=[
- hybrid_f0method,
- alpha,
- hop_length
- ]
- )
- with gr.Row():
- hybrid_f0method.change(
- fn=hoplength_show,
- inputs=[
- f0_method,
- hybrid_f0method
- ],
- outputs=[
- hop_length
- ]
- )
- refresh_model_1.click(
- fn=change_models_choices,
- inputs=[],
- outputs=[
- model_pth_1,
- model_index_1
- ]
- )
- model_pth_1.change(
- fn=get_index,
- inputs=[
- model_pth_1
- ],
- outputs=[
- model_index_1
- ]
- )
- with gr.Row():
- refresh_model_2.click(
- fn=change_models_choices,
- inputs=[],
- outputs=[
- model_pth_2,
- model_index_2
- ]
- )
- model_pth_2.change(
- fn=get_index,
- inputs=[
- model_pth_2
- ],
- outputs=[
- model_index_2
- ]
- )
- drop_audio.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- drop_audio
- ],
- outputs=[
- input_audio
- ]
- )
- with gr.Row():
- input_audio.change(
- fn=lambda audio: audio if os.path.isfile(audio) else None,
- inputs=[
- input_audio
- ],
- outputs=[
- play_input_audio
- ]
- )
- formant_shifting.change(
- fn=lambda a: [
- visible(a)
- for _ in range(4)
- ],
- inputs=[
- formant_shifting
- ],
- outputs=[
- formant_qfrency,
- formant_timbre,
- formant_qfrency,
- formant_timbre
- ]
- )
- embedders.change(
- fn=lambda embedders: visible(embedders == "custom"),
- inputs=[
- embedders
- ],
- outputs=[
- custom_embedders
- ]
- )
- with gr.Row():
- refresh_audio.click(
- fn=change_audios_choices,
- inputs=[
- input_audio
- ],
- outputs=[
- input_audio
- ]
- )
- model_index_1.change(
- fn=index_strength_show,
- inputs=[
- model_index_1
- ],
- outputs=[
- index_strength_1,
- nprobe_1
- ]
- )
- model_index_2.change(
- fn=index_strength_show,
- inputs=[
- model_index_2
- ],
- outputs=[
- index_strength_2,
- nprobe_2
- ]
- )
- with gr.Row():
- unlock_full_method.change(
- fn=unlock_f0,
- inputs=[
- unlock_full_method
- ],
- outputs=[
- f0_method
- ]
- )
- embedder_mode.change(
- fn=change_embedders_mode,
- inputs=[
- embedder_mode
- ],
- outputs=[
- embedders
- ]
- )
- proposal_pitch.change(
- fn=visible,
- inputs=[
- proposal_pitch
- ],
- outputs=[
- proposal_pitch_threshold
- ]
- )
- with gr.Row():
- model_pth_1.change(
- fn=get_speakers_id_and_architecture,
- inputs=[
- model_pth_1
- ],
- outputs=[
- sids_1,
- noise_scale_1
- ]
- )
- model_pth_2.change(
- fn=get_speakers_id_and_architecture,
- inputs=[
- model_pth_2
- ],
- outputs=[
- sids_2,
- noise_scale_2
- ]
- )
- embedders_mix.change(
- fn=visible,
- inputs=[
- embedders_mix
- ],
- outputs=[
- embedders_mix_column
- ]
- )
- with gr.Row():
- convert_button.click(
- fn=convert_with_vad,
- inputs=[
- num_spk,
- cleaner,
- clean_strength,
- autotune,
- f0_autotune_strength,
- checkpointing,
- model_pth_1,
- model_pth_2,
- model_index_1,
- model_index_2,
- pitch_1,
- pitch_2,
- index_strength_1,
- index_strength_2,
- export_format,
- input_audio,
- output_audio,
- predictor_onnx,
- f0_method,
- hybrid_f0method,
- hop_length,
- embedder_mode,
- embedders,
- custom_embedders,
- resample_sr3,
- filter_radius,
- rms_mix_rate,
- protect,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sids_1,
- sids_2,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale_1,
- noise_scale_2,
- vad_sensitivity,
- vad_frame_ms,
- nprobe_1,
- nprobe_2
- ],
- outputs=[
- play_output_audio
- ],
- api_name="convert_with_vad"
- )
\ No newline at end of file
diff --git a/main/app/tabs/inference/child/separate.py b/main/app/tabs/inference/child/separate.py
deleted file mode 100644
index 9e02642239424f1433ef19e28cca727db48a8d65..0000000000000000000000000000000000000000
--- a/main/app/tabs/inference/child/separate.py
+++ /dev/null
@@ -1,600 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.downloads import download_url
-from main.app.core.separate import separate_music
-
-from main.app.core.ui import (
- visible,
- shutil_move,
- separate_change,
- change_audios_choices,
- valueFalse_interactive
-)
-
-from main.app.variables import (
- configs,
- uvr_model,
- vr_models,
- mdx_models,
- file_types,
- audio_params,
- translations,
- reverb_models,
- karaoke_models,
- denoise_models,
- paths_for_files,
- sample_rate_choice,
- export_format_choices
-)
-
-def separate_tab():
- with gr.Row():
- gr.Markdown(translations["4_part"])
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- enable_denoise = gr.Checkbox(
- label=translations["denoise_mdx"],
- value=False,
- interactive=False
- )
- separate_backing = gr.Checkbox(
- label=translations["separator_backing"],
- value=False,
- interactive=True
- )
- separate_reverb = gr.Checkbox(
- label=translations["dereveb_audio"],
- value=False,
- interactive=True
- )
- enable_tta = gr.Checkbox(
- label=translations["enable_tta"],
- value=False,
- interactive=False
- )
- high_end_process = gr.Checkbox(
- label=translations["high_end_process"],
- value=False,
- interactive=False
- )
- enable_post_process = gr.Checkbox(
- label=translations["enable_post_process"],
- value=False,
- interactive=False
- )
- with gr.Row():
- model_name = gr.Dropdown(
- label=translations["separator_model"],
- value=uvr_model[0],
- choices=uvr_model,
- interactive=True
- )
- karaoke_model = gr.Dropdown(
- label=translations["separator_backing_model"],
- value=list(karaoke_models.keys())[0],
- choices=list(karaoke_models.keys()),
- interactive=True,
- visible=False
- )
- reverb_model = gr.Dropdown(
- label=translations["dereveb_model"],
- value=list(reverb_models.keys())[0],
- choices=list(reverb_models.keys()),
- interactive=True,
- visible=False
- )
- denoise_model = gr.Dropdown(
- label=translations["denoise_model"],
- value=list(denoise_models.keys())[0],
- choices=list(denoise_models.keys()),
- interactive=True,
- visible=False
- )
- with gr.Row():
- with gr.Column():
- separate_button = gr.Button(
- translations["separator_tab"],
- variant="primary"
- )
- with gr.Row():
- with gr.Column():
- with gr.Group():
- with gr.Row():
- shifts = gr.Slider(
- label=translations["shift"],
- info=translations["shift_info"],
- minimum=1,
- maximum=20,
- value=2,
- step=1,
- interactive=True
- )
- batch_size = gr.Slider(
- label=translations["batch_size"],
- info=translations["mdx_batch_size_info"],
- minimum=1,
- maximum=64,
- value=1,
- step=1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- segments_size = gr.Slider(
- label=translations["segments_size"],
- info=translations["segments_size_info"],
- minimum=32,
- maximum=3072,
- value=256,
- step=32,
- interactive=True
- )
- aggression = gr.Slider(
- label=translations['aggression'],
- info=translations["aggression_info"],
- minimum=1,
- maximum=50,
- value=5,
- step=1,
- interactive=True,
- visible=False
- )
- drop_audio = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- with gr.Accordion(
- translations["use_url"],
- open=False
- ):
- url = gr.Textbox(
- label=translations["url_audio"],
- value="",
- placeholder="https://www.youtube.com/...",
- scale=6
- )
- download_button = gr.Button(
- translations["downloads"]
- )
- with gr.Column():
- with gr.Group():
- with gr.Row():
- overlap = gr.Radio(
- label=translations["overlap"],
- info=translations["overlap_info"],
- choices=[
- "0.25",
- "0.5",
- "0.75",
- "0.99"
- ],
- value="0.25",
- interactive=True
- )
- with gr.Row():
- window_size = gr.Slider(
- label=translations["window_size"],
- info=translations["window_size_info"],
- minimum=320,
- maximum=1024,
- value=512,
- step=32,
- interactive=True,
- visible=False
- )
- hop_length = gr.Slider(
- label=translations['hop_length'],
- info=translations["hop_length_info"],
- minimum=64,
- maximum=8192,
- value=1024,
- step=1,
- interactive=True,
- visible=False
- )
- post_process_threshold = gr.Slider(
- label=translations['post_process_threshold'],
- info=translations["post_process_threshold_info"],
- minimum=0.1,
- maximum=0.3,
- value=0.2,
- step=0.1,
- interactive=True,
- visible=False
- )
- sample_rate = gr.Radio(
- choices=sample_rate_choice,
- value=44100,
- label=translations["sr"],
- info=translations["sr_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["input_output"],
- open=False
- ):
- export_format = gr.Radio(
- label=translations["export_format"],
- info=translations["export_info"],
- choices=export_format_choices,
- value="wav",
- interactive=True
- )
- input_audio = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- allow_custom_value=True,
- interactive=True
- )
- refresh_audio = gr.Button(
- translations["refresh"]
- )
- output_dirs = gr.Textbox(
- label=translations["output_folder"],
- value="audios",
- placeholder="audios",
- info=translations["output_folder_info"],
- interactive=True
- )
- audio_input = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- with gr.Row():
- gr.Markdown(translations["output_separator"])
- with gr.Row():
- instruments_audio = gr.Audio(
- interactive=False,
- label=translations["instruments"],
- visible=True,
- **audio_params
- )
- original_vocals = gr.Audio(
- interactive=False,
- label=translations["original_vocal"],
- visible=True,
- **audio_params
- )
- main_vocals = gr.Audio(
- interactive=False,
- label=translations["main_vocal"],
- visible=False,
- **audio_params
- )
- backing_vocals = gr.Audio(
- interactive=False,
- label=translations["backing_vocal"],
- visible=False,
- **audio_params
- )
- with gr.Row():
- model_name.change(
- fn=lambda a: valueFalse_interactive(a in list(mdx_models.keys()) + list(vr_models.keys())),
- inputs=[
- model_name
- ],
- outputs=[
- enable_denoise
- ]
- )
- separate_backing.change(
- fn=lambda a, b: valueFalse_interactive(a or b),
- inputs=[
- separate_backing,
- separate_reverb
- ],
- outputs=[
- enable_denoise
- ]
- )
- separate_reverb.change(
- fn=lambda a, b: valueFalse_interactive(a or b),
- inputs=[
- separate_backing,
- separate_reverb
- ],
- outputs=[
- enable_denoise
- ]
- )
- with gr.Row():
- input_audio.change(
- fn=lambda audio: audio if os.path.isfile(audio) else None,
- inputs=[
- input_audio
- ],
- outputs=[
- audio_input
- ]
- )
- drop_audio.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- drop_audio
- ],
- outputs=[
- input_audio
- ]
- )
- refresh_audio.click(
- fn=change_audios_choices,
- inputs=[
- input_audio
- ],
- outputs=[
- input_audio
- ]
- )
- with gr.Row():
- separate_backing.change(
- fn=lambda a: [
- visible(a)
- for _ in range(2)
- ],
- inputs=[
- separate_backing
- ],
- outputs=[
- main_vocals,
- backing_vocals
- ]
- )
- download_button.click(
- fn=download_url,
- inputs=[
- url
- ],
- outputs=[
- input_audio,
- audio_input,
- url
- ],
- api_name='download_url'
- )
- with gr.Row():
- model_name.change(
- fn=separate_change,
- inputs=[
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- karaoke_model,
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- with gr.Row():
- karaoke_model.change(
- fn=separate_change,
- inputs=[
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- karaoke_model,
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- separate_backing.change(
- fn=separate_change,
- inputs=[
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- karaoke_model,
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- with gr.Row():
- reverb_model.change(
- fn=separate_change,
- inputs=[
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- karaoke_model,
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- separate_reverb.change(
- fn=separate_change,
- inputs=[
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- karaoke_model,
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- with gr.Row():
- enable_denoise.change(
- fn=separate_change,
- inputs=[
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- karaoke_model,
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- enable_post_process.change(
- fn=separate_change,
- inputs=[
- model_name,
- karaoke_model,
- reverb_model,
- enable_post_process,
- separate_backing,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- karaoke_model,
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- with gr.Row():
- separate_button.click(
- fn=separate_music,
- inputs=[
- input_audio,
- output_dirs,
- export_format,
- model_name,
- karaoke_model,
- reverb_model,
- denoise_model,
- sample_rate,
- shifts,
- batch_size,
- overlap,
- aggression,
- hop_length,
- window_size,
- segments_size,
- post_process_threshold,
- enable_tta,
- enable_denoise,
- high_end_process,
- enable_post_process,
- separate_backing,
- separate_reverb
- ],
- outputs=[
- original_vocals,
- instruments_audio,
- main_vocals,
- backing_vocals
- ],
- api_name="separate_music"
- )
\ No newline at end of file
diff --git a/main/app/tabs/inference/inference.py b/main/app/tabs/inference/inference.py
deleted file mode 100644
index c477e6d777256245b87c328f6bf0cee3263578f0..0000000000000000000000000000000000000000
--- a/main/app/tabs/inference/inference.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import (
- configs,
- translations
-)
-
-def inference_tab():
- with gr.TabItem(translations["inference"]):
- if configs.get("separator_tab", True):
- from main.app.tabs.inference.child.separate import separate_tab
-
- with gr.TabItem(translations["separator_tab"]):
- gr.Markdown(f"## {translations['separator_tab']}")
- separate_tab()
-
- if configs.get("convert_tab", True):
- from main.app.tabs.inference.child.convert import convert_tab
-
- with gr.TabItem(translations["convert_audio"]):
- gr.Markdown(f"## {translations['convert_audio']}")
- convert_tab()
-
- if configs.get("convert_with_vad_tab", True):
- from main.app.tabs.inference.child.convert_with_vad import convert_with_vad_tab
-
- with gr.TabItem(translations["convert_with_vad"]):
- gr.Markdown(f"## {translations['convert_with_vad']}")
- convert_with_vad_tab()
-
- if configs.get("tts_tab", True):
- from main.app.tabs.inference.child.convert_tts import convert_tts_tab
-
- with gr.TabItem(translations["convert_text"]):
- gr.Markdown(translations["convert_text_markdown"])
- convert_tts_tab()
diff --git a/main/app/tabs/realtime/realtime.py b/main/app/tabs/realtime/realtime.py
deleted file mode 100644
index 70492eb7753f37c4e023879c4f14bcf147a17b86..0000000000000000000000000000000000000000
--- a/main/app/tabs/realtime/realtime.py
+++ /dev/null
@@ -1,2457 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.realtime import (
- realtime_stop,
- change_config,
- realtime_start,
- soundfile_record_audio,
-)
-
-from main.app.variables import (
- configs,
- method_f0,
- model_name,
- index_path,
- audio_params,
- translations,
- embedders_mode,
- embedders_model,
- sample_rate_choice,
- export_format_choices,
- realtime_presets_file
-)
-
-from main.app.core.ui import (
- visible,
- get_index,
- unlock_f0,
- shutil_move,
- visibleFalse,
- hoplength_show,
- input_channels_map,
- output_channels_map,
- update_audio_device,
- index_strength_show,
- change_models_choices,
- change_embedders_mode,
- update_value_from_json,
- update_button_from_json,
- update_dropdowns_from_json,
- change_audio_device_choices,
- change_realtime_preset_choices,
- get_speakers_id_and_architecture
-)
-
-from main.app.core.presets import (
- save_realtime_config,
- load_realtime_config
-)
-
-client_mode = True # "--client" in sys.argv
-
-def realtime_tab():
- with gr.TabItem(translations["realtime"]):
- gr.Markdown(translations["realtime_markdown"])
- with gr.Row():
- gr.Markdown(translations["realtime_markdown_2"])
- with gr.Row():
- status = gr.Label(
- label=translations["realtime_latency"],
- value=translations["realtime_not_startup"],
- elem_id="realtime-status-info"
- )
- with gr.Row():
- monitor = gr.Checkbox(
- label=translations["monitor"],
- value=False,
- interactive=True
- )
- exclusive_mode = gr.Checkbox(
- label=translations["exclusive_mode"],
- value=False,
- interactive=True
- )
- vad_enabled = gr.Checkbox(
- label=translations["vad_enabled"],
- value=False,
- interactive=True
- )
- clean_audio = gr.Checkbox(
- label=translations["clear_audio"],
- value=False,
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["audio_device"],
- open=True
- ):
- with gr.Row():
- input_audio_device = gr.Dropdown(
- label=translations["input_audio_device_label"],
- info=translations["input_audio_device_info"],
- choices=list(input_channels_map.keys()) if not client_mode else [],
- value=(list(input_channels_map.keys())[0] if len(list(input_channels_map.keys())) >= 1 else "") if not client_mode else None,
- interactive=True
- )
- output_audio_device = gr.Dropdown(
- label=translations["output_audio_device_label"],
- info=translations["output_audio_device_info"],
- choices=list(output_channels_map.keys()) if not client_mode else [],
- value=(list(output_channels_map.keys())[0] if len(list(output_channels_map.keys())) >= 1 else "") if not client_mode else None,
- interactive=True
- )
- monitor_output_device = gr.Dropdown(
- label=translations["monitor_output_device_label"],
- info=translations["monitor_output_device_info"],
- choices=list(output_channels_map.keys()) if not client_mode else [],
- value=(list(output_channels_map.keys())[0] if len(list(output_channels_map.keys())) >= 1 else "") if not client_mode else None,
- interactive=True,
- visible=False
- )
- with gr.Row():
- input_audio_gain = gr.Slider(
- minimum=0,
- maximum=2500,
- label=translations["input_audio_gain_label"],
- info=translations["input_audio_gain_info"],
- value=100,
- step=1,
- interactive=True
- )
- output_audio_gain = gr.Slider(
- minimum=0,
- maximum=4000,
- label=translations["output_audio_gain_label"],
- info=translations["output_audio_gain_info"],
- value=100,
- step=1,
- interactive=True
- )
- monitor_audio_gain = gr.Slider(
- minimum=0,
- maximum=4000,
- label=translations["monitor_audio_gain_label"],
- info=translations["monitor_audio_gain_info"],
- value=100,
- step=1,
- interactive=True,
- visible=False
- )
- with gr.Row(visible=not client_mode):
- input_audio_sample_rate = gr.Radio(
- choices=sample_rate_choice,
- value=48000,
- label=translations["samplerate"].split("|")[0],
- info=translations["samplerate_info"],
- interactive=True
- )
- output_audio_sample_rate = gr.Radio(
- choices=sample_rate_choice,
- value=48000,
- label=translations["samplerate"].split("|")[1],
- info=translations["samplerate_info"],
- interactive=True
- )
- monitor_audio_sample_rate = gr.Radio(
- choices=sample_rate_choice,
- value=48000,
- label=translations["samplerate"].split("|")[2],
- info=translations["samplerate_info"],
- interactive=True,
- visible=False
- )
- with gr.Row():
- asio_output_stereo = gr.Checkbox(
- label=translations["stereo_device"].split("|")[0],
- value=True,
- interactive=True,
- visible=False
- )
- asio_monitor_stereo = gr.Checkbox(
- label=translations["stereo_device"].split("|")[1],
- value=True,
- interactive=True,
- visible=False
- )
- with gr.Row(visible=False) as asio_row:
- input_asio_channels = gr.Slider(
- minimum=-1,
- maximum=128,
- label=translations["input_asio_channels_label"],
- info=translations["input_asio_channels_info"],
- value=0,
- step=1,
- interactive=True,
- visible=False
- )
- output_asio_channels = gr.Slider(
- minimum=-1,
- maximum=128,
- label=translations["output_asio_channels_label"],
- info=translations["output_asio_channels_info"],
- value=0,
- step=1,
- interactive=True,
- visible=False
- )
- monitor_asio_channels = gr.Slider(
- minimum=-1,
- maximum=128,
- label=translations["monitor_asio_channels_label"],
- info=translations["monitor_asio_channels_info"],
- value=0,
- step=1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- refresh_audio_device = gr.Button(
- value=translations["refresh_audio_device"],
- variant="secondary"
- )
- with gr.Row():
- start_realtime = gr.Button(
- value=translations["start_realtime_button"],
- variant="primary",
- interactive=True
- )
- stop_realtime = gr.Button(
- value=translations["stop_realtime_button"],
- variant="stop",
- interactive=False
- )
- with gr.Row():
- with gr.Accordion(translations["record"], open=False):
- with gr.Column():
- record_audio_path = gr.Textbox(
- label=translations["output_path"],
- placeholder="audios/record_audio.wav",
- info=translations["output_path_info"],
- value="audios/record_audio.wav",
- interactive=True,
- )
- export_format = gr.Radio(
- label=translations["export_format"],
- info=translations["export_info"],
- choices=export_format_choices,
- value="wav",
- interactive=True,
- )
- record_audio = gr.Button(
- translations["start_record"]
- )
- record_output = gr.Audio(
- label=translations["output_audio"],
- **audio_params
- )
- with gr.Row():
- chunk_size = gr.Slider(
- minimum=2.7,
- maximum=2730.7,
- step=0.1,
- label=translations["chunk_size"],
- info=translations["chunk_size_info"],
- value=1024,
- interactive=True
- )
- pitch = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- with gr.Row():
- with gr.Column():
- with gr.Accordion(
- translations["model_accordion"],
- open=True
- ):
- with gr.Row():
- model_pth = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- model_index = gr.Dropdown(
- label=translations["index_path"],
- choices=index_path,
- value=index_path[0] if len(index_path) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- model_refresh = gr.Button(
- translations["refresh"]
- )
- with gr.Row():
- index_strength = gr.Slider(
- label=translations["index_strength"],
- info=translations["index_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.01,
- interactive=True,
- visible=True
- )
- nprobe = gr.Slider(
- label=translations["nprobe"],
- info=translations["nprobe_info"],
- minimum=1,
- maximum=64,
- value=9,
- step=1,
- interactive=True,
- visible=True
- )
- with gr.Row():
- sid_dict, architecture_dict = get_speakers_id_and_architecture(model_pth.value)
- if sid_dict["visible"] == "hidden": sid_dict["visible"] = False
- if architecture_dict["visible"] == "hidden": architecture_dict["visible"] = False
-
- sids = gr.Dropdown(
- label=translations["sids_label"],
- info=translations["sids_info"],
- choices=sid_dict["choices"],
- value=sid_dict["value"],
- visible=sid_dict["visible"],
- interactive=True
- )
- with gr.Column():
- with gr.Accordion(
- translations["f0_method"],
- open=True
- ):
- with gr.Group():
- with gr.Row():
- predictor_onnx = gr.Checkbox(
- label=translations["predictor_onnx"],
- info=translations["predictor_onnx_info"],
- value=False,
- interactive=True
- )
- unlock_full_method = gr.Checkbox(
- label=translations["f0_unlock"],
- info=translations["f0_unlock_info"],
- value=False,
- interactive=True
- )
- f0_method = gr.Radio(
- label=translations["f0_method"],
- info=translations["f0_method_info"],
- choices=[m for m in method_f0 if m != "hybrid"],
- value="rmvpe",
- interactive=True
- )
- hop_length = gr.Slider(
- label=translations['hop_length'],
- info=translations["hop_length_info"],
- minimum=64,
- maximum=512,
- value=160,
- step=1,
- interactive=True,
- visible=False
- )
- with gr.Column():
- with gr.Accordion(
- translations["hubert_model"],
- open=True
- ):
- embedders_mix = gr.Checkbox(
- label=translations["embedders_mix"],
- info=translations["embedders_mix_info"],
- value=False,
- interactive=True
- )
- embedder_mode = gr.Radio(
- label=translations["embed_mode"],
- info=translations["embed_mode_info"],
- value="fairseq",
- choices=embedders_mode,
- interactive=True,
- visible=True)
- embedders = gr.Radio(
- label=translations["hubert_model"],
- info=translations["hubert_info"],
- choices=embedders_model,
- value="hubert_base",
- interactive=True
- )
- custom_embedders = gr.Textbox(
- label=translations["modelname"],
- info=translations["modelname_info"],
- value="",
- placeholder="hubert_base",
- interactive=True,
- visible=False
- )
- with gr.Column(visible=False) as embedders_mix_column:
- embedders_mix_layers = gr.Slider(
- label=translations["embedders_mix_layers"],
- info=translations["embedders_mix_layers_info"],
- minimum=1,
- maximum=12,
- value=9,
- step=1,
- interactive=True
- )
- embedders_mix_ratio = gr.Slider(
- label=translations["embedders_mix_ratio"],
- info=translations["embedders_mix_ratio_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True
- )
- with gr.Row():
- with gr.Accordion(
- translations["setting"],
- open=True
- ):
- with gr.Row():
- f0_autotune = gr.Checkbox(
- label=translations["autotune"],
- value=False,
- interactive=True
- )
- proposal_pitch = gr.Checkbox(
- label=translations["proposal_pitch"],
- value=False,
- interactive=True
- )
- with gr.Group():
- with gr.Row():
- f0_autotune_strength = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["autotune_rate"],
- info=translations["autotune_rate_info"],
- value=1,
- step=0.1,
- interactive=True,
- visible=False
- )
- proposal_pitch_threshold = gr.Slider(
- minimum=50.0,
- maximum=1200.0,
- label=translations["proposal_pitch_threshold"],
- info=translations["proposal_pitch_threshold_info"],
- value=255.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- rms_mix_rate = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["rms_mix_rate"],
- info=translations["rms_mix_rate_info"],
- value=1,
- step=0.1,
- interactive=True
- )
- protect = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["protect"],
- info=translations["protect_info"],
- value=0.5,
- step=0.01,
- interactive=True
- )
- with gr.Row():
- clean_strength = gr.Slider(
- label=translations["clean_strength"],
- info=translations["clean_strength_info"],
- minimum=0,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- filter_radius = gr.Slider(
- minimum=0,
- maximum=7,
- label=translations["filter_radius"],
- info=translations["filter_radius_info"],
- value=3,
- step=1,
- interactive=True
- )
- with gr.Column():
- silent_threshold = gr.Slider(
- minimum=-90,
- maximum=-60,
- label=translations["silent_threshold_label"],
- info=translations["silent_threshold_info"],
- value=-90,
- step=1,
- interactive=True
- )
- extra_convert_size = gr.Slider(
- minimum=0.1,
- maximum=5,
- label=translations["extra_convert_size_label"],
- info=translations["extra_convert_size_info"],
- value=0.5,
- step=0.1,
- interactive=True
- )
- cross_fade_overlap_size = gr.Slider(
- minimum=0.05,
- maximum=0.2,
- label=translations["cross_fade_overlap_size_label"],
- info=translations["cross_fade_overlap_size_info"],
- value=0.1,
- step=0.01,
- interactive=True
- )
- noise_scale = gr.Slider(
- minimum=0.1,
- maximum=1.0,
- label=translations["noise_scale"],
- info=translations["noise_scale_info"],
- value=0.4,
- step=0.01,
- interactive=True,
- visible=architecture_dict["visible"]
- )
- with gr.Row():
- vad_sensitivity = gr.Slider(
- minimum=0,
- maximum=3,
- label=translations["vad_sensitivity_label"],
- info=translations["vad_sensitivity_info"],
- value=3,
- step=1,
- interactive=True,
- visible=False
- )
- vad_frame_ms = gr.Slider(
- minimum=10,
- maximum=30,
- label=translations["vad_frame_ms_label"],
- info=translations["vad_frame_ms_info"],
- value=30,
- step=10,
- interactive=True,
- visible=False
- )
- with gr.Row():
- post_process = gr.Checkbox(
- label=translations["audio_effects"],
- value=False,
- interactive=True
- )
- reverb = gr.Checkbox(
- label=translations["reverb"],
- value=False,
- interactive=True,
- visible=False
- )
- chorus = gr.Checkbox(
- label=translations["chorus"],
- value=False,
- interactive=True,
- visible=False
- )
- delay = gr.Checkbox(
- label=translations["delay"],
- value=False,
- interactive=True,
- visible=False
- )
- phaser = gr.Checkbox(
- label=translations["phaser"],
- value=False,
- interactive=True,
- visible=False
- )
- compressor = gr.Checkbox(
- label=translations["compressor"],
- value=False,
- interactive=True,
- visible=False
- )
- with gr.Row():
- limiter = gr.Checkbox(
- label=translations["limiter"],
- value=False,
- interactive=True,
- visible=False
- )
- distortion = gr.Checkbox(
- label=translations["distortion"],
- value=False,
- interactive=True,
- visible=False
- )
- pitch_shift = gr.Checkbox(
- label=translations["pitch"],
- value=False,
- interactive=True,
- visible=False
- )
- gain = gr.Checkbox(
- label=translations["gain"],
- value=False,
- interactive=True,
- visible=False
- )
- bitcrush = gr.Checkbox(
- label=translations["bitcrush"],
- value=False,
- interactive=True,
- visible=False
- )
- clipping = gr.Checkbox(
- label=translations["clipping"],
- value=False,
- interactive=True,
- visible=False
- )
- with gr.Accordion(
- translations["reverb"],
- open=True,
- visible=False
- ) as reverb_accordion:
- reverb_freeze_mode = gr.Checkbox(
- label=translations["reverb_freeze"],
- info=translations["reverb_freeze_info"],
- value=False,
- interactive=True
- )
- reverb_room_size = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.15,
- label=translations["room_size"],
- info=translations["room_size_info"],
- interactive=True
- )
- reverb_damping = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.7,
- label=translations["damping"],
- info=translations["damping_info"],
- interactive=True
- )
- reverb_wet_gain = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.2,
- label=translations["wet_level"],
- info=translations["wet_level_info"],
- interactive=True
- )
- reverb_dry_gain = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.8,
- label=translations["dry_level"],
- info=translations["dry_level_info"],
- interactive=True
- )
- reverb_width = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=1,
- label=translations["width"],
- info=translations["width_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["chorus"],
- open=True,
- visible=False
- ) as chorus_accordion:
- chorus_depth = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["chorus_depth"],
- info=translations["chorus_depth_info"],
- interactive=True
- )
- chorus_rate = gr.Slider(
- minimum=0.1,
- maximum=10,
- step=0.1,
- value=1.5,
- label=translations["chorus_rate_hz"],
- info=translations["chorus_rate_hz_info"],
- interactive=True
- )
- chorus_mix = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["chorus_mix"],
- info=translations["chorus_mix_info"],
- interactive=True
- )
- chorus_center_delay = gr.Slider(
- minimum=0,
- maximum=50,
- step=1,
- value=10,
- label=translations["chorus_center_delay_ms"],
- info=translations["chorus_center_delay_ms_info"],
- interactive=True
- )
- chorus_feedback = gr.Slider(
- minimum=-1,
- maximum=1,
- step=0.01,
- value=0,
- label=translations["chorus_feedback"],
- info=translations["chorus_feedback_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["phaser"],
- open=True,
- visible=False
- ) as phaser_accordion:
- phaser_depth = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["phaser_depth"],
- info=translations["phaser_depth_info"],
- interactive=True
- )
- phaser_rate_hz = gr.Slider(
- minimum=0.1,
- maximum=10,
- step=0.1,
- value=1,
- label=translations["phaser_rate_hz"],
- info=translations["phaser_rate_hz_info"],
- interactive=True
- )
- phaser_mix = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["phaser_mix"],
- info=translations["phaser_mix_info"],
- interactive=True
- )
- phaser_centre_frequency_hz = gr.Slider(
- minimum=50,
- maximum=5000,
- step=10,
- value=1000,
- label=translations["phaser_centre_frequency_hz"],
- info=translations["phaser_centre_frequency_hz_info"],
- interactive=True
- )
- phaser_feedback = gr.Slider(
- minimum=-1,
- maximum=1,
- step=0.01,
- value=0,
- label=translations["phaser_feedback"],
- info=translations["phaser_feedback_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["delay"],
- open=True,
- visible=False
- ) as delay_accordion:
- delay_seconds = gr.Slider(
- minimum=0,
- maximum=5,
- step=0.01,
- value=0.5,
- label=translations["delay_seconds"],
- info=translations["delay_seconds_info"],
- interactive=True
- )
- delay_feedback = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["delay_feedback"],
- info=translations["delay_feedback_info"],
- interactive=True
- )
- delay_mix = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.01,
- value=0.5,
- label=translations["delay_mix"],
- info=translations["delay_mix_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["compressor"],
- open=True,
- visible=False
- ) as compressor_accordion:
- compressor_threshold = gr.Slider(
- minimum=-60,
- maximum=0,
- step=1,
- value=-20,
- label=translations["compressor_threshold_db"],
- info=translations["compressor_threshold_db_info"],
- interactive=True
- )
- compressor_ratio = gr.Slider(
- minimum=1,
- maximum=20,
- step=0.1,
- value=1,
- label=translations["compressor_ratio"],
- info=translations["compressor_ratio_info"],
- interactive=True
- )
- compressor_attack = gr.Slider(
- minimum=0.1,
- maximum=100,
- step=0.1,
- value=10,
- label=translations["compressor_attack_ms"],
- info=translations["compressor_attack_ms_info"],
- interactive=True
- )
- compressor_release = gr.Slider(
- minimum=10,
- maximum=1000,
- step=1,
- value=100,
- label=translations["compressor_release_ms"],
- info=translations["compressor_release_ms_info"],
- interactive=True
- )
- with gr.Accordion(
- translations["limiter"],
- open=True,
- visible=False
- ) as limiter_accordion:
- limiter_threshold = gr.Slider(
- minimum=-60,
- maximum=0,
- step=1,
- value=-1,
- label=translations["limiter_threshold_db"],
- info=translations["limiter_threshold_db_info"],
- interactive=True
- )
- limiter_release_time = gr.Slider(
- minimum=10,
- maximum=1000,
- step=1,
- value=100,
- label=translations["limiter_release_ms"],
- info=translations["limiter_release_ms_info"],
- interactive=True
- )
- with gr.Row():
- distortion_gain = gr.Slider(
- minimum=0,
- maximum=50,
- step=1,
- value=20,
- label=translations["distortion"],
- info=translations["distortion_info"],
- interactive=True,
- visible=False
- )
- pitch_shift_semitones = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- value=0,
- label=translations["pitch"],
- info=translations["pitch_info"],
- interactive=True,
- visible=False
- )
- gain_db = gr.Slider(
- minimum=-60,
- maximum=60,
- step=1,
- value=0,
- label=translations["gain"],
- info=translations["gain_info"],
- interactive=True,
- visible=False
- )
- bitcrush_bit_depth = gr.Slider(
- minimum=1,
- maximum=24,
- step=1,
- value=16,
- label=translations["bitcrush_bit_depth"],
- info=translations["bitcrush_bit_depth_info"],
- interactive=True,
- visible=False
- )
- clipping_threshold = gr.Slider(
- minimum=-60,
- maximum=0,
- step=1,
- value=-1,
- label=translations["clipping_threshold_db"],
- info=translations["clipping_threshold_db_info"],
- interactive=True,
- visible=False
- )
- with gr.Row():
- with gr.Accordion(
- translations["use_presets"],
- open=False
- ):
- with gr.Row():
- presets_name = gr.Dropdown(
- label=translations["file_preset"],
- choices=realtime_presets_file,
- value=realtime_presets_file[0] if len(realtime_presets_file) > 0 else '',
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- load_preset_button = gr.Button(
- translations["load_file"],
- variant="primary"
- )
- refresh_preset_button = gr.Button(
- translations["refresh"]
- )
- with gr.Accordion(
- translations["export_file"],
- open=False
- ):
- with gr.Row():
- with gr.Column():
- name_to_save_file = gr.Textbox(
- label=translations["filename_to_save"]
- )
- save_file_button = gr.Button(
- translations["export_file"]
- )
- with gr.Row():
- upload_presets = gr.Files(
- label=translations["upload_presets"],
- file_types=[".realtime.json"]
- )
- with gr.Row():
- json_audio_hidden = gr.JSON(
- visible=False
- )
- json_button_hidden = gr.JSON(
- visible=False
- )
- json_value_hidden = gr.JSON(
- visible=False
- )
- with gr.Row():
- post_process.change(
- fn=lambda a: [
- visibleFalse(a)
- for _ in range(11)
- ],
- inputs=[
- post_process
- ],
- outputs=[
- reverb,
- chorus,
- delay,
- phaser,
- compressor,
- pitch_shift,
- limiter,
- distortion,
- gain,
- bitcrush,
- clipping
- ]
- )
- reverb.change(
- fn=visible,
- inputs=[
- reverb
- ],
- outputs=[
- reverb_accordion
- ]
- )
- chorus.change(
- fn=visible,
- inputs=[
- chorus
- ],
- outputs=[
- chorus_accordion
- ]
- )
- with gr.Row():
- delay.change(
- fn=visible,
- inputs=[
- delay
- ],
- outputs=[
- delay_accordion
- ]
- )
- phaser.change(
- fn=visible,
- inputs=[
- phaser
- ],
- outputs=[
- phaser_accordion
- ]
- )
- compressor.change(
- fn=visible,
- inputs=[
- compressor
- ],
- outputs=[
- compressor_accordion
- ]
- )
- with gr.Row():
- limiter.change(
- fn=visible,
- inputs=[
- limiter
- ],
- outputs=[
- limiter_accordion
- ]
- )
- distortion.change(
- fn=visible,
- inputs=[
- distortion
- ],
- outputs=[
- distortion_gain
- ]
- )
- pitch_shift.change(
- fn=visible,
- inputs=[
- pitch_shift
- ],
- outputs=[
- pitch_shift_semitones
- ]
- )
- with gr.Row():
- gain.change(
- fn=visible,
- inputs=[
- gain
- ],
- outputs=[
- gain_db
- ]
- )
- bitcrush.change(
- fn=visible,
- inputs=[
- bitcrush
- ],
- outputs=[
- bitcrush_bit_depth
- ]
- )
- clipping.change(
- fn=visible,
- inputs=[
- clipping
- ],
- outputs=[
- clipping_threshold
- ]
- )
- with gr.Row():
- model_pth.change(
- fn=get_index,
- inputs=[
- model_pth
- ],
- outputs=[
- model_index
- ]
- )
- model_index.change(
- fn=index_strength_show,
- inputs=[
- model_index
- ],
- outputs=[
- index_strength,
- nprobe
- ]
- )
- model_refresh.click(
- fn=change_models_choices,
- inputs=[],
- outputs=[
- model_pth,
- model_index
- ]
- )
- with gr.Row():
- unlock_full_method.change(
- fn=lambda f0_method: {
- "choices": [
- m for m in unlock_f0(f0_method)["choices"]
- if m != "hybrid"
- ],
- "value": "rmvpe",
- "__type__": "update"
- },
- inputs=[
- unlock_full_method
- ],
- outputs=[
- f0_method
- ]
- )
- f0_method.change(
- fn=lambda f0_method: hoplength_show(f0_method, None),
- inputs=[
- f0_method
- ],
- outputs=[
- hop_length
- ]
- )
- embedder_mode.change(
- fn=change_embedders_mode,
- inputs=[
- embedder_mode
- ],
- outputs=[
- embedders
- ]
- )
- with gr.Row():
- embedders.change(
- fn=lambda embedders: visible(embedders == "custom"),
- inputs=[
- embedders
- ],
- outputs=[
- custom_embedders
- ]
- )
- f0_autotune.change(
- fn=visible,
- inputs=[
- f0_autotune
- ],
- outputs=[
- f0_autotune_strength
- ]
- )
- clean_audio.change(
- fn=visible,
- inputs=[
- clean_audio
- ],
- outputs=[
- clean_strength
- ]
- )
- with gr.Row():
- if not client_mode:
- input_audio_device.change(
- fn=update_audio_device,
- inputs=[
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- monitor
- ],
- outputs=[
- monitor_output_device,
- monitor_audio_gain,
- asio_row,
- input_asio_channels,
- output_asio_channels,
- monitor_asio_channels,
- input_audio_sample_rate,
- output_audio_sample_rate,
- monitor_audio_sample_rate,
- asio_output_stereo,
- asio_monitor_stereo
- ]
- )
- output_audio_device.change(
- fn=update_audio_device,
- inputs=[
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- monitor
- ],
- outputs=[
- monitor_output_device,
- monitor_audio_gain,
- asio_row,
- input_asio_channels,
- output_asio_channels,
- monitor_asio_channels,
- input_audio_sample_rate,
- output_audio_sample_rate,
- monitor_audio_sample_rate,
- asio_output_stereo,
- asio_monitor_stereo
- ]
- )
- monitor_output_device.change(
- fn=update_audio_device,
- inputs=[
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- monitor
- ],
- outputs=[
- monitor_output_device,
- monitor_audio_gain,
- asio_row,
- input_asio_channels,
- output_asio_channels,
- monitor_asio_channels,
- input_audio_sample_rate,
- output_audio_sample_rate,
- monitor_audio_sample_rate,
- asio_output_stereo,
- asio_monitor_stereo
- ]
- )
- with gr.Row():
- embedders_mix.change(
- fn=visible,
- inputs=[
- embedders_mix
- ],
- outputs=[
- embedders_mix_column
- ]
- )
- if not client_mode:
- monitor.change(
- fn=update_audio_device,
- inputs=[
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- monitor
- ],
- outputs=[
- monitor_output_device,
- monitor_audio_gain,
- asio_row,
- input_asio_channels,
- output_asio_channels,
- monitor_asio_channels,
- input_audio_sample_rate,
- output_audio_sample_rate,
- monitor_audio_sample_rate,
- asio_output_stereo,
- asio_monitor_stereo
- ]
- )
- with gr.Row():
- proposal_pitch.change(
- fn=visible,
- inputs=[
- proposal_pitch
- ],
- outputs=[
- proposal_pitch_threshold
- ]
- )
- vad_enabled.change(
- fn=lambda a: [
- visible(a)
- for _ in range(2)
- ],
- inputs=[
- vad_enabled
- ],
- outputs=[
- vad_sensitivity,
- vad_frame_ms
- ]
- )
- if not client_mode:
- refresh_audio_device.click(
- fn=change_audio_device_choices,
- inputs=[],
- outputs=[
- input_audio_device,
- output_audio_device,
- monitor_output_device
- ]
- )
- else:
- refresh_audio_device.click(
- fn=None,
- js="getAudioDevices",
- inputs=[],
- outputs=[
- json_audio_hidden
- ]
- )
- with gr.Row():
- model_pth.change(
- fn=get_speakers_id_and_architecture,
- inputs=[
- model_pth
- ],
- outputs=[
- sids,
- noise_scale
- ]
- )
- if client_mode:
- json_audio_hidden.change(
- fn=update_dropdowns_from_json,
- inputs=[
- json_audio_hidden
- ],
- outputs=[
- input_audio_device,
- output_audio_device,
- monitor_output_device
- ]
- )
- json_button_hidden.change(
- fn=update_button_from_json,
- inputs=[
- json_button_hidden
- ],
- outputs=[
- start_realtime,
- stop_realtime
- ]
- )
- json_value_hidden.change(
- fn=update_value_from_json,
- inputs=[
- json_value_hidden
- ],
- outputs=[
- record_audio,
- record_output
- ]
- )
- with gr.Row():
- if not client_mode:
- start_realtime.click(
- fn=realtime_start,
- inputs=[
- monitor,
- exclusive_mode,
- vad_enabled,
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- input_audio_gain,
- output_audio_gain,
- monitor_audio_gain,
- input_asio_channels,
- output_asio_channels,
- monitor_asio_channels,
- input_audio_sample_rate,
- output_audio_sample_rate,
- monitor_audio_sample_rate,
- chunk_size,
- pitch,
- model_pth,
- model_index,
- index_strength,
- predictor_onnx,
- f0_method,
- hop_length,
- embedder_mode,
- embedders,
- custom_embedders,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- post_process,
- sids,
- noise_scale,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- nprobe
- ],
- outputs=[
- status,
- start_realtime,
- stop_realtime
- ]
- )
- stop_realtime.click(
- fn=realtime_stop,
- inputs=[],
- outputs=[
- status,
- start_realtime,
- stop_realtime
- ]
- )
- record_audio.click(
- fn=soundfile_record_audio,
- inputs=[
- record_audio,
- record_audio_path,
- export_format
- ],
- outputs=[
- record_audio,
- record_output
- ]
- )
- else:
- start_realtime.click(
- fn=None,
- js="StreamAudioRealtime",
- inputs=[
- monitor,
- vad_enabled,
- input_audio_device,
- output_audio_device,
- monitor_output_device,
- input_audio_gain,
- output_audio_gain,
- monitor_audio_gain,
- chunk_size,
- pitch,
- model_pth,
- model_index,
- index_strength,
- predictor_onnx,
- f0_method,
- hop_length,
- embedder_mode,
- embedders,
- custom_embedders,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- exclusive_mode,
- post_process,
- sids,
- noise_scale,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix,
- nprobe
- ],
- outputs=[
- json_button_hidden
- ]
- )
- stop_realtime.click(
- fn=None,
- js="StopAudioStream",
- inputs=[],
- outputs=[
- json_button_hidden
- ]
- )
- record_audio.click(
- fn=None,
- js="SoundfileRecordAudio",
- inputs=[
- record_audio,
- record_audio_path,
- export_format
- ],
- outputs=[
- json_value_hidden
- ]
- )
- with gr.Row():
- cross_fade_overlap_size.change(
- js="(value) => window.ChangeConfig(value, 'cross_fade_overlap_size')" if client_mode else None,
- fn=(lambda value: change_config(value, "cross_fade_overlap_size")) if not client_mode else None,
- inputs=[
- cross_fade_overlap_size
- ],
- outputs=[]
- )
- extra_convert_size.change(
- js="(value) => window.ChangeConfig(value, 'extra_convert_size')" if client_mode else None,
- fn=(lambda value: change_config(value, "extra_convert_size")) if not client_mode else None,
- inputs=[
- extra_convert_size
- ],
- outputs=[]
- )
- silent_threshold.change(
- js="(value) => window.ChangeConfig(value, 'silent_threshold')" if client_mode else None,
- fn=(lambda value: change_config(value, "silent_threshold")) if not client_mode else None,
- inputs=[
- silent_threshold
- ],
- outputs=[]
- )
- with gr.Row():
- vad_enabled.change(
- js="(value) => window.ChangeConfig(value, 'vad_enabled')" if client_mode else None,
- fn=(lambda value: change_config(value, "vad_enabled")) if not client_mode else None,
- inputs=[
- vad_enabled
- ],
- outputs=[]
- )
- vad_sensitivity.change(
- js="(value) => window.ChangeConfig(value, 'vad_sensitivity')" if client_mode else None,
- fn=(lambda value: change_config(value, "vad_sensitivity")) if not client_mode else None,
- inputs=[
- vad_sensitivity
- ],
- outputs=[]
- )
- vad_frame_ms.change(
- js="(value) => window.ChangeConfig(value, 'vad_frame_ms')" if client_mode else None,
- fn=(lambda value: change_config(value, "vad_frame_ms")) if not client_mode else None,
- inputs=[
- vad_frame_ms
- ],
- outputs=[]
- )
- with gr.Row():
- input_audio_gain.change(
- js="(value) => window.ChangeConfig(value, 'input_audio_gain')" if client_mode else None,
- fn=(lambda value: change_config(value / 100.0, "input_audio_gain")) if not client_mode else None,
- inputs=[
- input_audio_gain
- ],
- outputs=[]
- )
- output_audio_gain.change(
- js="(value) => window.ChangeConfig(value, 'output_audio_gain')" if client_mode else None,
- fn=(lambda value: change_config(value / 100.0, "output_audio_gain")) if not client_mode else None,
- inputs=[
- output_audio_gain
- ],
- outputs=[]
- )
- monitor_audio_gain.change(
- js="(value) => window.ChangeConfig(value, 'monitor_audio_gain')" if client_mode else None,
- fn=(lambda value: change_config(value / 100.0, "monitor_audio_gain")) if not client_mode else None,
- inputs=[
- monitor_audio_gain
- ],
- outputs=[]
- )
- with gr.Row():
- index_strength.change(
- js="(value) => window.ChangeConfig(value, 'index_rate')" if client_mode else None,
- fn=(lambda value: change_config(value, "index_rate")) if not client_mode else None,
- inputs=[
- index_strength
- ],
- outputs=[]
- )
- nprobe.change(
- js="(value) => window.ChangeConfig(value, 'nprobe')" if client_mode else None,
- fn=(lambda value: change_config(value, "nprobe")) if not client_mode else None,
- inputs=[
- nprobe
- ],
- outputs=[]
- )
- rms_mix_rate.change(
- js="(value) => window.ChangeConfig(value, 'rms_mix_rate')" if client_mode else None,
- fn=(lambda value: change_config(value, "rms_mix_rate")) if not client_mode else None,
- inputs=[
- rms_mix_rate
- ],
- outputs=[]
- )
- protect.change(
- js="(value) => window.ChangeConfig(value, 'protect')" if client_mode else None,
- fn=(lambda value: change_config(value, "protect")) if not client_mode else None,
- inputs=[
- protect
- ],
- outputs=[]
- )
- with gr.Row():
- pitch.change(
- js="(value) => window.ChangeConfig(value, 'f0_up_key')" if client_mode else None,
- fn=(lambda value: change_config(value, "f0_up_key")) if not client_mode else None,
- inputs=[
- pitch
- ],
- outputs=[]
- )
- f0_autotune.change(
- js="(value) => window.ChangeConfig(value, 'f0_autotune')" if client_mode else None,
- fn=(lambda value: change_config(value, "f0_autotune")) if not client_mode else None,
- inputs=[
- f0_autotune
- ],
- outputs=[]
- )
- f0_autotune_strength.change(
- js="(value) => window.ChangeConfig(value, 'f0_autotune_strength')" if client_mode else None,
- fn=(lambda value: change_config(value, "f0_autotune_strength")) if not client_mode else None,
- inputs=[
- f0_autotune_strength
- ],
- outputs=[]
- )
- with gr.Row():
- proposal_pitch.change(
- js="(value) => window.ChangeConfig(value, 'proposal_pitch')" if client_mode else None,
- fn=(lambda value: change_config(value, "proposal_pitch")) if not client_mode else None,
- inputs=[
- proposal_pitch
- ],
- outputs=[]
- )
- proposal_pitch_threshold.change(
- js="(value) => window.ChangeConfig(value, 'proposal_pitch_threshold')" if client_mode else None,
- fn=(lambda value: change_config(value, "proposal_pitch_threshold")) if not client_mode else None,
- inputs=[
- proposal_pitch_threshold
- ],
- outputs=[]
- )
- clean_audio.change(
- js="(value) => window.ChangeConfig(value, 'clean_audio')" if client_mode else None,
- fn=(lambda value: change_config(value, "clean_audio")) if not client_mode else None,
- inputs=[
- clean_audio
- ],
- outputs=[]
- )
- with gr.Row():
- clean_strength.change(
- js="(value) => window.ChangeConfig(value, 'clean_strength')" if client_mode else None,
- fn=(lambda value: change_config(value, "clean_strength")) if not client_mode else None,
- inputs=[
- clean_strength
- ],
- outputs=[]
- )
- post_process.change(
- js="(value) => window.ChangeConfig(value, 'post_process')" if client_mode else None,
- fn=(lambda value: change_config(value, "post_process")) if not client_mode else None,
- inputs=[post_process],
- outputs=[]
- )
- reverb.change(
- js="(value) => window.ChangeConfig(value, 'reverb', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "reverb", if_kwargs=True)) if not client_mode else None,
- inputs=[
- reverb
- ],
- outputs=[]
- )
- with gr.Row():
- chorus.change(
- js="(value) => window.ChangeConfig(value, 'chorus', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "chorus", if_kwargs=True)) if not client_mode else None,
- inputs=[
- chorus
- ],
- outputs=[]
- )
- delay.change(
- js="(value) => window.ChangeConfig(value, 'delay', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "delay", if_kwargs=True)) if not client_mode else None,
- inputs=[
- delay
- ],
- outputs=[]
- )
- phaser.change(
- js="(value) => window.ChangeConfig(value, 'phaser', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "phaser", if_kwargs=True)) if not client_mode else None,
- inputs=[
- phaser
- ],
- outputs=[]
- )
- with gr.Row():
- compressor.change(
- js="(value) => window.ChangeConfig(value, 'compressor', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "compressor", if_kwargs=True)) if not client_mode else None,
- inputs=[
- compressor
- ],
- outputs=[]
- )
- limiter.change(
- js="(value) => window.ChangeConfig(value, 'limiter', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "limiter", if_kwargs=True)) if not client_mode else None,
- inputs=[
- limiter
- ],
- outputs=[]
- )
- distortion.change(
- js="(value) => window.ChangeConfig(value, 'distortion', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "distortion", if_kwargs=True)) if not client_mode else None,
- inputs=[
- distortion
- ],
- outputs=[]
- )
- with gr.Row():
- pitch_shift.change(
- js="(value) => window.ChangeConfig(value, 'pitch_shift', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "pitch_shift", if_kwargs=True)) if not client_mode else None,
- inputs=[
- pitch_shift
- ],
- outputs=[]
- )
- gain.change(
- js="(value) => window.ChangeConfig(value, 'gain', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "gain", if_kwargs=True)) if not client_mode else None,
- inputs=[
- gain
- ],
- outputs=[]
- )
- bitcrush.change(
- js="(value) => window.ChangeConfig(value, 'bitcrush', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "bitcrush", if_kwargs=True)) if not client_mode else None,
- inputs=[
- bitcrush
- ],
- outputs=[]
- )
- with gr.Row():
- clipping.change(
- js="(value) => window.ChangeConfig(value, 'clipping', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "clipping", if_kwargs=True)) if not client_mode else None,
- inputs=[
- clipping
- ],
- outputs=[]
- )
- pitch_shift_semitones.change(
- js="(value) => window.ChangeConfig(value, 'pitch_shift_semitones', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "pitch_shift_semitones", if_kwargs=True)) if not client_mode else None,
- inputs=[
- pitch_shift_semitones
- ],
- outputs=[]
- )
- gain_db.change(
- js="(value) => window.ChangeConfig(value, 'gain_db', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "gain_db", if_kwargs=True)) if not client_mode else None,
- inputs=[
- gain_db
- ],
- outputs=[]
- )
- with gr.Row():
- phaser_depth.change(
- js="(value) => window.ChangeConfig(value, 'phaser_depth', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "phaser_depth", if_kwargs=True)) if not client_mode else None,
- inputs=[
- phaser_depth
- ],
- outputs=[]
- )
- phaser_rate_hz.change(
- js="(value) => window.ChangeConfig(value, 'phaser_rate_hz', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "phaser_rate_hz", if_kwargs=True)) if not client_mode else None,
- inputs=[
- phaser_rate_hz
- ],
- outputs=[]
- )
- phaser_mix.change(
- js="(value) => window.ChangeConfig(value, 'phaser_mix', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "phaser_mix", if_kwargs=True)) if not client_mode else None,
- inputs=[
- phaser_mix
- ],
- outputs=[]
- )
- with gr.Row():
- phaser_centre_frequency_hz.change(
- js="(value) => window.ChangeConfig(value, 'phaser_centre_frequency_hz', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "phaser_centre_frequency_hz", if_kwargs=True)) if not client_mode else None,
- inputs=[phaser_centre_frequency_hz],
- outputs=[]
- )
- phaser_feedback.change(
- js="(value) => window.ChangeConfig(value, 'phaser_feedback', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "phaser_feedback", if_kwargs=True)) if not client_mode else None,
- inputs=[
- phaser_feedback
- ],
- outputs=[]
- )
- reverb_room_size.change(
- js="(value) => window.ChangeConfig(value, 'reverb_room_size', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "reverb_room_size", if_kwargs=True)) if not client_mode else None,
- inputs=[
- reverb_room_size
- ],
- outputs=[]
- )
- with gr.Row():
- reverb_damping.change(
- js="(value) => window.ChangeConfig(value, 'reverb_damping', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "reverb_damping", if_kwargs=True)) if not client_mode else None,
- inputs=[
- reverb_damping
- ],
- outputs=[]
- )
- reverb_wet_gain.change(
- js="(value) => window.ChangeConfig(value, 'reverb_wet_level', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "reverb_wet_level", if_kwargs=True)) if not client_mode else None,
- inputs=[
- reverb_wet_gain
- ],
- outputs=[]
- )
- reverb_dry_gain.change(
- js="(value) => window.ChangeConfig(value, 'reverb_dry_level', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "reverb_dry_level", if_kwargs=True)) if not client_mode else None,
- inputs=[
- reverb_dry_gain
- ],
- outputs=[]
- )
- with gr.Row():
- reverb_width.change(
- js="(value) => window.ChangeConfig(value, 'reverb_width', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "reverb_width", if_kwargs=True)) if not client_mode else None,
- inputs=[
- reverb_width
- ],
- outputs=[]
- )
- reverb_freeze_mode.change(
- js="(value) => window.ChangeConfig(value, 'reverb_freeze_mode', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "reverb_freeze_mode", if_kwargs=True)) if not client_mode else None,
- inputs=[
- reverb_freeze_mode
- ],
- outputs=[]
- )
- limiter_threshold.change(
- js="(value) => window.ChangeConfig(value, 'limiter_threshold', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "limiter_threshold", if_kwargs=True)) if not client_mode else None,
- inputs=[
- limiter_threshold
- ],
- outputs=[]
- )
- with gr.Row():
- limiter_release_time.change(
- js="(value) => window.ChangeConfig(value, 'limiter_release', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "limiter_release", if_kwargs=True)) if not client_mode else None,
- inputs=[
- limiter_release_time
- ],
- outputs=[]
- )
- chorus_rate.change(
- js="(value) => window.ChangeConfig(value, 'chorus_rate', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "chorus_rate", if_kwargs=True)) if not client_mode else None,
- inputs=[
- chorus_rate
- ],
- outputs=[]
- )
- chorus_depth.change(
- js="(value) => window.ChangeConfig(value, 'chorus_depth', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "chorus_depth", if_kwargs=True)) if not client_mode else None,
- inputs=[
- chorus_depth
- ],
- outputs=[]
- )
- with gr.Row():
- chorus_center_delay.change(
- js="(value) => window.ChangeConfig(value, 'chorus_delay', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "chorus_delay", if_kwargs=True)) if not client_mode else None,
- inputs=[
- chorus_center_delay
- ],
- outputs=[]
- )
- chorus_feedback.change(
- js="(value) => window.ChangeConfig(value, 'chorus_feedback', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "chorus_feedback", if_kwargs=True)) if not client_mode else None,
- inputs=[
- chorus_feedback
- ],
- outputs=[]
- )
- chorus_mix.change(
- js="(value) => window.ChangeConfig(value, 'chorus_mix', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "chorus_mix", if_kwargs=True)) if not client_mode else None,
- inputs=[
- chorus_mix
- ],
- outputs=[]
- )
- with gr.Row():
- bitcrush_bit_depth.change(
- js="(value) => window.ChangeConfig(value, 'bitcrush_bit_depth', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "bitcrush_bit_depth", if_kwargs=True)) if not client_mode else None,
- inputs=[
- bitcrush_bit_depth
- ],
- outputs=[]
- )
- clipping_threshold.change(
- js="(value) => window.ChangeConfig(value, 'clipping_threshold', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "clipping_threshold", if_kwargs=True)) if not client_mode else None,
- inputs=[
- clipping_threshold
- ],
- outputs=[]
- )
- distortion_gain.change(
- js="(value) => window.ChangeConfig(value, 'distortion_gain', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "distortion_gain", if_kwargs=True)) if not client_mode else None,
- inputs=[
- distortion_gain
- ],
- outputs=[]
- )
- with gr.Row():
- compressor_threshold.change(
- js="(value) => window.ChangeConfig(value, 'compressor_threshold', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "compressor_threshold", if_kwargs=True)) if not client_mode else None,
- inputs=[
- compressor_threshold
- ],
- outputs=[]
- )
- compressor_ratio.change(
- js="(value) => window.ChangeConfig(value, 'compressor_ratio', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "compressor_ratio", if_kwargs=True)) if not client_mode else None,
- inputs=[
- compressor_ratio
- ],
- outputs=[]
- )
- compressor_attack.change(
- js="(value) => window.ChangeConfig(value, 'compressor_attack', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "compressor_attack", if_kwargs=True)) if not client_mode else None,
- inputs=[
- compressor_attack
- ],
- outputs=[]
- )
- with gr.Row():
- compressor_release.change(
- js="(value) => window.ChangeConfig(value, 'compressor_release', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "compressor_release", if_kwargs=True)) if not client_mode else None,
- inputs=[
- compressor_release
- ],
- outputs=[]
- )
- delay_seconds.change(
- js="(value) => window.ChangeConfig(value, 'delay_seconds', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "delay_seconds", if_kwargs=True)) if not client_mode else None,
- inputs=[
- delay_seconds
- ],
- outputs=[]
- )
- delay_feedback.change(
- js="(value) => window.ChangeConfig(value, 'delay_feedback', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "delay_feedback", if_kwargs=True)) if not client_mode else None,
- inputs=[
- delay_feedback
- ],
- outputs=[]
- )
- with gr.Row():
- delay_mix.change(
- js="(value) => window.ChangeConfig(value, 'delay_mix', if_kwargs=true)" if client_mode else None,
- fn=(lambda value: change_config(value, "delay_mix", if_kwargs=True)) if not client_mode else None,
- inputs=[
- delay_mix
- ],
- outputs=[]
- )
- model_pth.change(
- js="(value) => window.ChangeConfig(value, 'model_path')" if client_mode else None,
- fn=(lambda value: change_config(value, "model_path")) if not client_mode else None,
- inputs=[
- model_pth
- ],
- outputs=[]
- )
- model_index.change(
- js="(value) => window.ChangeConfig(value, 'index_path')" if client_mode else None,
- fn=(lambda value: change_config(value, "index_path")) if not client_mode else None,
- inputs=[
- model_index
- ],
- outputs=[]
- )
- with gr.Row():
- f0_method.change(
- js="(value) => window.ChangeConfig(value, 'f0_method')" if client_mode else None,
- fn=(lambda value: change_config(value, "f0_method")) if not client_mode else None,
- inputs=[
- f0_method
- ],
- outputs=[]
- )
- predictor_onnx.change(
- js="(value) => window.ChangeConfig(value, 'predictor_onnx')" if client_mode else None,
- fn=(lambda value: change_config(value, "predictor_onnx")) if not client_mode else None,
- inputs=[
- predictor_onnx
- ],
- outputs=[]
- )
- embedders.change(
- js="(value) => window.ChangeConfig(value, 'embedder_model')" if client_mode else None,
- fn=(lambda value: change_config(value, "embedder_model")) if not client_mode else None,
- inputs=[
- embedders
- ],
- outputs=[]
- )
- with gr.Row():
- custom_embedders.change(
- js="(value) => window.ChangeConfig(value, 'embedder_model_custom')" if client_mode else None,
- fn=(lambda value: change_config(value, "embedder_model_custom")) if not client_mode else None,
- inputs=[
- custom_embedders
- ],
- outputs=[]
- )
- embedder_mode.change(
- js="(value) => window.ChangeConfig(value, 'embedders_mode')" if client_mode else None,
- fn=(lambda value: change_config(value, "embedders_mode")) if not client_mode else None,
- inputs=[
- embedder_mode
- ],
- outputs=[]
- )
- with gr.Row():
- embedders_mix.change(
- js="(value) => window.ChangeConfig(value, 'embedders_mix')" if client_mode else None,
- fn=(lambda value: change_config(value, "embedders_mix")) if not client_mode else None,
- inputs=[
- embedders_mix
- ],
- outputs=[]
- )
- embedders_mix_layers.change(
- js="(value) => window.ChangeConfig(value, 'embedders_mix_layers')" if client_mode else None,
- fn=(lambda value: change_config(value, "embedders_mix_layers")) if not client_mode else None,
- inputs=[
- embedders_mix_layers
- ],
- outputs=[]
- )
- embedders_mix_ratio.change(
- js="(value) => window.ChangeConfig(value, 'embedders_mix_ratio')" if client_mode else None,
- fn=(lambda value: change_config(value, "embedders_mix_ratio")) if not client_mode else None,
- inputs=[
- embedders_mix_ratio
- ],
- outputs=[]
- )
- with gr.Row():
- noise_scale.change(
- js="(value) => window.ChangeConfig(value, 'noise_scale')" if client_mode else None,
- fn=(lambda value: change_config(value, "noise_scale")) if not client_mode else None,
- inputs=[
- noise_scale
- ],
- outputs=[]
- )
- with gr.Row():
- load_preset_button.click(
- fn=load_realtime_config,
- inputs=[
- presets_name,
- exclusive_mode,
- vad_enabled,
- chunk_size,
- pitch,
- index_strength,
- predictor_onnx,
- hop_length,
- embedder_mode,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- post_process,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix
- ],
- outputs=[
- exclusive_mode,
- vad_enabled,
- chunk_size,
- pitch,
- index_strength,
- predictor_onnx,
- hop_length,
- embedder_mode,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- post_process,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix
- ]
- )
- refresh_preset_button.click(
- fn=change_realtime_preset_choices,
- inputs=[],
- outputs=[
- presets_name
- ]
- )
- save_file_button.click(
- fn=save_realtime_config,
- inputs=[
- name_to_save_file,
- exclusive_mode,
- vad_enabled,
- chunk_size,
- pitch,
- index_strength,
- predictor_onnx,
- hop_length,
- embedder_mode,
- f0_autotune,
- proposal_pitch,
- f0_autotune_strength,
- proposal_pitch_threshold,
- rms_mix_rate,
- protect,
- filter_radius,
- silent_threshold,
- extra_convert_size,
- cross_fade_overlap_size,
- vad_sensitivity,
- vad_frame_ms,
- clean_audio,
- clean_strength,
- post_process,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- chorus,
- distortion,
- reverb,
- pitch_shift,
- delay,
- compressor,
- limiter,
- gain,
- bitcrush,
- clipping,
- phaser,
- chorus_depth,
- chorus_rate,
- chorus_mix,
- chorus_center_delay,
- chorus_feedback,
- distortion_gain,
- reverb_room_size,
- reverb_damping,
- reverb_wet_gain,
- reverb_dry_gain,
- reverb_width,
- reverb_freeze_mode,
- pitch_shift_semitones,
- delay_seconds,
- delay_feedback,
- delay_mix,
- compressor_threshold,
- compressor_ratio,
- compressor_attack,
- compressor_release,
- limiter_threshold,
- limiter_release_time,
- gain_db,
- bitcrush_bit_depth,
- clipping_threshold,
- phaser_rate_hz,
- phaser_depth,
- phaser_centre_frequency_hz,
- phaser_feedback,
- phaser_mix
- ],
- outputs=[
- presets_name
- ]
- )
- with gr.Row():
- upload_presets.upload(
- fn=lambda presets_in: [
- shutil_move(preset.name, configs["presets_path"])
- for preset in presets_in
- ][0],
- inputs=[
- upload_presets
- ],
- outputs=[
- presets_name
- ]
- )
\ No newline at end of file
diff --git a/main/app/tabs/training/child/create_dataset.py b/main/app/tabs/training/child/create_dataset.py
deleted file mode 100644
index 8ff1c225eb4c44c3e7ef3def556b4687e10e732f..0000000000000000000000000000000000000000
--- a/main/app/tabs/training/child/create_dataset.py
+++ /dev/null
@@ -1,519 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.training import create_dataset
-
-from main.app.core.ui import (
- visible,
- create_dataset_change,
- valueFalse_interactive
-)
-from main.app.variables import (
- vr_models,
- uvr_model,
- mdx_models,
- translations,
- reverb_models,
- denoise_models,
- sample_rate_choice
-)
-
-def create_dataset_tab():
- with gr.Row():
- gr.Markdown(translations["create_dataset_markdown_2"])
- with gr.Group():
- with gr.Row():
- separate = gr.Checkbox(
- label=translations["separator_tab"],
- value=False,
- interactive=True
- )
- clean_dataset = gr.Checkbox(
- label=translations["clear_audio"],
- value=False,
- interactive=True
- )
- skip_seconds = gr.Checkbox(
- label=translations["skip"],
- value=False,
- interactive=True
- )
- separate_reverb = gr.Checkbox(
- label=translations["dereveb_audio"],
- value=False,
- interactive=False
- )
- with gr.Row(visible=False) as row:
- enable_tta = gr.Checkbox(
- label=translations["enable_tta"],
- value=False,
- interactive=False
- )
- high_end_process = gr.Checkbox(
- label=translations["high_end_process"],
- value=False,
- interactive=False
- )
- enable_post_process = gr.Checkbox(
- label=translations["enable_post_process"],
- value=False,
- interactive=False
- )
- enable_denoise = gr.Checkbox(
- label=translations["denoise_mdx"],
- value=False,
- interactive=False
- )
- with gr.Row():
- dataset_url = gr.Textbox(
- label=translations["url_audio"],
- info=translations["create_dataset_url"],
- value="",
- placeholder="https://www.youtube.com/...",
- interactive=True,
- scale=5
- )
- output_dataset = gr.Textbox(
- label=translations["output_data"],
- info=translations["output_data_info"],
- value="dataset",
- placeholder="dataset",
- interactive=True
- )
- with gr.Row():
- create_dataset_button = gr.Button(
- translations["createdataset"],
- variant="primary",
- scale=2,
- min_width=4000
- )
- with gr.Row(visible=False) as row_2:
- model_name = gr.Dropdown(
- label=translations["separator_model"],
- value=uvr_model[0],
- choices=uvr_model,
- interactive=True
- )
- reverb_model = gr.Dropdown(
- label=translations["dereveb_model"],
- value=list(reverb_models.keys())[0],
- choices=list(reverb_models.keys()),
- interactive=True
- )
- denoise_model = gr.Dropdown(
- label=translations["denoise_model"],
- value=list(denoise_models.keys())[0],
- choices=list(denoise_models.keys()),
- interactive=True,
- visible=False
- )
- with gr.Row():
- with gr.Column(visible=False) as row_3:
- with gr.Group():
- with gr.Row():
- overlap = gr.Radio(
- label=translations["overlap"],
- info=translations["overlap_info"],
- choices=[
- "0.25",
- "0.5",
- "0.75",
- "0.99"
- ],
- value="0.25",
- interactive=True)
- with gr.Row():
- window_size = gr.Slider(
- label=translations["window_size"],
- info=translations["window_size_info"],
- minimum=320,
- maximum=1024,
- value=512,
- step=32,
- interactive=True,
- visible=False
- )
- with gr.Row():
- shifts = gr.Slider(
- label=translations["shift"],
- info=translations["shift_info"],
- minimum=1,
- maximum=20,
- value=2,
- step=1,
- interactive=True
- )
- segments_size = gr.Slider(
- label=translations["segments_size"],
- info=translations["segments_size_info"],
- minimum=32,
- maximum=3072,
- value=256,
- step=32,
- interactive=True
- )
- with gr.Row():
- batch_size = gr.Slider(
- label=translations["batch_size"],
- info=translations["mdx_batch_size_info"],
- minimum=1,
- maximum=64,
- value=1,
- step=1,
- interactive=True,
- visible=False
- )
- hop_length = gr.Slider(
- label=translations['hop_length'],
- info=translations["hop_length_info"],
- minimum=64,
- maximum=8192,
- value=1024,
- step=1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- post_process_threshold = gr.Slider(
- label=translations['post_process_threshold'],
- info=translations["post_process_threshold_info"],
- minimum=0.1,
- maximum=0.3,
- value=0.2,
- step=0.1,
- interactive=True,
- visible=False
- )
- aggression = gr.Slider(
- label=translations['aggression'],
- info=translations["aggression_info"],
- minimum=1,
- maximum=50,
- value=5,
- step=1,
- interactive=True,
- visible=False
- )
- with gr.Column():
- sample_rate = gr.Radio(
- choices=sample_rate_choice,
- value=48000,
- label=translations["sr"],
- info=translations["sr_info"],
- interactive=True
- )
- clean_strength = gr.Slider(
- minimum=0,
- maximum=1,
- step=0.1,
- value=0.5,
- label=translations["clean_strength"],
- info=translations["clean_strength_info"],
- interactive=True,
- visible=False
- )
- with gr.Row():
- skip_start = gr.Textbox(
- label=translations["skip_start"],
- info=translations["skip_start_info"],
- value="",
- placeholder="0,...",
- interactive=True,
- visible=False
- )
- skip_end = gr.Textbox(
- label=translations["skip_end"],
- info=translations["skip_end_info"],
- value="",
- placeholder="0,...",
- interactive=True,
- visible=False
- )
- create_dataset_info = gr.Textbox(
- label=translations["create_dataset_info"],
- value="",
- interactive=False,
- lines=2
- )
- with gr.Row():
- separate.change(
- fn=lambda a: [
- visible(a)
- for _ in range(3)
- ],
- inputs=[
- separate
- ],
- outputs=[
- row,
- row_2,
- row_3
- ]
- )
- separate.change(
- fn=valueFalse_interactive,
- inputs=[
- separate
- ],
- outputs=[
- separate_reverb
- ]
- )
- separate.change(
- fn=create_dataset_change,
- inputs=[
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- with gr.Row():
- model_name.change(
- fn=create_dataset_change,
- inputs=[
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- reverb_model.change(
- fn=create_dataset_change,
- inputs=[
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- denoise_model.change(
- fn=create_dataset_change,
- inputs=[
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- with gr.Row():
- separate_reverb.change(
- fn=create_dataset_change,
- inputs=[
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- enable_denoise.change(
- fn=create_dataset_change,
- inputs=[
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- enable_post_process.change(
- fn=create_dataset_change,
- inputs=[
- model_name,
- reverb_model,
- enable_post_process,
- separate_reverb,
- enable_denoise
- ],
- outputs=[
- reverb_model,
- overlap,
- segments_size,
- hop_length,
- batch_size,
- shifts,
- window_size,
- aggression,
- post_process_threshold,
- denoise_model,
- enable_tta,
- high_end_process,
- enable_post_process,
- ]
- )
- with gr.Row():
- skip_seconds.change(
- fn=lambda a: [
- visible(a)
- for _ in range(2)
- ],
- inputs=[
- skip_seconds
- ],
- outputs=[
- skip_start,
- skip_end
- ]
- )
- clean_dataset.change(
- fn=visible,
- inputs=[
- clean_dataset
- ],
- outputs=[
- clean_strength
- ]
- )
- with gr.Row():
- model_name.change(
- fn=lambda a: valueFalse_interactive(a in list(mdx_models.keys()) + list(vr_models.keys())),
- inputs=[
- model_name
- ],
- outputs=[
- enable_denoise
- ]
- )
- separate_reverb.change(
- fn=valueFalse_interactive,
- inputs=[
- separate_reverb
- ],
- outputs=[
- enable_denoise
- ]
- )
- with gr.Row():
- create_dataset_button.click(
- fn=create_dataset,
- inputs=[
- dataset_url,
- output_dataset,
- skip_seconds,
- skip_start,
- skip_end,
- separate,
- model_name,
- reverb_model,
- denoise_model,
- sample_rate,
- shifts,
- batch_size,
- overlap,
- aggression,
- hop_length,
- window_size,
- segments_size,
- post_process_threshold,
- enable_tta,
- enable_denoise,
- high_end_process,
- enable_post_process,
- separate_reverb,
- clean_dataset,
- clean_strength
- ],
- outputs=[
- create_dataset_info
- ],
- api_name="create_dataset"
- )
\ No newline at end of file
diff --git a/main/app/tabs/training/child/create_reference.py b/main/app/tabs/training/child/create_reference.py
deleted file mode 100644
index 8fed8277a97b87de7fb0355cef5a55c1007bf89c..0000000000000000000000000000000000000000
--- a/main/app/tabs/training/child/create_reference.py
+++ /dev/null
@@ -1,390 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.training import create_reference
-
-from main.app.core.ui import (
- visible,
- unlock_f0,
- shutil_move,
- change_audios_choices,
- change_embedders_mode
-)
-
-from main.app.variables import (
- configs,
- method_f0,
- file_types,
- audio_params,
- translations,
- embedders_mode,
- paths_for_files,
- embedders_model,
- hybrid_f0_method,
-)
-
-def create_reference_tab():
- with gr.Row():
- gr.Markdown(translations["create_reference_markdown_2"])
- with gr.Row():
- pitch_guidance = gr.Checkbox(
- label=translations["training_pitch"],
- value=True,
- interactive=True
- )
- use_energy = gr.Checkbox(
- label=translations["train&energy"],
- value=False,
- interactive=True
- )
- f0_autotune = gr.Checkbox(
- label=translations["autotune"],
- value=False,
- interactive=True
- )
- proposal_pitch = gr.Checkbox(
- label=translations["proposal_pitch"],
- value=False,
- interactive=True
- )
- with gr.Row():
- create_reference_button = gr.Button(
- translations["create_reference"],
- variant="primary"
- )
- with gr.Row():
- f0_up_key = gr.Slider(
- minimum=-24,
- maximum=24,
- step=1,
- info=translations["pitch_info"],
- label=translations["pitch"],
- value=0,
- interactive=True
- )
- proposal_pitch_threshold = gr.Slider(
- minimum=50.0,
- maximum=1200.0,
- label=translations["proposal_pitch_threshold"],
- info=translations["proposal_pitch_threshold_info"],
- value=255.0,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- filter_radius = gr.Slider(
- minimum=0,
- maximum=7,
- label=translations["filter_radius"],
- info=translations["filter_radius_info"],
- value=3,
- step=1,
- interactive=True
- )
- f0_autotune_strength = gr.Slider(
- minimum=0,
- maximum=1,
- label=translations["autotune_rate"],
- info=translations["autotune_rate_info"],
- value=1,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Row():
- with gr.Column():
- with gr.Accordion(
- translations["input_output"],
- open=False
- ):
- with gr.Column():
- input_audio = gr.Dropdown(
- label=translations["audio_path"],
- value="",
- choices=paths_for_files,
- info=translations["provide_audio"],
- allow_custom_value=True,
- interactive=True
- )
- reference_name = gr.Textbox(
- label=translations["reference_name"],
- value="reference",
- placeholder="reference",
- info=translations["reference_name_info"],
- interactive=True
- )
- with gr.Column():
- refresh_audio = gr.Button(
- translations["refresh"]
- )
- with gr.Column():
- upload_audio = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types
- )
- with gr.Column():
- play_audio = gr.Audio(
- interactive=False,
- label=translations["input_audio"],
- **audio_params
- )
- with gr.Column() as f0_method_column:
- with gr.Accordion(
- label=translations["f0_method"],
- open=False
- ):
- with gr.Group():
- with gr.Row():
- predictor_onnx = gr.Checkbox(
- label=translations["predictor_onnx"],
- value=False,
- interactive=True
- )
- unlock_full_method = gr.Checkbox(
- label=translations["f0_unlock"],
- value=False,
- interactive=True
- )
- f0_method = gr.Radio(
- label=translations["f0_method"],
- info=translations["f0_method_info"],
- choices=method_f0,
- value="rmvpe",
- interactive=True
- )
- f0_hybrid_method = gr.Dropdown(
- label=translations["f0_method_hybrid"],
- info=translations["f0_method_hybrid_info"],
- choices=hybrid_f0_method,
- value=hybrid_f0_method[0],
- interactive=True,
- allow_custom_value=True,
- visible=False
- )
- with gr.Row():
- alpha = gr.Slider(
- label=translations["alpha_label"],
- info=translations["alpha_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Column():
- with gr.Accordion(
- label=translations["hubert_model"],
- open=False
- ):
- embedders_mix = gr.Checkbox(
- label=translations["embedders_mix"],
- info=translations["embedders_mix_info"],
- value=False,
- interactive=True
- )
- with gr.Row():
- version = gr.Radio(
- label=translations["training_version"],
- info=translations["training_version_info"],
- choices=[
- "v1",
- "v2"
- ],
- value="v2",
- interactive=True
- )
- with gr.Group():
- embedder_mode = gr.Radio(
- label=translations["embed_mode"],
- info=translations["embed_mode_info"],
- value="fairseq",
- choices=embedders_mode,
- interactive=True,
- visible=True
- )
- embedders = gr.Radio(
- label=translations["hubert_model"],
- info=translations["hubert_info"],
- choices=embedders_model,
- value="hubert_base",
- interactive=True
- )
- with gr.Row():
- embedders_custom = gr.Textbox(
- label=translations["modelname"],
- info=translations["modelname_info"],
- value="",
- placeholder="hubert_base",
- interactive=True,
- visible=False
- )
- with gr.Column(visible=False) as embedders_mix_column:
- embedders_mix_layers = gr.Slider(
- label=translations["embedders_mix_layers"],
- info=translations["embedders_mix_layers_info"],
- minimum=1,
- maximum=12,
- value=9,
- step=1,
- interactive=True
- )
- embedders_mix_ratio = gr.Slider(
- label=translations["embedders_mix_ratio"],
- info=translations["embedders_mix_ratio_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True
- )
- with gr.Row():
- create_reference_info = gr.Textbox(
- label=translations["reference_info"],
- value="",
- interactive=False,
- lines=2
- )
- with gr.Row():
- f0_autotune.change(
- fn=visible,
- inputs=[
- f0_autotune
- ],
- outputs=[
- f0_autotune_strength
- ]
- )
- proposal_pitch.change(
- fn=visible,
- inputs=[
- proposal_pitch
- ],
- outputs=[
- proposal_pitch_threshold
- ]
- )
- unlock_full_method.change(
- fn=unlock_f0,
- inputs=[
- unlock_full_method
- ],
- outputs=[
- f0_method
- ]
- )
- with gr.Row():
- input_audio.change(
- fn=lambda audio: audio,
- inputs=[
- input_audio
- ],
- outputs=[
- play_audio
- ]
- )
- refresh_audio.click(
- fn=change_audios_choices,
- inputs=[
- input_audio
- ],
- outputs=[
- input_audio
- ]
- )
- f0_method.change(
- fn=lambda method: [
- visible(method == "hybrid")
- for _ in range(2)
- ],
- inputs=[
- f0_method
- ],
- outputs=[
- f0_hybrid_method,
- alpha
- ]
- )
- with gr.Row():
- upload_audio.upload(
- fn=lambda audio_in: [
- shutil_move(audio.name, configs["audios_path"])
- for audio in audio_in
- ][0],
- inputs=[
- upload_audio
- ],
- outputs=[
- input_audio
- ]
- )
- embedder_mode.change(
- fn=change_embedders_mode,
- inputs=[
- embedder_mode
- ],
- outputs=[
- embedders
- ]
- )
- embedders.change(
- fn=lambda embedders: visible(embedders == "custom"),
- inputs=[
- embedders
- ],
- outputs=[
- embedders_custom
- ]
- )
- with gr.Row():
- pitch_guidance.change(
- fn=visible,
- inputs=[
- pitch_guidance
- ],
- outputs=[
- f0_method_column
- ]
- )
- embedders_mix.change(
- fn=visible,
- inputs=[
- embedders_mix
- ],
- outputs=[
- embedders_mix_column
- ]
- )
- create_reference_button.click(
- fn=create_reference,
- inputs=[
- input_audio,
- reference_name,
- pitch_guidance,
- use_energy,
- version,
- embedders,
- embedder_mode,
- f0_method,
- predictor_onnx,
- f0_up_key,
- filter_radius,
- f0_autotune,
- f0_autotune_strength,
- proposal_pitch,
- proposal_pitch_threshold,
- alpha,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio
- ],
- outputs=[
- create_reference_info
- ],
- api_name="create_reference"
- )
\ No newline at end of file
diff --git a/main/app/tabs/training/child/training.py b/main/app/tabs/training/child/training.py
deleted file mode 100644
index defc2ae3d7d8596a9099c4adad8c2dd872b1eedd..0000000000000000000000000000000000000000
--- a/main/app/tabs/training/child/training.py
+++ /dev/null
@@ -1,1020 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.core.process import zip_file
-
-from main.app.core.training import (
- extract,
- training,
- preprocess,
- create_index
-)
-
-from main.app.variables import (
- config,
- method_f0,
- file_types,
- model_name,
- index_path,
- pretrainedG,
- pretrainedD,
- translations,
- reference_list,
- embedders_mode,
- embedders_model,
- hybrid_f0_method
-)
-
-from main.app.core.ui import (
- visible,
- unlock_f0,
- gr_warning,
- shutil_move,
- get_gpu_info,
- vocoders_lock,
- unlock_version,
- unlock_vocoder,
- hoplength_show,
- gpu_number_str,
- pitch_guidance_lock,
- change_models_choices,
- change_embedders_mode,
- change_reference_choices,
- change_pretrained_choices
-)
-
-def training_model_tab():
- with gr.Row():
- gr.Markdown(translations["training_markdown"])
- with gr.Row():
- with gr.Column():
- with gr.Row():
- with gr.Column():
- modelname = gr.Textbox(
- label=translations["modelname"],
- info=translations["training_model_name"],
- value="",
- placeholder=translations["modelname"],
- interactive=True
- )
- sample_rate = gr.Radio(
- label=translations["sample_rate"],
- info=translations["sample_rate_info"],
- choices=[
- "24k",
- "32k",
- "40k",
- "44.1k",
- "48k"
- ],
- value="48k",
- interactive=True
- )
- rvc_version = gr.Radio(
- label=translations["training_version"],
- info=translations["training_version_info"],
- choices=[
- "v1",
- "v2"
- ],
- value="v2",
- interactive=True
- )
- with gr.Group():
- with gr.Row():
- clean_dataset = gr.Checkbox(
- label=translations["clear_dataset"],
- value=False,
- interactive=True
- )
- process_effects = gr.Checkbox(
- label=translations["preprocess_effect"],
- value=False,
- interactive=True
- )
- pitch_guidance = gr.Checkbox(
- label=translations["training_pitch"],
- value=True,
- interactive=True
- )
- with gr.Row():
- custom_reference = gr.Checkbox(
- label=translations["custom_reference"],
- value=False,
- interactive=True
- )
- checkpointing = gr.Checkbox(
- label=translations["memory_efficient_training"],
- value=False,
- interactive=True
- )
- dataset_upload = gr.Checkbox(
- label=translations["upload_dataset"],
- value=False,
- interactive=True
- )
- with gr.Row():
- split_audio_mode = gr.Radio(
- label=translations["split_audio_mode"],
- info=translations["split_audio_mode_info"],
- value="Automatic",
- choices=[
- "Automatic",
- "Simple",
- "Skip"
- ],
- interactive=True
- )
- normalization_mode = gr.Radio(
- label=translations["normalization_mode"],
- info=translations["normalization_mode_info"],
- value="post",
- choices=[
- "none",
- "pre",
- "post"
- ],
- interactive=True
- )
- with gr.Row(visible=False) as custom_reference_row:
- with gr.Accordion(
- translations["custom_reference"],
- open=True
- ):
- reference_name = gr.Dropdown(
- label=translations["reference_name"],
- info=translations["reference_name_info"],
- choices=reference_list,
- value=reference_list[0] if len(reference_list) >= 1 else "",
- allow_custom_value=True,
- interactive=True
- )
- reference_refresh = gr.Button(
- translations["refresh"],
- scale=2
- )
- with gr.Row(visible=False) as clean_dataset_row:
- clean_dataset_strength = gr.Slider(
- label=translations["clean_strength"],
- info=translations["clean_strength_info"],
- minimum=0,
- maximum=1,
- value=0.7,
- step=0.1,
- interactive=True
- )
- with gr.Column():
- preprocess_button = gr.Button(
- translations["preprocess_button"],
- scale=2
- )
- upload_dataset = gr.Files(
- label=translations["drop_audio"],
- file_types=file_types,
- visible=False
- )
- preprocess_info = gr.Textbox(
- label=translations["preprocess_info"],
- value="",
- interactive=False,
- container=True,
- lines=2
- )
- with gr.Column():
- with gr.Row():
- with gr.Column():
- with gr.Accordion(
- label=translations["f0_method"],
- open=False
- ):
- with gr.Group():
- with gr.Row():
- predictor_onnx = gr.Checkbox(
- label=translations["predictor_onnx"],
- value=False,
- interactive=True
- )
- unlock_full_method = gr.Checkbox(
- label=translations["f0_unlock"],
- value=False,
- interactive=True
- )
- autotune = gr.Checkbox(
- label=translations["autotune"],
- value=False,
- interactive=True
- )
- f0_method = gr.Radio(
- label=translations["f0_method"],
- info=translations["f0_method_info"],
- choices=method_f0,
- value="rmvpe",
- interactive=True
- )
- hybrid_f0method = gr.Dropdown(
- label=translations["f0_method_hybrid"],
- info=translations["f0_method_hybrid_info"],
- choices=hybrid_f0_method,
- value=hybrid_f0_method[0],
- interactive=True,
- allow_custom_value=True,
- visible=False
- )
- hop_length = gr.Slider(
- label=translations['hop_length'],
- info=translations["hop_length_info"],
- minimum=64,
- maximum=512,
- value=160,
- step=1,
- interactive=True,
- visible=False
- )
- f0_autotune_strength = gr.Slider(
- label=translations["autotune_rate"],
- info=translations["autotune_rate_info"],
- minimum=0,
- maximum=1,
- value=1,
- step=0.1,
- interactive=True,
- visible=False
- )
- alpha = gr.Slider(
- label=translations["alpha_label"],
- info=translations["alpha_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True,
- visible=False
- )
- with gr.Accordion(
- label=translations["hubert_model"],
- open=False
- ):
- embedders_mix = gr.Checkbox(
- label=translations["embedders_mix"],
- info=translations["embedders_mix_info"],
- value=False,
- interactive=True
- )
- with gr.Group():
- embedder_mode = gr.Radio(
- label=translations["embed_mode"],
- info=translations["embed_mode_info"],
- value="fairseq",
- choices=embedders_mode,
- interactive=True,
- visible=True
- )
- embedders = gr.Radio(
- label=translations["hubert_model"],
- info=translations["hubert_info"],
- choices=embedders_model,
- value="hubert_base",
- interactive=True
- )
- with gr.Row():
- embedders_custom = gr.Textbox(
- label=translations["modelname"],
- info=translations["modelname_info"],
- value="",
- placeholder="hubert_base",
- interactive=True,
- visible=False
- )
- with gr.Column(visible=False) as embedders_mix_column:
- embedders_mix_layers = gr.Slider(
- label=translations["embedders_mix_layers"],
- info=translations["embedders_mix_layers_info"],
- minimum=1,
- maximum=12,
- value=9,
- step=1,
- interactive=True
- )
- embedders_mix_ratio = gr.Slider(
- label=translations["embedders_mix_ratio"],
- info=translations["embedders_mix_ratio_info"],
- minimum=0.1,
- maximum=1,
- value=0.5,
- step=0.1,
- interactive=True
- )
- with gr.Column():
- extract_button = gr.Button(
- translations["extract_button"],
- scale=2
- )
- extract_info = gr.Textbox(
- label=translations["extract_info"],
- value="",
- interactive=False,
- lines=2
- )
- with gr.Column():
- with gr.Row():
- with gr.Column():
- total_epochs = gr.Slider(
- label=translations["total_epoch"],
- info=translations["total_epoch_info"],
- minimum=1,
- maximum=10000,
- value=300,
- step=1,
- interactive=True
- )
- save_epochs = gr.Slider(
- label=translations["save_epoch"],
- info=translations["save_epoch_info"],
- minimum=1,
- maximum=10000,
- value=50,
- step=1,
- interactive=True
- )
- with gr.Column():
- create_index_button = gr.Button(
- f"3. {translations['create_index']}",
- variant="primary",
- scale=2
- )
- training_button = gr.Button(
- f"4. {translations['training_model']}",
- variant="primary",
- scale=2
- )
- with gr.Row():
- with gr.Accordion(
- label=translations["setting"],
- open=False
- ):
- with gr.Row():
- index_algorithm = gr.Radio(
- label=translations["index_algorithm"],
- info=translations["index_algorithm_info"],
- choices=[
- "Auto",
- "Faiss",
- "KMeans"
- ],
- value="Auto",
- interactive=True
- )
- with gr.Row():
- nprobe = gr.Slider(
- label=translations["nprobe"],
- info=translations["nprobe_info"],
- minimum=1,
- maximum=64,
- value=9,
- step=1,
- interactive=True
- )
- with gr.Row():
- cache_in_gpu = gr.Checkbox(
- label=translations["cache_in_gpu"],
- info=translations["cache_in_gpu_info"],
- value=True,
- interactive=True
- )
- energy = gr.Checkbox(
- label=translations["train&energy"],
- info=translations["train&energy_info"],
- value=False,
- interactive=True
- )
- overtraining_detector = gr.Checkbox(
- label=translations["overtraining_detector"],
- info=translations["overtraining_detector_info"],
- value=False,
- interactive=True
- )
- with gr.Row():
- custom_dataset = gr.Checkbox(
- label=translations["custom_dataset"],
- info=translations["custom_dataset_info"],
- value=False,
- interactive=True
- )
- save_only_latest = gr.Checkbox(
- label=translations["save_only_latest"],
- info=translations["save_only_latest_info"],
- value=True,
- interactive=True
- )
- save_every_weights = gr.Checkbox(
- label=translations["save_every_weights"],
- info=translations["save_every_weights_info"],
- value=True,
- interactive=True
- )
- with gr.Row():
- cleanup_training = gr.Checkbox(
- label=translations["cleanup_training"],
- info=translations["cleanup_training_info"],
- value=False,
- interactive=True
- )
- not_use_pretrain = gr.Checkbox(
- label=translations["not_use_pretrain_2"],
- info=translations["not_use_pretrain_info"],
- value=False,
- interactive=True
- )
- custom_pretrain = gr.Checkbox(
- label=translations["custom_pretrain"],
- info=translations["custom_pretrain_info"],
- value=False,
- interactive=True
- )
- with gr.Column():
- dataset_path = gr.Textbox(
- label=translations["dataset_folder"],
- value="dataset",
- interactive=True,
- visible=False
- )
- with gr.Column():
- include_mutes = gr.Slider(
- minimum=0,
- maximum=10,
- value=2,
- step=1,
- label=translations["include_mutes"],
- info=translations["include_mutes_info"],
- interactive=True
- )
- with gr.Row(visible=False) as simple_option:
- chunk_len = gr.Slider(
- minimum=0.5,
- maximum=5.0,
- value=3.0,
- step=0.1,
- label=translations["chunk_length"],
- info=translations["chunk_length_info"],
- interactive=True
- )
- overlap_len = gr.Slider(
- minimum=0.0,
- maximum=0.4,
- value=0.3,
- step=0.1,
- label=translations["overlap_length"],
- info=translations["overlap_length_info"],
- interactive=True
- )
- threshold = gr.Slider(
- minimum=1,
- maximum=100,
- value=50,
- step=1,
- label=translations["threshold"],
- info=translations["overtraining_threshold"],
- interactive=True,
- visible=False
- )
- with gr.Accordion(
- translations["setting_cpu_gpu"],
- open=False
- ):
- with gr.Row():
- architecture = gr.Radio(
- label=translations["architecture"],
- info=translations["architecture_info"],
- choices=[
- "RVC",
- "SVC"
- ],
- value="RVC",
- interactive=True
- )
- with gr.Column():
- gpu_number = gr.Textbox(
- label=translations["gpu_number"],
- value=gpu_number_str(),
- info=translations["gpu_number_info"],
- interactive=True
- )
- gpu_str, gpu_len = get_gpu_info()
- gr.Textbox(
- label=translations["gpu_info"],
- value=gpu_str,
- info=translations["gpu_info_2"],
- interactive=False,
- lines=gpu_len
- )
- cpu_core = gr.Slider(
- label=translations["cpu_core"],
- info=translations["cpu_core_info"],
- minimum=1,
- maximum=os.cpu_count(),
- value=min(os.cpu_count(), 4),
- step=1,
- interactive=True
- )
- batch_size = gr.Slider(
- label=translations["batch_size"],
- info=translations["batch_size_info"],
- minimum=1,
- maximum=64,
- value=8,
- step=1,
- interactive=True
- )
- with gr.Group():
- multiscale_mel_loss = gr.Checkbox(
- label=translations["multiscale_mel_loss"],
- info=translations["multiscale_mel_loss_info"],
- value=False,
- interactive=True
- )
- cosine_annealing_lr = gr.Checkbox(
- label=translations["cosine_annealing_lr"],
- info=translations["cosine_annealing_lr_info"],
- value=False,
- interactive=True
- )
- vocoders = gr.Radio(
- label=translations["vocoder"],
- info=translations["vocoder_info"],
- choices=[
- "Default",
- "MRF-HiFi-GAN",
- "RefineGAN",
- "BigVGAN"
- ],
- value="Default",
- interactive=True
- )
- with gr.Row():
- deterministic = gr.Checkbox(
- label=translations["deterministic"],
- info=translations["deterministic_info"],
- value=False,
- interactive=config.device.startswith("cuda") and not config.is_zluda
- )
- benchmark = gr.Checkbox(
- label=translations["benchmark"],
- info=translations["benchmark_info"],
- value=False,
- interactive=config.device.startswith("cuda") and not config.is_zluda
- )
- with gr.Row():
- optimizer = gr.Radio(
- label=translations["optimizer"],
- info=translations["optimizer_info"],
- value="AdamW",
- choices=[
- "AdamW",
- "RAdam",
- "AnyPrecisionAdamW",
- "AdaBelief",
- "AdaBeliefV2"
- ],
- interactive=True
- )
- with gr.Row():
- model_author = gr.Textbox(
- label=translations["training_author"],
- info=translations["training_author_info"],
- value="",
- placeholder=translations["training_author"],
- interactive=True
- )
- with gr.Row():
- with gr.Column():
- with gr.Accordion(
- translations["custom_pretrain_info"],
- open=False,
- visible=False
- ) as pretrain_setting:
- pretrained_D = gr.Dropdown(
- label=translations["pretrain_file"].format(dg="D"),
- choices=pretrainedD,
- value=pretrainedD[0] if len(pretrainedD) > 0 else '',
- interactive=True,
- allow_custom_value=True
- )
- pretrained_G = gr.Dropdown(
- label=translations["pretrain_file"].format(dg="G"),
- choices=pretrainedG,
- value=pretrainedG[0] if len(pretrainedG) > 0 else '',
- interactive=True,
- allow_custom_value=True
- )
- pretrained_refresh = gr.Button(
- translations["refresh"],
- scale=2
- )
- with gr.Row():
- training_info = gr.Textbox(
- label=translations["train_info"],
- value="",
- interactive=False,
- lines=3
- )
- with gr.Row():
- with gr.Column():
- with gr.Accordion(
- translations["export_model"],
- open=False
- ):
- with gr.Row():
- model_file = gr.Dropdown(
- label=translations["model_name"],
- choices=model_name,
- value=model_name[0] if len(model_name) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- index_file = gr.Dropdown(
- label=translations["index_path"],
- choices=index_path,
- value=index_path[0] if len(index_path) >= 1 else "",
- interactive=True,
- allow_custom_value=True
- )
- with gr.Row():
- refresh_file = gr.Button(
- f"1. {translations['refresh']}",
- scale=2
- )
- zip_model = gr.Button(
- translations["zip_model"],
- variant="primary",
- scale=2
- )
- with gr.Row():
- zip_output = gr.File(
- label=translations["output_zip"],
- file_types=[".zip"],
- interactive=False,
- visible=False
- )
- with gr.Row():
- vocoders.change(
- fn=pitch_guidance_lock,
- inputs=[
- vocoders
- ],
- outputs=[
- pitch_guidance
- ]
- )
- pitch_guidance.change(
- fn=vocoders_lock,
- inputs=[
- pitch_guidance
- ],
- outputs=[
- vocoders
- ]
- )
- unlock_full_method.change(
- fn=unlock_f0,
- inputs=[
- unlock_full_method
- ],
- outputs=[
- f0_method
- ]
- )
- with gr.Row():
- refresh_file.click(
- fn=change_models_choices,
- inputs=[],
- outputs=[
- model_file,
- index_file
- ]
- )
- zip_model.click(
- fn=zip_file,
- inputs=[
- modelname,
- model_file,
- index_file
- ],
- outputs=[
- zip_output
- ]
- )
- dataset_path.change(
- fn=lambda folder: os.makedirs(folder, exist_ok=True) if folder else None,
- inputs=[
- dataset_path
- ],
- outputs=[]
- )
- with gr.Row():
- dataset_upload.change(
- fn=visible,
- inputs=[
- dataset_upload
- ],
- outputs=[
- upload_dataset
- ]
- )
- overtraining_detector.change(
- fn=visible,
- inputs=[
- overtraining_detector
- ],
- outputs=[
- threshold
- ]
- )
- clean_dataset.change(
- fn=visible,
- inputs=[
- clean_dataset
- ],
- outputs=[
- clean_dataset_row
- ]
- )
- with gr.Row():
- custom_dataset.change(
- fn=lambda custom_dataset: [
- visible(custom_dataset),
- "dataset"
- ],
- inputs=[
- custom_dataset
- ],
- outputs=[
- dataset_path,
- dataset_path
- ]
- )
- rvc_version.change(
- fn=unlock_vocoder,
- inputs=[
- rvc_version,
- vocoders
- ],
- outputs=[
- vocoders
- ]
- )
- vocoders.change(
- inputs=[
- rvc_version,
- vocoders
- ],
- fn=unlock_version,
- outputs=[
- rvc_version
- ]
- )
- with gr.Row():
- custom_reference.change(
- fn=visible,
- inputs=[
- custom_reference
- ],
- outputs=[
- custom_reference_row
- ]
- )
- f0_method.change(
- fn=lambda method, hybrid: [
- visible(method == "hybrid"),
- visible(method == "hybrid"),
- hoplength_show(method, hybrid)
- ],
- inputs=[
- f0_method,
- hybrid_f0method
- ],
- outputs=[
- hybrid_f0method,
- alpha,
- hop_length
- ]
- )
- hybrid_f0method.change(
- fn=hoplength_show,
- inputs=[
- f0_method,
- hybrid_f0method
- ],
- outputs=[
- hop_length
- ]
- )
- with gr.Row():
- autotune.change(
- fn=visible,
- inputs=[
- autotune
- ],
- outputs=[
- f0_autotune_strength
- ]
- )
- split_audio_mode.change(
- fn=lambda a: visible(a == "Simple"),
- inputs=[
- split_audio_mode
- ],
- outputs=[
- simple_option
- ]
- )
- upload_dataset.upload(
- fn=lambda files, folder: [
- shutil_move(f.name, os.path.join(folder, os.path.split(f.name)[1]))
- for f in files
- ] if folder != "" else gr_warning(translations["dataset_folder1"]),
- inputs=[
- upload_dataset,
- dataset_path
- ],
- outputs=[],
- api_name="upload_dataset"
- )
- with gr.Row():
- not_use_pretrain.change(
- fn=lambda a, b: visible(a and not b),
- inputs=[
- custom_pretrain,
- not_use_pretrain
- ],
- outputs=[
- pretrain_setting
- ]
- )
- custom_pretrain.change(
- fn=lambda a, b: visible(a and not b),
- inputs=[
- custom_pretrain,
- not_use_pretrain
- ],
- outputs=[
- pretrain_setting
- ]
- )
- pretrained_refresh.click(
- fn=change_pretrained_choices,
- inputs=[],
- outputs=[
- pretrained_D,
- pretrained_G
- ]
- )
- with gr.Row():
- embedder_mode.change(
- fn=change_embedders_mode,
- inputs=[
- embedder_mode
- ],
- outputs=[
- embedders
- ]
- )
- embedders.change(
- fn=lambda embedders: visible(embedders == "custom"),
- inputs=[
- embedders
- ],
- outputs=[
- embedders_custom
- ]
- )
- reference_refresh.click(
- fn=change_reference_choices,
- inputs=[],
- outputs=[
- reference_name
- ]
- )
- with gr.Row():
- embedders_mix.change(
- fn=visible,
- inputs=[
- embedders_mix
- ],
- outputs=[
- embedders_mix_column
- ]
- )
- with gr.Row():
- preprocess_button.click(
- fn=preprocess,
- inputs=[
- modelname,
- sample_rate,
- cpu_core,
- split_audio_mode,
- process_effects,
- dataset_path,
- clean_dataset,
- clean_dataset_strength,
- chunk_len,
- overlap_len,
- normalization_mode,
- architecture
- ],
- outputs=[
- preprocess_info
- ],
- api_name="preprocess"
- )
- with gr.Row():
- extract_button.click(
- fn=extract,
- inputs=[
- modelname,
- rvc_version,
- f0_method,
- pitch_guidance,
- hop_length,
- cpu_core,
- gpu_number,
- sample_rate,
- embedders,
- embedders_custom,
- predictor_onnx,
- embedder_mode,
- autotune,
- f0_autotune_strength,
- hybrid_f0method,
- energy,
- alpha,
- include_mutes,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- architecture
- ],
- outputs=[
- extract_info
- ],
- api_name="extract"
- )
- with gr.Row():
- create_index_button.click(
- fn=create_index,
- inputs=[
- modelname,
- rvc_version,
- index_algorithm,
- nprobe
- ],
- outputs=[
- training_info
- ],
- api_name="create_index"
- )
- with gr.Row():
- training_button.click(
- fn=training,
- inputs=[
- modelname,
- rvc_version,
- save_epochs,
- save_only_latest,
- save_every_weights,
- total_epochs,
- sample_rate,
- batch_size,
- gpu_number,
- pitch_guidance,
- not_use_pretrain,
- custom_pretrain,
- pretrained_G,
- pretrained_D,
- overtraining_detector,
- threshold,
- cleanup_training,
- cache_in_gpu,
- model_author,
- vocoders,
- checkpointing,
- deterministic,
- benchmark,
- optimizer,
- energy,
- custom_reference,
- reference_name,
- multiscale_mel_loss,
- embedders,
- embedders_custom,
- cosine_annealing_lr,
- architecture
- ],
- outputs=[
- training_info
- ],
- api_name="training_model"
- )
\ No newline at end of file
diff --git a/main/app/tabs/training/training.py b/main/app/tabs/training/training.py
deleted file mode 100644
index 6f7714bb874e8d41d0df86a3aef3a8c5835ee676..0000000000000000000000000000000000000000
--- a/main/app/tabs/training/training.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import os
-import sys
-
-import gradio as gr
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import (
- configs,
- translations
-)
-
-def training_tab():
- with gr.TabItem(translations["training_model"]):
- if configs.get("training_tab", True):
- from main.app.tabs.training.child.training import training_model_tab
-
- with gr.TabItem(translations["training_model"]):
- gr.Markdown(f"## {translations['training_model']}")
- training_model_tab()
-
- if configs.get("create_dataset_tab", True):
- from main.app.tabs.training.child.create_dataset import create_dataset_tab
-
- with gr.TabItem(translations["createdataset"]):
- gr.Markdown(translations["create_dataset_markdown"])
- create_dataset_tab()
-
- if configs.get("create_reference_tab", True):
- from main.app.tabs.training.child.create_reference import create_reference_tab
-
- with gr.TabItem(translations["create_reference"]):
- gr.Markdown(translations["create_reference_markdown"])
- create_reference_tab()
\ No newline at end of file
diff --git a/main/app/variables.py b/main/app/variables.py
deleted file mode 100644
index 07b9d3a222805da7c194fdd4c6e60f2cda860db1..0000000000000000000000000000000000000000
--- a/main/app/variables.py
+++ /dev/null
@@ -1,345 +0,0 @@
-import os
-import re
-import sys
-import csv
-import json
-import spaces
-import logging
-import logging.handlers
-
-@spaces.GPU
-def dummpy():
- pass
-
-import gradio as gr
-
-from packaging import version
-
-sys.path.append(os.getcwd())
-
-from main.configs.config import Config
-
-logger = logging.getLogger(__name__)
-logger.propagate = False
-
-config = Config()
-python = sys.executable
-translations = config.translations
-configs_json = os.path.join("main", "configs", "config.json")
-configs = json.load(open(configs_json, "r"))
-
-configs["debug_mode"] = "--debug" in sys.argv
-configs["tensorrt"] = "--tensorrt" in sys.argv
-
-with open(configs_json, "w") as f:
- json.dump(configs, f, indent=4)
-
-gradio_version = version.parse(gr.__version__) <= version.parse("6.0.0")
-
-audio_params = {
- "show_download_button": True,
- "show_share_button": True
-} if gradio_version else {
- "buttons": ["download", "share"]
-}
-
-if not logger.hasHandlers():
- console_handler = logging.StreamHandler()
- console_formatter = logging.Formatter(fmt="\n%(asctime)s.%(msecs)03d | %(levelname)s | %(module)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
- console_handler.setFormatter(console_formatter)
- console_handler.setLevel(logging.DEBUG if config.debug_mode else logging.INFO)
- file_handler = logging.handlers.RotatingFileHandler(os.path.join(configs["logs_path"], "app.log"), maxBytes=10*1024*1024, backupCount=3, encoding='utf-8')
- file_formatter = logging.Formatter(fmt="\n%(asctime)s.%(msecs)03d | %(levelname)s | %(module)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
- file_handler.setFormatter(file_formatter)
- file_handler.setLevel(logging.DEBUG)
- logger.addHandler(console_handler)
- logger.addHandler(file_handler)
- logger.setLevel(logging.DEBUG)
-
-if config.device in ["cpu", "mps", "ocl:0", "privateuseone:0"] and configs.get("fp16", False) and not configs.get("allow_fp16_all_backend", False):
- logger.warning(translations["fp16_not_support"])
- configs["fp16"] = config.is_half = False
-
- with open(configs_json, "w") as f:
- json.dump(configs, f, indent=4)
-
-if configs.get("asio_enabled", False):
- logger.debug(translations["enabled_asio"])
- os.environ["SD_ENABLE_ASIO"] = "1"
-
-models = {}
-model_options = {}
-
-file_types = [
- ".wav",
- ".mp3",
- ".flac",
- ".ogg",
- ".opus",
- ".m4a",
- ".mp4",
- ".aac",
- ".alac",
- ".wma",
- ".aiff",
- ".webm",
- ".ac3"
-]
-
-export_format_choices = [
- "wav",
- "mp3",
- "flac",
- "ogg",
- "opus",
- "m4a",
- "mp4",
- "aac",
- "alac",
- "wma",
- "aiff",
- "webm",
- "ac3"
-]
-
-method_f0 = [
- "mangio-crepe-full",
- "crepe-full",
- "fcpe",
- "rmvpe",
- "harvest-stonemask",
- "pyin",
- "hybrid"
-]
-
-method_f0_full = [
- "rmvpe-mix",
- "rmvpe-mix-medfilt",
- "hpa-rmvpe",
- "hpa-rmvpe-medfilt",
- "hpa-rmvpe-previous",
- "hpa-rmvpe-previous-medfilt",
- "rmvpe",
- "rmvpe-medfilt",
- "djcm",
- "djcm-medfilt",
- "djcm-svs",
- "djcm-svs-medfilt",
- "swift",
- "fcpe",
- "fcpe-previous",
- "fcpe-legacy",
- "mangio-crepe-full",
- "crepe-full",
- "mangio-crepe-large",
- "crepe-large",
- "mangio-crepe-medium",
- "crepe-medium",
- "mangio-crepe-small",
- "crepe-small",
- "mangio-crepe-tiny",
- "crepe-tiny",
- "harvest-stonemask",
- "harvest",
- "pesto",
- "swipe-stonemask",
- "swipe",
- "mangio-penn",
- "penn",
- "dio-stonemask",
- "dio",
- "pm-ac",
- "pm-cc",
- "pm-shs",
- "pyin",
- "yin",
- "piptrack",
- "hybrid"
-]
-
-hybrid_f0_method = [
- "hybrid[pm+dio]",
- "hybrid[pm+crepe-tiny]",
- "hybrid[pm+crepe]",
- "hybrid[pm+fcpe]",
- "hybrid[pm+rmvpe]",
- "hybrid[pm+harvest]",
- "hybrid[pm+yin]",
- "hybrid[dio+crepe-tiny]",
- "hybrid[dio+crepe]",
- "hybrid[dio+fcpe]",
- "hybrid[dio+rmvpe]",
- "hybrid[dio+harvest]",
- "hybrid[dio+yin]",
- "hybrid[crepe-tiny+crepe]",
- "hybrid[crepe-tiny+fcpe]",
- "hybrid[crepe-tiny+rmvpe]",
- "hybrid[crepe-tiny+harvest]",
- "hybrid[crepe+fcpe]",
- "hybrid[crepe+rmvpe]",
- "hybrid[crepe+harvest]",
- "hybrid[crepe+yin]",
- "hybrid[fcpe+rmvpe]",
- "hybrid[fcpe+harvest]",
- "hybrid[fcpe+yin]",
- "hybrid[rmvpe+harvest]",
- "hybrid[rmvpe+yin]",
- "hybrid[harvest+yin]"
-]
-
-embedders_mode = [
- "fairseq",
- "onnx",
- "transformers",
- "whisper"
-]
-
-embedders_model = [
- "hubert_base",
- "contentvec_base",
- "vietnamese_hubert_base",
- "japanese_hubert_base",
- "korean_hubert_base",
- "chinese_hubert_base",
- "portuguese_hubert_base",
- "spin-v1",
- "spin-v2",
- "custom"
-]
-
-whisper_model = [
- "tiny",
- "tiny.en",
- "base",
- "base.en",
- "small",
- "small.en",
- "medium",
- "medium.en",
- "large-v1",
- "large-v2",
- "large-v3",
- "large-v3-turbo"
-]
-
-whisper_languages = configs.get("whisper_languages", ["vi", "en"])
-
-sample_rate_choice = [
- 8000,
- 11025,
- 12000,
- 16000,
- 22050,
- 24000,
- 32000,
- 44100,
- 48000,
- 88200,
- 96000,
- 176400,
- 192000,
- 352800,
- 384000
-]
-
-paths_for_files = sorted([
- os.path.abspath(os.path.join(root, f))
- for root, _, files in os.walk(configs["audios_path"])
- for f in files
- if os.path.splitext(f)[1].lower() in file_types and not f.startswith(("Convert", "output"))
-])
-
-reference_list = sorted([
- re.sub(r'_v\d+_(?:[A-Za-z0-9_]+?)_(True|False)_(True|False)$', '', name)
- for name in os.listdir(configs["reference_path"])
- if (
- os.path.exists(os.path.join(configs["reference_path"], name)) and
- os.path.isdir(os.path.join(configs["reference_path"], name))
- )
-])
-
-model_name = sorted([
- model for model in os.listdir(configs["weights_path"])
- if model.endswith((".pth", ".onnx")) and not model.startswith("G_") and not model.startswith("D_")
-])
-
-index_path = sorted([
- os.path.join(root, name)
- for root, _, files in os.walk(configs["logs_path"], topdown=False)
- for name in files
- if name.endswith(".index") and "trained" not in name
-])
-
-pretraineds = os.listdir(configs["pretrained_custom_path"])
-
-pretrainedD = [
- model for model in pretraineds
- if model.endswith(".pth") and "D" in model
-]
-
-pretrainedG = [
- model for model in pretraineds
- if model.endswith(".pth") and "G" in model
-]
-
-all_presets = os.listdir(configs["presets_path"])
-
-presets_file = sorted([
- f for f in all_presets
- if f.endswith(".conversion.json")
-])
-
-audio_effect_presets_file = sorted([
- f for f in all_presets
- if f.endswith(".effect.json")
-])
-
-realtime_presets_file = sorted([
- f for f in all_presets
- if f.endswith(".realtime.json")
-])
-
-f0_file = sorted([
- os.path.abspath(os.path.join(root, f))
- for root, _, files in os.walk(configs["f0_path"])
- for f in files if f.endswith(".txt")
-])
-
-language = configs.get("language", "vi-VN")
-theme = configs.get("theme", "NoCrypt/miku")
-
-edgetts = configs.get("edge_tts", ["vi-VN-HoaiMyNeural", "vi-VN-NamMinhNeural"])
-google_tts_voice = configs.get("google_tts_voice", ["vi", "en"])
-
-vr_models = configs.get("vr_models", "")
-demucs_models = configs.get("demucs_models", "")
-mdx_models = configs.get("mdx_models", "")
-karaoke_models = configs.get("karaoke_models", "")
-reverb_models = configs.get("reverb_models", "")
-denoise_models = configs.get("denoise_models", "")
-uvr_model = list(demucs_models.keys()) + list(vr_models.keys()) + list(mdx_models.keys())
-
-font = configs.get("font", "https://fonts.googleapis.com/css2?family=Saira&display=swap")
-csv_path = configs["csv_path"]
-
-try:
- if "--allow_all_disk" in sys.argv and sys.platform == "win32":
- import win32api
- allow_disk = win32api.GetLogicalDriveStrings().split('\x00')[:-1]
- else: allow_disk = []
-except:
- allow_disk = []
-
-try:
- for row in list(csv.DictReader(open(csv_path, newline='', encoding='utf-8'))):
- filename = row['Filename']
- url = None
-
- for value in row.values():
- if isinstance(value, str) and "huggingface" in value:
- url = value
- break
-
- if url: models[filename] = url
-except:
- pass
\ No newline at end of file
diff --git a/main/configs/config.json b/main/configs/config.json
deleted file mode 100644
index a8136b026f5b2834c6ba164e90fa3a3b904d2361..0000000000000000000000000000000000000000
--- a/main/configs/config.json
+++ /dev/null
@@ -1,741 +0,0 @@
-{
- "language": "vi-VN",
- "support_language": [
- "en-US",
- "vi-VN"
- ],
- "theme": "NoCrypt/miku",
- "themes": [
- "NoCrypt/miku",
- "gstaff/xkcd",
- "JohnSmith9982/small_and_pretty",
- "ParityError/Interstellar",
- "earneleh/paris",
- "shivi/calm_seafoam",
- "Hev832/Applio",
- "YTheme/Minecraft",
- "gstaff/sketch",
- "SebastianBravo/simci_css",
- "allenai/gradio-theme",
- "Nymbo/Nymbo_Theme_5",
- "lone17/kotaemon",
- "Zarkel/IBM_Carbon_Theme",
- "SherlockRamos/Feliz",
- "freddyaboulton/dracula_revamped",
- "freddyaboulton/bad-theme-space",
- "gradio/dracula_revamped",
- "abidlabs/dracula_revamped",
- "gradio/dracula_test",
- "gradio/seafoam",
- "gradio/glass",
- "gradio/monochrome",
- "gradio/soft",
- "gradio/default",
- "gradio/base",
- "abidlabs/pakistan",
- "dawood/microsoft_windows",
- "ysharma/steampunk",
- "ysharma/huggingface",
- "abidlabs/Lime",
- "freddyaboulton/this-theme-does-not-exist-2",
- "aliabid94/new-theme",
- "aliabid94/test2",
- "aliabid94/test3",
- "aliabid94/test4",
- "abidlabs/banana",
- "freddyaboulton/test-blue",
- "gstaff/whiteboard",
- "ysharma/llamas",
- "abidlabs/font-test",
- "YenLai/Superhuman",
- "bethecloud/storj_theme",
- "sudeepshouche/minimalist",
- "knotdgaf/gradiotest",
- "ParityError/Anime",
- "Ajaxon6255/Emerald_Isle",
- "ParityError/LimeFace",
- "finlaymacklon/smooth_slate",
- "finlaymacklon/boxy_violet",
- "derekzen/stardust",
- "EveryPizza/Cartoony-Gradio-Theme",
- "Ifeanyi/Cyanister",
- "Tshackelton/IBMPlex-DenseReadable",
- "snehilsanyal/scikit-learn",
- "Himhimhim/xkcd",
- "nota-ai/theme",
- "rawrsor1/Everforest",
- "rottenlittlecreature/Moon_Goblin",
- "abidlabs/test-yellow",
- "abidlabs/test-yellow3",
- "idspicQstitho/dracula_revamped",
- "kfahn/AnimalPose",
- "HaleyCH/HaleyCH_Theme",
- "simulKitke/dracula_test",
- "braintacles/CrimsonNight",
- "wentaohe/whiteboardv2",
- "reilnuud/polite",
- "remilia/Ghostly",
- "Franklisi/darkmode",
- "coding-alt/soft",
- "xiaobaiyuan/theme_land",
- "step-3-profit/Midnight-Deep",
- "xiaobaiyuan/theme_demo",
- "Taithrah/Minimal",
- "Insuz/SimpleIndigo",
- "zkunn/Alipay_Gradio_theme",
- "Insuz/Mocha",
- "xiaobaiyuan/theme_brief",
- "Ama434/434-base-Barlow",
- "Ama434/def_barlow",
- "Ama434/neutral-barlow",
- "dawood/dracula_test",
- "nuttea/Softblue",
- "BlueDancer/Alien_Diffusion",
- "naughtondale/monochrome",
- "Dagfinn1962/standard",
- "default"
- ],
- "mdx_models": {
- "Main_340": "UVR-MDX-NET_Main_340.onnx",
- "Main_390": "UVR-MDX-NET_Main_390.onnx",
- "Main_406": "UVR-MDX-NET_Main_406.onnx",
- "Main_427": "UVR-MDX-NET_Main_427.onnx",
- "Main_438": "UVR-MDX-NET_Main_438.onnx",
- "Inst_full_292": "UVR-MDX-NET-Inst_full_292.onnx",
- "Inst_HQ_1": "UVR-MDX-NET-Inst_HQ_1.onnx",
- "Inst_HQ_2": "UVR-MDX-NET-Inst_HQ_2.onnx",
- "Inst_HQ_3": "UVR-MDX-NET-Inst_HQ_3.onnx",
- "Inst_HQ_4": "UVR-MDX-NET-Inst_HQ_4.onnx",
- "Inst_HQ_5": "UVR-MDX-NET-Inst_HQ_5.onnx",
- "Kim_Vocal_1": "Kim_Vocal_1.onnx",
- "Kim_Vocal_2": "Kim_Vocal_2.onnx",
- "Kim_Inst": "Kim_Inst.onnx",
- "Inst_187_beta": "UVR-MDX-NET_Inst_187_beta.onnx",
- "Inst_82_beta": "UVR-MDX-NET_Inst_82_beta.onnx",
- "Inst_90_beta": "UVR-MDX-NET_Inst_90_beta.onnx",
- "Voc_FT": "UVR-MDX-NET-Voc_FT.onnx",
- "Crowd_HQ": "UVR-MDX-NET_Crowd_HQ_1.onnx",
- "MDXNET_9482": "UVR_MDXNET_9482.onnx",
- "Inst_1": "UVR-MDX-NET-Inst_1.onnx",
- "Inst_2": "UVR-MDX-NET-Inst_2.onnx",
- "Inst_3": "UVR-MDX-NET-Inst_3.onnx",
- "MDXNET_1_9703": "UVR_MDXNET_1_9703.onnx",
- "MDXNET_2_9682": "UVR_MDXNET_2_9682.onnx",
- "MDXNET_3_9662": "UVR_MDXNET_3_9662.onnx",
- "Inst_Main": "UVR-MDX-NET-Inst_Main.onnx",
- "MDXNET_Main": "UVR_MDXNET_Main.onnx"
- },
- "demucs_models": {
- "HT-Tuned": "htdemucs_ft.pth",
- "HT-Normal": "htdemucs.pth",
- "HD_MMI": "hdemucs_mmi.pth",
- "HT_6S": "htdemucs_6s.pth"
- },
- "vr_models": {
- "HP-1": "1_HP-UVR.pth",
- "HP-2": "2_HP-UVR.pth",
- "HP-Vocal-1": "3_HP-Vocal-UVR.pth",
- "HP-Vocal-2": "4_HP-Vocal-UVR.pth",
- "HP2-1": "7_HP2-UVR.pth",
- "HP2-2": "8_HP2-UVR.pth",
- "HP2-3": "9_HP2-UVR.pth",
- "SP-2B-1": "10_SP-UVR-2B-32000-1.pth",
- "SP-2B-2": "11_SP-UVR-2B-32000-2.pth",
- "SP-3B-1": "12_SP-UVR-3B-44100.pth",
- "SP-4B-1": "13_SP-UVR-4B-44100-1.pth",
- "SP-4B-2": "14_SP-UVR-4B-44100-2.pth",
- "SP-MID-1": "15_SP-UVR-MID-44100-1.pth",
- "SP-MID-2": "16_SP-UVR-MID-44100-2.pth"
- },
- "karaoke_models": {
- "MDX-Version-1": "UVR_MDXNET_KARA.onnx",
- "MDX-Version-2": "UVR_MDXNET_KARA_2.onnx",
- "VR-Version-1": "5_HP-Karaoke-UVR.pth",
- "VR-Version-2": "6_HP-Karaoke-UVR.pth"
- },
- "reverb_models": {
- "MDX-Reverb": "Reverb_HQ_By_FoxJoy.onnx",
- "VR-Reverb": "UVR-DeEcho-DeReverb.pth",
- "Echo-Aggressive": "UVR-De-Echo-Aggressive.pth",
- "Echo-Normal": "UVR-De-Echo-Normal.pth"
- },
- "denoise_models": {
- "Lite": "UVR-DeNoise-Lite.pth",
- "Normal": "UVR-DeNoise.pth"
- },
- "edge_tts": [
- "af-ZA-AdriNeural",
- "af-ZA-WillemNeural",
- "sq-AL-AnilaNeural",
- "sq-AL-IlirNeural",
- "am-ET-AmehaNeural",
- "am-ET-MekdesNeural",
- "ar-DZ-AminaNeural",
- "ar-DZ-IsmaelNeural",
- "ar-BH-AliNeural",
- "ar-BH-LailaNeural",
- "ar-EG-SalmaNeural",
- "ar-EG-ShakirNeural",
- "ar-IQ-BasselNeural",
- "ar-IQ-RanaNeural",
- "ar-JO-SanaNeural",
- "ar-JO-TaimNeural",
- "ar-KW-FahedNeural",
- "ar-KW-NouraNeural",
- "ar-LB-LaylaNeural",
- "ar-LB-RamiNeural",
- "ar-LY-ImanNeural",
- "ar-LY-OmarNeural",
- "ar-MA-JamalNeural",
- "ar-MA-MounaNeural",
- "ar-OM-AbdullahNeural",
- "ar-OM-AyshaNeural",
- "ar-QA-AmalNeural",
- "ar-QA-MoazNeural",
- "ar-SA-HamedNeural",
- "ar-SA-ZariyahNeural",
- "ar-SY-AmanyNeural",
- "ar-SY-LaithNeural",
- "ar-TN-HediNeural",
- "ar-TN-ReemNeural",
- "ar-AE-FatimaNeural",
- "ar-AE-HamdanNeural",
- "ar-YE-MaryamNeural",
- "ar-YE-SalehNeural",
- "az-AZ-BabekNeural",
- "az-AZ-BanuNeural",
- "bn-BD-NabanitaNeural",
- "bn-BD-PradeepNeural",
- "bn-IN-BashkarNeural",
- "bn-IN-TanishaaNeural",
- "bs-BA-GoranNeural",
- "bs-BA-VesnaNeural",
- "bg-BG-BorislavNeural",
- "bg-BG-KalinaNeural",
- "my-MM-NilarNeural",
- "my-MM-ThihaNeural",
- "ca-ES-EnricNeural",
- "ca-ES-JoanaNeural",
- "zh-HK-HiuGaaiNeural",
- "zh-HK-HiuMaanNeural",
- "zh-HK-WanLungNeural",
- "zh-CN-XiaoxiaoNeural",
- "zh-CN-XiaoyiNeural",
- "zh-CN-YunjianNeural",
- "zh-CN-YunxiNeural",
- "zh-CN-YunxiaNeural",
- "zh-CN-YunyangNeural",
- "zh-CN-liaoning-XiaobeiNeural",
- "zh-TW-HsiaoChenNeural",
- "zh-TW-YunJheNeural",
- "zh-TW-HsiaoYuNeural",
- "zh-CN-shaanxi-XiaoniNeural",
- "hr-HR-GabrijelaNeural",
- "hr-HR-SreckoNeural",
- "cs-CZ-AntoninNeural",
- "cs-CZ-VlastaNeural",
- "da-DK-ChristelNeural",
- "da-DK-JeppeNeural",
- "nl-BE-ArnaudNeural",
- "nl-BE-DenaNeural",
- "nl-NL-ColetteNeural",
- "nl-NL-FennaNeural",
- "nl-NL-MaartenNeural",
- "en-AU-NatashaNeural",
- "en-AU-WilliamNeural",
- "en-CA-ClaraNeural",
- "en-CA-LiamNeural",
- "en-HK-SamNeural",
- "en-HK-YanNeural",
- "en-IN-NeerjaExpressiveNeural",
- "en-IN-NeerjaNeural",
- "en-IN-PrabhatNeural",
- "en-IE-ConnorNeural",
- "en-IE-EmilyNeural",
- "en-KE-AsiliaNeural",
- "en-KE-ChilembaNeural",
- "en-NZ-MitchellNeural",
- "en-NZ-MollyNeural",
- "en-NG-AbeoNeural",
- "en-NG-EzinneNeural",
- "en-PH-JamesNeural",
- "en-PH-RosaNeural",
- "en-SG-LunaNeural",
- "en-SG-WayneNeural",
- "en-ZA-LeahNeural",
- "en-ZA-LukeNeural",
- "en-TZ-ElimuNeural",
- "en-TZ-ImaniNeural",
- "en-GB-LibbyNeural",
- "en-GB-MaisieNeural",
- "en-GB-RyanNeural",
- "en-GB-SoniaNeural",
- "en-GB-ThomasNeural",
- "en-US-AvaMultilingualNeural",
- "en-US-AndrewMultilingualNeural",
- "en-US-EmmaMultilingualNeural",
- "en-US-BrianMultilingualNeural",
- "en-US-AvaNeural",
- "en-US-AndrewNeural",
- "en-US-EmmaNeural",
- "en-US-BrianNeural",
- "en-US-AnaNeural",
- "en-US-AriaNeural",
- "en-US-ChristopherNeural",
- "en-US-EricNeural",
- "en-US-GuyNeural",
- "en-US-JennyNeural",
- "en-US-MichelleNeural",
- "en-US-RogerNeural",
- "en-US-SteffanNeural",
- "et-EE-AnuNeural",
- "et-EE-KertNeural",
- "fil-PH-AngeloNeural",
- "fil-PH-BlessicaNeural",
- "fi-FI-HarriNeural",
- "fi-FI-NooraNeural",
- "fr-BE-CharlineNeural",
- "fr-BE-GerardNeural",
- "fr-CA-ThierryNeural",
- "fr-CA-AntoineNeural",
- "fr-CA-JeanNeural",
- "fr-CA-SylvieNeural",
- "fr-FR-VivienneMultilingualNeural",
- "fr-FR-RemyMultilingualNeural",
- "fr-FR-DeniseNeural",
- "fr-FR-EloiseNeural",
- "fr-FR-HenriNeural",
- "fr-CH-ArianeNeural",
- "fr-CH-FabriceNeural",
- "gl-ES-RoiNeural",
- "gl-ES-SabelaNeural",
- "ka-GE-EkaNeural",
- "ka-GE-GiorgiNeural",
- "de-AT-IngridNeural",
- "de-AT-JonasNeural",
- "de-DE-SeraphinaMultilingualNeural",
- "de-DE-FlorianMultilingualNeural",
- "de-DE-AmalaNeural",
- "de-DE-ConradNeural",
- "de-DE-KatjaNeural",
- "de-DE-KillianNeural",
- "de-CH-JanNeural",
- "de-CH-LeniNeural",
- "el-GR-AthinaNeural",
- "el-GR-NestorasNeural",
- "gu-IN-DhwaniNeural",
- "gu-IN-NiranjanNeural",
- "he-IL-AvriNeural",
- "he-IL-HilaNeural",
- "hi-IN-MadhurNeural",
- "hi-IN-SwaraNeural",
- "hu-HU-NoemiNeural",
- "hu-HU-TamasNeural",
- "is-IS-GudrunNeural",
- "is-IS-GunnarNeural",
- "id-ID-ArdiNeural",
- "id-ID-GadisNeural",
- "ga-IE-ColmNeural",
- "ga-IE-OrlaNeural",
- "it-IT-GiuseppeNeural",
- "it-IT-DiegoNeural",
- "it-IT-ElsaNeural",
- "it-IT-IsabellaNeural",
- "ja-JP-KeitaNeural",
- "ja-JP-NanamiNeural",
- "jv-ID-DimasNeural",
- "jv-ID-SitiNeural",
- "kn-IN-GaganNeural",
- "kn-IN-SapnaNeural",
- "kk-KZ-AigulNeural",
- "kk-KZ-DauletNeural",
- "km-KH-PisethNeural",
- "km-KH-SreymomNeural",
- "ko-KR-HyunsuNeural",
- "ko-KR-InJoonNeural",
- "ko-KR-SunHiNeural",
- "lo-LA-ChanthavongNeural",
- "lo-LA-KeomanyNeural",
- "lv-LV-EveritaNeural",
- "lv-LV-NilsNeural",
- "lt-LT-LeonasNeural",
- "lt-LT-OnaNeural",
- "mk-MK-AleksandarNeural",
- "mk-MK-MarijaNeural",
- "ms-MY-OsmanNeural",
- "ms-MY-YasminNeural",
- "ml-IN-MidhunNeural",
- "ml-IN-SobhanaNeural",
- "mt-MT-GraceNeural",
- "mt-MT-JosephNeural",
- "mr-IN-AarohiNeural",
- "mr-IN-ManoharNeural",
- "mn-MN-BataaNeural",
- "mn-MN-YesuiNeural",
- "ne-NP-HemkalaNeural",
- "ne-NP-SagarNeural",
- "nb-NO-FinnNeural",
- "nb-NO-PernilleNeural",
- "ps-AF-GulNawazNeural",
- "ps-AF-LatifaNeural",
- "fa-IR-DilaraNeural",
- "fa-IR-FaridNeural",
- "pl-PL-MarekNeural",
- "pl-PL-ZofiaNeural",
- "pt-BR-ThalitaNeural",
- "pt-BR-AntonioNeural",
- "pt-BR-FranciscaNeural",
- "pt-PT-DuarteNeural",
- "pt-PT-RaquelNeural",
- "ro-RO-AlinaNeural",
- "ro-RO-EmilNeural",
- "ru-RU-DmitryNeural",
- "ru-RU-SvetlanaNeural",
- "sr-RS-NicholasNeural",
- "sr-RS-SophieNeural",
- "si-LK-SameeraNeural",
- "si-LK-ThiliniNeural",
- "sk-SK-LukasNeural",
- "sk-SK-ViktoriaNeural",
- "sl-SI-PetraNeural",
- "sl-SI-RokNeural",
- "so-SO-MuuseNeural",
- "so-SO-UbaxNeural",
- "es-AR-ElenaNeural",
- "es-AR-TomasNeural",
- "es-BO-MarceloNeural",
- "es-BO-SofiaNeural",
- "es-CL-CatalinaNeural",
- "es-CL-LorenzoNeural",
- "es-ES-XimenaNeural",
- "es-CO-GonzaloNeural",
- "es-CO-SalomeNeural",
- "es-CR-JuanNeural",
- "es-CR-MariaNeural",
- "es-CU-BelkysNeural",
- "es-CU-ManuelNeural",
- "es-DO-EmilioNeural",
- "es-DO-RamonaNeural",
- "es-EC-AndreaNeural",
- "es-EC-LuisNeural",
- "es-SV-LorenaNeural",
- "es-SV-RodrigoNeural",
- "es-GQ-JavierNeural",
- "es-GQ-TeresaNeural",
- "es-GT-AndresNeural",
- "es-GT-MartaNeural",
- "es-HN-CarlosNeural",
- "es-HN-KarlaNeural",
- "es-MX-DaliaNeural",
- "es-MX-JorgeNeural",
- "es-NI-FedericoNeural",
- "es-NI-YolandaNeural",
- "es-PA-MargaritaNeural",
- "es-PA-RobertoNeural",
- "es-PY-MarioNeural",
- "es-PY-TaniaNeural",
- "es-PE-AlexNeural",
- "es-PE-CamilaNeural",
- "es-PR-KarinaNeural",
- "es-PR-VictorNeural",
- "es-ES-AlvaroNeural",
- "es-ES-ElviraNeural",
- "es-US-AlonsoNeural",
- "es-US-PalomaNeural",
- "es-UY-MateoNeural",
- "es-UY-ValentinaNeural",
- "es-VE-PaolaNeural",
- "es-VE-SebastianNeural",
- "su-ID-JajangNeural",
- "su-ID-TutiNeural",
- "sw-KE-RafikiNeural",
- "sw-KE-ZuriNeural",
- "sw-TZ-DaudiNeural",
- "sw-TZ-RehemaNeural",
- "sv-SE-MattiasNeural",
- "sv-SE-SofieNeural",
- "ta-IN-PallaviNeural",
- "ta-IN-ValluvarNeural",
- "ta-MY-KaniNeural",
- "ta-MY-SuryaNeural",
- "ta-SG-AnbuNeural",
- "ta-SG-VenbaNeural",
- "ta-LK-KumarNeural",
- "ta-LK-SaranyaNeural",
- "te-IN-MohanNeural",
- "te-IN-ShrutiNeural",
- "th-TH-NiwatNeural",
- "th-TH-PremwadeeNeural",
- "tr-TR-AhmetNeural",
- "tr-TR-EmelNeural",
- "uk-UA-OstapNeural",
- "uk-UA-PolinaNeural",
- "ur-IN-GulNeural",
- "ur-IN-SalmanNeural",
- "ur-PK-AsadNeural",
- "ur-PK-UzmaNeural",
- "uz-UZ-MadinaNeural",
- "uz-UZ-SardorNeural",
- "vi-VN-HoaiMyNeural",
- "vi-VN-NamMinhNeural",
- "cy-GB-AledNeural",
- "cy-GB-NiaNeural",
- "zu-ZA-ThandoNeural",
- "zu-ZA-ThembaNeural"
- ],
- "google_tts_voice": [
- "af",
- "am",
- "ar",
- "bg",
- "bn",
- "bs",
- "ca",
- "cs",
- "cy",
- "da",
- "de",
- "el",
- "en",
- "es",
- "et",
- "eu",
- "fi",
- "fr",
- "fr-CA",
- "gl",
- "gu",
- "ha",
- "hi",
- "hr",
- "hu",
- "id",
- "is",
- "it",
- "iw",
- "ja",
- "jw",
- "km",
- "kn",
- "ko",
- "la",
- "lt",
- "lv",
- "ml",
- "mr",
- "ms",
- "my",
- "ne",
- "nl",
- "no",
- "pa",
- "pl",
- "pt",
- "pt-PT",
- "ro",
- "ru",
- "si",
- "sk",
- "sq",
- "sr",
- "su",
- "sv",
- "sw",
- "ta",
- "te",
- "th",
- "tl",
- "tr",
- "uk",
- "ur",
- "vi",
- "yue",
- "zh-CN",
- "zh-TW",
- "zh"
- ],
- "whisper_languages": [
- "en",
- "zh",
- "de",
- "es",
- "ru",
- "ko",
- "fr",
- "ja",
- "pt",
- "tr",
- "pl",
- "ca",
- "nl",
- "ar",
- "sv",
- "it",
- "id",
- "hi",
- "fi",
- "vi",
- "he",
- "uk",
- "el",
- "ms",
- "cs",
- "ro",
- "da",
- "hu",
- "ta",
- "no",
- "th",
- "ur",
- "hr",
- "bg",
- "lt",
- "la",
- "mi",
- "ml",
- "cy",
- "sk",
- "te",
- "fa",
- "lv",
- "bn",
- "sr",
- "az",
- "sl",
- "kn",
- "et",
- "mk",
- "br",
- "eu",
- "is",
- "hy",
- "ne",
- "mn",
- "bs",
- "kk",
- "sq",
- "sw",
- "gl",
- "mr",
- "pa",
- "si",
- "km",
- "sn",
- "yo",
- "so",
- "af",
- "oc",
- "ka",
- "be",
- "tg",
- "sd",
- "gu",
- "am",
- "yi",
- "lo",
- "uz",
- "fo",
- "ht",
- "ps",
- "tk",
- "nn",
- "mt",
- "sa",
- "lb",
- "my",
- "bo",
- "tl",
- "mg",
- "as",
- "tt",
- "haw",
- "ln",
- "ha",
- "ba",
- "jw",
- "su",
- "yue"
- ],
- "fp16": false,
- "editing_tab": true,
- "inference_tab": true,
- "create_and_training_tab": true,
- "extra_tab": true,
- "separator_tab": true,
- "convert_tab": true,
- "convert_with_vad_tab": true,
- "tts_tab": true,
- "effects_tab": true,
- "quirk_tab": true,
- "create_dataset_tab": true,
- "training_tab": true,
- "fushion_tab": true,
- "read_tab": true,
- "onnx_tab": true,
- "svc_tab": true,
- "downloads_tab": true,
- "f0_extractor_tab": true,
- "settings_tab": true,
- "create_srt_tab": true,
- "realtime_tab": true,
- "create_reference_tab": true,
- "analyzer_tab": true,
- "font": "https://fonts.googleapis.com/css2?family=Saira&display=swap",
- "app_port": 7860,
- "tensorboard_port": 6870,
- "num_of_restart": 5,
- "server_name": "0.0.0.0",
- "app_show_error": true,
- "delete_exists_file": false,
- "audio_effects_path": "main/inference/audio_effects.py",
- "convert_path": "main/inference/conversion/convert.py",
- "separate_path": "main/inference/separate_music.py",
- "create_dataset_path": "main/inference/create_dataset.py",
- "preprocess_path": "main/inference/preprocess/preprocess.py",
- "extract_path": "main/inference/extracting/extract.py",
- "create_index_path": "main/inference/create_index.py",
- "train_path": "main/inference/training/train.py",
- "create_reference_path": "main/inference/create_reference.py",
- "ico_path": "assets/ico.png",
- "csv_path": "assets/spreadsheet.csv",
- "weights_path": "assets/weights",
- "logs_path": "assets/logs",
- "binary_path": "assets/binary",
- "f0_path": "assets/f0",
- "language_path": "assets/languages",
- "presets_path": "assets/presets",
- "embedders_path": "assets/models/embedders",
- "predictors_path": "assets/models/predictors",
- "pretrained_custom_path": "assets/models/pretrained_custom",
- "pretrained_v1_path": "assets/models/pretrained_v1",
- "pretrained_v2_path": "assets/models/pretrained_v2",
- "speaker_diarization_path": "assets/models/speaker_diarization",
- "uvr5_path": "assets/models/uvr5",
- "audios_path": "audios",
- "reference_path": "assets/logs/reference",
- "demucs_segments_enable": true,
- "demucs_cpu_mode": false,
- "limit_f0": 12,
- "debug_mode": true,
- "pretrain_strict": true,
- "cpu_mode": false,
- "brain": false,
- "tf32": false,
- "discord_presence": true,
- "f0_min": 50,
- "f0_max": 1100,
- "turn_on_resize_f0_for_all": false,
- "allow_fp16_all_backend": false,
- "asio_enabled": false,
- "ffmpeg_download": true,
- "compile_all": false,
- "compile_mode": null,
- "compile_cache_dir": "assets/cache",
- "check_data": false,
- "tensorrt": false,
- "faiss_cpu": false,
- "allow_unsafe_fairseq": false,
- "del4stem": true,
- "enable_rmvpe_chunk": false,
- "rmvpe_chunk_size": 8000
-}
\ No newline at end of file
diff --git a/main/configs/config.py b/main/configs/config.py
deleted file mode 100644
index ce918e4719a91927e222b323fa29f379fc43f8c5..0000000000000000000000000000000000000000
--- a/main/configs/config.py
+++ /dev/null
@@ -1,192 +0,0 @@
-import os
-import sys
-import json
-import torch
-import onnxruntime
-
-sys.path.append(os.getcwd())
-
-from main.library.backends import directml, opencl, xpu, zluda
-
-version_config_paths = [
- os.path.join(version, size)
- for version in ["v1", "v2"]
- for size in ["24000.json", "32000.json", "40000.json", "44100.json", "48000.json"]
-]
-
-def singleton(cls):
- instances = {}
-
- def get_instance(*args, **kwargs):
- if cls not in instances: instances[cls] = cls(*args, **kwargs)
- return instances[cls]
-
- return get_instance
-
-@singleton
-class Config:
- def __init__(self):
- self.configs_path = os.path.join("main", "configs", "config.json")
- self.configs = json.load(open(self.configs_path, "r"))
-
- self.cpu_mode = self.configs.get("cpu_mode", False)
- self.cuda_available = torch.cuda.is_available()
- self.is_zluda = self.cuda_available and torch.cuda.get_device_name().endswith("[ZLUDA]")
- self.hip_version = torch.version.hip if hasattr(torch.version, "hip") else None
- if self.is_zluda: zluda.init_zluda()
-
- self.debug_mode = self.configs.get("debug_mode", False)
- self.json_config = self.load_config_json()
- self.translations = self.multi_language()
-
- self.gpu_mem = None
- self.per_preprocess = 3.7
- self.device = self.get_default_device()
- self.tensorrt = self.configs.get("tensorrt", False)
- self.providers = self.get_providers()
-
- self.cuda_tf32 = self.cuda_available and hasattr(torch.cuda, "is_tf32_supported") and torch.cuda.is_tf32_supported()
- self.cuda_bf16 = self.cuda_available and hasattr(torch.cuda, "is_bf16_supported") and torch.cuda.is_bf16_supported()
- self.xpu_fp16 = hasattr(torch, "xpu") and torch.xpu.is_available() and hasattr(torch.xpu, "is_bf16_supported") and torch.xpu.is_bf16_supported()
-
- self.tf32_support = self.device.startswith("cuda") and self.cuda_tf32
- self.bf16_support = self.device.startswith(("cuda", "xpu")) and self.cuda_bf16 or self.xpu_fp16
-
- self.brain = self.configs.get("brain", False) and self.bf16_support and not self.cpu_mode
- self.tf32 = self.configs.get("tf32", False) and self.tf32_support and not self.is_zluda and not self.cpu_mode
-
- self.is_half = self.is_fp16()
- self.compile_all = self.device.startswith("cuda") and self.configs.get("compile_all", False)
- self.compile_mode = self.configs.get("compile_mode", None)
- self.allow_is_half = not self.device.startswith(("cpu", "mps", "ocl", "privateuseone")) or self.configs.get("allow_fp16_all_backend", False)
- self.x_pad, self.x_query, self.x_center, self.x_max = self.device_config()
- if self.compile_all: self.setup_compile()
-
- def multi_language(self):
- try:
- lang = self.configs.get("language", "vi-VN")
-
- if len([l for l in os.listdir(self.configs["language_path"]) if l.endswith(".json")]) < 1:
- raise FileNotFoundError("Không tìm thấy bất cứ gói ngôn ngữ nào(No package languages found)")
-
- if not lang: lang = "vi-VN"
-
- if lang not in self.configs["support_language"]:
- raise ValueError("Ngôn ngữ không được hỗ trợ (Language not supported)")
-
- lang_path = os.path.join(self.configs["language_path"], f"{lang}.json")
- if not os.path.exists(lang_path):
- lang_path = os.path.join(self.configs["language_path"], "vi-VN.json")
-
- with open(lang_path, encoding="utf-8") as f:
- translations = json.load(f)
- except json.JSONDecodeError:
- print(self.translations["empty_json"].format(file=lang))
- pass
-
- return translations
-
- def is_fp16(self):
- fp16 = self.configs.get("fp16", False)
-
- if self.device in ["cpu", "mps", "ocl", "privateuseone"] and fp16:
- self.configs["fp16"] = False
- fp16 = False
-
- with open(self.configs_path, "w") as f:
- json.dump(self.configs, f, indent=4)
-
- if not fp16: self.per_preprocess = 3.0
- return fp16
-
- def load_config_json(self):
- configs = {}
-
- for config_file in version_config_paths:
- try:
- with open(os.path.join("main", "configs", config_file), "r") as f:
- configs[config_file] = json.load(f)
- except json.JSONDecodeError:
- print(self.translations["empty_json"].format(file=config_file))
- pass
-
- return configs
-
- def setup_compile(self):
- import importlib
-
- try:
- importlib.import_module("triton")
- except ModuleNotFoundError:
- self.compile_all = False
- self.configs["compile_all"] = False
-
- with open(self.configs_path, "w") as f:
- json.dump(self.configs, f, indent=4)
-
- if self.compile_all:
- dirs = self.configs.get("compile_cache_dir", "none")
-
- if dirs != "none":
- if not os.path.exists(dirs): os.makedirs(dirs)
- os.environ["TORCHINDUCTOR_CACHE_DIR"] = dirs
-
- import torch._inductor.config as config
-
- torch._dynamo.config.capture_scalar_outputs = True
- config.freezing = True
-
- def device_config(self):
- if self.gpu_mem is not None and self.gpu_mem <= 4:
- self.per_preprocess = 3.0
- return 1, 5, 30, 32
-
- return (3, 10, 60, 65) if self.is_half else (1, 6, 38, 41)
-
- def get_default_device(self):
- if not self.cpu_mode:
- if torch.cuda.is_available():
- device = "cuda:0"
- self.gpu_mem = torch.cuda.get_device_properties(int(device.split(":")[-1])).total_memory // (1024**3)
- elif hasattr(torch, "xpu") and torch.xpu.is_available():
- device = "xpu:0"
- self.gpu_mem = torch.xpu.get_device_properties(int(device.split(":")[-1])).total_memory // (1024**3)
- xpu.setup_gradscaler()
- elif directml.is_available():
- device = "privateuseone:0"
- elif opencl.is_available():
- device = "ocl:0"
- elif torch.backends.mps.is_available():
- device = "mps"
- else:
- device = "cpu"
- else:
- torch.cuda.is_available = lambda : False
- directml.is_available = lambda : False
- opencl.is_available = lambda : False
- torch.backends.mps.is_available = lambda : False
- if hasattr(torch, "xpu"): torch.xpu.is_available = lambda: False
-
- device = "cpu"
-
- return device
-
- def get_providers(self):
- ort_providers = onnxruntime.get_available_providers()
- providers = []
-
- if self.device.startswith("cuda"):
- if "TensorrtExecutionProvider" in ort_providers and self.tensorrt: providers.append("TensorrtExecutionProvider")
- if "CUDAExecutionProvider" in ort_providers: providers.append("CUDAExecutionProvider")
- elif "ROCMExecutionProvider" in ort_providers: providers.append("ROCMExecutionProvider")
- elif "MIGraphXExecutionProvider" in ort_providers: providers.append("MIGraphXExecutionProvider")
- elif "DmlExecutionProvider" in ort_providers: providers.append("DmlExecutionProvider")
- elif self.device.startswith("xpu"):
- if "OpenVINOExecutionProvider" in ort_providers: providers.append("OpenVINOExecutionProvider")
- elif "DnnlExecutionProvider" in ort_providers: providers.append("DnnlExecutionProvider")
- elif "DmlExecutionProvider" in ort_providers: providers.append("DmlExecutionProvider")
- elif "DmlExecutionProvider" in ort_providers and self.device.startswith(("ocl", "privateuseone")): providers.append("DmlExecutionProvider")
- elif "CoreMLExecutionProvider" in ort_providers and self.device.startswith("mps"): providers.append("CoreMLExecutionProvider")
-
- providers.append("CPUExecutionProvider")
- return providers
\ No newline at end of file
diff --git a/main/configs/rpc.py b/main/configs/rpc.py
deleted file mode 100644
index b23bb867fc7cb64583c0c7f0f5a175971a48665f..0000000000000000000000000000000000000000
--- a/main/configs/rpc.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import os
-import sys
-import json
-import time
-import struct
-import codecs
-
-sys.path.append(os.getcwd())
-
-from main.app.variables import translations
-
-CLIENT_ID = "1392816674159202396"
-
-def create_payload(opcode, payload):
- data = json.dumps(payload).encode("utf-8")
-
- return struct.pack(
- "= 1:
- b, a = butter(4, frequency / (0.5 * sample_rate), btype='low')
- boosted = _filtfilt(b, a, audio)
- return boosted * (10 ** (gain_db / 20))
- return audio
-
- def treble_boost(audio, gain_db, frequency, sample_rate):
- if gain_db >= 1:
- b, a = butter(4, frequency / (0.5 * sample_rate), btype='high')
- boosted = _filtfilt(b, a, audio)
- return boosted * (10 ** (gain_db / 20))
- return audio
-
- def fade_out_effect(audio, sr, duration=3.0):
- length = int(duration * sr)
- end = audio.shape[0]
- if length > end: length = end
- start = end - length
- audio[start:end] = audio[start:end] * np.linspace(1.0, 0.0, length)
- return audio
-
- def fade_in_effect(audio, sr, duration=3.0):
- length = int(duration * sr)
- start = 0
- if length > audio.shape[0]: length = audio.shape[0]
- end = length
- audio[start:end] = audio[start:end] * np.linspace(0.0, 1.0, length)
- return audio
-
- if not input_path or not os.path.exists(input_path):
- logger.warning(translations["input_not_valid"])
- sys.exit(1)
-
- if not output_path:
- logger.warning(translations["output_not_valid"])
- sys.exit(1)
-
- if os.path.exists(output_path): os.remove(output_path)
-
- try:
- input_path = input_path.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
- try:
- audio, sample_rate = sf.read(input_path, dtype=np.float32)
- except:
- audio, sample_rate = librosa.load(input_path, sr=None)
- except Exception as e:
- logger.debug(f"{translations['errors_loading_audio']}: {e}")
- raise RuntimeError(f"{translations['errors_loading_audio']}: {e}")
-
- try:
- board = Pedalboard([HighpassFilter()])
-
- if chorus:
- board.append(
- Chorus(
- depth=chorus_depth,
- rate_hz=chorus_rate,
- mix=chorus_mix,
- centre_delay_ms=chorus_delay,
- feedback=chorus_feedback
- )
- )
-
- if distortion:
- board.append(
- Distortion(
- drive_db=distortion_drive
- )
- )
-
- if reverb:
- board.append(
- Reverb(
- room_size=reverb_room_size,
- damping=reverb_damping,
- wet_level=reverb_wet_level,
- dry_level=reverb_dry_level,
- width=reverb_width,
- freeze_mode=int(reverb_freeze_mode)
- )
- )
-
- if pitchshift:
- board.append(
- PitchShift(
- semitones=pitch_shift
- )
- )
-
- if delay:
- board.append(
- Delay(
- delay_seconds=delay_seconds,
- feedback=delay_feedback,
- mix=delay_mix
- )
- )
-
- if compressor:
- board.append(
- Compressor(
- threshold_db=compressor_threshold,
- ratio=compressor_ratio,
- attack_ms=compressor_attack_ms,
- release_ms=compressor_release_ms
- )
- )
-
- if limiter:
- board.append(
- Limiter(
- threshold_db=limiter_threshold,
- release_ms=limiter_release
- )
- )
-
- if gain:
- board.append(
- Gain(
- gain_db=gain_db
- )
- )
-
- if bitcrush:
- board.append(
- Bitcrush(
- bit_depth=bitcrush_bit_depth
- )
- )
-
- if clipping:
- board.append(
- Clipping(
- threshold_db=clipping_threshold
- )
- )
-
- if phaser: board.append(
- Phaser(
- rate_hz=phaser_rate_hz,
- depth=phaser_depth,
- centre_frequency_hz=phaser_centre_frequency_hz,
- feedback=phaser_feedback,
- mix=phaser_mix
- )
- )
-
- processed_audio = board(audio, sample_rate)
-
- if treble_bass_boost:
- processed_audio = bass_boost(
- processed_audio,
- bass_boost_db,
- bass_boost_frequency,
- sample_rate
- )
-
- processed_audio = treble_boost(
- processed_audio,
- treble_boost_db,
- treble_boost_frequency,
- sample_rate
- )
-
- if fade_in_out:
- processed_audio = fade_in_effect(
- processed_audio,
- sample_rate,
- fade_in_duration
- )
-
- processed_audio = fade_out_effect(
- processed_audio,
- sample_rate,
- fade_out_duration
- )
-
- if resample and resample_sr != sample_rate and resample_sr > 0:
- processed_audio = librosa.resample(
- processed_audio,
- orig_sr=sample_rate,
- target_sr=resample_sr,
- res_type="soxr_vhq"
- )
-
- sample_rate = resample_sr
-
- sf.write(
- replace_export_format(output_path, export_format),
- processed_audio,
- sample_rate,
- format=export_format
- )
-
- if audio_combination:
- pydub_load(
- audio_combination_input,
- combination_volume
- ).overlay(
- pydub_load(
- replace_export_format(output_path, export_format),
- main_volume
- )
- ).export(
- replace_export_format(output_path, export_format),
- format=export_format
- )
- except Exception as e:
- import traceback
- logger.debug(traceback.format_exc())
- raise RuntimeError(translations["apply_error"].format(e=e))
- return output_path
-
-def main():
- args = parse_arguments()
-
- process_audio(
- input_path=args.input_path,
- output_path=args.output_path,
- resample=args.resample,
- resample_sr=args.resample_sr,
- chorus_depth=args.chorus_depth,
- chorus_rate=args.chorus_rate,
- chorus_mix=args.chorus_mix,
- chorus_delay=args.chorus_delay,
- chorus_feedback=args.chorus_feedback,
- distortion_drive=args.drive_db,
- reverb_room_size=args.reverb_room_size,
- reverb_damping=args.reverb_damping,
- reverb_wet_level=args.reverb_wet_level,
- reverb_dry_level=args.reverb_dry_level,
- reverb_width=args.reverb_width,
- reverb_freeze_mode=args.reverb_freeze_mode,
- pitch_shift=args.pitch_shift,
- delay_seconds=args.delay_seconds,
- delay_feedback=args.delay_feedback,
- delay_mix=args.delay_mix,
- compressor_threshold=args.compressor_threshold,
- compressor_ratio=args.compressor_ratio,
- compressor_attack_ms=args.compressor_attack_ms,
- compressor_release_ms=args.compressor_release_ms,
- limiter_threshold=args.limiter_threshold,
- limiter_release=args.limiter_release,
- gain_db=args.gain_db,
- bitcrush_bit_depth=args.bitcrush_bit_depth,
- clipping_threshold=args.clipping_threshold,
- phaser_rate_hz=args.phaser_rate_hz,
- phaser_depth=args.phaser_depth,
- phaser_centre_frequency_hz=args.phaser_centre_frequency_hz,
- phaser_feedback=args.phaser_feedback,
- phaser_mix=args.phaser_mix,
- bass_boost_db=args.bass_boost_db,
- bass_boost_frequency=args.bass_boost_frequency,
- treble_boost_db=args.treble_boost_db,
- treble_boost_frequency=args.treble_boost_frequency,
- fade_in_duration=args.fade_in_duration,
- fade_out_duration=args.fade_out_duration,
- export_format=args.export_format,
- chorus=args.chorus,
- distortion=args.distortion,
- reverb=args.reverb,
- pitchshift=args.pitchshift,
- delay=args.delay,
- compressor=args.compressor,
- limiter=args.limiter,
- gain=args.gain,
- bitcrush=args.bitcrush,
- clipping=args.clipping,
- phaser=args.phaser,
- treble_bass_boost=args.treble_bass_boost,
- fade_in_out=args.fade_in_out,
- audio_combination=args.audio_combination,
- audio_combination_input=args.audio_combination_input,
- main_volume=args.main_volume,
- combination_volume=args.combination_volume
- )
-
-if __name__ == "__main__": main()
\ No newline at end of file
diff --git a/main/inference/conversion/convert.py b/main/inference/conversion/convert.py
deleted file mode 100644
index f7e29c62303f749257d5fe7a162465806b7a37b8..0000000000000000000000000000000000000000
--- a/main/inference/conversion/convert.py
+++ /dev/null
@@ -1,711 +0,0 @@
-import os
-import sys
-import time
-import torch
-import spaces
-import librosa
-import logging
-import argparse
-import warnings
-
-import numpy as np
-import soundfile as sf
-
-from tqdm import tqdm
-from scipy import signal
-
-sys.path.append(os.getcwd())
-
-from main.app.core.ui import replace_export_format
-from main.inference.conversion.pipeline import Pipeline
-from main.library.audio.audio import load_audio, cut, restore
-from main.app.variables import config, logger, translations, file_types
-from main.library.audio.audio_processing import preprocess, postprocess
-from main.library.utils import check_assets, check_upscaler, load_embedders_model, clear_gpu_cache, load_model, strtobool, load_faiss_index
-
-if not config.debug_mode:
- warnings.filterwarnings("ignore")
-
- for l in [
- "torch",
- "faiss",
- "omegaconf",
- "httpx",
- "httpcore",
- "faiss.loader",
- "numba.core",
- "urllib3",
- "transformers",
- "matplotlib"
- ]:
- logging.getLogger(l).setLevel(logging.ERROR)
-
-def parse_arguments():
- parser = argparse.ArgumentParser()
- parser.add_argument("--convert", action='store_true')
- parser.add_argument("--pitch", type=int, default=0)
- parser.add_argument("--filter_radius", type=int, default=3)
- parser.add_argument("--index_rate", type=float, default=0.5)
- parser.add_argument("--rms_mix_rate", type=float, default=1)
- parser.add_argument("--protect", type=float, default=0.33)
- parser.add_argument("--hop_length", type=int, default=64)
- parser.add_argument("--f0_method", type=str, default="rmvpe")
- parser.add_argument("--embedder_model", type=str, default="hubert_base")
- parser.add_argument("--input_path", type=str, required=True)
- parser.add_argument("--output_path", type=str, default="./audios/output.wav")
- parser.add_argument("--export_format", type=str, default="wav")
- parser.add_argument("--pth_path", type=str, required=True)
- parser.add_argument("--index_path", type=str, default="")
- parser.add_argument("--f0_autotune", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--f0_autotune_strength", type=float, default=1)
- parser.add_argument("--clean_audio", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--clean_strength", type=float, default=0.7)
- parser.add_argument("--resample_sr", type=int, default=0)
- parser.add_argument("--split_audio", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--checkpointing", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--f0_file", type=str, default="")
- parser.add_argument("--predictor_onnx", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--embedders_mode", type=str, default="fairseq")
- parser.add_argument("--formant_shifting", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--formant_qfrency", type=float, default=0.8)
- parser.add_argument("--formant_timbre", type=float, default=0.8)
- parser.add_argument("--proposal_pitch", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--proposal_pitch_threshold", type=float, default=255.0)
- parser.add_argument("--audio_processing", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--alpha", type=float, default=0.5)
- parser.add_argument("--sid", type=int, default=0, required=False)
- parser.add_argument("--embedders_mix", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--embedders_mix_layers", type=int, default=9, required=False)
- parser.add_argument("--embedders_mix_ratio", type=float, default=0.5)
- parser.add_argument("--noise_scale", type=float, default=0.35)
- parser.add_argument("--nprobe", type=int, default=1)
- parser.add_argument("--audio_upscaler", type=lambda x: bool(strtobool(x)), default=False)
-
- return parser.parse_args()
-
-def main():
- args = parse_arguments()
-
- (
- pitch,
- filter_radius,
- index_rate,
- rms_mix_rate,
- protect,
- hop_length,
- f0_method,
- input_path,
- output_path,
- pth_path,
- index_path,
- f0_autotune,
- f0_autotune_strength,
- clean_audio,
- clean_strength,
- export_format,
- embedder_model,
- resample_sr,
- split_audio,
- checkpointing,
- f0_file,
- predictor_onnx,
- embedders_mode,
- formant_shifting,
- formant_qfrency,
- formant_timbre,
- proposal_pitch,
- proposal_pitch_threshold,
- audio_processing,
- alpha,
- sid,
- embedders_mix,
- embedders_mix_layers,
- embedders_mix_ratio,
- noise_scale,
- nprobe,
- audio_upscaler
- ) = (
- args.pitch,
- args.filter_radius,
- args.index_rate,
- args.rms_mix_rate,
- args.protect,
- args.hop_length,
- args.f0_method,
- args.input_path,
- args.output_path,
- args.pth_path,
- args.index_path,
- args.f0_autotune,
- args.f0_autotune_strength,
- args.clean_audio,
- args.clean_strength,
- args.export_format,
- args.embedder_model,
- args.resample_sr,
- args.split_audio,
- args.checkpointing,
- args.f0_file,
- args.predictor_onnx,
- args.embedders_mode,
- args.formant_shifting,
- args.formant_qfrency,
- args.formant_timbre,
- args.proposal_pitch,
- args.proposal_pitch_threshold,
- args.audio_processing,
- args.alpha,
- args.sid,
- args.embedders_mix,
- args.embedders_mix_layers,
- args.embedders_mix_ratio,
- args.noise_scale,
- args.nprobe,
- args.audio_upscaler
- )
-
- run_convert_script(
- pitch=pitch,
- filter_radius=filter_radius,
- index_rate=index_rate,
- rms_mix_rate=rms_mix_rate,
- protect=protect,
- hop_length=hop_length,
- f0_method=f0_method,
- input_path=input_path,
- output_path=output_path,
- pth_path=pth_path,
- index_path=index_path,
- f0_autotune=f0_autotune,
- f0_autotune_strength=f0_autotune_strength,
- clean_audio=clean_audio,
- clean_strength=clean_strength,
- export_format=export_format,
- embedder_model=embedder_model,
- resample_sr=resample_sr,
- split_audio=split_audio,
- checkpointing=checkpointing,
- f0_file=f0_file,
- predictor_onnx=predictor_onnx,
- embedders_mode=embedders_mode,
- formant_shifting=formant_shifting,
- formant_qfrency=formant_qfrency,
- formant_timbre=formant_timbre,
- proposal_pitch=proposal_pitch,
- proposal_pitch_threshold=proposal_pitch_threshold,
- audio_processing=audio_processing,
- alpha=alpha,
- sid=sid,
- embedders_mix=embedders_mix,
- embedders_mix_layers=embedders_mix_layers,
- embedders_mix_ratio=embedders_mix_ratio,
- noise_scale=noise_scale,
- nprobe=nprobe,
- audio_upscaler=audio_upscaler
- )
-
-@spaces.GPU
-def run_convert_script(
- pitch=0,
- filter_radius=3,
- index_rate=0.5,
- rms_mix_rate=1,
- protect=0.5,
- hop_length=64,
- f0_method="rmvpe",
- input_path=None,
- output_path="./output.wav",
- pth_path=None,
- index_path=None,
- f0_autotune=False,
- f0_autotune_strength=1,
- clean_audio=False,
- clean_strength=0.7,
- export_format="wav",
- embedder_model="hubert_base",
- resample_sr=0,
- split_audio=False,
- checkpointing=False,
- f0_file=None,
- predictor_onnx=False,
- embedders_mode="fairseq",
- formant_shifting=False,
- formant_qfrency=0.8,
- formant_timbre=0.8,
- proposal_pitch=False,
- proposal_pitch_threshold=255.0,
- audio_processing=False,
- alpha=0.5,
- sid=0,
- embedders_mix = False,
- embedders_mix_layers = 9,
- embedders_mix_ratio = 0.5,
- noise_scale = 0.35,
- nprobe = 1,
- audio_upscaler = False
-):
- if audio_upscaler: check_upscaler()
- check_assets(
- f0_method,
- embedder_model,
- predictor_onnx=predictor_onnx,
- embedders_mode=embedders_mode
- )
-
- log_data = {
- translations["pitch"]: pitch,
- translations["filter_radius"]: filter_radius,
- translations["index_strength"]: index_rate,
- translations["rms_mix_rate"]: rms_mix_rate,
- translations["protect"]: protect,
- translations["hop_length"]: hop_length,
- translations["f0_method"]: f0_method,
- translations["audio_path"]: input_path,
- translations["output_path"]: replace_export_format(output_path, export_format),
- translations["model_path"]: pth_path,
- translations["indexpath"]: index_path,
- translations["autotune"]: f0_autotune,
- translations["autotune_rate_info"]: f0_autotune_strength,
- translations["clear_audio"]: clean_audio,
- translations["clean_strength"]: clean_strength,
- translations["sample_rate"]: resample_sr,
- translations["export_format"]: export_format,
- translations["hubert_model"]: embedder_model,
- translations["split_audio"]: split_audio,
- translations["memory_efficient_training"]: checkpointing,
- translations["predictor_onnx"]: predictor_onnx,
- translations["f0_file"]: f0_file,
- translations["embed_mode"]: embedders_mode,
- translations["proposal_pitch"]: proposal_pitch,
- translations["proposal_pitch_threshold"]: proposal_pitch_threshold,
- translations["audio_processing"]: audio_processing,
- translations["alpha_label"]: alpha,
- translations["embedders_mix"]: embedders_mix,
- translations["embedders_mix_layers"]: embedders_mix_layers,
- translations["embedders_mix_ratio"]: embedders_mix_ratio,
- translations["formant_qfrency"]: formant_qfrency,
- translations["formant_timbre"]: formant_timbre,
- translations["noise_scale"]: noise_scale,
- translations["nprobe"]: nprobe,
- translations["audio_upscaler"]: audio_upscaler
- }
-
- for key, value in log_data.items():
- logger.debug(f"{key}: {value}")
-
- if not pth_path or not os.path.exists(pth_path) or os.path.isdir(pth_path) or not pth_path.endswith((".pth", ".onnx")):
- logger.warning(translations["provide_file"].format(filename=translations["model"]))
- sys.exit(1)
-
- cvt = VoiceConverter(pth_path, sid, noise_scale, checkpointing)
-
- pid_path = os.path.join("assets", "convert_pid.txt")
- with open(pid_path, "w") as pid_file:
- pid_file.write(str(os.getpid()))
-
- def convert_audio(audio_path, output_audio):
- cvt.convert_audio(
- pitch=pitch,
- filter_radius=filter_radius,
- index_rate=index_rate,
- rms_mix_rate=rms_mix_rate,
- protect=protect,
- hop_length=hop_length,
- f0_method=f0_method,
- audio_input_path=audio_path,
- audio_output_path=output_audio,
- index_path=index_path,
- f0_autotune=f0_autotune,
- f0_autotune_strength=f0_autotune_strength,
- clean_audio=clean_audio,
- clean_strength=clean_strength,
- export_format=export_format,
- embedder_model=embedder_model,
- resample_sr=resample_sr,
- f0_file=f0_file,
- predictor_onnx=predictor_onnx,
- embedders_mode=embedders_mode,
- formant_shifting=formant_shifting,
- formant_qfrency=formant_qfrency,
- formant_timbre=formant_timbre,
- split_audio=split_audio,
- proposal_pitch=proposal_pitch,
- proposal_pitch_threshold=proposal_pitch_threshold,
- audio_processing=audio_processing,
- alpha=alpha,
- embedders_mix=embedders_mix,
- embedders_mix_layers=embedders_mix_layers,
- embedders_mix_ratio=embedders_mix_ratio,
- nprobe=nprobe,
- audio_upscaler=audio_upscaler
- )
-
- start_time = time.time()
-
- if os.path.isdir(input_path):
- logger.info(translations["convert_batch"])
-
- audio_files = [
- f
- for f in os.listdir(input_path)
- if f.lower().endswith(tuple(file_types))
- ]
-
- if not audio_files:
- logger.warning(translations["not_found_audio"])
- sys.exit(1)
-
- logger.info(translations["found_audio"].format(audio_files=len(audio_files)))
-
- for audio in audio_files:
- audio_path = os.path.join(input_path, audio)
- output_audio = os.path.join(input_path, os.path.splitext(audio)[0] + f"_output.{export_format}")
-
- logger.info(f"{translations['convert_audio']} '{audio_path}'...")
- if os.path.exists(output_audio): os.remove(output_audio)
-
- convert_audio(audio_path, output_audio)
-
- logger.info(
- translations["convert_batch_success"].format(
- elapsed_time=f"{(time.time() - start_time):.2f}",
- output_path=replace_export_format(output_path, export_format)
- )
- )
- else:
- if not os.path.exists(input_path):
- logger.warning(translations["not_found_audio"])
- sys.exit(1)
-
- logger.info(f"{translations['convert_audio']} '{input_path}'...")
- if os.path.exists(output_path): os.remove(output_path)
-
- convert_audio(input_path, output_path)
-
- logger.info(
- translations["convert_audio_success"].format(
- input_path=input_path,
- elapsed_time=f"{(time.time() - start_time):.2f}",
- output_path=replace_export_format(output_path, export_format)
- )
- )
-
- if os.path.exists(pid_path): os.remove(pid_path)
-
-class VoiceConverter:
- def __init__(
- self,
- model_path,
- sid = 0,
- noise_scale = 0.35,
- checkpointing = False
- ):
- self.config = config
- self.device = config.device
- self.hubert_model = None
- self.tgt_sr = None
- self.net_g = None
- self.vc = None
- self.cpt = None
- self.version = None
- self.n_spk = None
- self.use_f0 = None
- self.loaded_model = None
- self.index = None
- self.big_tsr = None
- self.vocoder = "Default"
- self.checkpointing = checkpointing
- self.sample_rate = 16000
- self.sid = sid
- self.noise_scale = noise_scale
- self.get_vc(model_path, sid)
-
- def convert_audio(
- self,
- audio_input_path,
- audio_output_path,
- index_path,
- embedder_model,
- pitch,
- f0_method,
- index_rate,
- rms_mix_rate,
- protect,
- hop_length,
- f0_autotune,
- f0_autotune_strength,
- filter_radius,
- clean_audio,
- clean_strength,
- export_format,
- resample_sr = 0,
- f0_file = None,
- predictor_onnx = False,
- embedders_mode = "fairseq",
- formant_shifting = False,
- formant_qfrency = 0.8,
- formant_timbre = 0.8,
- split_audio = False,
- proposal_pitch = False,
- proposal_pitch_threshold = 0,
- audio_processing = False,
- alpha = 0.5,
- embedders_mix = False,
- embedders_mix_layers = 9,
- embedders_mix_ratio = 0.5,
- nprobe = 1,
- audio_upscaler = False
- ):
- try:
- with tqdm(total=10, desc=translations["convert_audio"], ncols=100, unit="a", leave=not split_audio) as pbar:
- audio = load_audio(
- audio_input_path,
- sample_rate=self.sample_rate,
- formant_shifting=formant_shifting,
- formant_qfrency=formant_qfrency,
- formant_timbre=formant_timbre
- )
-
- if audio_processing:
- audio = preprocess(
- audio,
- self.sample_rate
- )
-
- try:
- audio_max = np.abs(audio).max() / 0.95
- if audio_max > 1: audio /= audio_max
- except:
- import shutil
-
- shutil.copy(audio_input_path, audio_output_path)
- return
-
- if self.hubert_model is None:
- models = load_embedders_model(embedder_model, embedders_mode)
- if isinstance(models, torch.nn.Module):
- models = models.to(self.device).to(torch.float16 if self.config.is_half else torch.float32).eval()
- if config.compile_all and embedders_mode != "whisper": models = torch.compile(models, mode=self.config.compile_mode)
- self.hubert_model = models
-
- if index_rate != 0 and (self.index is None or self.big_tsr is None):
- self.index, self.big_tsr = load_faiss_index(index_path.strip().strip('"').strip("\n").strip('"').strip().replace("trained", "added"), nprobe)
-
- pbar.update(1)
- if split_audio:
- pbar.close()
-
- chunks = cut(
- audio,
- self.sample_rate,
- db_thresh=-60,
- min_interval=500
- )
-
- logger.info(f"{translations['split_total']}: {len(chunks)}")
- pbar = tqdm(total=len(chunks) * 5 + 4, desc=translations["convert_audio"], ncols=100, unit="a", leave=True)
- else: chunks = [(audio, 0, 0)]
-
- pbar.update(1)
- converted_chunks = [
- (
- start,
- end,
- self.vc.pipeline(
- logger=logger,
- model=self.hubert_model,
- net_g=self.net_g,
- sid=self.sid,
- audio=waveform,
- f0_up_key=pitch,
- f0_method=f0_method,
- index=self.index,
- big_tsr=self.big_tsr,
- index_rate=index_rate,
- pitch_guidance=self.use_f0,
- filter_radius=filter_radius,
- rms_mix_rate=rms_mix_rate,
- version=self.version,
- protect=protect,
- hop_length=hop_length,
- f0_autotune=f0_autotune,
- f0_autotune_strength=f0_autotune_strength,
- f0_file=f0_file,
- predictor_onnx=predictor_onnx,
- pbar=pbar,
- proposal_pitch=proposal_pitch,
- proposal_pitch_threshold=proposal_pitch_threshold,
- energy_use=self.energy,
- alpha=alpha,
- embedders_mix=embedders_mix,
- embedders_mix_layers=embedders_mix_layers,
- embedders_mix_ratio=embedders_mix_ratio,
- )
- )
- for waveform, start, end in chunks
- ]
-
- pbar.update(1)
-
- audio_output = restore(
- converted_chunks,
- total_len=len(audio),
- dtype=converted_chunks[0][2].dtype
- ) if split_audio else converted_chunks[0][2]
-
- if audio_processing:
- audio_output = postprocess(
- audio_output,
- self.tgt_sr
- )
-
- if clean_audio:
- from main.library.audio.noisereduce import TorchGate
-
- if not hasattr(self, "tg"):
- self.tg = TorchGate(
- self.tgt_sr,
- prop_decrease=clean_strength
- ).to(self.device)
-
- audio_output = self.tg(
- torch.from_numpy(audio_output).unsqueeze(0).to(self.device).float()
- ).squeeze(0).cpu().detach().numpy()
-
- target_len = int(np.round(len(audio) / self.sample_rate * self.tgt_sr))
- if len(audio_output) != target_len: audio_output = signal.resample_poly(audio_output, target_len, len(audio_output))
-
- audio_output_resample = None
-
- if audio_upscaler:
- from main.library.audio.upscaler import FlashSR, upscaler
-
- if not hasattr(self, "flash_sr"):
- self.flash_sr = FlashSR(
- os.path.join("assets", "models", "upscalers", "upscalers.pth"),
- device=self.device,
- is_half=self.config.is_half
- )
-
- audio_output_resample = librosa.resample(
- audio_output,
- orig_sr=self.tgt_sr,
- target_sr=192000,
- res_type="soxr_vhq"
- )
-
- audio_output_resample = upscaler(audio_output_resample, self.flash_sr, pbar, device=self.device)
- audio_output_resample = audio_output_resample.float().flatten().cpu().detach().numpy()
- self.tgt_sr = 192000
- elif self.tgt_sr != resample_sr and resample_sr > 0:
- audio_output_resample = librosa.resample(
- audio_output,
- orig_sr=self.tgt_sr,
- target_sr=resample_sr,
- res_type="soxr_vhq"
- )
-
- self.tgt_sr = resample_sr
-
- pbar.update(1)
-
- try:
- sf.write(
- audio_output_path,
- audio_output if audio_output_resample is None else audio_output_resample,
- self.tgt_sr,
- format=export_format
- )
- except:
- logger.info(translations["sr_not_support"])
-
- sf.write(
- audio_output_path,
- librosa.resample(
- audio_output,
- orig_sr=self.tgt_sr,
- target_sr=48000,
- res_type="soxr_vhq"
- ),
- 48000,
- format=export_format
- )
-
- pbar.update(1)
- except Exception as e:
- import traceback
-
- logger.debug(traceback.format_exc())
- logger.error(translations["error_convert"].format(e=e))
-
- def get_vc(self, weight_root, sid):
- if sid == "" or sid == []:
- self.cleanup()
- clear_gpu_cache()
-
- if not self.loaded_model or self.loaded_model != weight_root:
- self.loaded_model = weight_root
- self.cpt = load_model(weight_root)
- if self.cpt is not None: self.setup()
-
- def cleanup(self):
- if self.hubert_model is not None:
- del self.net_g, self.n_spk, self.vc, self.hubert_model, self.tgt_sr, self.index, self.big_tsr
- self.hubert_model = self.net_g = self.n_spk = self.vc = self.tgt_sr = self.index = self.big_tsr = None
- clear_gpu_cache()
-
- del self.net_g, self.cpt
- clear_gpu_cache()
- self.cpt = None
-
- def setup(self):
- if self.cpt is not None:
- if self.loaded_model.endswith(".pth"):
- from main.library.algorithm.synthesizers import Synthesizer, SynthesizerSVC
-
- self.tgt_sr = self.cpt["config"][-1]
- self.cpt["config"][-3] = self.cpt["weight"]["emb_g.weight"].shape[0]
-
- self.use_f0 = self.cpt.get("f0", 1)
- self.version = self.cpt.get("version", "v1")
- self.vocoder = self.cpt.get("vocoder", "Default")
- self.energy = self.cpt.get("energy", False)
- self.architecture = self.cpt.get("architecture", "RVC")
-
- if self.vocoder != "Default": self.config.is_half = False
-
- if self.architecture == "RVC":
- self.net_g = Synthesizer(
- *self.cpt["config"],
- use_f0=self.use_f0,
- text_enc_hidden_dim=768 if self.version == "v2" else 256,
- vocoder=self.vocoder,
- checkpointing=self.checkpointing,
- energy=self.energy
- )
- else:
- self.net_g = SynthesizerSVC(
- *self.cpt["config"],
- text_enc_hidden_dim=768 if self.version == "v2" else 256,
- vocoder=self.vocoder,
- checkpointing=self.checkpointing,
- noise_scale=self.noise_scale
- )
-
- del self.net_g.enc_q
-
- self.net_g.load_state_dict(self.cpt["weight"], strict=False)
- self.net_g.eval().to(self.device)
- self.net_g.to(torch.float16 if self.config.is_half else torch.float32)
- if config.compile_all: self.net_g = torch.compile(self.net_g, mode=self.config.compile_mode)
- self.n_spk = self.cpt["config"][-3]
- else:
- self.net_g = self.cpt.to(config.device)
- self.tgt_sr = self.cpt.cpt.get("tgt_sr", 32000)
- self.use_f0 = self.cpt.cpt.get("f0", 1)
- self.version = self.cpt.cpt.get("version", "v1")
- self.energy = self.cpt.cpt.get("energy", False)
-
- self.vc = Pipeline(self.tgt_sr, self.config)
-
-if __name__ == "__main__": main()
\ No newline at end of file
diff --git a/main/inference/conversion/pipeline.py b/main/inference/conversion/pipeline.py
deleted file mode 100644
index 8d093c63b7029d63e7c7d541e19af8ff109fa2e7..0000000000000000000000000000000000000000
--- a/main/inference/conversion/pipeline.py
+++ /dev/null
@@ -1,316 +0,0 @@
-import os
-import sys
-import torch
-
-import numpy as np
-import torch.nn.functional as F
-
-from scipy import signal
-
-sys.path.append(os.getcwd())
-
-from main.library.audio.features import change_rms
-from main.app.variables import translations, configs
-from main.library.utils import extract_features, clear_gpu_cache
-
-bh, ah = signal.butter(
- N=5,
- Wn=48,
- btype="high",
- fs=16000
-)
-
-class Pipeline:
- def __init__(
- self,
- tgt_sr,
- config
- ):
- self.x_pad = config.x_pad
- self.x_query = config.x_query
- self.x_center = config.x_center
- self.x_max = config.x_max
- self.sample_rate = 16000
- self.window = 160
- self.t_pad = self.sample_rate * self.x_pad
- self.t_pad_tgt = tgt_sr * self.x_pad
- self.t_pad2 = self.t_pad * 2
- self.t_query = self.sample_rate * self.x_query
- self.t_center = self.sample_rate * self.x_center
- self.t_max = self.sample_rate * self.x_max
- self.f0_min = configs.get("f0_min", 50)
- self.f0_max = configs.get("f0_max", 1100)
- self.device = config.device
- self.is_half = config.is_half
- self.dtype = torch.float16 if self.is_half else torch.float32
- self.tgt_sr = tgt_sr
-
- def voice_conversion(
- self,
- model,
- net_g,
- sid,
- audio0,
- pitch,
- pitchf,
- index,
- big_tsr,
- index_rate,
- version,
- protect,
- energy,
- embedders_mix = False,
- embedders_mix_layers = 9,
- embedders_mix_ratio = 0.5
- ):
- pitch_guidance = pitch is not None and pitchf is not None
- energy_use = energy is not None
-
- feats = torch.from_numpy(audio0).to(self.device).to(self.dtype)
- feats = feats.mean(-1) if feats.dim() == 2 else feats
- assert feats.dim() == 1, feats.dim()
-
- with torch.no_grad():
- feats = extract_features(
- model,
- feats.view(1, -1),
- version,
- mix=embedders_mix,
- mix_layers=embedders_mix_layers,
- mix_ratio=embedders_mix_ratio
- )
-
- feats0 = feats.clone() if protect < 0.5 and pitch_guidance else None
-
- if index is not None and big_tsr is not None and index_rate != 0:
- score, ix = index.search(feats[0], k=8)
- weight = (1 / score).square()
- query = (big_tsr[ix] * (weight / weight.sum(dim=1, keepdim=True)).unsqueeze(2)).sum(dim=1)
- feats = query.unsqueeze(0) * index_rate + (1.0 - index_rate) * feats
-
- feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
- p_len = min(audio0.shape[0] // self.window, feats.shape[1])
-
- if pitch_guidance: pitch, pitchf = pitch[:, :p_len], pitchf[:, :p_len]
- if energy_use: energy = energy[:p_len].unsqueeze(0)
-
- if feats0 is not None:
- pitchff = pitchf.clone()
- pitchff[pitchf > 0] = 1
- pitchff[pitchf < 1] = protect
- pitchff = pitchff.unsqueeze(-1)
-
- feats0 = F.interpolate(feats0.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
- feats = (feats * pitchff + feats0 * (1 - pitchff)).to(feats0.dtype)
-
- p_len = torch.tensor([p_len], device=self.device).long()
- feats = feats.to(self.dtype)
-
- audio1 = net_g.infer(
- feats,
- p_len,
- pitch if pitch_guidance else None,
- pitchf.to(self.dtype) if pitch_guidance else None,
- sid,
- energy.to(self.dtype) if energy_use else None
- )[0][0, 0].data.cpu().float().numpy()
-
- del feats, feats0, p_len
-
- clear_gpu_cache()
- return audio1
-
- def pipeline(
- self,
- logger,
- model,
- net_g,
- sid,
- audio,
- f0_up_key,
- f0_method,
- index,
- big_tsr,
- index_rate,
- pitch_guidance,
- filter_radius,
- rms_mix_rate,
- version,
- protect,
- hop_length,
- f0_autotune,
- f0_autotune_strength,
- f0_file=None,
- predictor_onnx=False,
- pbar=None,
- proposal_pitch=False,
- proposal_pitch_threshold=255.0,
- energy_use=False,
- alpha = 0.5,
- embedders_mix = False,
- embedders_mix_layers = 9,
- embedders_mix_ratio = 0.5,
- ):
- opt_ts, audio_opt = [], []
- audio = signal.filtfilt(bh, ah, audio)
- audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode="reflect")
-
- if audio_pad.shape[0] > self.t_max:
- audio_sum = np.zeros_like(audio)
-
- for i in range(self.window):
- audio_sum += audio_pad[i : i - self.window]
-
- for t in range(self.t_center, audio.shape[0], self.t_center):
- opt_ts.append(
- t - self.t_query + np.where(np.abs(audio_sum[t - self.t_query : t + self.t_query]) == np.abs(audio_sum[t - self.t_query : t + self.t_query]).min())[0][0]
- )
-
- pbar.update(1)
-
- s = 0
- t, inp_f0 = None, None
- audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode="reflect")
- sid = torch.tensor(sid, device=self.device).unsqueeze(0).long()
- p_len = audio_pad.shape[0] // self.window
-
- if f0_file and os.path.exists(f0_file) and f0_file.endswith(".txt"):
- try:
- with open(f0_file, "r") as f:
- raw_lines = f.read()
-
- if len(raw_lines) > 0:
- inp_f0 = []
-
- for line in raw_lines.strip("\n").split("\n"):
- inp_f0.append([float(i) for i in line.split(",")])
-
- inp_f0 = np.array(inp_f0, dtype=np.float32)
- except:
- logger.error(translations["error_readfile"])
- inp_f0 = None
-
- pbar.update(1)
-
- if pitch_guidance:
- if not hasattr(self, "f0_generator"):
- from main.library.predictors.Generator import Generator
-
- self.f0_generator = Generator(
- self.sample_rate,
- hop_length,
- self.f0_min,
- self.f0_max,
- alpha,
- self.is_half,
- self.device,
- predictor_onnx
- )
-
- pitch, pitchf = self.f0_generator.calculator(
- self.x_pad,
- f0_method,
- audio_pad,
- f0_up_key,
- p_len,
- filter_radius,
- f0_autotune,
- f0_autotune_strength,
- manual_f0=inp_f0,
- proposal_pitch=proposal_pitch,
- proposal_pitch_threshold=proposal_pitch_threshold
- )
-
- if self.device == "mps": pitchf = pitchf.astype(np.float32)
-
- pitch, pitchf = (
- torch.tensor(pitch[:p_len], device=self.device).unsqueeze(0).long(),
- torch.tensor(pitchf[:p_len], device=self.device).unsqueeze(0).float()
- )
-
- pbar.update(1)
-
- if energy_use:
- if not hasattr(self, "rms_extract"):
- from main.inference.extracting.rms import RMSEnergyExtractor
-
- self.rms_extract = RMSEnergyExtractor(
- frame_length=2048,
- hop_length=self.window,
- center=True,
- pad_mode = "reflect"
- ).to(self.device).eval()
-
- energy = self.rms_extract(
- torch.from_numpy(audio_pad).to(self.device).unsqueeze(0)
- )[:p_len].to(self.device).float()
-
- pbar.update(1)
- pbar.total = pbar.total + len(opt_ts)
- pbar.refresh()
-
- for t in opt_ts:
- t = t // self.window * self.window
- audio_opt.append(
- self.voice_conversion(
- model,
- net_g,
- sid,
- audio_pad[s : t + self.t_pad2 + self.window],
- pitch[:, s // self.window : (t + self.t_pad2) // self.window] if pitch_guidance else None,
- pitchf[:, s // self.window : (t + self.t_pad2) // self.window] if pitch_guidance else None,
- index,
- big_tsr,
- index_rate,
- version,
- protect,
- energy[:, s // self.window : (t + self.t_pad2) // self.window] if energy_use else None,
- embedders_mix=embedders_mix,
- embedders_mix_layers=embedders_mix_layers,
- embedders_mix_ratio=embedders_mix_ratio
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- s = t
- pbar.update(1)
-
- audio_opt.append(
- self.voice_conversion(
- model,
- net_g,
- sid,
- audio_pad[t:],
- (pitch[:, t // self.window :] if t is not None else pitch) if pitch_guidance else None,
- (pitchf[:, t // self.window :] if t is not None else pitchf) if pitch_guidance else None,
- index,
- big_tsr,
- index_rate,
- version,
- protect,
- (energy[:, t // self.window :] if t is not None else energy) if energy_use else None,
- embedders_mix=embedders_mix,
- embedders_mix_layers=embedders_mix_layers,
- embedders_mix_ratio=embedders_mix_ratio
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
-
- pbar.update(1)
-
- audio_opt = np.concatenate(audio_opt)
- if rms_mix_rate != 1:
- audio_opt = change_rms(
- audio,
- self.sample_rate,
- audio_opt,
- self.tgt_sr,
- rms_mix_rate,
- device=self.device
- ).cpu().numpy()
-
- audio_max = np.abs(audio_opt).max() / 0.99
- if audio_max > 1: audio_opt /= audio_max
-
- if pitch_guidance: del pitch, pitchf
- del sid
-
- clear_gpu_cache()
- return audio_opt
\ No newline at end of file
diff --git a/main/inference/create_dataset.py b/main/inference/create_dataset.py
deleted file mode 100644
index 5a15a1403933b47e91054537612e6a1e5db1f2d1..0000000000000000000000000000000000000000
--- a/main/inference/create_dataset.py
+++ /dev/null
@@ -1,449 +0,0 @@
-import os
-import sys
-import time
-import torch
-import yt_dlp
-import shutil
-import librosa
-import argparse
-import warnings
-
-import numpy as np
-import soundfile as sf
-
-from urllib.parse import urlparse
-
-sys.path.append(os.getcwd())
-
-from main.library.utils import strtobool
-from main.inference.separate_music import _separate
-from main.app.variables import config, logger, translations
-
-dataset_temp = "dataset_temp"
-
-def parse_arguments():
- parser = argparse.ArgumentParser()
- parser.add_argument("--create_dataset", action='store_true')
- parser.add_argument("--input_data", type=str, required=True)
- parser.add_argument("--output_dirs", type=str, default="./dataset")
- parser.add_argument("--skip_seconds", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--skip_start_audios", type=str, default="0")
- parser.add_argument("--skip_end_audios", type=str, default="0")
- parser.add_argument("--separate", type=lambda x: bool(strtobool(x)), default=True)
- parser.add_argument("--model_name", type=str, default="MDXNET_Main")
- parser.add_argument("--reverb_model", type=str, default="MDX-Reverb")
- parser.add_argument("--denoise_model", type=str, default="Normal")
- parser.add_argument("--sample_rate", type=int, default=48000)
- parser.add_argument("--shifts", type=int, default=2)
- parser.add_argument("--batch_size", type=int, default=1)
- parser.add_argument("--overlap", type=float, default=0.25)
- parser.add_argument("--aggression", type=int, default=5)
- parser.add_argument("--hop_length", type=int, default=1024)
- parser.add_argument("--window_size", type=int, default=512)
- parser.add_argument("--segments_size", type=int, default=256)
- parser.add_argument("--post_process_threshold", type=float, default=0.2)
- parser.add_argument("--enable_tta", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--enable_denoise", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--high_end_process", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--enable_post_process", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--separate_reverb", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--clean_dataset", type=lambda x: bool(strtobool(x)), default=False)
- parser.add_argument("--clean_strength", type=float, default=0.7)
-
- return parser.parse_args()
-
-def main():
- args = parse_arguments()
-
- (
- input_data,
- output_dirs,
- skip_seconds,
- skip_start_audios,
- skip_end_audios,
- separate,
- model_name,
- reverb_model,
- denoise_model,
- sample_rate,
- shifts,
- batch_size,
- overlap,
- aggression,
- hop_length,
- window_size,
- segments_size,
- post_process_threshold,
- enable_tta,
- enable_denoise,
- high_end_process,
- enable_post_process,
- separate_reverb,
- clean_dataset,
- clean_strength
- ) = (
- args.input_data,
- args.output_dirs,
- args.skip_seconds,
- args.skip_start_audios,
- args.skip_end_audios,
- args.separate,
- args.model_name,
- args.reverb_model,
- args.denoise_model,
- args.sample_rate,
- args.shifts,
- args.batch_size,
- args.overlap,
- args.aggression,
- args.hop_length,
- args.window_size,
- args.segments_size,
- args.post_process_threshold,
- args.enable_tta,
- args.enable_denoise,
- args.high_end_process,
- args.enable_post_process,
- args.separate_reverb,
- args.clean_dataset,
- args.clean_strength
- )
-
- create_dataset(
- input_data,
- output_dirs,
- skip_seconds,
- skip_start_audios,
- skip_end_audios,
- separate,
- model_name,
- reverb_model,
- denoise_model,
- sample_rate,
- shifts,
- batch_size,
- overlap,
- aggression,
- hop_length,
- window_size,
- segments_size,
- post_process_threshold,
- enable_tta,
- enable_denoise,
- high_end_process,
- enable_post_process,
- separate_reverb,
- clean_dataset,
- clean_strength
- )
-
-def create_dataset(
- input_data,
- output_dirs,
- skip_seconds,
- skip_start_audios,
- skip_end_audios,
- separate,
- model_name,
- reverb_model="MDX-Reverb",
- denoise_model="Normal",
- sample_rate=48000,
- shifts=2,
- batch_size=1,
- overlap=0.25,
- aggression=5,
- hop_length=1024,
- window_size=512,
- segments_size=256,
- post_process_threshold=0.2,
- enable_tta=False,
- enable_denoise=False,
- high_end_process=False,
- enable_post_process=False,
- separate_reverb=False,
- clean_dataset=False,
- clean_strength=0.7
-):
- log_data = {
- translations["audio_path"]: input_data,
- translations["output_path"]: output_dirs,
- translations["skip"]: skip_seconds,
- translations["separator_tab"]: separate,
- translations["modelname"]: model_name,
- translations["dereveb_audio"]: separate_reverb,
- translations["sr"]: sample_rate,
- translations["shift"]: shifts,
- translations["batch_size"]: batch_size,
- translations["overlap"]: overlap,
- translations["aggression"]: aggression,
- translations["hop_length"]: hop_length,
- translations["window_size"]: window_size,
- translations["segments_size"]: segments_size,
- translations["post_process_threshold"]: post_process_threshold,
- translations["enable_tta"]: enable_tta,
- translations["denoise_mdx"]: enable_denoise,
- translations["high_end_process"]: high_end_process,
- translations["enable_post_process"]: enable_post_process,
- translations["clear_dataset"]: clean_dataset,
- translations["clean_strength"]: clean_strength,
- translations["dereveb_model"]: reverb_model,
- translations["denoise_model"]: denoise_model,
- translations["skip_start"]: skip_start_audios,
- translations["skip_end"]: skip_end_audios
- }
-
- for key, value in log_data.items():
- logger.debug(f"{key}: {value}")
-
- start_time = time.time()
- inputs_data = input_data.replace(", ", ",").split(",")
-
- pid_path = os.path.join("assets", "create_dataset_pid.txt")
- with open(pid_path, "w") as pid_file:
- pid_file.write(str(os.getpid()))
-
- try:
- if os.path.exists(dataset_temp): shutil.rmtree(dataset_temp, ignore_errors=True)
- else: os.makedirs(dataset_temp, exist_ok=True)
-
- audio_path = [
- downloader(
- url,
- f"audio_{str(inputs_data.index(url))}"
- ) if is_url(url) else url
- for url in inputs_data
- ]
-
- if skip_seconds:
- skip_start_audios, skip_end_audios = (
- skip_start_audios.replace(", ", ",").split(","),
- skip_end_audios.replace(", ", ",").split(",")
- )
-
- if len(skip_start_audios) < len(audio_path) or len(skip_end_audios) < len(audio_path):
- logger.warning(translations["skip |