Upload Complited files

.github/workflows/code_formatter.yml

@@ -0,0 +1,51 @@
+name: Code Formatter
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  push_format:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{github.ref_name}}
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Black
+        run: pip install "black[jupyter]"
+
+      - name: Run Black
+        # run: black $(git ls-files '*.py')
+        run: black . --exclude=".*\.ipynb$"
+
+      - name: Commit Back
+        continue-on-error: true
+        id: commitback
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git add --all
+          git commit -m "chore(format): run black on ${{github.ref_name}}"
+
+      - name: Create Pull Request
+        if: steps.commitback.outcome == 'success'
+        continue-on-error: true
+        uses: peter-evans/create-pull-request@v5
+        with:
+          delete-branch: true
+          body: "Automatically apply code formatter change"
+          title: "chore(format): run black on ${{github.ref_name}}"
+          commit-message: "chore(format): run black on ${{github.ref_name}}"
+          branch: formatter/${{github.ref_name}}

.gitignore

@@ -0,0 +1,166 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# mine
+.flac
+.pth
+.pt

LICENSE.md

@@ -0,0 +1,25 @@
+
+
+##  KindaHex Non-Commercial Use License (HNCU)
+
+
+This repository is licensed under the **KindaHex Non-Commercial Use License (HNCU)**. By using, modifying, or distributing any content from this repository, you agree to the terms outlined below.
+
+### Terms of Use:
+1. **Non-Commercial Use Only**: You are permitted to use, modify, and distribute the contents of this repository **only for non-commercial purposes**. Commercial use, including selling, licensing, or distributing for profit, is strictly prohibited.
+   
+2. **Modification and Derivative Works**: You may modify the contents of this repository and create derivative works. However, any modification or derivative work must also adhere to the non-commercial restriction and be subject to the terms of this license.
+
+3. **Attribution**: When using or distributing the content (either as-is or modified), you must provide proper attribution to the original creator (blane187gt) in a manner that is reasonable and customary for the medium.
+
+4. **No Warranty**: The content in this repository is provided "as-is," without any warranty, express or implied, including but not limited to warranties of merchantability or fitness for a particular purpose.
+
+5. **Compliance with Laws**: You are responsible for ensuring that your use of the content complies with all applicable laws and regulations.
+
+6. **Termination**: If you violate any of the terms of this license, your rights to use the repository’s content will be automatically terminated. You must cease all use and distribution of the content immediately upon termination.
+
+### Restrictions:
+- You may **not** use this repository's content for commercial gain, including but not limited to creating products, services, or tools that are sold or monetized.
+- You may **not** sublicense or transfer rights to third parties for commercial purposes.
+- You may not use the content in any manner that competes with the original repository or its creator.
+

README.md

@@ -1,3 +1,43 @@
----
-license: mit
----
+# HexGen RVC
+
+
+https://colab.research.google.com/drive/1dmGS0vEWuX55Z1w1tSRD6lJDV8s2deY0?usp=sharing
+
+HexGen RVC is a tool designed for generating high-quality AI vocal covers using advanced source separation, vocal modeling, and audio processing techniques. This project builds on several community-driven efforts, integrating the best tools and frameworks available for music and vocal manipulation.
+
+## Features
+- **AI-Driven Vocal Cover Generation**: Produce custom vocal covers with ease.
+- **Source Separation**: Isolate instrumentals and vocals from any track.
+- **Efficient Workflow**: Streamlined integration with popular tools for music processing.
+- **Colab Support**: Easily deploy and test models in Google Colab environments.
+
+## Installation
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/blane187gt/hexGen-RVC.git
+   cd hexGen-RVC
+   ```
+2. Follow specific setup instructions provided in the [documentation](https://github.com/blane187gt/hexGen-RVC/wiki) (if available) or in the code comments.
+
+## Usage
+1. Prepare your audio input file(s) and place them in the appropriate folder.
+2. Run the script or Colab notebook as per the instructions.
+3. Customize the output by tweaking the parameters and models used.
+
+## Credits
+This project would not have been possible without the contributions and support of the following tools and creators:
+
+- [Audio Separator](https://github.com/karaokenerds/python-audio-separator) by [Andrew Beveridge](https://github.com/beveradb)
+- [Applio](https://github.com/IAHispano/Applio) by [IAHispano](https://github.com/IAHispano)
+- [yt-dlp](https://github.com/yt-dlp/yt-dlp)
+- [Ultimate Vocal Remover GUI](https://github.com/Anjok07/ultimatevocalremovergui) by [Anjok07](https://github.com/Anjok07)
+- [Music Source Separation Universal Training Code](https://github.com/ZFTurbo/Music-Source-Separation-Training) by [ZFTurbo](https://github.com/ZFTurbo)
+- [AICoverGen](https://github.com/SociallyIneptWeeb/AICoverGen) by [SociallyIneptWeeb](https://github.com/SociallyIneptWeeb)
+- [FullmatheusBallZ](https://www.youtube.com/@FullmatheusBallZ) for testing the Colab scripts.
+- [Shirou](https://github.com/ShiromiyaG), the original project inspiration.
+
+## Contributing
+Feel free to submit pull requests or create issues for any improvements or bugs you encounter. Contributions are always welcome!
+
+## License
+This project is licensed under the terms specified in the `LICENSE` file. Ensure compliance with third-party dependencies when using or modifying this project.

assets/config.json

@@ -0,0 +1,6 @@
+{
+  "lang": {
+    "override": false,
+    "selected_lang": "en_US"
+  }
+}

assets/i18n/i18n.py

@@ -0,0 +1,52 @@
+import os, sys
+import json
+from pathlib import Path
+from locale import getdefaultlocale
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+
+class I18nAuto:
+    LANGUAGE_PATH = os.path.join(now_dir, "assets", "i18n", "languages")
+
+    def __init__(self, language=None):
+        with open(
+            os.path.join(now_dir, "assets", "config.json"), "r", encoding="utf8"
+        ) as file:
+            config = json.load(file)
+            override = config["lang"]["override"]
+            lang_prefix = config["lang"]["selected_lang"]
+
+        self.language = lang_prefix
+
+        if override == False:
+            language = language or getdefaultlocale()[0]
+            lang_prefix = language[:2] if language is not None else "en"
+            available_languages = self._get_available_languages()
+            matching_languages = [
+                lang for lang in available_languages if lang.startswith(lang_prefix)
+            ]
+            self.language = matching_languages[0] if matching_languages else "en_US"
+
+        self.language_map = self._load_language_list()
+
+    def _load_language_list(self):
+        try:
+            file_path = Path(self.LANGUAGE_PATH) / f"{self.language}.json"
+            with open(file_path, "r", encoding="utf-8") as file:
+                return json.load(file)
+        except FileNotFoundError:
+            raise FileNotFoundError(
+                f"Failed to load language file for {self.language}. Check if the correct .json file exists."
+            )
+
+    def _get_available_languages(self):
+        language_files = [path.stem for path in Path(self.LANGUAGE_PATH).glob("*.json")]
+        return language_files
+
+    def _language_exists(self, language):
+        return (Path(self.LANGUAGE_PATH) / f"{language}.json").exists()
+
+    def __call__(self, key):
+        return self.language_map.get(key, key)

assets/i18n/languages/en_US.json

@@ -0,0 +1,89 @@
+{
+    "Voice Model": "Voice Model",
+    "Select the voice model to use for the conversion.": "Select the voice model to use for the conversion.",
+    "Index File": "Index File",
+    "Select the index file to use for the conversion.": "Select the index file to use for the conversion.",
+    "Refresh": "Refresh",
+    "Unload Voice": "Unload Voice",
+    "Upload Audio": "Upload Audio",
+    "Select Audio": "Select Audio",
+    "Select the audio to convert.": "Select the audio to convert.",
+    "Advanced Settings": "Advanced Settings",
+    "RVC Settings": "RVC Settings",
+    "Output Path": "Output Path",
+    "Enter output path": "Enter output path",
+    "The path where the output audio will be saved, by default in audio_files/rvc/output.wav": "The path where the output audio will be saved, by default in audio_files/rvc/output.wav",
+    "Clear Outputs (Deletes all audios in assets/audios)": "Clear Outputs (Deletes all audios in assets/audios)",
+    "Export Format": "Export Format",
+    "Select the format to export the audio.": "Select the format to export the audio.",
+    "Split Audio": "Split Audio",
+    "Split the audio into chunks for inference to obtain better results in some cases.": "Split the audio into chunks for inference to obtain better results in some cases.",
+    "Pitch Extractor": "Pitch Extractor",
+    "Pitch extract Algorith.": "Pitch extract Algorith.",
+    "Hop Length": "Hop Length",
+    "Hop length for pitch extraction.": "Hop length for pitch extraction.",
+    "Embedder Model": "Embedder Model",
+    "Model used for learning speaker embedding.": "Model used for learning speaker embedding.",
+    "Autotune": "Autotune",
+    "Apply a soft autotune to your inferences, recommended for singing conversions.": "Apply a soft autotune to your inferences, recommended for singing conversions.",
+    "Pitch": "Pitch",
+    "Adjust the pitch of the audio.": "Adjust the pitch of the audio.",
+    "Filter Radius": "Filter Radius",
+    "If the number is greater than or equal to three, employing median filtering on the collected tone results has the potential to decrease respiration.": "If the number is greater than or equal to three, employing median filtering on the collected tone results has the potential to decrease respiration.",
+    "Search Feature Ratio": "Search Feature Ratio",
+    "Influence exerted by the index file; a higher value corresponds to greater influence. However, opting for lower values can help mitigate artifacts present in the audio.": "Influence exerted by the index file; a higher value corresponds to greater influence. However, opting for lower values can help mitigate artifacts present in the audio.",
+    "Volume Envelope": "Volume Envelope",
+    "Substitute or blend with the volume envelope of the output. The closer the ratio is to 1, the more the output envelope is employed.": "Substitute or blend with the volume envelope of the output. The closer the ratio is to 1, the more the output envelope is employed.",
+    "Protect Voiceless Consonants": "Protect Voiceless Consonants",
+    "Safeguard distinct consonants and breathing sounds to prevent electro-acoustic tearing and other artifacts. Pulling the parameter to its maximum value of 0.5 offers comprehensive protection. However, reducing this value might decrease the extent of protection while potentially mitigating the indexing effect.": "Safeguard distinct consonants and breathing sounds to prevent electro-acoustic tearing and other artifacts. Pulling the parameter to its maximum value of 0.5 offers comprehensive protection. However, reducing this value might decrease the extent of protection while potentially mitigating the indexing effect.",
+    "Audio Separation Settings": "Audio Separation Settings",
+    "Use TTA": "Use TTA",
+    "Use Test Time Augmentation.": "Use Test Time Augmentation.",
+    "Batch Size": "Batch Size",
+    "Set the batch size for the separation.": "Set the batch size for the separation.",
+    "Vocals Model": "Vocals Model",
+    "Select the vocals model to use for the separation.": "Select the vocals model to use for the separation.",
+    "Karaoke Model": "Karaoke Model",
+    "Select the karaoke model to use for the separation.": "Select the karaoke model to use for the separation.",
+    "Dereverb Model": "Dereverb Model",
+    "Select the dereverb model to use for the separation.": "Select the dereverb model to use for the separation.",
+    "Deeecho": "Deeecho",
+    "Apply deeecho to the audio.": "Apply deeecho to the audio.",
+    "Deeecho Model": "Deeecho Model",
+    "Select the deeecho model to use for the separation.": "Select the deeecho model to use for the separation.",
+    "Denoise": "Denoise",
+    "Apply denoise to the audio.": "Apply denoise to the audio.",
+    "Denoise Model": "Denoise Model",
+    "Select the denoise model to use for the separation.": "Select the denoise model to use for the separation.",
+    "Audio post-process Settings": "Audio post-process Settings",
+    "Delete Audios": "Delete Audios",
+    "Delete the audios after the conversion.": "Delete the audios after the conversion.",
+    "Reverb": "Reverb",
+    "Apply reverb to the audio.": "Apply reverb to the audio.",
+    "Reverb Room Size": "Reverb Room Size",
+    "Set the room size of the reverb.": "Set the room size of the reverb.",
+    "Reverb Damping": "Reverb Damping",
+    "Set the damping of the reverb.": "Set the damping of the reverb.",
+    "Reverb Wet Gain": "Reverb Wet Gain",
+    "Set the wet gain of the reverb.": "Set the wet gain of the reverb.",
+    "Reverb Dry Gain": "Reverb Dry Gain",
+    "Set the dry gain of the reverb.": "Set the dry gain of the reverb.",
+    "Reverb Width": "Reverb Width",
+    "Set the width of the reverb.": "Set the width of the reverb.",
+    "Vocals Volume": "Vocals Volume",
+    "Adjust the volume of the vocals.": "Adjust the volume of the vocals.",
+    "Instrumentals Volume": "Instrumentals Volume",
+    "Adjust the volume of the Instrumentals.": "Adjust the volume of the Instrumentals.",
+    "Backing Vocals Volume": "Backing Vocals Volume",
+    "Adjust the volume of the backing vocals.": "Adjust the volume of the backing vocals.",
+    "Device Settings": "Device Settings",
+    "Device": "Device",
+    "Select the device to use for the conversion. 0 to ∞ separated by - and for CPU leave only an -": "Select the device to use for the conversion. 0 to ∞ separated by - and for CPU leave only an -",
+    "Convert": "Convert",
+    "Output Information": "Output Information",
+    "The output information will be displayed here.": "The output information will be displayed here.",
+    "Export Audio": "Export Audio",
+    "Music URL": "Music URL",
+    "Download": "Download",
+    "Model URL": "Model URL"
+}

assets/i18n/languages/pt_BR.json

@@ -0,0 +1,89 @@
+{
+    "Voice Model": "Modelo de Voz",
+    "Select the voice model to use for the conversion.": "Selecione o modelo de voz a ser usado para a conversão.",
+    "Index File": "Arquivo Index",
+    "Select the index file to use for the conversion.": "Selecione o arquivo Index a ser usado para a conversão.",
+    "Refresh": "Atualizar",
+    "Unload Voice": "Descarregar Voz",
+    "Upload Audio": "Carregar Áudio",
+    "Select Audio": "Selecionar Áudio",
+    "Select the audio to convert.": "Selecione o áudio a ser convertido.",
+    "Advanced Settings": "Configurações Avançadas",
+    "RVC Settings": "Configurações RVC",
+    "Output Path": "Caminho de Saída",
+    "Enter output path": "Insira o caminho de saída",
+    "The path where the output audio will be saved, by default in audio_files/rvc/output.wav": "O caminho onde o áudio de saída será salvo, por padrão em audio_files/rvc/output.wav",
+    "Clear Outputs (Deletes all audios in assets/audios)": "Limpar Saídas (Exclui todos os áudios em assets/audios)",
+    "Export Format": "Formato de Exportação",
+    "Select the format to export the audio.": "Selecione o formato para exportar o áudio.",
+    "Split Audio": "Dividir Áudio",
+    "Split the audio into chunks for inference to obtain better results in some cases.": "Divida o áudio em partes para inferência para obter melhores resultados em alguns casos.",
+    "Pitch Extractor": "Extrator de Pitch",
+    "Pitch extract Algorith.": "Algoritmo de Extração de Pitch",
+    "Hop Length": "Hop Length",
+    "Hop length for pitch extraction.": "Hop Length para extração de pitch.",
+    "Embedder Model": "Modelo de Embedding",
+    "Model used for learning speaker embedding.": "Modelo usado para aprendizado de embedding de locutor.",
+    "Autotune": "Autotune",
+    "Apply a soft autotune to your inferences, recommended for singing conversions.": "Aplique um autotune suave às suas inferências, recomendado para conversões de canto.",
+    "Pitch": "Pitch",
+    "Adjust the pitch of the audio.": "Ajuste o pitch do áudio.",
+    "Filter Radius": "Raio do Filtro",
+    "If the number is greater than or equal to three, employing median filtering on the collected tone results has the potential to decrease respiration.": "Se o número for maior ou igual a três, o uso de filtragem mediana nos resultados de tom coletados tem o potencial de diminuir a respiração.",
+    "Search Feature Ratio": "Proporção da Função de Busca",
+    "Influence exerted by the index file; a higher value corresponds to greater influence. However, opting for lower values can help mitigate artifacts present in the audio.": "Influência exercida pelo arquivo de índice; um valor mais alto corresponde a maior influência. No entanto, optar por valores mais baixos pode ajudar a mitigar artefatos presentes no áudio.",
+    "Volume Envelope": "Envelope de Volume",
+    "Substitute or blend with the volume envelope of the output. The closer the ratio is to 1, the more the output envelope is employed.": "Substitua ou misture com o envelope de volume da saída. Quanto mais próximo o valor estiver de 1, mais o envelope de saída será empregado.",
+    "Protect Voiceless Consonants": "Proteger Consoantes Surdas",
+    "Safeguard distinct consonants and breathing sounds to prevent electro-acoustic tearing and other artifacts. Pulling the parameter to its maximum value of 0.5 offers comprehensive protection. However, reducing this value might decrease the extent of protection while potentially mitigating the indexing effect.": "Proteja consoantes distintas e sons de respiração para evitar rasgos eletroacústicos e outros artefatos. Ajustar o parâmetro para seu valor máximo de 0,5 oferece proteção abrangente. No entanto, reduzir esse valor pode diminuir a extensão da proteção enquanto potencialmente mitiga o efeito de indexação.",
+    "Audio Separation Settings": "Configurações de Separação de Áudio",
+    "Use TTA": "Usar TTA",
+    "Use Test Time Augmentation.": "Usar Aumento de Tempo de Teste.",
+    "Batch Size": "Batch Size",
+    "Set the batch size for the separation.": "Defina o Batch Size para a separação.",
+    "Vocals Model": "Modelo de Vocais",
+    "Select the vocals model to use for the separation.": "Selecione o modelo de vocais a ser usado para a separação.",
+    "Karaoke Model": "Modelo de Karaokê",
+    "Select the karaoke model to use for the separation.": "Selecione o modelo de karaokê a ser usado para a separação.",
+    "Dereverb Model": "Modelo de Dereverb",
+    "Select the dereverb model to use for the separation.": "Selecione o modelo de dereverb a ser usado para a separação.",
+    "Deeecho": "Deeecho",
+    "Apply deeecho to the audio.": "Aplicar deeecho ao áudio.",
+    "Deeecho Model": "Modelo de Deeecho",
+    "Select the deeecho model to use for the separation.": "Selecione o modelo de deeecho a ser usado para a separação.",
+    "Denoise": "Redução de Ruído",
+    "Apply denoise to the audio.": "Aplicar redução de ruído ao áudio.",
+    "Denoise Model": "Modelo de Redução de Ruído",
+    "Select the denoise model to use for the separation.": "Selecione o modelo de redução de ruído a ser usado para a separação.",
+    "Audio post-process Settings": "Configurações de Pós-processamento de Áudio",
+    "Delete Audios": "Excluir Áudios",
+    "Delete the audios after the conversion.": "Excluir os áudios após a conversão.",
+    "Reverb": "Reverberação",
+    "Apply reverb to the audio.": "Aplicar reverberação ao áudio.",
+    "Reverb Room Size": "Tamanho da Sala de Reverberação",
+    "Set the room size of the reverb.": "Definir o tamanho da sala de reverberação.",
+    "Reverb Damping": "Amortecimento da Reverberação",
+    "Set the damping of the reverb.": "Definir o amortecimento da reverberação.",
+    "Reverb Wet Gain": "Ganho Molhado da Reverberação",
+    "Set the wet gain of the reverb.": "Definir o ganho molhado da reverberação.",
+    "Reverb Dry Gain": "Ganho Seco da Reverberação",
+    "Set the dry gain of the reverb.": "Definir o ganho seco da reverberação.",
+    "Reverb Width": "Largura da Reverberação",
+    "Set the width of the reverb.": "Definir a largura da reverberação.",
+    "Vocals Volume": "Volume dos Vocais",
+    "Adjust the volume of the vocals.": "Ajustar o volume dos vocais.",
+    "Instrumentals Volume": "Volume dos Instrumentais",
+    "Adjust the volume of the Instrumentals.": "Ajustar o volume dos instrumentais.",
+    "Backing Vocals Volume": "Volume dos Vocais de Apoio",
+    "Adjust the volume of the backing vocals.": "Ajustar o volume dos vocais de apoio.",
+    "Device Settings": "Configurações do Dispositivo",
+    "Device": "Dispositivo",
+    "Select the device to use for the conversion. 0 to ∞ separated by - and for CPU leave only an -": "Selecione o dispositivo a ser usado para a conversão. 0 a ∞ separados por - e para CPU deixe apenas um -",
+    "Convert": "Converter",
+    "Output Information": "Informações de Saída",
+    "The output information will be displayed here.": "As informações de saída serão exibidas aqui.",
+    "Export Audio": "Exportar Áudio",
+    "Music URL": "URL da Música",
+    "Download": "Baixar",
+    "Model URL": "URL do Modelo"
+}

assets/i18n/scan.py

@@ -0,0 +1,71 @@
+import ast
+import json
+from pathlib import Path
+from collections import OrderedDict
+
+
+def extract_i18n_strings(node):
+    i18n_strings = []
+
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "i18n"
+    ):
+        for arg in node.args:
+            if isinstance(arg, ast.Str):
+                i18n_strings.append(arg.s)
+
+    for child_node in ast.iter_child_nodes(node):
+        i18n_strings.extend(extract_i18n_strings(child_node))
+
+    return i18n_strings
+
+
+def process_file(file_path):
+    with open(file_path, "r", encoding="utf8") as file:
+        code = file.read()
+        if "I18nAuto" in code:
+            tree = ast.parse(code)
+            i18n_strings = extract_i18n_strings(tree)
+            print(file_path, len(i18n_strings))
+            return i18n_strings
+    return []
+
+
+# Use pathlib for file handling
+py_files = Path(".").rglob("*.py")
+
+# Use a set to store unique strings
+code_keys = set()
+
+for py_file in py_files:
+    strings = process_file(py_file)
+    code_keys.update(strings)
+
+print()
+print("Total unique:", len(code_keys))
+
+standard_file = "languages/en_US.json"
+with open(standard_file, "r", encoding="utf-8") as file:
+    standard_data = json.load(file, object_pairs_hook=OrderedDict)
+standard_keys = set(standard_data.keys())
+
+# Combine unused and missing keys sections
+unused_keys = standard_keys - code_keys
+missing_keys = code_keys - standard_keys
+
+print("Unused keys:", len(unused_keys))
+for unused_key in unused_keys:
+    print("\t", unused_key)
+
+print("Missing keys:", len(missing_keys))
+for missing_key in missing_keys:
+    print("\t", missing_key)
+
+code_keys_dict = OrderedDict((s, s) for s in code_keys)
+
+# Use context manager for writing back to the file
+with open(standard_file, "w", encoding="utf-8") as file:
+    json.dump(code_keys_dict, file, ensure_ascii=False, indent=4, sort_keys=True)
+    file.write("\n")

core.py

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

main.py

@@ -0,0 +1,53 @@
+import gradio as gr
+import sys, os
+from tabs.full_inference import full_inference_tab
+from tabs.download_model import download_model_tab
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+DEFAULT_PORT = 7755
+MAX_PORT_ATTEMPTS = 10
+
+from assets.i18n.i18n import I18nAuto
+
+i18n = I18nAuto()
+
+
+with gr.Blocks(title="hexGen-RVC", css="footer{display:none !important}") as app:
+    gr.Markdown("# hexGen RVC")
+    with gr.Tab(i18n("Full Inference")):
+        full_inference_tab()
+    with gr.Tab(i18n("Download Model")):
+        download_model_tab()
+
+
+def launch(port):
+    app.launch(
+        share="--share" in sys.argv,
+        inbrowser="--open" in sys.argv,
+        server_port=port,
+    )
+
+
+def get_port_from_args():
+    if "--port" in sys.argv:
+        port_index = sys.argv.index("--port") + 1
+        if port_index < len(sys.argv):
+            return int(sys.argv[port_index])
+    return DEFAULT_PORT
+
+
+if __name__ == "__main__":
+    port = get_port_from_args()
+    for _ in range(MAX_PORT_ATTEMPTS):
+        try:
+            launch(port)
+            break
+        except OSError:
+            print(
+                f"Failed to launch on port {port}, trying again on port {port - 1}..."
+            )
+            port -= 1
+        except Exception as error:
+            print(f"An error occurred launching Gradio: {error}")
+            break

programs/applio_code/rvc/configs/config.py

@@ -0,0 +1,192 @@
+import torch
+import json
+import os
+
+
+version_config_paths = [
+    os.path.join("v1", "32000.json"),
+    os.path.join("v1", "40000.json"),
+    os.path.join("v1", "48000.json"),
+    os.path.join("v2", "48000.json"),
+    os.path.join("v2", "40000.json"),
+    os.path.join("v2", "32000.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.device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        self.is_half = self.device != "cpu"
+        self.gpu_name = (
+            torch.cuda.get_device_name(int(self.device.split(":")[-1]))
+            if self.device.startswith("cuda")
+            else None
+        )
+        self.json_config = self.load_config_json()
+        self.gpu_mem = None
+        self.x_pad, self.x_query, self.x_center, self.x_max = self.device_config()
+
+    def load_config_json(self) -> dict:
+        configs = {}
+        for config_file in version_config_paths:
+            config_path = os.path.join(
+                "programs", "applio_code", "rvc", "configs", config_file
+            )
+            with open(config_path, "r") as f:
+                configs[config_file] = json.load(f)
+        return configs
+
+    def has_mps(self) -> bool:
+        # Check if Metal Performance Shaders are available - for macOS 12.3+.
+        return torch.backends.mps.is_available()
+
+    def has_xpu(self) -> bool:
+        # Check if XPU is available.
+        return hasattr(torch, "xpu") and torch.xpu.is_available()
+
+    def set_precision(self, precision):
+        if precision not in ["fp32", "fp16"]:
+            raise ValueError("Invalid precision type. Must be 'fp32' or 'fp16'.")
+
+        fp16_run_value = precision == "fp16"
+        preprocess_target_version = "3.7" if precision == "fp16" else "3.0"
+        preprocess_path = os.path.join(
+            os.path.dirname(__file__),
+            os.pardir,
+            "rvc",
+            "train",
+            "preprocess",
+            "preprocess.py",
+        )
+
+        for config_path in version_config_paths:
+            full_config_path = os.path.join(
+                "programs", "applio_code", "rvc", "configs", config_path
+            )
+            try:
+                with open(full_config_path, "r") as f:
+                    config = json.load(f)
+                config["train"]["fp16_run"] = fp16_run_value
+                with open(full_config_path, "w") as f:
+                    json.dump(config, f, indent=4)
+            except FileNotFoundError:
+                print(f"File not found: {full_config_path}")
+
+        if os.path.exists(preprocess_path):
+            with open(preprocess_path, "r") as f:
+                preprocess_content = f.read()
+            preprocess_content = preprocess_content.replace(
+                "3.0" if precision == "fp16" else "3.7", preprocess_target_version
+            )
+            with open(preprocess_path, "w") as f:
+                f.write(preprocess_content)
+
+        return f"Overwritten preprocess and config.json to use {precision}."
+
+    def get_precision(self):
+        if not version_config_paths:
+            raise FileNotFoundError("No configuration paths provided.")
+
+        full_config_path = os.path.join(
+            "programs", "applio_code", "rvc", "configs", version_config_paths[0]
+        )
+        try:
+            with open(full_config_path, "r") as f:
+                config = json.load(f)
+            fp16_run_value = config["train"].get("fp16_run", False)
+            precision = "fp16" if fp16_run_value else "fp32"
+            return precision
+        except FileNotFoundError:
+            print(f"File not found: {full_config_path}")
+            return None
+
+    def device_config(self) -> tuple:
+        if self.device.startswith("cuda"):
+            self.set_cuda_config()
+        elif self.has_mps():
+            self.device = "mps"
+            self.is_half = False
+            self.set_precision("fp32")
+        else:
+            self.device = "cpu"
+            self.is_half = False
+            self.set_precision("fp32")
+
+        # Configuration for 6GB GPU memory
+        x_pad, x_query, x_center, x_max = (
+            (3, 10, 60, 65) if self.is_half else (1, 6, 38, 41)
+        )
+        if self.gpu_mem is not None and self.gpu_mem <= 4:
+            # Configuration for 5GB GPU memory
+            x_pad, x_query, x_center, x_max = (1, 5, 30, 32)
+
+        return x_pad, x_query, x_center, x_max
+
+    def set_cuda_config(self):
+        i_device = int(self.device.split(":")[-1])
+        self.gpu_name = torch.cuda.get_device_name(i_device)
+        # Zluda
+        if self.gpu_name.endswith("[ZLUDA]"):
+            print("Zluda compatibility enabled, experimental feature.")
+            torch.backends.cudnn.enabled = False
+            torch.backends.cuda.enable_flash_sdp(False)
+            torch.backends.cuda.enable_math_sdp(True)
+            torch.backends.cuda.enable_mem_efficient_sdp(False)
+        low_end_gpus = ["16", "P40", "P10", "1060", "1070", "1080"]
+        if (
+            any(gpu in self.gpu_name for gpu in low_end_gpus)
+            and "V100" not in self.gpu_name.upper()
+        ):
+            self.is_half = False
+            self.set_precision("fp32")
+
+        self.gpu_mem = torch.cuda.get_device_properties(i_device).total_memory // (
+            1024**3
+        )
+
+
+def max_vram_gpu(gpu):
+    if torch.cuda.is_available():
+        gpu_properties = torch.cuda.get_device_properties(gpu)
+        total_memory_gb = round(gpu_properties.total_memory / 1024 / 1024 / 1024)
+        return total_memory_gb
+    else:
+        return "0"
+
+
+def get_gpu_info():
+    ngpu = torch.cuda.device_count()
+    gpu_infos = []
+    if torch.cuda.is_available() or ngpu != 0:
+        for i in range(ngpu):
+            gpu_name = torch.cuda.get_device_name(i)
+            mem = int(
+                torch.cuda.get_device_properties(i).total_memory / 1024 / 1024 / 1024
+                + 0.4
+            )
+            gpu_infos.append(f"{i}: {gpu_name} ({mem} GB)")
+    if len(gpu_infos) > 0:
+        gpu_info = "\n".join(gpu_infos)
+    else:
+        gpu_info = "Unfortunately, there is no compatible GPU available to support your training."
+    return gpu_info
+
+
+def get_number_of_gpus():
+    if torch.cuda.is_available():
+        num_gpus = torch.cuda.device_count()
+        return "-".join(map(str, range(num_gpus)))
+    else:
+        return "-"

programs/applio_code/rvc/configs/v1/32000.json

@@ -0,0 +1,47 @@
+{
+  "train": {
+    "log_interval": 200,
+    "seed": 1234,
+    "epochs": 20000,
+    "learning_rate": 1e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "batch_size": 4,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 12800,
+    "init_lr_ratio": 1,
+    "warmup_epochs": 0,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "max_wav_value": 32768.0,
+    "sample_rate": 32000,
+    "filter_length": 1024,
+    "hop_length": 320,
+    "win_length": 1024,
+    "n_mel_channels": 80,
+    "mel_fmin": 0.0,
+    "mel_fmax": null
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "text_enc_hidden_dim": 256,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [10,4,2,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4,4],
+    "use_spectral_norm": false,
+    "gin_channels": 256,
+    "spk_embed_dim": 109
+  }
+}

programs/applio_code/rvc/configs/v1/40000.json

@@ -0,0 +1,47 @@
+{
+  "train": {
+    "log_interval": 200,
+    "seed": 1234,
+    "epochs": 20000,
+    "learning_rate": 1e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "batch_size": 4,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 12800,
+    "init_lr_ratio": 1,
+    "warmup_epochs": 0,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "max_wav_value": 32768.0,
+    "sample_rate": 40000,
+    "filter_length": 2048,
+    "hop_length": 400,
+    "win_length": 2048,
+    "n_mel_channels": 125,
+    "mel_fmin": 0.0,
+    "mel_fmax": null
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "text_enc_hidden_dim": 256,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [10,10,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4],
+    "use_spectral_norm": false,
+    "gin_channels": 256,
+    "spk_embed_dim": 109
+  }
+}

programs/applio_code/rvc/configs/v1/48000.json

@@ -0,0 +1,47 @@
+{
+  "train": {
+    "log_interval": 200,
+    "seed": 1234,
+    "epochs": 20000,
+    "learning_rate": 1e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "batch_size": 4,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 11520,
+    "init_lr_ratio": 1,
+    "warmup_epochs": 0,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "max_wav_value": 32768.0,
+    "sample_rate": 48000,
+    "filter_length": 2048,
+    "hop_length": 480,
+    "win_length": 2048,
+    "n_mel_channels": 128,
+    "mel_fmin": 0.0,
+    "mel_fmax": null
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "text_enc_hidden_dim": 256,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [10,6,2,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4,4],
+    "use_spectral_norm": false,
+    "gin_channels": 256,
+    "spk_embed_dim": 109
+  }
+}

programs/applio_code/rvc/configs/v2/32000.json

@@ -0,0 +1,43 @@
+{
+  "train": {
+    "log_interval": 200,
+    "seed": 1234,
+    "learning_rate": 1e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 12800,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "max_wav_value": 32768.0,
+    "sample_rate": 32000,
+    "filter_length": 1024,
+    "hop_length": 320,
+    "win_length": 1024,
+    "n_mel_channels": 80,
+    "mel_fmin": 0.0,
+    "mel_fmax": null
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "text_enc_hidden_dim": 768,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [10,8,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [20,16,4,4],
+    "use_spectral_norm": false,
+    "gin_channels": 256,
+    "spk_embed_dim": 109
+  }
+}

programs/applio_code/rvc/configs/v2/40000.json

@@ -0,0 +1,43 @@
+{
+  "train": {
+    "log_interval": 200,
+    "seed": 1234,
+    "learning_rate": 1e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 12800,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "max_wav_value": 32768.0,
+    "sample_rate": 40000,
+    "filter_length": 2048,
+    "hop_length": 400,
+    "win_length": 2048,
+    "n_mel_channels": 125,
+    "mel_fmin": 0.0,
+    "mel_fmax": null
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "text_enc_hidden_dim": 768,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [10,10,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4],
+    "use_spectral_norm": false,
+    "gin_channels": 256,
+    "spk_embed_dim": 109
+  }
+}

programs/applio_code/rvc/configs/v2/48000.json

@@ -0,0 +1,43 @@
+{
+  "train": {
+    "log_interval": 200,
+    "seed": 1234,
+    "learning_rate": 1e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 17280,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "max_wav_value": 32768.0,
+    "sample_rate": 48000,
+    "filter_length": 2048,
+    "hop_length": 480,
+    "win_length": 2048,
+    "n_mel_channels": 128,
+    "mel_fmin": 0.0,
+    "mel_fmax": null
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "text_enc_hidden_dim": 768,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [12,10,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [24,20,4,4],
+    "use_spectral_norm": false,
+    "gin_channels": 256,
+    "spk_embed_dim": 109
+  }
+}

programs/applio_code/rvc/infer/infer.py

@@ -0,0 +1,470 @@
+import os
+import sys
+import time
+import torch
+import librosa
+import logging
+import traceback
+import numpy as np
+import soundfile as sf
+
+from scipy.io import wavfile
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+from programs.applio_code.rvc.infer.pipeline import Pipeline as VC
+from programs.applio_code.rvc.lib.utils import load_audio_infer, load_embedding
+from programs.applio_code.rvc.lib.tools.split_audio import process_audio, merge_audio
+from programs.applio_code.rvc.lib.algorithm.synthesizers import Synthesizer
+from programs.applio_code.rvc.configs.config import Config
+
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("faiss").setLevel(logging.WARNING)
+logging.getLogger("faiss.loader").setLevel(logging.WARNING)
+
+
+class VoiceConverter:
+    """
+    A class for performing voice conversion using the Retrieval-Based Voice Conversion (RVC) method.
+    """
+
+    def __init__(self):
+        """
+        Initializes the VoiceConverter with default configuration, and sets up models and parameters.
+        """
+        self.config = Config()  # Load RVC configuration
+        self.hubert_model = (
+            None  # Initialize the Hubert model (for embedding extraction)
+        )
+        self.last_embedder_model = None  # Last used embedder model
+        self.tgt_sr = None  # Target sampling rate for the output audio
+        self.net_g = None  # Generator network for voice conversion
+        self.vc = None  # Voice conversion pipeline instance
+        self.cpt = None  # Checkpoint for loading model weights
+        self.version = None  # Model version
+        self.n_spk = None  # Number of speakers in the model
+        self.use_f0 = None  # Whether the model uses F0
+
+    def load_hubert(self, embedder_model: str, embedder_model_custom: str = None):
+        """
+        Loads the HuBERT model for speaker embedding extraction.
+        """
+        self.hubert_model = load_embedding(embedder_model, embedder_model_custom)
+        self.hubert_model.to(self.config.device)
+        self.hubert_model = (
+            self.hubert_model.half()
+            if self.config.is_half
+            else self.hubert_model.float()
+        )
+        self.hubert_model.eval()
+
+    @staticmethod
+    def convert_audio_format(input_path, output_path, output_format):
+        """
+        Converts an audio file to a specified output format.
+        """
+        try:
+            if output_format != "WAV":
+                print(f"Converting audio to {output_format} format...")
+                audio, sample_rate = librosa.load(input_path, sr=None)
+                common_sample_rates = [
+                    8000,
+                    11025,
+                    12000,
+                    16000,
+                    22050,
+                    24000,
+                    32000,
+                    44100,
+                    48000,
+                ]
+                target_sr = min(common_sample_rates, key=lambda x: abs(x - sample_rate))
+                audio = librosa.resample(
+                    audio, orig_sr=sample_rate, target_sr=target_sr
+                )
+                sf.write(output_path, audio, target_sr, format=output_format.lower())
+            return output_path
+        except Exception as error:
+            print(f"An error occurred converting the audio format: {error}")
+
+    def convert_audio(
+        self,
+        audio_input_path: str,
+        audio_output_path: str,
+        model_path: str,
+        index_path: str,
+        embedder_model: str,
+        pitch: int,
+        f0_file: str,
+        f0_method: str,
+        index_rate: float,
+        volume_envelope: int,
+        protect: float,
+        hop_length: int,
+        split_audio: bool,
+        f0_autotune: bool,
+        filter_radius: int,
+        embedder_model_custom: str,
+        export_format: str,
+        resample_sr: int = 0,
+        sid: int = 0,
+    ):
+        """
+        Performs voice conversion on the input audio.
+        """
+        self.get_vc(model_path, sid)
+
+        try:
+            start_time = time.time()
+            print(f"Converting audio '{audio_input_path}'...")
+            audio = load_audio_infer(
+                audio_input_path,
+                16000,
+            )
+            audio_max = np.abs(audio).max() / 0.95
+
+            if audio_max > 1:
+                audio /= audio_max
+
+            if not self.hubert_model or embedder_model != self.last_embedder_model:
+                self.load_hubert(embedder_model, embedder_model_custom)
+                self.last_embedder_model = embedder_model
+
+            file_index = (
+                index_path.strip()
+                .strip('"')
+                .strip("\n")
+                .strip('"')
+                .strip()
+                .replace("trained", "added")
+            )
+
+            if self.tgt_sr != resample_sr >= 16000:
+                self.tgt_sr = resample_sr
+
+            if split_audio:
+                result, new_dir_path = process_audio(audio_input_path)
+                if result == "Error":
+                    return "Error with Split Audio", None
+
+                dir_path = (
+                    new_dir_path.strip().strip('"').strip("\n").strip('"').strip()
+                )
+                if dir_path:
+                    paths = [
+                        os.path.join(root, name)
+                        for root, _, files in os.walk(dir_path, topdown=False)
+                        for name in files
+                        if name.endswith(".wav") and root == dir_path
+                    ]
+                try:
+                    for path in paths:
+                        self.convert_audio(
+                            audio_input_path=path,
+                            audio_output_path=path,
+                            model_path=model_path,
+                            index_path=index_path,
+                            sid=sid,
+                            pitch=pitch,
+                            f0_file=None,
+                            f0_method=f0_method,
+                            index_rate=index_rate,
+                            resample_sr=resample_sr,
+                            volume_envelope=volume_envelope,
+                            protect=protect,
+                            hop_length=hop_length,
+                            split_audio=False,
+                            f0_autotune=f0_autotune,
+                            filter_radius=filter_radius,
+                            export_format=export_format,
+                            embedder_model=embedder_model,
+                            embedder_model_custom=embedder_model_custom,
+                        )
+                except Exception as error:
+                    print(f"An error occurred processing the segmented audio: {error}")
+                    print(traceback.format_exc())
+                    return f"Error {error}"
+                print("Finished processing segmented audio, now merging audio...")
+                merge_timestamps_file = os.path.join(
+                    os.path.dirname(new_dir_path),
+                    f"{os.path.basename(audio_input_path).split('.')[0]}_timestamps.txt",
+                )
+                self.tgt_sr, audio_opt = merge_audio(merge_timestamps_file)
+                os.remove(merge_timestamps_file)
+                sf.write(audio_output_path, audio_opt, self.tgt_sr, format="WAV")
+            else:
+                audio_opt = self.vc.pipeline(
+                    model=self.hubert_model,
+                    net_g=self.net_g,
+                    sid=sid,
+                    audio=audio,
+                    input_audio_path=audio_input_path,
+                    pitch=pitch,
+                    f0_method=f0_method,
+                    file_index=file_index,
+                    index_rate=index_rate,
+                    pitch_guidance=self.use_f0,
+                    filter_radius=filter_radius,
+                    tgt_sr=self.tgt_sr,
+                    resample_sr=resample_sr,
+                    volume_envelope=volume_envelope,
+                    version=self.version,
+                    protect=protect,
+                    hop_length=hop_length,
+                    f0_autotune=f0_autotune,
+                    f0_file=f0_file,
+                )
+
+            if audio_output_path:
+                sf.write(audio_output_path, audio_opt, self.tgt_sr, format="WAV")
+            output_path_format = audio_output_path.replace(
+                ".wav", f".{export_format.lower()}"
+            )
+            audio_output_path = self.convert_audio_format(
+                audio_output_path, output_path_format, export_format
+            )
+
+            elapsed_time = time.time() - start_time
+            print(
+                f"Conversion completed at '{audio_output_path}' in {elapsed_time:.2f} seconds."
+            )
+
+        except Exception as error:
+            print(f"An error occurred during audio conversion: {error}")
+            print(traceback.format_exc())
+
+    def convert_audio_batch(
+        self,
+        audio_input_paths: str,
+        audio_output_path: str,
+        model_path: str,
+        index_path: str,
+        embedder_model: str,
+        pitch: int,
+        f0_file: str,
+        f0_method: str,
+        index_rate: float,
+        volume_envelope: int,
+        protect: float,
+        hop_length: int,
+        split_audio: bool,
+        f0_autotune: bool,
+        filter_radius: int,
+        embedder_model_custom: str,
+        export_format: str,
+        resample_sr: int = 0,
+        sid: int = 0,
+        pid_file_path: str = None,
+    ):
+        """
+        Performs voice conversion on a batch of input audio files.
+        """
+        pid = os.getpid()
+        with open(pid_file_path, "w") as pid_file:
+            pid_file.write(str(pid))
+        try:
+            if not self.hubert_model or embedder_model != self.last_embedder_model:
+                self.load_hubert(embedder_model, embedder_model_custom)
+                self.last_embedder_model = embedder_model
+            self.get_vc(model_path, sid)
+            file_index = (
+                index_path.strip()
+                .strip('"')
+                .strip("\n")
+                .strip('"')
+                .strip()
+                .replace("trained", "added")
+            )
+            start_time = time.time()
+            print(f"Converting audio batch '{audio_input_paths}'...")
+            audio_files = [
+                f
+                for f in os.listdir(audio_input_paths)
+                if f.endswith((".mp3", ".wav", ".flac", ".m4a", ".ogg", ".opus"))
+            ]
+            print(f"Detected {len(audio_files)} audio files for inference.")
+            for i, audio_input_path in enumerate(audio_files):
+                audio_output_paths = os.path.join(
+                    audio_output_path,
+                    f"{os.path.splitext(os.path.basename(audio_input_path))[0]}_output.{export_format.lower()}",
+                )
+                if os.path.exists(audio_output_paths):
+                    continue
+                print(f"Converting audio '{audio_input_path}'...")
+                audio_input_path = os.path.join(audio_input_paths, audio_input_path)
+
+                audio = load_audio_infer(
+                    audio_input_path,
+                    16000,
+                )
+                audio_max = np.abs(audio).max() / 0.95
+
+                if audio_max > 1:
+                    audio /= audio_max
+
+                if self.tgt_sr != resample_sr >= 16000:
+                    self.tgt_sr = resample_sr
+
+                if split_audio:
+                    result, new_dir_path = process_audio(audio_input_path)
+                    if result == "Error":
+                        return "Error with Split Audio", None
+
+                    dir_path = (
+                        new_dir_path.strip().strip('"').strip("\n").strip('"').strip()
+                    )
+                    if dir_path:
+                        paths = [
+                            os.path.join(root, name)
+                            for root, _, files in os.walk(dir_path, topdown=False)
+                            for name in files
+                            if name.endswith(".wav") and root == dir_path
+                        ]
+                    try:
+                        for path in paths:
+                            self.convert_audio(
+                                audio_input_path=path,
+                                audio_output_path=path,
+                                model_path=model_path,
+                                index_path=index_path,
+                                sid=sid,
+                                pitch=pitch,
+                                f0_file=None,
+                                f0_method=f0_method,
+                                index_rate=index_rate,
+                                resample_sr=resample_sr,
+                                volume_envelope=volume_envelope,
+                                protect=protect,
+                                hop_length=hop_length,
+                                split_audio=False,
+                                f0_autotune=f0_autotune,
+                                filter_radius=filter_radius,
+                                export_format=export_format,
+                                embedder_model=embedder_model,
+                                embedder_model_custom=embedder_model_custom,
+                            )
+                    except Exception as error:
+                        print(
+                            f"An error occurred processing the segmented audio: {error}"
+                        )
+                        print(traceback.format_exc())
+                        return f"Error {error}"
+                    print("Finished processing segmented audio, now merging audio...")
+                    merge_timestamps_file = os.path.join(
+                        os.path.dirname(new_dir_path),
+                        f"{os.path.basename(audio_input_path).split('.')[0]}_timestamps.txt",
+                    )
+                    self.tgt_sr, audio_opt = merge_audio(merge_timestamps_file)
+                    os.remove(merge_timestamps_file)
+                else:
+                    audio_opt = self.vc.pipeline(
+                        model=self.hubert_model,
+                        net_g=self.net_g,
+                        sid=sid,
+                        audio=audio,
+                        input_audio_path=audio_input_path,
+                        pitch=pitch,
+                        f0_method=f0_method,
+                        file_index=file_index,
+                        index_rate=index_rate,
+                        pitch_guidance=self.use_f0,
+                        filter_radius=filter_radius,
+                        tgt_sr=self.tgt_sr,
+                        resample_sr=resample_sr,
+                        volume_envelope=volume_envelope,
+                        version=self.version,
+                        protect=protect,
+                        hop_length=hop_length,
+                        f0_autotune=f0_autotune,
+                        f0_file=f0_file,
+                    )
+
+                if audio_output_paths:
+                    sf.write(audio_output_paths, audio_opt, self.tgt_sr, format="WAV")
+                output_path_format = audio_output_paths.replace(
+                    ".wav", f".{export_format.lower()}"
+                )
+                audio_output_paths = self.convert_audio_format(
+                    audio_output_paths, output_path_format, export_format
+                )
+                print(f"Conversion completed at '{audio_output_paths}'.")
+            elapsed_time = time.time() - start_time
+            print(f"Batch conversion completed in {elapsed_time:.2f} seconds.")
+            os.remove(pid_file_path)
+        except Exception as error:
+            print(f"An error occurred during audio conversion: {error}")
+            print(traceback.format_exc())
+
+    def get_vc(self, weight_root, sid):
+        """
+        Loads the voice conversion model and sets up the pipeline.
+        """
+        if sid == "" or sid == []:
+            self.cleanup_model()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+        self.load_model(weight_root)
+
+        if self.cpt is not None:
+            self.setup_network()
+            self.setup_vc_instance()
+
+    def cleanup_model(self):
+        """
+        Cleans up the model and releases resources.
+        """
+        if self.hubert_model is not None:
+            del self.net_g, self.n_spk, self.vc, self.hubert_model, self.tgt_sr
+            self.hubert_model = self.net_g = self.n_spk = self.vc = self.tgt_sr = None
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+        del self.net_g, self.cpt
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        self.cpt = None
+
+    def load_model(self, weight_root):
+        """
+        Loads the model weights from the specified path.
+        """
+        self.cpt = (
+            torch.load(weight_root, map_location="cpu")
+            if os.path.isfile(weight_root)
+            else None
+        )
+
+    def setup_network(self):
+        """
+        Sets up the network configuration based on the loaded checkpoint.
+        """
+        if self.cpt is not None:
+            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.text_enc_hidden_dim = 768 if self.version == "v2" else 256
+            self.net_g = Synthesizer(
+                *self.cpt["config"],
+                use_f0=self.use_f0,
+                text_enc_hidden_dim=self.text_enc_hidden_dim,
+                is_half=self.config.is_half,
+            )
+            del self.net_g.enc_q
+            self.net_g.load_state_dict(self.cpt["weight"], strict=False)
+            self.net_g.eval().to(self.config.device)
+            self.net_g = (
+                self.net_g.half() if self.config.is_half else self.net_g.float()
+            )
+
+    def setup_vc_instance(self):
+        """
+        Sets up the voice conversion pipeline instance based on the target sampling rate and configuration.
+        """
+        if self.cpt is not None:
+            self.vc = VC(self.tgt_sr, self.config)
+            self.n_spk = self.cpt["config"][-3]

programs/applio_code/rvc/infer/pipeline.py

@@ -0,0 +1,701 @@
+import os
+import gc
+import re
+import sys
+import torch
+import torch.nn.functional as F
+import torchcrepe
+import faiss
+import librosa
+import numpy as np
+from scipy import signal
+from torch import Tensor
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+from programs.applio_code.rvc.lib.predictors.RMVPE import RMVPE0Predictor
+from programs.applio_code.rvc.lib.predictors.FCPE import FCPEF0Predictor
+
+import logging
+
+logging.getLogger("faiss").setLevel(logging.WARNING)
+
+# Constants for high-pass filter
+FILTER_ORDER = 5
+CUTOFF_FREQUENCY = 48  # Hz
+SAMPLE_RATE = 16000  # Hz
+bh, ah = signal.butter(
+    N=FILTER_ORDER, Wn=CUTOFF_FREQUENCY, btype="high", fs=SAMPLE_RATE
+)
+
+input_audio_path2wav = {}
+
+
+class AudioProcessor:
+    """
+    A class for processing audio signals, specifically for adjusting RMS levels.
+    """
+
+    def change_rms(
+        source_audio: np.ndarray,
+        source_rate: int,
+        target_audio: np.ndarray,
+        target_rate: int,
+        rate: float,
+    ) -> np.ndarray:
+        """
+        Adjust the RMS level of target_audio to match the RMS of source_audio, with a given blending rate.
+
+        Args:
+            source_audio: The source audio signal as a NumPy array.
+            source_rate: The sampling rate of the source audio.
+            target_audio: The target audio signal to adjust.
+            target_rate: The sampling rate of the target audio.
+            rate: The blending rate between the source and target RMS levels.
+        """
+        # Calculate RMS of both audio data
+        rms1 = librosa.feature.rms(
+            y=source_audio,
+            frame_length=source_rate // 2 * 2,
+            hop_length=source_rate // 2,
+        )
+        rms2 = librosa.feature.rms(
+            y=target_audio,
+            frame_length=target_rate // 2 * 2,
+            hop_length=target_rate // 2,
+        )
+
+        # Interpolate RMS to match target audio length
+        rms1 = F.interpolate(
+            torch.from_numpy(rms1).float().unsqueeze(0),
+            size=target_audio.shape[0],
+            mode="linear",
+        ).squeeze()
+        rms2 = F.interpolate(
+            torch.from_numpy(rms2).float().unsqueeze(0),
+            size=target_audio.shape[0],
+            mode="linear",
+        ).squeeze()
+        rms2 = torch.maximum(rms2, torch.zeros_like(rms2) + 1e-6)
+
+        # Adjust target audio RMS based on the source audio RMS
+        adjusted_audio = (
+            target_audio
+            * (torch.pow(rms1, 1 - rate) * torch.pow(rms2, rate - 1)).numpy()
+        )
+        return adjusted_audio
+
+
+class Autotune:
+    """
+    A class for applying autotune to a given fundamental frequency (F0) contour.
+    """
+
+    def __init__(self, ref_freqs):
+        """
+        Initializes the Autotune class with a set of reference frequencies.
+
+        Args:
+            ref_freqs: A list of reference frequencies representing musical notes.
+        """
+        self.ref_freqs = ref_freqs
+        self.note_dict = self.generate_interpolated_frequencies()
+
+    def generate_interpolated_frequencies(self):
+        """
+        Generates a dictionary of interpolated frequencies between reference frequencies.
+        """
+        note_dict = []
+        for i in range(len(self.ref_freqs) - 1):
+            freq_low = self.ref_freqs[i]
+            freq_high = self.ref_freqs[i + 1]
+            interpolated_freqs = np.linspace(
+                freq_low, freq_high, num=10, endpoint=False
+            )
+            note_dict.extend(interpolated_freqs)
+        note_dict.append(self.ref_freqs[-1])
+        return note_dict
+
+    def autotune_f0(self, f0):
+        """
+        Autotunes a given F0 contour by snapping each frequency to the closest reference frequency.
+
+        Args:
+            f0: The input F0 contour as a NumPy array.
+        """
+        autotuned_f0 = np.zeros_like(f0)
+        for i, freq in enumerate(f0):
+            closest_note = min(self.note_dict, key=lambda x: abs(x - freq))
+            autotuned_f0[i] = closest_note
+        return autotuned_f0
+
+
+class Pipeline:
+    """
+    The main pipeline class for performing voice conversion, including preprocessing, F0 estimation,
+    voice conversion using a model, and post-processing.
+    """
+
+    def __init__(self, tgt_sr, config):
+        """
+        Initializes the Pipeline class with target sampling rate and configuration parameters.
+
+        Args:
+            tgt_sr: The target sampling rate for the output audio.
+            config: A configuration object containing various parameters for the pipeline.
+        """
+        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.is_half = config.is_half
+        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.time_step = self.window / self.sample_rate * 1000
+        self.f0_min = 50
+        self.f0_max = 1100
+        self.f0_mel_min = 1127 * np.log(1 + self.f0_min / 700)
+        self.f0_mel_max = 1127 * np.log(1 + self.f0_max / 700)
+        self.device = config.device
+        self.ref_freqs = [
+            65.41,
+            82.41,
+            110.00,
+            146.83,
+            196.00,
+            246.94,
+            329.63,
+            440.00,
+            587.33,
+            783.99,
+            1046.50,
+        ]
+        self.autotune = Autotune(self.ref_freqs)
+        self.note_dict = self.autotune.note_dict
+
+    def get_f0_crepe(
+        self,
+        x,
+        f0_min,
+        f0_max,
+        p_len,
+        hop_length,
+        model="full",
+    ):
+        """
+        Estimates the fundamental frequency (F0) of a given audio signal using the Crepe model.
+
+        Args:
+            x: The input audio signal as a NumPy array.
+            f0_min: Minimum F0 value to consider.
+            f0_max: Maximum F0 value to consider.
+            p_len: Desired length of the F0 output.
+            hop_length: Hop length for the Crepe model.
+            model: Crepe model size to use ("full" or "tiny").
+        """
+        x = x.astype(np.float32)
+        x /= np.quantile(np.abs(x), 0.999)
+        audio = torch.from_numpy(x).to(self.device, copy=True)
+        audio = torch.unsqueeze(audio, dim=0)
+        if audio.ndim == 2 and audio.shape[0] > 1:
+            audio = torch.mean(audio, dim=0, keepdim=True).detach()
+        audio = audio.detach()
+        pitch: Tensor = torchcrepe.predict(
+            audio,
+            self.sample_rate,
+            hop_length,
+            f0_min,
+            f0_max,
+            model,
+            batch_size=hop_length * 2,
+            device=self.device,
+            pad=True,
+        )
+        p_len = p_len or x.shape[0] // hop_length
+        source = np.array(pitch.squeeze(0).cpu().float().numpy())
+        source[source < 0.001] = np.nan
+        target = np.interp(
+            np.arange(0, len(source) * p_len, len(source)) / p_len,
+            np.arange(0, len(source)),
+            source,
+        )
+        f0 = np.nan_to_num(target)
+        return f0
+
+    def get_f0_hybrid(
+        self,
+        methods_str,
+        x,
+        f0_min,
+        f0_max,
+        p_len,
+        hop_length,
+    ):
+        """
+        Estimates the fundamental frequency (F0) using a hybrid approach combining multiple methods.
+
+        Args:
+            methods_str: A string specifying the methods to combine (e.g., "hybrid[crepe+rmvpe]").
+            x: The input audio signal as a NumPy array.
+            f0_min: Minimum F0 value to consider.
+            f0_max: Maximum F0 value to consider.
+            p_len: Desired length of the F0 output.
+            hop_length: Hop length for F0 estimation methods.
+        """
+        methods_str = re.search("hybrid\[(.+)\]", methods_str)
+        if methods_str:
+            methods = [method.strip() for method in methods_str.group(1).split("+")]
+        f0_computation_stack = []
+        print(f"Calculating f0 pitch estimations for methods {str(methods)}")
+        x = x.astype(np.float32)
+        x /= np.quantile(np.abs(x), 0.999)
+        for method in methods:
+            f0 = None
+            if method == "crepe":
+                f0 = self.get_f0_crepe_computation(
+                    x, f0_min, f0_max, p_len, int(hop_length)
+                )
+            elif method == "rmvpe":
+                self.model_rmvpe = RMVPE0Predictor(
+                    os.path.join(
+                        "programs",
+                        "applio_code",
+                        "rvc",
+                        "models",
+                        "predictors",
+                        "rmvpe.pt",
+                    ),
+                    is_half=self.is_half,
+                    device=self.device,
+                )
+                f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03)
+                f0 = f0[1:]
+            elif method == "fcpe":
+                self.model_fcpe = FCPEF0Predictor(
+                    os.path.join(
+                        "programs",
+                        "applio_code",
+                        "rvc",
+                        "models",
+                        "predictors",
+                        "fcpe.pt",
+                    ),
+                    f0_min=int(f0_min),
+                    f0_max=int(f0_max),
+                    dtype=torch.float32,
+                    device=self.device,
+                    sample_rate=self.sample_rate,
+                    threshold=0.03,
+                )
+                f0 = self.model_fcpe.compute_f0(x, p_len=p_len)
+                del self.model_fcpe
+                gc.collect()
+            f0_computation_stack.append(f0)
+
+        f0_computation_stack = [fc for fc in f0_computation_stack if fc is not None]
+        f0_median_hybrid = None
+        if len(f0_computation_stack) == 1:
+            f0_median_hybrid = f0_computation_stack[0]
+        else:
+            f0_median_hybrid = np.nanmedian(f0_computation_stack, axis=0)
+        return f0_median_hybrid
+
+    def get_f0(
+        self,
+        input_audio_path,
+        x,
+        p_len,
+        pitch,
+        f0_method,
+        filter_radius,
+        hop_length,
+        f0_autotune,
+        inp_f0=None,
+    ):
+        """
+        Estimates the fundamental frequency (F0) of a given audio signal using various methods.
+
+        Args:
+            input_audio_path: Path to the input audio file.
+            x: The input audio signal as a NumPy array.
+            p_len: Desired length of the F0 output.
+            pitch: Key to adjust the pitch of the F0 contour.
+            f0_method: Method to use for F0 estimation (e.g., "crepe").
+            filter_radius: Radius for median filtering the F0 contour.
+            hop_length: Hop length for F0 estimation methods.
+            f0_autotune: Whether to apply autotune to the F0 contour.
+            inp_f0: Optional input F0 contour to use instead of estimating.
+        """
+        global input_audio_path2wav
+        if f0_method == "crepe":
+            f0 = self.get_f0_crepe(x, self.f0_min, self.f0_max, p_len, int(hop_length))
+        elif f0_method == "crepe-tiny":
+            f0 = self.get_f0_crepe(
+                x, self.f0_min, self.f0_max, p_len, int(hop_length), "tiny"
+            )
+        elif f0_method == "rmvpe":
+            self.model_rmvpe = RMVPE0Predictor(
+                os.path.join(
+                    "programs", "applio_code", "rvc", "models", "predictors", "rmvpe.pt"
+                ),
+                is_half=self.is_half,
+                device=self.device,
+            )
+            f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03)
+        elif f0_method == "fcpe":
+            self.model_fcpe = FCPEF0Predictor(
+                os.path.join(
+                    "programs", "applio_code", "rvc", "models", "predictors", "fcpe.pt"
+                ),
+                f0_min=int(self.f0_min),
+                f0_max=int(self.f0_max),
+                dtype=torch.float32,
+                device=self.device,
+                sample_rate=self.sample_rate,
+                threshold=0.03,
+            )
+            f0 = self.model_fcpe.compute_f0(x, p_len=p_len)
+            del self.model_fcpe
+            gc.collect()
+        elif "hybrid" in f0_method:
+            input_audio_path2wav[input_audio_path] = x.astype(np.double)
+            f0 = self.get_f0_hybrid(
+                f0_method,
+                x,
+                self.f0_min,
+                self.f0_max,
+                p_len,
+                hop_length,
+            )
+
+        if f0_autotune == "True":
+            f0 = Autotune.autotune_f0(self, f0)
+
+        f0 *= pow(2, pitch / 12)
+        tf0 = self.sample_rate // self.window
+        if inp_f0 is not None:
+            delta_t = np.round(
+                (inp_f0[:, 0].max() - inp_f0[:, 0].min()) * tf0 + 1
+            ).astype("int16")
+            replace_f0 = np.interp(
+                list(range(delta_t)), inp_f0[:, 0] * 100, inp_f0[:, 1]
+            )
+            shape = f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)].shape[0]
+            f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)] = replace_f0[
+                :shape
+            ]
+        f0bak = f0.copy()
+        f0_mel = 1127 * np.log(1 + f0 / 700)
+        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - self.f0_mel_min) * 254 / (
+            self.f0_mel_max - self.f0_mel_min
+        ) + 1
+        f0_mel[f0_mel <= 1] = 1
+        f0_mel[f0_mel > 255] = 255
+        f0_coarse = np.rint(f0_mel).astype(np.int)
+
+        return f0_coarse, f0bak
+
+    def voice_conversion(
+        self,
+        model,
+        net_g,
+        sid,
+        audio0,
+        pitch,
+        pitchf,
+        index,
+        big_npy,
+        index_rate,
+        version,
+        protect,
+    ):
+        """
+        Performs voice conversion on a given audio segment.
+
+        Args:
+            model: The feature extractor model.
+            net_g: The generative model for synthesizing speech.
+            sid: Speaker ID for the target voice.
+            audio0: The input audio segment.
+            pitch: Quantized F0 contour for pitch guidance.
+            pitchf: Original F0 contour for pitch guidance.
+            index: FAISS index for speaker embedding retrieval.
+            big_npy: Speaker embeddings stored in a NumPy array.
+            index_rate: Blending rate for speaker embedding retrieval.
+            version: Model version ("v1" or "v2").
+            protect: Protection level for preserving the original pitch.
+        """
+        feats = torch.from_numpy(audio0)
+        if self.is_half:
+            feats = feats.half()
+        else:
+            feats = feats.float()
+        if feats.dim() == 2:
+            feats = feats.mean(-1)
+        assert feats.dim() == 1, feats.dim()
+        feats = feats.view(1, -1)
+        padding_mask = torch.BoolTensor(feats.shape).to(self.device).fill_(False)
+
+        with torch.no_grad():
+            feats = model(feats.to(self.device))["last_hidden_state"]
+            feats = (
+                model.final_proj(feats[0]).unsqueeze(0) if version == "v1" else feats
+            )
+        if protect < 0.5 and pitch != None and pitchf != None:
+            feats0 = feats.clone()
+        if (
+            isinstance(index, type(None)) == False
+            and isinstance(big_npy, type(None)) == False
+            and index_rate != 0
+        ):
+            npy = feats[0].cpu().numpy()
+            if self.is_half:
+                npy = npy.astype("float32")
+
+            score, ix = index.search(npy, k=8)
+            weight = np.square(1 / score)
+            weight /= weight.sum(axis=1, keepdims=True)
+            npy = np.sum(big_npy[ix] * np.expand_dims(weight, axis=2), axis=1)
+
+            if self.is_half:
+                npy = npy.astype("float16")
+            feats = (
+                torch.from_numpy(npy).unsqueeze(0).to(self.device) * index_rate
+                + (1 - index_rate) * feats
+            )
+
+        feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
+        if protect < 0.5 and pitch != None and pitchf != None:
+            feats0 = F.interpolate(feats0.permute(0, 2, 1), scale_factor=2).permute(
+                0, 2, 1
+            )
+        p_len = audio0.shape[0] // self.window
+        if feats.shape[1] < p_len:
+            p_len = feats.shape[1]
+            if pitch != None and pitchf != None:
+                pitch = pitch[:, :p_len]
+                pitchf = pitchf[:, :p_len]
+
+        if protect < 0.5 and pitch != None and pitchf != None:
+            pitchff = pitchf.clone()
+            pitchff[pitchf > 0] = 1
+            pitchff[pitchf < 1] = protect
+            pitchff = pitchff.unsqueeze(-1)
+            feats = feats * pitchff + feats0 * (1 - pitchff)
+            feats = feats.to(feats0.dtype)
+        p_len = torch.tensor([p_len], device=self.device).long()
+        with torch.no_grad():
+            if pitch != None and pitchf != None:
+                audio1 = (
+                    (net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0])
+                    .data.cpu()
+                    .float()
+                    .numpy()
+                )
+            else:
+                audio1 = (
+                    (net_g.infer(feats, p_len, sid)[0][0, 0]).data.cpu().float().numpy()
+                )
+        del feats, p_len, padding_mask
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        return audio1
+
+    def pipeline(
+        self,
+        model,
+        net_g,
+        sid,
+        audio,
+        input_audio_path,
+        pitch,
+        f0_method,
+        file_index,
+        index_rate,
+        pitch_guidance,
+        filter_radius,
+        tgt_sr,
+        resample_sr,
+        volume_envelope,
+        version,
+        protect,
+        hop_length,
+        f0_autotune,
+        f0_file,
+    ):
+        """
+        The main pipeline function for performing voice conversion.
+
+        Args:
+            model: The feature extractor model.
+            net_g: The generative model for synthesizing speech.
+            sid: Speaker ID for the target voice.
+            audio: The input audio signal.
+            input_audio_path: Path to the input audio file.
+            pitch: Key to adjust the pitch of the F0 contour.
+            f0_method: Method to use for F0 estimation.
+            file_index: Path to the FAISS index file for speaker embedding retrieval.
+            index_rate: Blending rate for speaker embedding retrieval.
+            pitch_guidance: Whether to use pitch guidance during voice conversion.
+            filter_radius: Radius for median filtering the F0 contour.
+            tgt_sr: Target sampling rate for the output audio.
+            resample_sr: Resampling rate for the output audio.
+            volume_envelope: Blending rate for adjusting the RMS level of the output audio.
+            version: Model version.
+            protect: Protection level for preserving the original pitch.
+            hop_length: Hop length for F0 estimation methods.
+            f0_autotune: Whether to apply autotune to the F0 contour.
+            f0_file: Path to a file containing an F0 contour to use.
+        """
+        if file_index != "" and os.path.exists(file_index) == True and index_rate != 0:
+            try:
+                index = faiss.read_index(file_index)
+                big_npy = index.reconstruct_n(0, index.ntotal)
+            except Exception as error:
+                print(f"An error occurred reading the FAISS index: {error}")
+                index = big_npy = None
+        else:
+            index = big_npy = None
+        audio = signal.filtfilt(bh, ah, audio)
+        audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode="reflect")
+        opt_ts = []
+        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]
+                )
+        s = 0
+        audio_opt = []
+        t = None
+        audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode="reflect")
+        p_len = audio_pad.shape[0] // self.window
+        inp_f0 = None
+        if hasattr(f0_file, "name") == True:
+            try:
+                with open(f0_file.name, "r") as f:
+                    lines = f.read().strip("\n").split("\n")
+                inp_f0 = []
+                for line in lines:
+                    inp_f0.append([float(i) for i in line.split(",")])
+                inp_f0 = np.array(inp_f0, dtype="float32")
+            except Exception as error:
+                print(f"An error occurred reading the F0 file: {error}")
+        sid = torch.tensor(sid, device=self.device).unsqueeze(0).long()
+        if pitch_guidance == True:
+            pitch, pitchf = self.get_f0(
+                input_audio_path,
+                audio_pad,
+                p_len,
+                pitch,
+                f0_method,
+                filter_radius,
+                hop_length,
+                f0_autotune,
+                inp_f0,
+            )
+            pitch = pitch[:p_len]
+            pitchf = pitchf[:p_len]
+            if self.device == "mps":
+                pitchf = pitchf.astype(np.float32)
+            pitch = torch.tensor(pitch, device=self.device).unsqueeze(0).long()
+            pitchf = torch.tensor(pitchf, device=self.device).unsqueeze(0).float()
+        for t in opt_ts:
+            t = t // self.window * self.window
+            if pitch_guidance == True:
+                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],
+                        pitchf[:, s // self.window : (t + self.t_pad2) // self.window],
+                        index,
+                        big_npy,
+                        index_rate,
+                        version,
+                        protect,
+                    )[self.t_pad_tgt : -self.t_pad_tgt]
+                )
+            else:
+                audio_opt.append(
+                    self.voice_conversion(
+                        model,
+                        net_g,
+                        sid,
+                        audio_pad[s : t + self.t_pad2 + self.window],
+                        None,
+                        None,
+                        index,
+                        big_npy,
+                        index_rate,
+                        version,
+                        protect,
+                    )[self.t_pad_tgt : -self.t_pad_tgt]
+                )
+            s = t
+        if pitch_guidance == True:
+            audio_opt.append(
+                self.voice_conversion(
+                    model,
+                    net_g,
+                    sid,
+                    audio_pad[t:],
+                    pitch[:, t // self.window :] if t is not None else pitch,
+                    pitchf[:, t // self.window :] if t is not None else pitchf,
+                    index,
+                    big_npy,
+                    index_rate,
+                    version,
+                    protect,
+                )[self.t_pad_tgt : -self.t_pad_tgt]
+            )
+        else:
+            audio_opt.append(
+                self.voice_conversion(
+                    model,
+                    net_g,
+                    sid,
+                    audio_pad[t:],
+                    None,
+                    None,
+                    index,
+                    big_npy,
+                    index_rate,
+                    version,
+                    protect,
+                )[self.t_pad_tgt : -self.t_pad_tgt]
+            )
+        audio_opt = np.concatenate(audio_opt)
+        if volume_envelope != 1:
+            audio_opt = AudioProcessor.change_rms(
+                audio, self.sample_rate, audio_opt, tgt_sr, volume_envelope
+            )
+        if resample_sr >= self.sample_rate and tgt_sr != resample_sr:
+            audio_opt = librosa.resample(
+                audio_opt, orig_sr=tgt_sr, target_sr=resample_sr
+            )
+        audio_max = np.abs(audio_opt).max() / 0.99
+        max_int16 = 32768
+        if audio_max > 1:
+            max_int16 /= audio_max
+        audio_opt = (audio_opt * max_int16).astype(np.int16)
+        del pitch, pitchf, sid
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        return audio_opt

programs/applio_code/rvc/lib/algorithm/attentions.py

@@ -0,0 +1,292 @@
+import math
+import torch
+
+from programs.applio_code.rvc.lib.algorithm.commons import convert_pad_shape
+
+
+class MultiHeadAttention(torch.nn.Module):
+    """
+    Multi-head attention module with optional relative positional encoding and proximal bias.
+
+    Args:
+        channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        n_heads (int): Number of attention heads.
+        p_dropout (float, optional): Dropout probability. Defaults to 0.0.
+        window_size (int, optional): Window size for relative positional encoding. Defaults to None.
+        heads_share (bool, optional): Whether to share relative positional embeddings across heads. Defaults to True.
+        block_length (int, optional): Block length for local attention. Defaults to None.
+        proximal_bias (bool, optional): Whether to use proximal bias in self-attention. Defaults to False.
+        proximal_init (bool, optional): Whether to initialize the key projection weights the same as query projection weights. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        channels,
+        out_channels,
+        n_heads,
+        p_dropout=0.0,
+        window_size=None,
+        heads_share=True,
+        block_length=None,
+        proximal_bias=False,
+        proximal_init=False,
+    ):
+        super().__init__()
+        assert channels % n_heads == 0
+
+        self.channels = channels
+        self.out_channels = out_channels
+        self.n_heads = n_heads
+        self.p_dropout = p_dropout
+        self.window_size = window_size
+        self.heads_share = heads_share
+        self.block_length = block_length
+        self.proximal_bias = proximal_bias
+        self.proximal_init = proximal_init
+        self.attn = None
+
+        self.k_channels = channels // n_heads
+        self.conv_q = torch.nn.Conv1d(channels, channels, 1)
+        self.conv_k = torch.nn.Conv1d(channels, channels, 1)
+        self.conv_v = torch.nn.Conv1d(channels, channels, 1)
+        self.conv_o = torch.nn.Conv1d(channels, out_channels, 1)
+        self.drop = torch.nn.Dropout(p_dropout)
+
+        if window_size is not None:
+            n_heads_rel = 1 if heads_share else n_heads
+            rel_stddev = self.k_channels**-0.5
+            self.emb_rel_k = torch.nn.Parameter(
+                torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
+                * rel_stddev
+            )
+            self.emb_rel_v = torch.nn.Parameter(
+                torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
+                * rel_stddev
+            )
+
+        torch.nn.init.xavier_uniform_(self.conv_q.weight)
+        torch.nn.init.xavier_uniform_(self.conv_k.weight)
+        torch.nn.init.xavier_uniform_(self.conv_v.weight)
+        if proximal_init:
+            with torch.no_grad():
+                self.conv_k.weight.copy_(self.conv_q.weight)
+                self.conv_k.bias.copy_(self.conv_q.bias)
+
+    def forward(self, x, c, attn_mask=None):
+        q = self.conv_q(x)
+        k = self.conv_k(c)
+        v = self.conv_v(c)
+
+        x, self.attn = self.attention(q, k, v, mask=attn_mask)
+
+        x = self.conv_o(x)
+        return x
+
+    def attention(self, query, key, value, mask=None):
+        # reshape [b, d, t] -> [b, n_h, t, d_k]
+        b, d, t_s, t_t = (*key.size(), query.size(2))
+        query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
+        key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+        value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+
+        scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
+        if self.window_size is not None:
+            assert (
+                t_s == t_t
+            ), "Relative attention is only available for self-attention."
+            key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
+            rel_logits = self._matmul_with_relative_keys(
+                query / math.sqrt(self.k_channels), key_relative_embeddings
+            )
+            scores_local = self._relative_position_to_absolute_position(rel_logits)
+            scores = scores + scores_local
+        if self.proximal_bias:
+            assert t_s == t_t, "Proximal bias is only available for self-attention."
+            scores = scores + self._attention_bias_proximal(t_s).to(
+                device=scores.device, dtype=scores.dtype
+            )
+        if mask is not None:
+            scores = scores.masked_fill(mask == 0, -1e4)
+            if self.block_length is not None:
+                assert (
+                    t_s == t_t
+                ), "Local attention is only available for self-attention."
+                block_mask = (
+                    torch.ones_like(scores)
+                    .triu(-self.block_length)
+                    .tril(self.block_length)
+                )
+                scores = scores.masked_fill(block_mask == 0, -1e4)
+        p_attn = torch.nn.functional.softmax(scores, dim=-1)  # [b, n_h, t_t, t_s]
+        p_attn = self.drop(p_attn)
+        output = torch.matmul(p_attn, value)
+        if self.window_size is not None:
+            relative_weights = self._absolute_position_to_relative_position(p_attn)
+            value_relative_embeddings = self._get_relative_embeddings(
+                self.emb_rel_v, t_s
+            )
+            output = output + self._matmul_with_relative_values(
+                relative_weights, value_relative_embeddings
+            )
+        output = (
+            output.transpose(2, 3).contiguous().view(b, d, t_t)
+        )  # [b, n_h, t_t, d_k] -> [b, d, t_t]
+        return output, p_attn
+
+    def _matmul_with_relative_values(self, x, y):
+        """
+        x: [b, h, l, m]
+        y: [h or 1, m, d]
+        ret: [b, h, l, d]
+        """
+        ret = torch.matmul(x, y.unsqueeze(0))
+        return ret
+
+    def _matmul_with_relative_keys(self, x, y):
+        """
+        x: [b, h, l, d]
+        y: [h or 1, m, d]
+        ret: [b, h, l, m]
+        """
+        ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
+        return ret
+
+    def _get_relative_embeddings(self, relative_embeddings, length):
+        # Pad first before slice to avoid using cond ops.
+        pad_length = max(length - (self.window_size + 1), 0)
+        slice_start_position = max((self.window_size + 1) - length, 0)
+        slice_end_position = slice_start_position + 2 * length - 1
+        if pad_length > 0:
+            padded_relative_embeddings = torch.nn.functional.pad(
+                relative_embeddings,
+                convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]),
+            )
+        else:
+            padded_relative_embeddings = relative_embeddings
+        used_relative_embeddings = padded_relative_embeddings[
+            :, slice_start_position:slice_end_position
+        ]
+        return used_relative_embeddings
+
+    def _relative_position_to_absolute_position(self, x):
+        """
+        x: [b, h, l, 2*l-1]
+        ret: [b, h, l, l]
+        """
+        batch, heads, length, _ = x.size()
+
+        # Concat columns of pad to shift from relative to absolute indexing.
+        x = torch.nn.functional.pad(
+            x, convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 1]])
+        )
+
+        # Concat extra elements so to add up to shape (len+1, 2*len-1).
+        x_flat = x.view([batch, heads, length * 2 * length])
+        x_flat = torch.nn.functional.pad(
+            x_flat, convert_pad_shape([[0, 0], [0, 0], [0, length - 1]])
+        )
+
+        # Reshape and slice out the padded elements.
+        x_final = x_flat.view([batch, heads, length + 1, 2 * length - 1])[
+            :, :, :length, length - 1 :
+        ]
+        return x_final
+
+    def _absolute_position_to_relative_position(self, x):
+        """
+        x: [b, h, l, l]
+        ret: [b, h, l, 2*l-1]
+        """
+        batch, heads, length, _ = x.size()
+        # padd along column
+        x = torch.nn.functional.pad(
+            x, convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length - 1]])
+        )
+        x_flat = x.view([batch, heads, length**2 + length * (length - 1)])
+        # add 0's in the beginning that will skew the elements after reshape
+        x_flat = torch.nn.functional.pad(
+            x_flat, convert_pad_shape([[0, 0], [0, 0], [length, 0]])
+        )
+        x_final = x_flat.view([batch, heads, length, 2 * length])[:, :, :, 1:]
+        return x_final
+
+    def _attention_bias_proximal(self, length):
+        """Bias for self-attention to encourage attention to close positions.
+        Args:
+            length: an integer scalar.
+        """
+        r = torch.arange(length, dtype=torch.float32)
+        diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
+        return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
+
+
+class FFN(torch.nn.Module):
+    """
+    Feed-forward network module.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        filter_channels (int): Number of filter channels in the convolution layers.
+        kernel_size (int): Kernel size of the convolution layers.
+        p_dropout (float, optional): Dropout probability. Defaults to 0.0.
+        activation (str, optional): Activation function to use. Defaults to None.
+        causal (bool, optional): Whether to use causal padding in the convolution layers. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        filter_channels,
+        kernel_size,
+        p_dropout=0.0,
+        activation=None,
+        causal=False,
+    ):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.filter_channels = filter_channels
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+        self.activation = activation
+        self.causal = causal
+
+        if causal:
+            self.padding = self._causal_padding
+        else:
+            self.padding = self._same_padding
+
+        self.conv_1 = torch.nn.Conv1d(in_channels, filter_channels, kernel_size)
+        self.conv_2 = torch.nn.Conv1d(filter_channels, out_channels, kernel_size)
+        self.drop = torch.nn.Dropout(p_dropout)
+
+    def forward(self, x, x_mask):
+        x = self.conv_1(self.padding(x * x_mask))
+        if self.activation == "gelu":
+            x = x * torch.sigmoid(1.702 * x)
+        else:
+            x = torch.relu(x)
+        x = self.drop(x)
+        x = self.conv_2(self.padding(x * x_mask))
+        return x * x_mask
+
+    def _causal_padding(self, x):
+        if self.kernel_size == 1:
+            return x
+        pad_l = self.kernel_size - 1
+        pad_r = 0
+        padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+        x = torch.nn.functional.pad(x, convert_pad_shape(padding))
+        return x
+
+    def _same_padding(self, x):
+        if self.kernel_size == 1:
+            return x
+        pad_l = (self.kernel_size - 1) // 2
+        pad_r = self.kernel_size // 2
+        padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+        x = torch.nn.functional.pad(x, convert_pad_shape(padding))
+        return x

programs/applio_code/rvc/lib/algorithm/commons.py

@@ -0,0 +1,225 @@
+import math
+import torch
+from typing import List, Optional
+
+
+def init_weights(m, mean=0.0, std=0.01):
+    """
+    Initialize the weights of a module.
+
+    Args:
+        m: The module to initialize.
+        mean: The mean of the normal distribution.
+        std: The standard deviation of the normal distribution.
+    """
+    classname = m.__class__.__name__
+    if classname.find("Conv") != -1:
+        m.weight.data.normal_(mean, std)
+
+
+def get_padding(kernel_size, dilation=1):
+    """
+    Calculate the padding needed for a convolution.
+
+    Args:
+        kernel_size: The size of the kernel.
+        dilation: The dilation of the convolution.
+    """
+    return int((kernel_size * dilation - dilation) / 2)
+
+
+def convert_pad_shape(pad_shape):
+    """
+    Convert the pad shape to a list of integers.
+
+    Args:
+        pad_shape: The pad shape..
+    """
+    l = pad_shape[::-1]
+    pad_shape = [item for sublist in l for item in sublist]
+    return pad_shape
+
+
+def kl_divergence(m_p, logs_p, m_q, logs_q):
+    """
+    Calculate the KL divergence between two distributions.
+
+    Args:
+        m_p: The mean of the first distribution.
+        logs_p: The log of the standard deviation of the first distribution.
+        m_q: The mean of the second distribution.
+        logs_q: The log of the standard deviation of the second distribution.
+    """
+    kl = (logs_q - logs_p) - 0.5
+    kl += (
+        0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
+    )
+    return kl
+
+
+def slice_segments(
+    x: torch.Tensor, ids_str: torch.Tensor, segment_size: int = 4, dim: int = 2
+):
+    """
+    Slice segments from a tensor, handling tensors with different numbers of dimensions.
+
+    Args:
+        x (torch.Tensor): The tensor to slice.
+        ids_str (torch.Tensor): The starting indices of the segments.
+        segment_size (int, optional): The size of each segment. Defaults to 4.
+        dim (int, optional): The dimension to slice across (2D or 3D tensors). Defaults to 2.
+    """
+    if dim == 2:
+        ret = torch.zeros_like(x[:, :segment_size])
+    elif dim == 3:
+        ret = torch.zeros_like(x[:, :, :segment_size])
+
+    for i in range(x.size(0)):
+        idx_str = ids_str[i].item()
+        idx_end = idx_str + segment_size
+        if dim == 2:
+            ret[i] = x[i, idx_str:idx_end]
+        else:
+            ret[i] = x[i, :, idx_str:idx_end]
+
+    return ret
+
+
+def rand_slice_segments(x, x_lengths=None, segment_size=4):
+    """
+    Randomly slice segments from a tensor.
+
+    Args:
+        x: The tensor to slice.
+        x_lengths: The lengths of the sequences.
+        segment_size: The size of each segment.
+    """
+    b, d, t = x.size()
+    if x_lengths is None:
+        x_lengths = t
+    ids_str_max = x_lengths - segment_size + 1
+    ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
+    ret = slice_segments(x, ids_str, segment_size, dim=3)
+    return ret, ids_str
+
+
+def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):
+    """
+    Generate a 1D timing signal.
+
+    Args:
+        length: The length of the signal.
+        channels: The number of channels of the signal.
+        min_timescale: The minimum timescale.
+        max_timescale: The maximum timescale.
+    """
+    position = torch.arange(length, dtype=torch.float)
+    num_timescales = channels // 2
+    log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / (
+        num_timescales - 1
+    )
+    inv_timescales = min_timescale * torch.exp(
+        torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment
+    )
+    scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
+    signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
+    signal = torch.nn.functional.pad(signal, [0, 0, 0, channels % 2])
+    signal = signal.view(1, channels, length)
+    return signal
+
+
+def subsequent_mask(length):
+    """
+    Generate a subsequent mask.
+
+    Args:
+        length: The length of the sequence.
+    """
+    mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
+    return mask
+
+
+@torch.jit.script
+def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
+    """
+    Fused add tanh sigmoid multiply operation.
+
+    Args:
+        input_a: The first input tensor.
+        input_b: The second input tensor.
+        n_channels: The number of channels.
+    """
+    n_channels_int = n_channels[0]
+    in_act = input_a + input_b
+    t_act = torch.tanh(in_act[:, :n_channels_int, :])
+    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
+    acts = t_act * s_act
+    return acts
+
+
+# Zluda, same as previous, but without jit.script
+def fused_add_tanh_sigmoid_multiply_no_jit(input_a, input_b, n_channels):
+    """
+    Fused add tanh sigmoid multiply operation.
+
+    Args:
+        input_a: The first input tensor.
+        input_b: The second input tensor.
+        n_channels: The number of channels.
+    """
+    n_channels_int = n_channels[0]
+    in_act = input_a + input_b
+    t_act = torch.tanh(in_act[:, :n_channels_int, :])
+    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
+    acts = t_act * s_act
+    return acts
+
+
+def convert_pad_shape(pad_shape: List[List[int]]) -> List[int]:
+    """
+    Convert the pad shape to a list of integers.
+
+    Args:
+        pad_shape: The pad shape.
+    """
+    return torch.tensor(pad_shape).flip(0).reshape(-1).int().tolist()
+
+
+def sequence_mask(length: torch.Tensor, max_length: Optional[int] = None):
+    """
+    Generate a sequence mask.
+
+    Args:
+        length: The lengths of the sequences.
+        max_length: The maximum length of the sequences.
+    """
+    if max_length is None:
+        max_length = length.max()
+    x = torch.arange(max_length, dtype=length.dtype, device=length.device)
+    return x.unsqueeze(0) < length.unsqueeze(1)
+
+
+def clip_grad_value(parameters, clip_value, norm_type=2):
+    """
+    Clip the gradients of a list of parameters.
+
+    Args:
+        parameters: The list of parameters to clip.
+        clip_value: The maximum value of the gradients.
+        norm_type: The type of norm to use for clipping.
+    """
+    if isinstance(parameters, torch.Tensor):
+        parameters = [parameters]
+    parameters = list(filter(lambda p: p.grad is not None, parameters))
+    norm_type = float(norm_type)
+    if clip_value is not None:
+        clip_value = float(clip_value)
+
+    total_norm = 0
+    for p in parameters:
+        param_norm = p.grad.data.norm(norm_type)
+        total_norm += param_norm.item() ** norm_type
+        if clip_value is not None:
+            p.grad.data.clamp_(min=-clip_value, max=clip_value)
+    total_norm = total_norm ** (1.0 / norm_type)
+    return total_norm

programs/applio_code/rvc/lib/algorithm/discriminators.py

@@ -0,0 +1,199 @@
+import torch
+from torch.nn.utils.parametrizations import spectral_norm, weight_norm
+
+from programs.applio_code.rvc.lib.algorithm.commons import get_padding
+from programs.applio_code.rvc.lib.algorithm.residuals import LRELU_SLOPE
+
+
+class MultiPeriodDiscriminator(torch.nn.Module):
+    """
+    Multi-period discriminator.
+
+    This class implements a multi-period discriminator, which is used to
+    discriminate between real and fake audio signals. The discriminator
+    is composed of a series of convolutional layers that are applied to
+    the input signal at different periods.
+
+    Args:
+        use_spectral_norm (bool): Whether to use spectral normalization.
+            Defaults to False.
+    """
+
+    def __init__(self, use_spectral_norm=False):
+        super(MultiPeriodDiscriminator, self).__init__()
+        periods = [2, 3, 5, 7, 11, 17]
+        self.discriminators = torch.nn.ModuleList(
+            [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
+            + [DiscriminatorP(p, use_spectral_norm=use_spectral_norm) for p in periods]
+        )
+
+    def forward(self, y, y_hat):
+        """
+        Forward pass of the multi-period discriminator.
+
+        Args:
+            y (torch.Tensor): Real audio signal.
+            y_hat (torch.Tensor): Fake audio signal.
+        """
+        y_d_rs, y_d_gs, fmap_rs, fmap_gs = [], [], [], []
+        for d in self.discriminators:
+            y_d_r, fmap_r = d(y)
+            y_d_g, fmap_g = d(y_hat)
+            y_d_rs.append(y_d_r)
+            y_d_gs.append(y_d_g)
+            fmap_rs.append(fmap_r)
+            fmap_gs.append(fmap_g)
+
+        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+
+
+class MultiPeriodDiscriminatorV2(torch.nn.Module):
+    """
+    Multi-period discriminator V2.
+
+    This class implements a multi-period discriminator V2, which is used
+    to discriminate between real and fake audio signals. The discriminator
+    is composed of a series of convolutional layers that are applied to
+    the input signal at different periods.
+
+    Args:
+        use_spectral_norm (bool): Whether to use spectral normalization.
+            Defaults to False.
+    """
+
+    def __init__(self, use_spectral_norm=False):
+        super(MultiPeriodDiscriminatorV2, self).__init__()
+        periods = [2, 3, 5, 7, 11, 17, 23, 37]
+        self.discriminators = torch.nn.ModuleList(
+            [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
+            + [DiscriminatorP(p, use_spectral_norm=use_spectral_norm) for p in periods]
+        )
+
+    def forward(self, y, y_hat):
+        """
+        Forward pass of the multi-period discriminator V2.
+
+        Args:
+            y (torch.Tensor): Real audio signal.
+            y_hat (torch.Tensor): Fake audio signal.
+        """
+        y_d_rs, y_d_gs, fmap_rs, fmap_gs = [], [], [], []
+        for d in self.discriminators:
+            y_d_r, fmap_r = d(y)
+            y_d_g, fmap_g = d(y_hat)
+            y_d_rs.append(y_d_r)
+            y_d_gs.append(y_d_g)
+            fmap_rs.append(fmap_r)
+            fmap_gs.append(fmap_g)
+
+        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+
+
+class DiscriminatorS(torch.nn.Module):
+    """
+    Discriminator for the short-term component.
+
+    This class implements a discriminator for the short-term component
+    of the audio signal. The discriminator is composed of a series of
+    convolutional layers that are applied to the input signal.
+    """
+
+    def __init__(self, use_spectral_norm=False):
+        super(DiscriminatorS, self).__init__()
+        norm_f = spectral_norm if use_spectral_norm else weight_norm
+        self.convs = torch.nn.ModuleList(
+            [
+                norm_f(torch.nn.Conv1d(1, 16, 15, 1, padding=7)),
+                norm_f(torch.nn.Conv1d(16, 64, 41, 4, groups=4, padding=20)),
+                norm_f(torch.nn.Conv1d(64, 256, 41, 4, groups=16, padding=20)),
+                norm_f(torch.nn.Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
+                norm_f(torch.nn.Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
+                norm_f(torch.nn.Conv1d(1024, 1024, 5, 1, padding=2)),
+            ]
+        )
+        self.conv_post = norm_f(torch.nn.Conv1d(1024, 1, 3, 1, padding=1))
+        self.lrelu = torch.nn.LeakyReLU(LRELU_SLOPE)
+
+    def forward(self, x):
+        """
+        Forward pass of the discriminator.
+
+        Args:
+            x (torch.Tensor): Input audio signal.
+        """
+        fmap = []
+        for conv in self.convs:
+            x = self.lrelu(conv(x))
+            fmap.append(x)
+        x = self.conv_post(x)
+        fmap.append(x)
+        x = torch.flatten(x, 1, -1)
+        return x, fmap
+
+
+class DiscriminatorP(torch.nn.Module):
+    """
+    Discriminator for the long-term component.
+
+    This class implements a discriminator for the long-term component
+    of the audio signal. The discriminator is composed of a series of
+    convolutional layers that are applied to the input signal at a given
+    period.
+
+    Args:
+        period (int): Period of the discriminator.
+        kernel_size (int): Kernel size of the convolutional layers.
+            Defaults to 5.
+        stride (int): Stride of the convolutional layers. Defaults to 3.
+        use_spectral_norm (bool): Whether to use spectral normalization.
+            Defaults to False.
+    """
+
+    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
+        super(DiscriminatorP, self).__init__()
+        self.period = period
+        norm_f = spectral_norm if use_spectral_norm else weight_norm
+
+        in_channels = [1, 32, 128, 512, 1024]
+        out_channels = [32, 128, 512, 1024, 1024]
+
+        self.convs = torch.nn.ModuleList(
+            [
+                norm_f(
+                    torch.nn.Conv2d(
+                        in_ch,
+                        out_ch,
+                        (kernel_size, 1),
+                        (stride, 1),
+                        padding=(get_padding(kernel_size, 1), 0),
+                    )
+                )
+                for in_ch, out_ch in zip(in_channels, out_channels)
+            ]
+        )
+
+        self.conv_post = norm_f(torch.nn.Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
+        self.lrelu = torch.nn.LeakyReLU(LRELU_SLOPE)
+
+    def forward(self, x):
+        """
+        Forward pass of the discriminator.
+
+        Args:
+            x (torch.Tensor): Input audio signal.
+        """
+        fmap = []
+        b, c, t = x.shape
+        if t % self.period != 0:
+            n_pad = self.period - (t % self.period)
+            x = torch.nn.functional.pad(x, (0, n_pad), "reflect")
+        x = x.view(b, c, -1, self.period)
+
+        for conv in self.convs:
+            x = self.lrelu(conv(x))
+            fmap.append(x)
+
+        x = self.conv_post(x)
+        fmap.append(x)
+        x = torch.flatten(x, 1, -1)
+        return x, fmap

programs/applio_code/rvc/lib/algorithm/encoders.py

@@ -0,0 +1,219 @@
+import math
+import torch
+from typing import Optional
+
+from programs.applio_code.rvc.lib.algorithm.commons import sequence_mask
+from programs.applio_code.rvc.lib.algorithm.modules import WaveNet
+from programs.applio_code.rvc.lib.algorithm.normalization import LayerNorm
+from programs.applio_code.rvc.lib.algorithm.attentions import FFN, MultiHeadAttention
+
+
+class Encoder(torch.nn.Module):
+    """
+    Encoder module for the Transformer model.
+
+    Args:
+        hidden_channels (int): Number of hidden channels in the encoder.
+        filter_channels (int): Number of filter channels in the feed-forward network.
+        n_heads (int): Number of attention heads.
+        n_layers (int): Number of encoder layers.
+        kernel_size (int, optional): Kernel size of the convolution layers in the feed-forward network. Defaults to 1.
+        p_dropout (float, optional): Dropout probability. Defaults to 0.0.
+        window_size (int, optional): Window size for relative positional encoding. Defaults to 10.
+    """
+
+    def __init__(
+        self,
+        hidden_channels,
+        filter_channels,
+        n_heads,
+        n_layers,
+        kernel_size=1,
+        p_dropout=0.0,
+        window_size=10,
+        **kwargs
+    ):
+        super().__init__()
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+        self.window_size = window_size
+
+        self.drop = torch.nn.Dropout(p_dropout)
+        self.attn_layers = torch.nn.ModuleList()
+        self.norm_layers_1 = torch.nn.ModuleList()
+        self.ffn_layers = torch.nn.ModuleList()
+        self.norm_layers_2 = torch.nn.ModuleList()
+        for i in range(self.n_layers):
+            self.attn_layers.append(
+                MultiHeadAttention(
+                    hidden_channels,
+                    hidden_channels,
+                    n_heads,
+                    p_dropout=p_dropout,
+                    window_size=window_size,
+                )
+            )
+            self.norm_layers_1.append(LayerNorm(hidden_channels))
+            self.ffn_layers.append(
+                FFN(
+                    hidden_channels,
+                    hidden_channels,
+                    filter_channels,
+                    kernel_size,
+                    p_dropout=p_dropout,
+                )
+            )
+            self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+    def forward(self, x, x_mask):
+        attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+        x = x * x_mask
+        for i in range(self.n_layers):
+            y = self.attn_layers[i](x, x, attn_mask)
+            y = self.drop(y)
+            x = self.norm_layers_1[i](x + y)
+
+            y = self.ffn_layers[i](x, x_mask)
+            y = self.drop(y)
+            x = self.norm_layers_2[i](x + y)
+        x = x * x_mask
+        return x
+
+
+class TextEncoder(torch.nn.Module):
+    """Text Encoder with configurable embedding dimension.
+
+    Args:
+        out_channels (int): Output channels of the encoder.
+        hidden_channels (int): Hidden channels of the encoder.
+        filter_channels (int): Filter channels of the encoder.
+        n_heads (int): Number of attention heads.
+        n_layers (int): Number of encoder layers.
+        kernel_size (int): Kernel size of the convolutional layers.
+        p_dropout (float): Dropout probability.
+        embedding_dim (int): Embedding dimension for phone embeddings (v1 = 256, v2 = 768).
+        f0 (bool, optional): Whether to use F0 embedding. Defaults to True.
+    """
+
+    def __init__(
+        self,
+        out_channels,
+        hidden_channels,
+        filter_channels,
+        n_heads,
+        n_layers,
+        kernel_size,
+        p_dropout,
+        embedding_dim,
+        f0=True,
+    ):
+        super(TextEncoder, self).__init__()
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = float(p_dropout)
+        self.emb_phone = torch.nn.Linear(embedding_dim, hidden_channels)
+        self.lrelu = torch.nn.LeakyReLU(0.1, inplace=True)
+        if f0:
+            self.emb_pitch = torch.nn.Embedding(256, hidden_channels)
+        self.encoder = Encoder(
+            hidden_channels,
+            filter_channels,
+            n_heads,
+            n_layers,
+            kernel_size,
+            float(p_dropout),
+        )
+        self.proj = torch.nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+    def forward(
+        self, phone: torch.Tensor, pitch: Optional[torch.Tensor], lengths: torch.Tensor
+    ):
+        if pitch is None:
+            x = self.emb_phone(phone)
+        else:
+            x = self.emb_phone(phone) + self.emb_pitch(pitch)
+        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
+        x = self.lrelu(x)
+        x = torch.transpose(x, 1, -1)  # [b, h, t]
+        x_mask = torch.unsqueeze(sequence_mask(lengths, x.size(2)), 1).to(x.dtype)
+        x = self.encoder(x * x_mask, x_mask)
+        stats = self.proj(x) * x_mask
+
+        m, logs = torch.split(stats, self.out_channels, dim=1)
+        return m, logs, x_mask
+
+
+class PosteriorEncoder(torch.nn.Module):
+    """Posterior Encoder for inferring latent representation.
+
+    Args:
+        in_channels (int): Number of channels in the input.
+        out_channels (int): Number of channels in the output.
+        hidden_channels (int): Number of hidden channels in the encoder.
+        kernel_size (int): Kernel size of the convolutional layers.
+        dilation_rate (int): Dilation rate of the convolutional layers.
+        n_layers (int): Number of layers in the encoder.
+        gin_channels (int, optional): Number of channels for the global conditioning input. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        hidden_channels,
+        kernel_size,
+        dilation_rate,
+        n_layers,
+        gin_channels=0,
+    ):
+        super(PosteriorEncoder, self).__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+        self.gin_channels = gin_channels
+
+        self.pre = torch.nn.Conv1d(in_channels, hidden_channels, 1)
+        self.enc = WaveNet(
+            hidden_channels,
+            kernel_size,
+            dilation_rate,
+            n_layers,
+            gin_channels=gin_channels,
+        )
+        self.proj = torch.nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+    def forward(
+        self, x: torch.Tensor, x_lengths: torch.Tensor, g: Optional[torch.Tensor] = None
+    ):
+        x_mask = torch.unsqueeze(sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+        x = self.pre(x) * x_mask
+        x = self.enc(x, x_mask, g=g)
+        stats = self.proj(x) * x_mask
+        m, logs = torch.split(stats, self.out_channels, dim=1)
+        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
+        return z, m, logs, x_mask
+
+    def remove_weight_norm(self):
+        """Removes weight normalization from the encoder."""
+        self.enc.remove_weight_norm()
+
+    def __prepare_scriptable__(self):
+        """Prepares the module for scripting."""
+        for hook in self.enc._forward_pre_hooks.values():
+            if (
+                hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                and hook.__class__.__name__ == "WeightNorm"
+            ):
+                torch.nn.utils.remove_weight_norm(self.enc)
+        return self

programs/applio_code/rvc/lib/algorithm/generators.py

@@ -0,0 +1,199 @@
+import torch
+from torch.nn.utils import remove_weight_norm
+from torch.nn.utils.parametrizations import weight_norm
+from typing import Optional
+
+from programs.applio_code.rvc.lib.algorithm.residuals import (
+    LRELU_SLOPE,
+    ResBlock1,
+    ResBlock2,
+)
+from programs.applio_code.rvc.lib.algorithm.commons import init_weights
+
+
+class Generator(torch.nn.Module):
+    """Generator for synthesizing audio. Optimized for performance and quality.
+
+    Args:
+        initial_channel (int): Number of channels in the initial convolutional layer.
+        resblock (str): Type of residual block to use (1 or 2).
+        resblock_kernel_sizes (list): Kernel sizes of the residual blocks.
+        resblock_dilation_sizes (list): Dilation rates of the residual blocks.
+        upsample_rates (list): Upsampling rates.
+        upsample_initial_channel (int): Number of channels in the initial upsampling layer.
+        upsample_kernel_sizes (list): Kernel sizes of the upsampling layers.
+        gin_channels (int, optional): Number of channels for the global conditioning input. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        initial_channel,
+        resblock,
+        resblock_kernel_sizes,
+        resblock_dilation_sizes,
+        upsample_rates,
+        upsample_initial_channel,
+        upsample_kernel_sizes,
+        gin_channels=0,
+    ):
+        super(Generator, self).__init__()
+        self.num_kernels = len(resblock_kernel_sizes)
+        self.num_upsamples = len(upsample_rates)
+        self.conv_pre = torch.nn.Conv1d(
+            initial_channel, upsample_initial_channel, 7, 1, padding=3
+        )
+        resblock = ResBlock1 if resblock == "1" else ResBlock2
+
+        self.ups_and_resblocks = torch.nn.ModuleList()
+        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
+            self.ups_and_resblocks.append(
+                weight_norm(
+                    torch.nn.ConvTranspose1d(
+                        upsample_initial_channel // (2**i),
+                        upsample_initial_channel // (2 ** (i + 1)),
+                        k,
+                        u,
+                        padding=(k - u) // 2,
+                    )
+                )
+            )
+            ch = upsample_initial_channel // (2 ** (i + 1))
+            for j, (k, d) in enumerate(
+                zip(resblock_kernel_sizes, resblock_dilation_sizes)
+            ):
+                self.ups_and_resblocks.append(resblock(ch, k, d))
+
+        self.conv_post = torch.nn.Conv1d(ch, 1, 7, 1, padding=3, bias=False)
+        self.ups_and_resblocks.apply(init_weights)
+
+        if gin_channels != 0:
+            self.cond = torch.nn.Conv1d(gin_channels, upsample_initial_channel, 1)
+
+        def forward(self, x: torch.Tensor, g: Optional[torch.Tensor] = None):
+            x = self.conv_pre(x)
+            if g is not None:
+                x = x + self.cond(g)
+
+            resblock_idx = 0
+            for _ in range(self.num_upsamples):
+                x = torch.nn.functional.leaky_relu(x, LRELU_SLOPE)
+                x = self.ups_and_resblocks[resblock_idx](x)
+                resblock_idx += 1
+                xs = 0
+                for _ in range(self.num_kernels):
+                    xs += self.ups_and_resblocks[resblock_idx](x)
+                    resblock_idx += 1
+                x = xs / self.num_kernels
+
+            x = torch.nn.functional.leaky_relu(x)
+            x = self.conv_post(x)
+            x = torch.tanh(x)
+
+            return x
+
+    def __prepare_scriptable__(self):
+        """Prepares the module for scripting."""
+        for l in self.ups_and_resblocks:
+            for hook in l._forward_pre_hooks.values():
+                if (
+                    hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                    and hook.__class__.__name__ == "WeightNorm"
+                ):
+                    torch.nn.utils.remove_weight_norm(l)
+        return self
+
+    def remove_weight_norm(self):
+        """Removes weight normalization from the upsampling and residual blocks."""
+        for l in self.ups_and_resblocks:
+            remove_weight_norm(l)
+
+
+class SineGen(torch.nn.Module):
+    """Sine wave generator.
+
+    Args:
+        samp_rate (int): Sampling rate in Hz.
+        harmonic_num (int, optional): Number of harmonic overtones. Defaults to 0.
+        sine_amp (float, optional): Amplitude of sine waveform. Defaults to 0.1.
+        noise_std (float, optional): Standard deviation of Gaussian noise. Defaults to 0.003.
+        voiced_threshold (float, optional): F0 threshold for voiced/unvoiced classification. Defaults to 0.
+        flag_for_pulse (bool, optional): Whether this SineGen is used inside PulseGen. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        samp_rate,
+        harmonic_num=0,
+        sine_amp=0.1,
+        noise_std=0.003,
+        voiced_threshold=0,
+        flag_for_pulse=False,
+    ):
+        super(SineGen, self).__init__()
+        self.sine_amp = sine_amp
+        self.noise_std = noise_std
+        self.harmonic_num = harmonic_num
+        self.dim = self.harmonic_num + 1
+        self.sample_rate = samp_rate
+        self.voiced_threshold = voiced_threshold
+
+    def _f02uv(self, f0):
+        """Converts F0 to voiced/unvoiced signal.
+
+        Args:
+            f0 (torch.Tensor): F0 tensor with shape (batch_size, length, 1)..
+        """
+        uv = torch.ones_like(f0)
+        uv = uv * (f0 > self.voiced_threshold)
+        return uv
+
+    def forward(self, f0: torch.Tensor, upp: int):
+        """Generates sine waves.
+
+        Args:
+            f0 (torch.Tensor): F0 tensor with shape (batch_size, length, 1).
+            upp (int): Upsampling factor.
+        """
+        with torch.no_grad():
+            f0 = f0[:, None].transpose(1, 2)
+            f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
+            f0_buf[:, :, 0] = f0[:, :, 0]
+            f0_buf[:, :, 1:] = (
+                f0_buf[:, :, 0:1]
+                * torch.arange(2, self.harmonic_num + 2, device=f0.device)[
+                    None, None, :
+                ]
+            )
+            rad_values = (f0_buf / float(self.sample_rate)) % 1
+            rand_ini = torch.rand(
+                f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
+            )
+            rand_ini[:, 0] = 0
+            rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
+            tmp_over_one = torch.cumsum(rad_values, 1)
+            tmp_over_one *= upp
+            tmp_over_one = torch.nn.functional.interpolate(
+                tmp_over_one.transpose(2, 1),
+                scale_factor=float(upp),
+                mode="linear",
+                align_corners=True,
+            ).transpose(2, 1)
+            rad_values = torch.nn.functional.interpolate(
+                rad_values.transpose(2, 1), scale_factor=float(upp), mode="nearest"
+            ).transpose(2, 1)
+            tmp_over_one %= 1
+            tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
+            cumsum_shift = torch.zeros_like(rad_values)
+            cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
+            sine_waves = torch.sin(
+                torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * torch.pi
+            )
+            sine_waves = sine_waves * self.sine_amp
+            uv = self._f02uv(f0)
+            uv = torch.nn.functional.interpolate(
+                uv.transpose(2, 1), scale_factor=float(upp), mode="nearest"
+            ).transpose(2, 1)
+            noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
+            noise = noise_amp * torch.randn_like(sine_waves)
+            sine_waves = sine_waves * uv + noise
+        return sine_waves, uv, noise

programs/applio_code/rvc/lib/algorithm/modules.py

@@ -0,0 +1,130 @@
+import torch
+from programs.applio_code.rvc.lib.algorithm.commons import (
+    fused_add_tanh_sigmoid_multiply_no_jit,
+    fused_add_tanh_sigmoid_multiply,
+)
+
+
+class WaveNet(torch.nn.Module):
+    """WaveNet residual blocks as used in WaveGlow
+
+    Args:
+        hidden_channels (int): Number of hidden channels.
+        kernel_size (int): Size of the convolutional kernel.
+        dilation_rate (int): Dilation rate of the convolution.
+        n_layers (int): Number of convolutional layers.
+        gin_channels (int, optional): Number of conditioning channels. Defaults to 0.
+        p_dropout (float, optional): Dropout probability. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        hidden_channels,
+        kernel_size,
+        dilation_rate,
+        n_layers,
+        gin_channels=0,
+        p_dropout=0,
+    ):
+        super(WaveNet, self).__init__()
+        assert kernel_size % 2 == 1
+        self.hidden_channels = hidden_channels
+        self.kernel_size = (kernel_size,)
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+        self.gin_channels = gin_channels
+        self.p_dropout = p_dropout
+
+        self.in_layers = torch.nn.ModuleList()
+        self.res_skip_layers = torch.nn.ModuleList()
+        self.drop = torch.nn.Dropout(p_dropout)
+
+        if gin_channels != 0:
+            cond_layer = torch.nn.Conv1d(
+                gin_channels, 2 * hidden_channels * n_layers, 1
+            )
+            self.cond_layer = torch.nn.utils.parametrizations.weight_norm(
+                cond_layer, name="weight"
+            )
+
+        dilations = [dilation_rate**i for i in range(n_layers)]
+        paddings = [(kernel_size * d - d) // 2 for d in dilations]
+
+        for i in range(n_layers):
+            in_layer = torch.nn.Conv1d(
+                hidden_channels,
+                2 * hidden_channels,
+                kernel_size,
+                dilation=dilations[i],
+                padding=paddings[i],
+            )
+            in_layer = torch.nn.utils.parametrizations.weight_norm(
+                in_layer, name="weight"
+            )
+            self.in_layers.append(in_layer)
+
+            res_skip_channels = (
+                hidden_channels if i == n_layers - 1 else 2 * hidden_channels
+            )
+
+            res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
+            res_skip_layer = torch.nn.utils.parametrizations.weight_norm(
+                res_skip_layer, name="weight"
+            )
+            self.res_skip_layers.append(res_skip_layer)
+
+    def forward(self, x, x_mask, g=None, **kwargs):
+        """Forward pass.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, hidden_channels, time_steps).
+            x_mask (torch.Tensor): Mask tensor of shape (batch_size, 1, time_steps).
+            g (torch.Tensor, optional): Conditioning tensor of shape (batch_size, gin_channels, time_steps).
+                Defaults to None.
+        """
+        output = torch.zeros_like(x)
+        n_channels_tensor = torch.IntTensor([self.hidden_channels])
+
+        if g is not None:
+            g = self.cond_layer(g)
+
+        # Zluda
+        is_zluda = x.device.type == "cuda" and torch.cuda.get_device_name().endswith(
+            "[ZLUDA]"
+        )
+
+        for i in range(self.n_layers):
+            x_in = self.in_layers[i](x)
+            if g is not None:
+                cond_offset = i * 2 * self.hidden_channels
+                g_l = g[:, cond_offset : cond_offset + 2 * self.hidden_channels, :]
+            else:
+                g_l = torch.zeros_like(x_in)
+
+            # Preventing HIP crash by not using jit-decorated function
+            if is_zluda:
+                acts = fused_add_tanh_sigmoid_multiply_no_jit(
+                    x_in, g_l, n_channels_tensor
+                )
+            else:
+                acts = fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor)
+
+            acts = self.drop(acts)
+
+            res_skip_acts = self.res_skip_layers[i](acts)
+            if i < self.n_layers - 1:
+                res_acts = res_skip_acts[:, : self.hidden_channels, :]
+                x = (x + res_acts) * x_mask
+                output = output + res_skip_acts[:, self.hidden_channels :, :]
+            else:
+                output = output + res_skip_acts
+        return output * x_mask
+
+    def remove_weight_norm(self):
+        """Remove weight normalization from the module."""
+        if self.gin_channels != 0:
+            torch.nn.utils.remove_weight_norm(self.cond_layer)
+        for l in self.in_layers:
+            torch.nn.utils.remove_weight_norm(l)
+        for l in self.res_skip_layers:
+            torch.nn.utils.remove_weight_norm(l)

programs/applio_code/rvc/lib/algorithm/normalization.py

@@ -0,0 +1,31 @@
+import torch
+
+
+class LayerNorm(torch.nn.Module):
+    """Layer normalization module.
+
+    Args:
+        channels (int): Number of channels.
+        eps (float, optional): Epsilon value for numerical stability. Defaults to 1e-5.
+    """
+
+    def __init__(self, channels, eps=1e-5):
+        super().__init__()
+        self.eps = eps
+        self.gamma = torch.nn.Parameter(torch.ones(channels))
+        self.beta = torch.nn.Parameter(torch.zeros(channels))
+
+    def forward(self, x):
+        """Forward pass.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, channels, time_steps).
+
+        """
+        # Transpose to (batch_size, time_steps, channels) for layer_norm
+        x = x.transpose(1, -1)
+        x = torch.nn.functional.layer_norm(
+            x, (x.size(-1),), self.gamma, self.beta, self.eps
+        )
+        # Transpose back to (batch_size, channels, time_steps)
+        return x.transpose(1, -1)

programs/applio_code/rvc/lib/algorithm/nsf.py

@@ -0,0 +1,200 @@
+import math
+import torch
+from torch.nn.utils import remove_weight_norm
+from torch.nn.utils.parametrizations import weight_norm
+from typing import Optional
+
+from programs.applio_code.rvc.lib.algorithm.generators import SineGen
+from programs.applio_code.rvc.lib.algorithm.residuals import (
+    LRELU_SLOPE,
+    ResBlock1,
+    ResBlock2,
+)
+from programs.applio_code.rvc.lib.algorithm.commons import init_weights
+
+
+class SourceModuleHnNSF(torch.nn.Module):
+    """
+    Source Module for harmonic-plus-noise excitation.
+
+    Args:
+        sample_rate (int): Sampling rate in Hz.
+        harmonic_num (int, optional): Number of harmonics above F0. Defaults to 0.
+        sine_amp (float, optional): Amplitude of sine source signal. Defaults to 0.1.
+        add_noise_std (float, optional): Standard deviation of additive Gaussian noise. Defaults to 0.003.
+        voiced_threshod (float, optional): Threshold to set voiced/unvoiced given F0. Defaults to 0.
+        is_half (bool, optional): Whether to use half precision. Defaults to True.
+    """
+
+    def __init__(
+        self,
+        sample_rate,
+        harmonic_num=0,
+        sine_amp=0.1,
+        add_noise_std=0.003,
+        voiced_threshod=0,
+        is_half=True,
+    ):
+        super(SourceModuleHnNSF, self).__init__()
+
+        self.sine_amp = sine_amp
+        self.noise_std = add_noise_std
+        self.is_half = is_half
+
+        self.l_sin_gen = SineGen(
+            sample_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
+        )
+        self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
+        self.l_tanh = torch.nn.Tanh()
+
+    def forward(self, x: torch.Tensor, upsample_factor: int = 1):
+        sine_wavs, uv, _ = self.l_sin_gen(x, upsample_factor)
+        sine_wavs = sine_wavs.to(dtype=self.l_linear.weight.dtype)
+        sine_merge = self.l_tanh(self.l_linear(sine_wavs))
+        return sine_merge, None, None
+
+
+class GeneratorNSF(torch.nn.Module):
+    """
+    Generator for synthesizing audio using the NSF (Neural Source Filter) approach.
+
+    Args:
+        initial_channel (int): Number of channels in the initial convolutional layer.
+        resblock (str): Type of residual block to use (1 or 2).
+        resblock_kernel_sizes (list): Kernel sizes of the residual blocks.
+        resblock_dilation_sizes (list): Dilation rates of the residual blocks.
+        upsample_rates (list): Upsampling rates.
+        upsample_initial_channel (int): Number of channels in the initial upsampling layer.
+        upsample_kernel_sizes (list): Kernel sizes of the upsampling layers.
+        gin_channels (int): Number of channels for the global conditioning input.
+        sr (int): Sampling rate.
+        is_half (bool, optional): Whether to use half precision. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        initial_channel,
+        resblock,
+        resblock_kernel_sizes,
+        resblock_dilation_sizes,
+        upsample_rates,
+        upsample_initial_channel,
+        upsample_kernel_sizes,
+        gin_channels,
+        sr,
+        is_half=False,
+    ):
+        super(GeneratorNSF, self).__init__()
+
+        self.num_kernels = len(resblock_kernel_sizes)
+        self.num_upsamples = len(upsample_rates)
+        self.f0_upsamp = torch.nn.Upsample(scale_factor=math.prod(upsample_rates))
+        self.m_source = SourceModuleHnNSF(
+            sample_rate=sr, harmonic_num=0, is_half=is_half
+        )
+
+        self.conv_pre = torch.nn.Conv1d(
+            initial_channel, upsample_initial_channel, 7, 1, padding=3
+        )
+        resblock_cls = ResBlock1 if resblock == "1" else ResBlock2
+
+        self.ups = torch.nn.ModuleList()
+        self.noise_convs = torch.nn.ModuleList()
+
+        channels = [
+            upsample_initial_channel // (2 ** (i + 1))
+            for i in range(len(upsample_rates))
+        ]
+        stride_f0s = [
+            math.prod(upsample_rates[i + 1 :]) if i + 1 < len(upsample_rates) else 1
+            for i in range(len(upsample_rates))
+        ]
+
+        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
+            self.ups.append(
+                weight_norm(
+                    torch.nn.ConvTranspose1d(
+                        upsample_initial_channel // (2**i),
+                        channels[i],
+                        k,
+                        u,
+                        padding=(k - u) // 2,
+                    )
+                )
+            )
+
+            self.noise_convs.append(
+                torch.nn.Conv1d(
+                    1,
+                    channels[i],
+                    kernel_size=(stride_f0s[i] * 2 if stride_f0s[i] > 1 else 1),
+                    stride=stride_f0s[i],
+                    padding=(stride_f0s[i] // 2 if stride_f0s[i] > 1 else 0),
+                )
+            )
+
+        self.resblocks = torch.nn.ModuleList(
+            [
+                resblock_cls(channels[i], k, d)
+                for i in range(len(self.ups))
+                for k, d in zip(resblock_kernel_sizes, resblock_dilation_sizes)
+            ]
+        )
+
+        self.conv_post = torch.nn.Conv1d(channels[-1], 1, 7, 1, padding=3, bias=False)
+        self.ups.apply(init_weights)
+
+        if gin_channels != 0:
+            self.cond = torch.nn.Conv1d(gin_channels, upsample_initial_channel, 1)
+
+        self.upp = math.prod(upsample_rates)
+        self.lrelu_slope = LRELU_SLOPE
+
+    def forward(self, x, f0, g: Optional[torch.Tensor] = None):
+        har_source, _, _ = self.m_source(f0, self.upp)
+        har_source = har_source.transpose(1, 2)
+        x = self.conv_pre(x)
+
+        if g is not None:
+            x = x + self.cond(g)
+
+        for i, (ups, noise_convs) in enumerate(zip(self.ups, self.noise_convs)):
+            x = torch.nn.functional.leaky_relu(x, self.lrelu_slope)
+            x = ups(x)
+            x = x + noise_convs(har_source)
+
+            xs = sum(
+                [
+                    resblock(x)
+                    for j, resblock in enumerate(self.resblocks)
+                    if j in range(i * self.num_kernels, (i + 1) * self.num_kernels)
+                ]
+            )
+            x = xs / self.num_kernels
+
+        x = torch.nn.functional.leaky_relu(x)
+        x = torch.tanh(self.conv_post(x))
+        return x
+
+    def remove_weight_norm(self):
+        for l in self.ups:
+            remove_weight_norm(l)
+        for l in self.resblocks:
+            l.remove_weight_norm()
+
+    def __prepare_scriptable__(self):
+        for l in self.ups:
+            for hook in l._forward_pre_hooks.values():
+                if (
+                    hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                    and hook.__class__.__name__ == "WeightNorm"
+                ):
+                    remove_weight_norm(l)
+        for l in self.resblocks:
+            for hook in l._forward_pre_hooks.values():
+                if (
+                    hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                    and hook.__class__.__name__ == "WeightNorm"
+                ):
+                    remove_weight_norm(l)
+        return self

programs/applio_code/rvc/lib/algorithm/residuals.py

@@ -0,0 +1,309 @@
+from typing import Optional
+import torch
+from torch.nn.utils import remove_weight_norm
+from torch.nn.utils.parametrizations import weight_norm
+
+from programs.applio_code.rvc.lib.algorithm.modules import WaveNet
+from programs.applio_code.rvc.lib.algorithm.commons import get_padding, init_weights
+
+LRELU_SLOPE = 0.1
+
+
+# Helper functions
+def create_conv1d_layer(channels, kernel_size, dilation):
+    return weight_norm(
+        torch.nn.Conv1d(
+            channels,
+            channels,
+            kernel_size,
+            1,
+            dilation=dilation,
+            padding=get_padding(kernel_size, dilation),
+        )
+    )
+
+
+def apply_mask(tensor, mask):
+    return tensor * mask if mask is not None else tensor
+
+
+class ResBlockBase(torch.nn.Module):
+    def __init__(self, channels, kernel_size, dilations):
+        super(ResBlockBase, self).__init__()
+        self.convs1 = torch.nn.ModuleList(
+            [create_conv1d_layer(channels, kernel_size, d) for d in dilations]
+        )
+        self.convs1.apply(init_weights)
+
+        self.convs2 = torch.nn.ModuleList(
+            [create_conv1d_layer(channels, kernel_size, 1) for _ in dilations]
+        )
+        self.convs2.apply(init_weights)
+
+    def forward(self, x, x_mask=None):
+        for c1, c2 in zip(self.convs1, self.convs2):
+            xt = torch.nn.functional.leaky_relu(x, LRELU_SLOPE)
+            xt = apply_mask(xt, x_mask)
+            xt = torch.nn.functional.leaky_relu(c1(xt), LRELU_SLOPE)
+            xt = apply_mask(xt, x_mask)
+            xt = c2(xt)
+            x = xt + x
+        return apply_mask(x, x_mask)
+
+    def remove_weight_norm(self):
+        for conv in self.convs1 + self.convs2:
+            remove_weight_norm(conv)
+
+
+class ResBlock1(ResBlockBase):
+    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
+        super(ResBlock1, self).__init__(channels, kernel_size, dilation)
+
+
+class ResBlock2(ResBlockBase):
+    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
+        super(ResBlock2, self).__init__(channels, kernel_size, dilation)
+
+
+class Log(torch.nn.Module):
+    """Logarithm module for flow-based models.
+
+    This module computes the logarithm of the input and its log determinant.
+    During reverse, it computes the exponential of the input.
+    """
+
+    def forward(self, x, x_mask, reverse=False, **kwargs):
+        """Forward pass.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+            x_mask (torch.Tensor): Mask tensor.
+            reverse (bool, optional): Whether to reverse the operation. Defaults to False.
+        """
+        if not reverse:
+            y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
+            logdet = torch.sum(-y, [1, 2])
+            return y, logdet
+        else:
+            x = torch.exp(x) * x_mask
+            return x
+
+
+class Flip(torch.nn.Module):
+    """Flip module for flow-based models.
+
+    This module flips the input along the time dimension.
+    """
+
+    def forward(self, x, *args, reverse=False, **kwargs):
+        """Forward pass.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+            reverse (bool, optional): Whether to reverse the operation. Defaults to False.
+        """
+        x = torch.flip(x, [1])
+        if not reverse:
+            logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
+            return x, logdet
+        else:
+            return x
+
+
+class ElementwiseAffine(torch.nn.Module):
+    """Elementwise affine transformation module for flow-based models.
+
+    This module performs an elementwise affine transformation on the input.
+
+    Args:
+        channels (int): Number of channels.
+
+    """
+
+    def __init__(self, channels):
+        super().__init__()
+        self.channels = channels
+        self.m = torch.nn.Parameter(torch.zeros(channels, 1))
+        self.logs = torch.nn.Parameter(torch.zeros(channels, 1))
+
+    def forward(self, x, x_mask, reverse=False, **kwargs):
+        """Forward pass.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+            x_mask (torch.Tensor): Mask tensor.
+            reverse (bool, optional): Whether to reverse the operation. Defaults to False.
+        """
+        if not reverse:
+            y = self.m + torch.exp(self.logs) * x
+            y = y * x_mask
+            logdet = torch.sum(self.logs * x_mask, [1, 2])
+            return y, logdet
+        else:
+            x = (x - self.m) * torch.exp(-self.logs) * x_mask
+            return x
+
+
+class ResidualCouplingBlock(torch.nn.Module):
+    """Residual Coupling Block for normalizing flow.
+
+    Args:
+        channels (int): Number of channels in the input.
+        hidden_channels (int): Number of hidden channels in the coupling layer.
+        kernel_size (int): Kernel size of the convolutional layers.
+        dilation_rate (int): Dilation rate of the convolutional layers.
+        n_layers (int): Number of layers in the coupling layer.
+        n_flows (int, optional): Number of coupling layers in the block. Defaults to 4.
+        gin_channels (int, optional): Number of channels for the global conditioning input. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        channels,
+        hidden_channels,
+        kernel_size,
+        dilation_rate,
+        n_layers,
+        n_flows=4,
+        gin_channels=0,
+    ):
+        super(ResidualCouplingBlock, self).__init__()
+        self.channels = channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+        self.n_flows = n_flows
+        self.gin_channels = gin_channels
+
+        self.flows = torch.nn.ModuleList()
+        for i in range(n_flows):
+            self.flows.append(
+                ResidualCouplingLayer(
+                    channels,
+                    hidden_channels,
+                    kernel_size,
+                    dilation_rate,
+                    n_layers,
+                    gin_channels=gin_channels,
+                    mean_only=True,
+                )
+            )
+            self.flows.append(Flip())
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        x_mask: torch.Tensor,
+        g: Optional[torch.Tensor] = None,
+        reverse: bool = False,
+    ):
+        if not reverse:
+            for flow in self.flows:
+                x, _ = flow(x, x_mask, g=g, reverse=reverse)
+        else:
+            for flow in reversed(self.flows):
+                x = flow.forward(x, x_mask, g=g, reverse=reverse)
+        return x
+
+    def remove_weight_norm(self):
+        """Removes weight normalization from the coupling layers."""
+        for i in range(self.n_flows):
+            self.flows[i * 2].remove_weight_norm()
+
+    def __prepare_scriptable__(self):
+        """Prepares the module for scripting."""
+        for i in range(self.n_flows):
+            for hook in self.flows[i * 2]._forward_pre_hooks.values():
+                if (
+                    hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                    and hook.__class__.__name__ == "WeightNorm"
+                ):
+                    torch.nn.utils.remove_weight_norm(self.flows[i * 2])
+
+        return self
+
+
+class ResidualCouplingLayer(torch.nn.Module):
+    """Residual coupling layer for flow-based models.
+
+    Args:
+        channels (int): Number of channels.
+        hidden_channels (int): Number of hidden channels.
+        kernel_size (int): Size of the convolutional kernel.
+        dilation_rate (int): Dilation rate of the convolution.
+        n_layers (int): Number of convolutional layers.
+        p_dropout (float, optional): Dropout probability. Defaults to 0.
+        gin_channels (int, optional): Number of conditioning channels. Defaults to 0.
+        mean_only (bool, optional): Whether to use mean-only coupling. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        channels,
+        hidden_channels,
+        kernel_size,
+        dilation_rate,
+        n_layers,
+        p_dropout=0,
+        gin_channels=0,
+        mean_only=False,
+    ):
+        assert channels % 2 == 0, "channels should be divisible by 2"
+        super().__init__()
+        self.channels = channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+        self.half_channels = channels // 2
+        self.mean_only = mean_only
+
+        self.pre = torch.nn.Conv1d(self.half_channels, hidden_channels, 1)
+        self.enc = WaveNet(
+            hidden_channels,
+            kernel_size,
+            dilation_rate,
+            n_layers,
+            p_dropout=p_dropout,
+            gin_channels=gin_channels,
+        )
+        self.post = torch.nn.Conv1d(
+            hidden_channels, self.half_channels * (2 - mean_only), 1
+        )
+        self.post.weight.data.zero_()
+        self.post.bias.data.zero_()
+
+    def forward(self, x, x_mask, g=None, reverse=False):
+        """Forward pass.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, channels, time_steps).
+            x_mask (torch.Tensor): Mask tensor of shape (batch_size, 1, time_steps).
+            g (torch.Tensor, optional): Conditioning tensor of shape (batch_size, gin_channels, time_steps).
+                Defaults to None.
+            reverse (bool, optional): Whether to reverse the operation. Defaults to False.
+        """
+        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
+        h = self.pre(x0) * x_mask
+        h = self.enc(h, x_mask, g=g)
+        stats = self.post(h) * x_mask
+        if not self.mean_only:
+            m, logs = torch.split(stats, [self.half_channels] * 2, 1)
+        else:
+            m = stats
+            logs = torch.zeros_like(m)
+
+        if not reverse:
+            x1 = m + x1 * torch.exp(logs) * x_mask
+            x = torch.cat([x0, x1], 1)
+            logdet = torch.sum(logs, [1, 2])
+            return x, logdet
+        else:
+            x1 = (x1 - m) * torch.exp(-logs) * x_mask
+            x = torch.cat([x0, x1], 1)
+            return x
+
+    def remove_weight_norm(self):
+        """Remove weight normalization from the module."""
+        self.enc.remove_weight_norm()

programs/applio_code/rvc/lib/algorithm/synthesizers.py

@@ -0,0 +1,243 @@
+import torch
+from typing import Optional
+
+from programs.applio_code.rvc.lib.algorithm.nsf import GeneratorNSF
+from programs.applio_code.rvc.lib.algorithm.generators import Generator
+from programs.applio_code.rvc.lib.algorithm.commons import (
+    slice_segments,
+    rand_slice_segments,
+)
+from programs.applio_code.rvc.lib.algorithm.residuals import ResidualCouplingBlock
+from programs.applio_code.rvc.lib.algorithm.encoders import (
+    TextEncoder,
+    PosteriorEncoder,
+)
+
+
+class Synthesizer(torch.nn.Module):
+    """
+    Base Synthesizer model.
+
+    Args:
+        spec_channels (int): Number of channels in the spectrogram.
+        segment_size (int): Size of the audio segment.
+        inter_channels (int): Number of channels in the intermediate layers.
+        hidden_channels (int): Number of channels in the hidden layers.
+        filter_channels (int): Number of channels in the filter layers.
+        n_heads (int): Number of attention heads.
+        n_layers (int): Number of layers in the encoder.
+        kernel_size (int): Size of the convolution kernel.
+        p_dropout (float): Dropout probability.
+        resblock (str): Type of residual block.
+        resblock_kernel_sizes (list): Kernel sizes for the residual blocks.
+        resblock_dilation_sizes (list): Dilation sizes for the residual blocks.
+        upsample_rates (list): Upsampling rates for the decoder.
+        upsample_initial_channel (int): Number of channels in the initial upsampling layer.
+        upsample_kernel_sizes (list): Kernel sizes for the upsampling layers.
+        spk_embed_dim (int): Dimension of the speaker embedding.
+        gin_channels (int): Number of channels in the global conditioning vector.
+        sr (int): Sampling rate of the audio.
+        use_f0 (bool): Whether to use F0 information.
+        text_enc_hidden_dim (int): Hidden dimension for the text encoder.
+        kwargs: Additional keyword arguments.
+    """
+
+    def __init__(
+        self,
+        spec_channels,
+        segment_size,
+        inter_channels,
+        hidden_channels,
+        filter_channels,
+        n_heads,
+        n_layers,
+        kernel_size,
+        p_dropout,
+        resblock,
+        resblock_kernel_sizes,
+        resblock_dilation_sizes,
+        upsample_rates,
+        upsample_initial_channel,
+        upsample_kernel_sizes,
+        spk_embed_dim,
+        gin_channels,
+        sr,
+        use_f0,
+        text_enc_hidden_dim=768,
+        **kwargs
+    ):
+        super(Synthesizer, self).__init__()
+        self.spec_channels = spec_channels
+        self.inter_channels = inter_channels
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = float(p_dropout)
+        self.resblock = resblock
+        self.resblock_kernel_sizes = resblock_kernel_sizes
+        self.resblock_dilation_sizes = resblock_dilation_sizes
+        self.upsample_rates = upsample_rates
+        self.upsample_initial_channel = upsample_initial_channel
+        self.upsample_kernel_sizes = upsample_kernel_sizes
+        self.segment_size = segment_size
+        self.gin_channels = gin_channels
+        self.spk_embed_dim = spk_embed_dim
+        self.use_f0 = use_f0
+
+        self.enc_p = TextEncoder(
+            inter_channels,
+            hidden_channels,
+            filter_channels,
+            n_heads,
+            n_layers,
+            kernel_size,
+            float(p_dropout),
+            text_enc_hidden_dim,
+            f0=use_f0,
+        )
+
+        if use_f0:
+            self.dec = GeneratorNSF(
+                inter_channels,
+                resblock,
+                resblock_kernel_sizes,
+                resblock_dilation_sizes,
+                upsample_rates,
+                upsample_initial_channel,
+                upsample_kernel_sizes,
+                gin_channels=gin_channels,
+                sr=sr,
+                is_half=kwargs["is_half"],
+            )
+        else:
+            self.dec = Generator(
+                inter_channels,
+                resblock,
+                resblock_kernel_sizes,
+                resblock_dilation_sizes,
+                upsample_rates,
+                upsample_initial_channel,
+                upsample_kernel_sizes,
+                gin_channels=gin_channels,
+            )
+
+        self.enc_q = PosteriorEncoder(
+            spec_channels,
+            inter_channels,
+            hidden_channels,
+            5,
+            1,
+            16,
+            gin_channels=gin_channels,
+        )
+        self.flow = ResidualCouplingBlock(
+            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
+        )
+        self.emb_g = torch.nn.Embedding(self.spk_embed_dim, gin_channels)
+
+    def remove_weight_norm(self):
+        """Removes weight normalization from the model."""
+        self.dec.remove_weight_norm()
+        self.flow.remove_weight_norm()
+        self.enc_q.remove_weight_norm()
+
+    def __prepare_scriptable__(self):
+        for hook in self.dec._forward_pre_hooks.values():
+            if (
+                hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                and hook.__class__.__name__ == "WeightNorm"
+            ):
+                torch.nn.utils.remove_weight_norm(self.dec)
+        for hook in self.flow._forward_pre_hooks.values():
+            if (
+                hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                and hook.__class__.__name__ == "WeightNorm"
+            ):
+                torch.nn.utils.remove_weight_norm(self.flow)
+        if hasattr(self, "enc_q"):
+            for hook in self.enc_q._forward_pre_hooks.values():
+                if (
+                    hook.__module__ == "torch.nn.utils.parametrizations.weight_norm"
+                    and hook.__class__.__name__ == "WeightNorm"
+                ):
+                    torch.nn.utils.remove_weight_norm(self.enc_q)
+        return self
+
+    @torch.jit.ignore
+    def forward(
+        self,
+        phone: torch.Tensor,
+        phone_lengths: torch.Tensor,
+        pitch: Optional[torch.Tensor] = None,
+        pitchf: Optional[torch.Tensor] = None,
+        y: torch.Tensor = None,
+        y_lengths: torch.Tensor = None,
+        ds: Optional[torch.Tensor] = None,
+    ):
+        """
+        Forward pass of the model.
+
+        Args:
+            phone (torch.Tensor): Phoneme sequence.
+            phone_lengths (torch.Tensor): Lengths of the phoneme sequences.
+            pitch (torch.Tensor, optional): Pitch sequence.
+            pitchf (torch.Tensor, optional): Fine-grained pitch sequence.
+            y (torch.Tensor, optional): Target spectrogram.
+            y_lengths (torch.Tensor, optional): Lengths of the target spectrograms.
+            ds (torch.Tensor, optional): Speaker embedding. Defaults to None.
+        """
+        g = self.emb_g(ds).unsqueeze(-1)
+        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
+        if y is not None:
+            z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
+            z_p = self.flow(z, y_mask, g=g)
+            z_slice, ids_slice = rand_slice_segments(z, y_lengths, self.segment_size)
+            if self.use_f0:
+                pitchf = slice_segments(pitchf, ids_slice, self.segment_size, 2)
+                o = self.dec(z_slice, pitchf, g=g)
+            else:
+                o = self.dec(z_slice, g=g)
+            return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
+        else:
+            return None, None, x_mask, None, (None, None, m_p, logs_p, None, None)
+
+    @torch.jit.export
+    def infer(
+        self,
+        phone: torch.Tensor,
+        phone_lengths: torch.Tensor,
+        pitch: Optional[torch.Tensor] = None,
+        nsff0: Optional[torch.Tensor] = None,
+        sid: torch.Tensor = None,
+        rate: Optional[torch.Tensor] = None,
+    ):
+        """
+        Inference of the model.
+
+        Args:
+            phone (torch.Tensor): Phoneme sequence.
+            phone_lengths (torch.Tensor): Lengths of the phoneme sequences.
+            pitch (torch.Tensor, optional): Pitch sequence.
+            nsff0 (torch.Tensor, optional): Fine-grained pitch sequence.
+            sid (torch.Tensor): Speaker embedding.
+            rate (torch.Tensor, optional): Rate for time-stretching. Defaults to None.
+        """
+        g = self.emb_g(sid).unsqueeze(-1)
+        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
+        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
+        if rate is not None:
+            assert isinstance(rate, torch.Tensor)
+            head = int(z_p.shape[2] * (1.0 - rate.item()))
+            z_p = z_p[:, :, head:]
+            x_mask = x_mask[:, :, head:]
+            if self.use_f0:
+                nsff0 = nsff0[:, head:]
+        if self.use_f0:
+            z = self.flow(z_p, x_mask, g=g, reverse=True)
+            o = self.dec(z * x_mask, nsff0, g=g)
+        else:
+            z = self.flow(z_p, x_mask, g=g, reverse=True)
+            o = self.dec(z * x_mask, g=g)
+        return o, x_mask, (z, z_p, m_p, logs_p)

programs/applio_code/rvc/lib/predictors/F0Extractor.py

@@ -0,0 +1,107 @@
+import dataclasses
+import pathlib
+import libf0
+import librosa
+import numpy as np
+import resampy
+import torch
+import torchcrepe
+import torchfcpe
+import os
+
+# from tools.anyf0.rmvpe import RMVPE
+from programs.applio_code.rvc.lib.predictors.RMVPE import RMVPE0Predictor
+from programs.applio_code.rvc.configs.config import Config
+
+config = Config()
+
+
+@dataclasses.dataclass
+class F0Extractor:
+    wav_path: pathlib.Path
+    sample_rate: int = 44100
+    hop_length: int = 512
+    f0_min: int = 50
+    f0_max: int = 1600
+    method: str = "rmvpe"
+    x: np.ndarray = dataclasses.field(init=False)
+
+    def __post_init__(self):
+        self.x, self.sample_rate = librosa.load(self.wav_path, sr=self.sample_rate)
+
+    @property
+    def hop_size(self) -> float:
+        return self.hop_length / self.sample_rate
+
+    @property
+    def wav16k(self) -> np.ndarray:
+        return resampy.resample(self.x, self.sample_rate, 16000)
+
+    def extract_f0(self) -> np.ndarray:
+        f0 = None
+        method = self.method
+        # Fall back to CPU for ZLUDA as these methods use CUcFFT
+        device = (
+            "cpu"
+            if "cuda" in config.device
+            and torch.cuda.get_device_name().endswith("[ZLUDA]")
+            else config.device
+        )
+
+        if method == "crepe":
+            wav16k_torch = torch.FloatTensor(self.wav16k).unsqueeze(0).to(device)
+            f0 = torchcrepe.predict(
+                wav16k_torch,
+                sample_rate=16000,
+                hop_length=160,
+                batch_size=512,
+                fmin=self.f0_min,
+                fmax=self.f0_max,
+                device=device,
+            )
+            f0 = f0[0].cpu().numpy()
+        elif method == "fcpe":
+            audio = librosa.to_mono(self.x)
+            audio_length = len(audio)
+            f0_target_length = (audio_length // self.hop_length) + 1
+            audio = (
+                torch.from_numpy(audio).float().unsqueeze(0).unsqueeze(-1).to(device)
+            )
+            model = torchfcpe.spawn_bundled_infer_model(device=device)
+
+            f0 = model.infer(
+                audio,
+                sr=self.sample_rate,
+                decoder_mode="local_argmax",
+                threshold=0.006,
+                f0_min=self.f0_min,
+                f0_max=self.f0_max,
+                interp_uv=False,
+                output_interp_target_length=f0_target_length,
+            )
+            f0 = f0.squeeze().cpu().numpy()
+        elif method == "rmvpe":
+            is_half = False if device == "cpu" else config.is_half
+            model_rmvpe = RMVPE0Predictor(
+                os.path.join(
+                    "programs", "applio_code", "rvc", "models", "predictors", "rmvpe.pt"
+                ),
+                is_half=is_half,
+                device=device,
+                # hop_length=80
+            )
+            f0 = model_rmvpe.infer_from_audio(self.wav16k, thred=0.03)
+
+        else:
+            raise ValueError(f"Unknown method: {self.method}")
+        return libf0.hz_to_cents(f0, librosa.midi_to_hz(0))
+
+    def plot_f0(self, f0):
+        from matplotlib import pyplot as plt
+
+        plt.figure(figsize=(10, 4))
+        plt.plot(f0)
+        plt.title(self.method)
+        plt.xlabel("Time (frames)")
+        plt.ylabel("F0 (cents)")
+        plt.show()

programs/applio_code/rvc/lib/predictors/FCPE.py

@@ -0,0 +1,920 @@
+from typing import Union
+
+import torch.nn.functional as F
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.nn.utils.parametrizations import weight_norm
+from torchaudio.transforms import Resample
+import os
+import librosa
+import soundfile as sf
+import torch.utils.data
+from librosa.filters import mel as librosa_mel_fn
+import math
+from functools import partial
+
+from einops import rearrange, repeat
+from local_attention import LocalAttention
+from torch import nn
+
+os.environ["LRU_CACHE_CAPACITY"] = "3"
+
+
+def load_wav_to_torch(full_path, target_sr=None, return_empty_on_exception=False):
+    """Loads wav file to torch tensor."""
+    try:
+        data, sample_rate = sf.read(full_path, always_2d=True)
+    except Exception as error:
+        print(f"An error occurred loading {full_path}: {error}")
+        if return_empty_on_exception:
+            return [], sample_rate or target_sr or 48000
+        else:
+            raise
+
+    data = data[:, 0] if len(data.shape) > 1 else data
+    assert len(data) > 2
+
+    # Normalize data
+    max_mag = (
+        -np.iinfo(data.dtype).min
+        if np.issubdtype(data.dtype, np.integer)
+        else max(np.amax(data), -np.amin(data))
+    )
+    max_mag = (
+        (2**31) + 1 if max_mag > (2**15) else ((2**15) + 1 if max_mag > 1.01 else 1.0)
+    )
+    data = torch.FloatTensor(data.astype(np.float32)) / max_mag
+
+    # Handle exceptions and resample
+    if (torch.isinf(data) | torch.isnan(data)).any() and return_empty_on_exception:
+        return [], sample_rate or target_sr or 48000
+    if target_sr is not None and sample_rate != target_sr:
+        data = torch.from_numpy(
+            librosa.core.resample(
+                data.numpy(), orig_sr=sample_rate, target_sr=target_sr
+            )
+        )
+        sample_rate = target_sr
+
+    return data, sample_rate
+
+
+def dynamic_range_compression(x, C=1, clip_val=1e-5):
+    return np.log(np.clip(x, a_min=clip_val, a_max=None) * C)
+
+
+def dynamic_range_decompression(x, C=1):
+    return np.exp(x) / C
+
+
+def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
+    return torch.log(torch.clamp(x, min=clip_val) * C)
+
+
+def dynamic_range_decompression_torch(x, C=1):
+    return torch.exp(x) / C
+
+
+class STFT:
+    def __init__(
+        self,
+        sr=22050,
+        n_mels=80,
+        n_fft=1024,
+        win_size=1024,
+        hop_length=256,
+        fmin=20,
+        fmax=11025,
+        clip_val=1e-5,
+    ):
+        self.target_sr = sr
+        self.n_mels = n_mels
+        self.n_fft = n_fft
+        self.win_size = win_size
+        self.hop_length = hop_length
+        self.fmin = fmin
+        self.fmax = fmax
+        self.clip_val = clip_val
+        self.mel_basis = {}
+        self.hann_window = {}
+
+    def get_mel(self, y, keyshift=0, speed=1, center=False, train=False):
+        sample_rate = self.target_sr
+        n_mels = self.n_mels
+        n_fft = self.n_fft
+        win_size = self.win_size
+        hop_length = self.hop_length
+        fmin = self.fmin
+        fmax = self.fmax
+        clip_val = self.clip_val
+
+        factor = 2 ** (keyshift / 12)
+        n_fft_new = int(np.round(n_fft * factor))
+        win_size_new = int(np.round(win_size * factor))
+        hop_length_new = int(np.round(hop_length * speed))
+
+        # Optimize mel_basis and hann_window caching
+        mel_basis = self.mel_basis if not train else {}
+        hann_window = self.hann_window if not train else {}
+
+        mel_basis_key = str(fmax) + "_" + str(y.device)
+        if mel_basis_key not in mel_basis:
+            mel = librosa_mel_fn(
+                sr=sample_rate, n_fft=n_fft, n_mels=n_mels, fmin=fmin, fmax=fmax
+            )
+            mel_basis[mel_basis_key] = torch.from_numpy(mel).float().to(y.device)
+
+        keyshift_key = str(keyshift) + "_" + str(y.device)
+        if keyshift_key not in hann_window:
+            hann_window[keyshift_key] = torch.hann_window(win_size_new).to(y.device)
+
+        # Padding and STFT
+        pad_left = (win_size_new - hop_length_new) // 2
+        pad_right = max(
+            (win_size_new - hop_length_new + 1) // 2,
+            win_size_new - y.size(-1) - pad_left,
+        )
+        mode = "reflect" if pad_right < y.size(-1) else "constant"
+        y = torch.nn.functional.pad(y.unsqueeze(1), (pad_left, pad_right), mode=mode)
+        y = y.squeeze(1)
+
+        spec = torch.stft(
+            y,
+            n_fft_new,
+            hop_length=hop_length_new,
+            win_length=win_size_new,
+            window=hann_window[keyshift_key],
+            center=center,
+            pad_mode="reflect",
+            normalized=False,
+            onesided=True,
+            return_complex=True,
+        )
+        spec = torch.sqrt(spec.real.pow(2) + spec.imag.pow(2) + (1e-9))
+
+        # Handle keyshift and mel conversion
+        if keyshift != 0:
+            size = n_fft // 2 + 1
+            resize = spec.size(1)
+            spec = (
+                F.pad(spec, (0, 0, 0, size - resize))
+                if resize < size
+                else spec[:, :size, :]
+            )
+            spec = spec * win_size / win_size_new
+        spec = torch.matmul(mel_basis[mel_basis_key], spec)
+        spec = dynamic_range_compression_torch(spec, clip_val=clip_val)
+        return spec
+
+    def __call__(self, audiopath):
+        audio, sr = load_wav_to_torch(audiopath, target_sr=self.target_sr)
+        spect = self.get_mel(audio.unsqueeze(0)).squeeze(0)
+        return spect
+
+
+stft = STFT()
+
+
+def softmax_kernel(
+    data, *, projection_matrix, is_query, normalize_data=True, eps=1e-4, device=None
+):
+    b, h, *_ = data.shape
+
+    # Normalize data
+    data_normalizer = (data.shape[-1] ** -0.25) if normalize_data else 1.0
+
+    # Project data
+    ratio = projection_matrix.shape[0] ** -0.5
+    projection = repeat(projection_matrix, "j d -> b h j d", b=b, h=h)
+    projection = projection.type_as(data)
+    data_dash = torch.einsum("...id,...jd->...ij", (data_normalizer * data), projection)
+
+    # Calculate diagonal data
+    diag_data = data**2
+    diag_data = torch.sum(diag_data, dim=-1)
+    diag_data = (diag_data / 2.0) * (data_normalizer**2)
+    diag_data = diag_data.unsqueeze(dim=-1)
+
+    # Apply softmax
+    if is_query:
+        data_dash = ratio * (
+            torch.exp(
+                data_dash
+                - diag_data
+                - torch.max(data_dash, dim=-1, keepdim=True).values
+            )
+            + eps
+        )
+    else:
+        data_dash = ratio * (torch.exp(data_dash - diag_data + eps))
+
+    return data_dash.type_as(data)
+
+
+def orthogonal_matrix_chunk(cols, qr_uniform_q=False, device=None):
+    unstructured_block = torch.randn((cols, cols), device=device)
+    q, r = torch.linalg.qr(unstructured_block.cpu(), mode="reduced")
+    q, r = map(lambda t: t.to(device), (q, r))
+
+    if qr_uniform_q:
+        d = torch.diag(r, 0)
+        q *= d.sign()
+    return q.t()
+
+
+def exists(val):
+    return val is not None
+
+
+def empty(tensor):
+    return tensor.numel() == 0
+
+
+def default(val, d):
+    return val if exists(val) else d
+
+
+def cast_tuple(val):
+    return (val,) if not isinstance(val, tuple) else val
+
+
+class PCmer(nn.Module):
+    def __init__(
+        self,
+        num_layers,
+        num_heads,
+        dim_model,
+        dim_keys,
+        dim_values,
+        residual_dropout,
+        attention_dropout,
+    ):
+        super().__init__()
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.dim_model = dim_model
+        self.dim_values = dim_values
+        self.dim_keys = dim_keys
+        self.residual_dropout = residual_dropout
+        self.attention_dropout = attention_dropout
+
+        self._layers = nn.ModuleList([_EncoderLayer(self) for _ in range(num_layers)])
+
+    def forward(self, phone, mask=None):
+        for layer in self._layers:
+            phone = layer(phone, mask)
+        return phone
+
+
+class _EncoderLayer(nn.Module):
+    def __init__(self, parent: PCmer):
+        super().__init__()
+        self.conformer = ConformerConvModule(parent.dim_model)
+        self.norm = nn.LayerNorm(parent.dim_model)
+        self.dropout = nn.Dropout(parent.residual_dropout)
+        self.attn = SelfAttention(
+            dim=parent.dim_model, heads=parent.num_heads, causal=False
+        )
+
+    def forward(self, phone, mask=None):
+        phone = phone + (self.attn(self.norm(phone), mask=mask))
+        phone = phone + (self.conformer(phone))
+        return phone
+
+
+def calc_same_padding(kernel_size):
+    pad = kernel_size // 2
+    return (pad, pad - (kernel_size + 1) % 2)
+
+
+class Swish(nn.Module):
+    def forward(self, x):
+        return x * x.sigmoid()
+
+
+class Transpose(nn.Module):
+    def __init__(self, dims):
+        super().__init__()
+        assert len(dims) == 2, "dims must be a tuple of two dimensions"
+        self.dims = dims
+
+    def forward(self, x):
+        return x.transpose(*self.dims)
+
+
+class GLU(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, x):
+        out, gate = x.chunk(2, dim=self.dim)
+        return out * gate.sigmoid()
+
+
+class DepthWiseConv1d(nn.Module):
+    def __init__(self, chan_in, chan_out, kernel_size, padding):
+        super().__init__()
+        self.padding = padding
+        self.conv = nn.Conv1d(chan_in, chan_out, kernel_size, groups=chan_in)
+
+    def forward(self, x):
+        x = F.pad(x, self.padding)
+        return self.conv(x)
+
+
+class ConformerConvModule(nn.Module):
+    def __init__(
+        self, dim, causal=False, expansion_factor=2, kernel_size=31, dropout=0.0
+    ):
+        super().__init__()
+
+        inner_dim = dim * expansion_factor
+        padding = calc_same_padding(kernel_size) if not causal else (kernel_size - 1, 0)
+
+        self.net = nn.Sequential(
+            nn.LayerNorm(dim),
+            Transpose((1, 2)),
+            nn.Conv1d(dim, inner_dim * 2, 1),
+            GLU(dim=1),
+            DepthWiseConv1d(
+                inner_dim, inner_dim, kernel_size=kernel_size, padding=padding
+            ),
+            Swish(),
+            nn.Conv1d(inner_dim, dim, 1),
+            Transpose((1, 2)),
+            nn.Dropout(dropout),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+def linear_attention(q, k, v):
+    if v is None:
+        out = torch.einsum("...ed,...nd->...ne", k, q)
+        return out
+    else:
+        k_cumsum = k.sum(dim=-2)
+        D_inv = 1.0 / (torch.einsum("...nd,...d->...n", q, k_cumsum.type_as(q)) + 1e-8)
+        context = torch.einsum("...nd,...ne->...de", k, v)
+        out = torch.einsum("...de,...nd,...n->...ne", context, q, D_inv)
+        return out
+
+
+def gaussian_orthogonal_random_matrix(
+    nb_rows, nb_columns, scaling=0, qr_uniform_q=False, device=None
+):
+    nb_full_blocks = int(nb_rows / nb_columns)
+    block_list = []
+
+    for _ in range(nb_full_blocks):
+        q = orthogonal_matrix_chunk(
+            nb_columns, qr_uniform_q=qr_uniform_q, device=device
+        )
+        block_list.append(q)
+
+    remaining_rows = nb_rows - nb_full_blocks * nb_columns
+    if remaining_rows > 0:
+        q = orthogonal_matrix_chunk(
+            nb_columns, qr_uniform_q=qr_uniform_q, device=device
+        )
+        block_list.append(q[:remaining_rows])
+
+    final_matrix = torch.cat(block_list)
+
+    if scaling == 0:
+        multiplier = torch.randn((nb_rows, nb_columns), device=device).norm(dim=1)
+    elif scaling == 1:
+        multiplier = math.sqrt((float(nb_columns))) * torch.ones(
+            (nb_rows,), device=device
+        )
+    else:
+        raise ValueError(f"Invalid scaling {scaling}")
+
+    return torch.diag(multiplier) @ final_matrix
+
+
+class FastAttention(nn.Module):
+    def __init__(
+        self,
+        dim_heads,
+        nb_features=None,
+        ortho_scaling=0,
+        causal=False,
+        generalized_attention=False,
+        kernel_fn=nn.ReLU(),
+        qr_uniform_q=False,
+        no_projection=False,
+    ):
+        super().__init__()
+        nb_features = default(nb_features, int(dim_heads * math.log(dim_heads)))
+
+        self.dim_heads = dim_heads
+        self.nb_features = nb_features
+        self.ortho_scaling = ortho_scaling
+
+        self.create_projection = partial(
+            gaussian_orthogonal_random_matrix,
+            nb_rows=self.nb_features,
+            nb_columns=dim_heads,
+            scaling=ortho_scaling,
+            qr_uniform_q=qr_uniform_q,
+        )
+        projection_matrix = self.create_projection()
+        self.register_buffer("projection_matrix", projection_matrix)
+
+        self.generalized_attention = generalized_attention
+        self.kernel_fn = kernel_fn
+        self.no_projection = no_projection
+        self.causal = causal
+
+    @torch.no_grad()
+    def redraw_projection_matrix(self):
+        projections = self.create_projection()
+        self.projection_matrix.copy_(projections)
+        del projections
+
+    def forward(self, q, k, v):
+        device = q.device
+
+        if self.no_projection:
+            q = q.softmax(dim=-1)
+            k = torch.exp(k) if self.causal else k.softmax(dim=-2)
+        else:
+            create_kernel = partial(
+                softmax_kernel, projection_matrix=self.projection_matrix, device=device
+            )
+            q = create_kernel(q, is_query=True)
+            k = create_kernel(k, is_query=False)
+
+        attn_fn = linear_attention if not self.causal else self.causal_linear_fn
+
+        if v is None:
+            out = attn_fn(q, k, None)
+            return out
+        else:
+            out = attn_fn(q, k, v)
+            return out
+
+
+class SelfAttention(nn.Module):
+    def __init__(
+        self,
+        dim,
+        causal=False,
+        heads=8,
+        dim_head=64,
+        local_heads=0,
+        local_window_size=256,
+        nb_features=None,
+        feature_redraw_interval=1000,
+        generalized_attention=False,
+        kernel_fn=nn.ReLU(),
+        qr_uniform_q=False,
+        dropout=0.0,
+        no_projection=False,
+    ):
+        super().__init__()
+        assert dim % heads == 0, "dimension must be divisible by number of heads"
+        dim_head = default(dim_head, dim // heads)
+        inner_dim = dim_head * heads
+        self.fast_attention = FastAttention(
+            dim_head,
+            nb_features,
+            causal=causal,
+            generalized_attention=generalized_attention,
+            kernel_fn=kernel_fn,
+            qr_uniform_q=qr_uniform_q,
+            no_projection=no_projection,
+        )
+
+        self.heads = heads
+        self.global_heads = heads - local_heads
+        self.local_attn = (
+            LocalAttention(
+                window_size=local_window_size,
+                causal=causal,
+                autopad=True,
+                dropout=dropout,
+                look_forward=int(not causal),
+                rel_pos_emb_config=(dim_head, local_heads),
+            )
+            if local_heads > 0
+            else None
+        )
+
+        self.to_q = nn.Linear(dim, inner_dim)
+        self.to_k = nn.Linear(dim, inner_dim)
+        self.to_v = nn.Linear(dim, inner_dim)
+        self.to_out = nn.Linear(inner_dim, dim)
+        self.dropout = nn.Dropout(dropout)
+
+    @torch.no_grad()
+    def redraw_projection_matrix(self):
+        self.fast_attention.redraw_projection_matrix()
+
+    def forward(
+        self,
+        x,
+        context=None,
+        mask=None,
+        context_mask=None,
+        name=None,
+        inference=False,
+        **kwargs,
+    ):
+        _, _, _, h, gh = *x.shape, self.heads, self.global_heads
+
+        cross_attend = exists(context)
+        context = default(context, x)
+        context_mask = default(context_mask, mask) if not cross_attend else context_mask
+        q, k, v = self.to_q(x), self.to_k(context), self.to_v(context)
+
+        q, k, v = map(lambda t: rearrange(t, "b n (h d) -> b h n d", h=h), (q, k, v))
+        (q, lq), (k, lk), (v, lv) = map(lambda t: (t[:, :gh], t[:, gh:]), (q, k, v))
+
+        attn_outs = []
+        if not empty(q):
+            if exists(context_mask):
+                global_mask = context_mask[:, None, :, None]
+                v.masked_fill_(~global_mask, 0.0)
+            if cross_attend:
+                pass  # TODO: Implement cross-attention
+            else:
+                out = self.fast_attention(q, k, v)
+            attn_outs.append(out)
+
+        if not empty(lq):
+            assert (
+                not cross_attend
+            ), "local attention is not compatible with cross attention"
+            out = self.local_attn(lq, lk, lv, input_mask=mask)
+            attn_outs.append(out)
+
+        out = torch.cat(attn_outs, dim=1)
+        out = rearrange(out, "b h n d -> b n (h d)")
+        out = self.to_out(out)
+        return self.dropout(out)
+
+
+def l2_regularization(model, l2_alpha):
+    l2_loss = []
+    for module in model.modules():
+        if type(module) is nn.Conv2d:
+            l2_loss.append((module.weight**2).sum() / 2.0)
+    return l2_alpha * sum(l2_loss)
+
+
+class FCPE(nn.Module):
+    def __init__(
+        self,
+        input_channel=128,
+        out_dims=360,
+        n_layers=12,
+        n_chans=512,
+        use_siren=False,
+        use_full=False,
+        loss_mse_scale=10,
+        loss_l2_regularization=False,
+        loss_l2_regularization_scale=1,
+        loss_grad1_mse=False,
+        loss_grad1_mse_scale=1,
+        f0_max=1975.5,
+        f0_min=32.70,
+        confidence=False,
+        threshold=0.05,
+        use_input_conv=True,
+    ):
+        super().__init__()
+        if use_siren is True:
+            raise ValueError("Siren is not supported yet.")
+        if use_full is True:
+            raise ValueError("Full model is not supported yet.")
+
+        self.loss_mse_scale = loss_mse_scale if (loss_mse_scale is not None) else 10
+        self.loss_l2_regularization = (
+            loss_l2_regularization if (loss_l2_regularization is not None) else False
+        )
+        self.loss_l2_regularization_scale = (
+            loss_l2_regularization_scale
+            if (loss_l2_regularization_scale is not None)
+            else 1
+        )
+        self.loss_grad1_mse = loss_grad1_mse if (loss_grad1_mse is not None) else False
+        self.loss_grad1_mse_scale = (
+            loss_grad1_mse_scale if (loss_grad1_mse_scale is not None) else 1
+        )
+        self.f0_max = f0_max if (f0_max is not None) else 1975.5
+        self.f0_min = f0_min if (f0_min is not None) else 32.70
+        self.confidence = confidence if (confidence is not None) else False
+        self.threshold = threshold if (threshold is not None) else 0.05
+        self.use_input_conv = use_input_conv if (use_input_conv is not None) else True
+
+        self.cent_table_b = torch.Tensor(
+            np.linspace(
+                self.f0_to_cent(torch.Tensor([f0_min]))[0],
+                self.f0_to_cent(torch.Tensor([f0_max]))[0],
+                out_dims,
+            )
+        )
+        self.register_buffer("cent_table", self.cent_table_b)
+
+        # conv in stack
+        _leaky = nn.LeakyReLU()
+        self.stack = nn.Sequential(
+            nn.Conv1d(input_channel, n_chans, 3, 1, 1),
+            nn.GroupNorm(4, n_chans),
+            _leaky,
+            nn.Conv1d(n_chans, n_chans, 3, 1, 1),
+        )
+
+        # transformer
+        self.decoder = PCmer(
+            num_layers=n_layers,
+            num_heads=8,
+            dim_model=n_chans,
+            dim_keys=n_chans,
+            dim_values=n_chans,
+            residual_dropout=0.1,
+            attention_dropout=0.1,
+        )
+        self.norm = nn.LayerNorm(n_chans)
+
+        # out
+        self.n_out = out_dims
+        self.dense_out = weight_norm(nn.Linear(n_chans, self.n_out))
+
+    def forward(
+        self, mel, infer=True, gt_f0=None, return_hz_f0=False, cdecoder="local_argmax"
+    ):
+        if cdecoder == "argmax":
+            self.cdecoder = self.cents_decoder
+        elif cdecoder == "local_argmax":
+            self.cdecoder = self.cents_local_decoder
+
+        x = (
+            self.stack(mel.transpose(1, 2)).transpose(1, 2)
+            if self.use_input_conv
+            else mel
+        )
+        x = self.decoder(x)
+        x = self.norm(x)
+        x = self.dense_out(x)
+        x = torch.sigmoid(x)
+
+        if not infer:
+            gt_cent_f0 = self.f0_to_cent(gt_f0)
+            gt_cent_f0 = self.gaussian_blurred_cent(gt_cent_f0)
+            loss_all = self.loss_mse_scale * F.binary_cross_entropy(x, gt_cent_f0)
+            if self.loss_l2_regularization:
+                loss_all = loss_all + l2_regularization(
+                    model=self, l2_alpha=self.loss_l2_regularization_scale
+                )
+            x = loss_all
+        if infer:
+            x = self.cdecoder(x)
+            x = self.cent_to_f0(x)
+            x = (1 + x / 700).log() if not return_hz_f0 else x
+
+        return x
+
+    def cents_decoder(self, y, mask=True):
+        B, N, _ = y.size()
+        ci = self.cent_table[None, None, :].expand(B, N, -1)
+        rtn = torch.sum(ci * y, dim=-1, keepdim=True) / torch.sum(
+            y, dim=-1, keepdim=True
+        )
+        if mask:
+            confident = torch.max(y, dim=-1, keepdim=True)[0]
+            confident_mask = torch.ones_like(confident)
+            confident_mask[confident <= self.threshold] = float("-INF")
+            rtn = rtn * confident_mask
+        return (rtn, confident) if self.confidence else rtn
+
+    def cents_local_decoder(self, y, mask=True):
+        B, N, _ = y.size()
+        ci = self.cent_table[None, None, :].expand(B, N, -1)
+        confident, max_index = torch.max(y, dim=-1, keepdim=True)
+        local_argmax_index = torch.arange(0, 9).to(max_index.device) + (max_index - 4)
+        local_argmax_index = torch.clamp(local_argmax_index, 0, self.n_out - 1)
+        ci_l = torch.gather(ci, -1, local_argmax_index)
+        y_l = torch.gather(y, -1, local_argmax_index)
+        rtn = torch.sum(ci_l * y_l, dim=-1, keepdim=True) / torch.sum(
+            y_l, dim=-1, keepdim=True
+        )
+        if mask:
+            confident_mask = torch.ones_like(confident)
+            confident_mask[confident <= self.threshold] = float("-INF")
+            rtn = rtn * confident_mask
+        return (rtn, confident) if self.confidence else rtn
+
+    def cent_to_f0(self, cent):
+        return 10.0 * 2 ** (cent / 1200.0)
+
+    def f0_to_cent(self, f0):
+        return 1200.0 * torch.log2(f0 / 10.0)
+
+    def gaussian_blurred_cent(self, cents):
+        mask = (cents > 0.1) & (cents < (1200.0 * np.log2(self.f0_max / 10.0)))
+        B, N, _ = cents.size()
+        ci = self.cent_table[None, None, :].expand(B, N, -1)
+        return torch.exp(-torch.square(ci - cents) / 1250) * mask.float()
+
+
+class FCPEInfer:
+    def __init__(self, model_path, device=None, dtype=torch.float32):
+        if device is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.device = device
+        ckpt = torch.load(model_path, map_location=torch.device(self.device))
+        self.args = DotDict(ckpt["config"])
+        self.dtype = dtype
+        model = FCPE(
+            input_channel=self.args.model.input_channel,
+            out_dims=self.args.model.out_dims,
+            n_layers=self.args.model.n_layers,
+            n_chans=self.args.model.n_chans,
+            use_siren=self.args.model.use_siren,
+            use_full=self.args.model.use_full,
+            loss_mse_scale=self.args.loss.loss_mse_scale,
+            loss_l2_regularization=self.args.loss.loss_l2_regularization,
+            loss_l2_regularization_scale=self.args.loss.loss_l2_regularization_scale,
+            loss_grad1_mse=self.args.loss.loss_grad1_mse,
+            loss_grad1_mse_scale=self.args.loss.loss_grad1_mse_scale,
+            f0_max=self.args.model.f0_max,
+            f0_min=self.args.model.f0_min,
+            confidence=self.args.model.confidence,
+        )
+        model.to(self.device).to(self.dtype)
+        model.load_state_dict(ckpt["model"])
+        model.eval()
+        self.model = model
+        self.wav2mel = Wav2Mel(self.args, dtype=self.dtype, device=self.device)
+
+    @torch.no_grad()
+    def __call__(self, audio, sr, threshold=0.05):
+        self.model.threshold = threshold
+        audio = audio[None, :]
+        mel = self.wav2mel(audio=audio, sample_rate=sr).to(self.dtype)
+        f0 = self.model(mel=mel, infer=True, return_hz_f0=True)
+        return f0
+
+
+class Wav2Mel:
+    def __init__(self, args, device=None, dtype=torch.float32):
+        self.sample_rate = args.mel.sampling_rate
+        self.hop_size = args.mel.hop_size
+        if device is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.device = device
+        self.dtype = dtype
+        self.stft = STFT(
+            args.mel.sampling_rate,
+            args.mel.num_mels,
+            args.mel.n_fft,
+            args.mel.win_size,
+            args.mel.hop_size,
+            args.mel.fmin,
+            args.mel.fmax,
+        )
+        self.resample_kernel = {}
+
+    def extract_nvstft(self, audio, keyshift=0, train=False):
+        mel = self.stft.get_mel(audio, keyshift=keyshift, train=train).transpose(1, 2)
+        return mel
+
+    def extract_mel(self, audio, sample_rate, keyshift=0, train=False):
+        audio = audio.to(self.dtype).to(self.device)
+        if sample_rate == self.sample_rate:
+            audio_res = audio
+        else:
+            key_str = str(sample_rate)
+            if key_str not in self.resample_kernel:
+                self.resample_kernel[key_str] = Resample(
+                    sample_rate, self.sample_rate, lowpass_filter_width=128
+                )
+            self.resample_kernel[key_str] = (
+                self.resample_kernel[key_str].to(self.dtype).to(self.device)
+            )
+            audio_res = self.resample_kernel[key_str](audio)
+
+        mel = self.extract_nvstft(
+            audio_res, keyshift=keyshift, train=train
+        )  # B, n_frames, bins
+        n_frames = int(audio.shape[1] // self.hop_size) + 1
+        mel = (
+            torch.cat((mel, mel[:, -1:, :]), 1) if n_frames > int(mel.shape[1]) else mel
+        )
+        mel = mel[:, :n_frames, :] if n_frames < int(mel.shape[1]) else mel
+        return mel
+
+    def __call__(self, audio, sample_rate, keyshift=0, train=False):
+        return self.extract_mel(audio, sample_rate, keyshift=keyshift, train=train)
+
+
+class DotDict(dict):
+    def __getattr__(*args):
+        val = dict.get(*args)
+        return DotDict(val) if type(val) is dict else val
+
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+class F0Predictor(object):
+    def compute_f0(self, wav, p_len):
+        pass
+
+    def compute_f0_uv(self, wav, p_len):
+        pass
+
+
+class FCPEF0Predictor(F0Predictor):
+    def __init__(
+        self,
+        model_path,
+        hop_length=512,
+        f0_min=50,
+        f0_max=1100,
+        dtype=torch.float32,
+        device=None,
+        sample_rate=44100,
+        threshold=0.05,
+    ):
+        self.fcpe = FCPEInfer(model_path, device=device, dtype=dtype)
+        self.hop_length = hop_length
+        self.f0_min = f0_min
+        self.f0_max = f0_max
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.threshold = threshold
+        self.sample_rate = sample_rate
+        self.dtype = dtype
+        self.name = "fcpe"
+
+    def repeat_expand(
+        self,
+        content: Union[torch.Tensor, np.ndarray],
+        target_len: int,
+        mode: str = "nearest",
+    ):
+        ndim = content.ndim
+        content = (
+            content[None, None]
+            if ndim == 1
+            else content[None] if ndim == 2 else content
+        )
+        assert content.ndim == 3
+        is_np = isinstance(content, np.ndarray)
+        content = torch.from_numpy(content) if is_np else content
+        results = torch.nn.functional.interpolate(content, size=target_len, mode=mode)
+        results = results.numpy() if is_np else results
+        return results[0, 0] if ndim == 1 else results[0] if ndim == 2 else results
+
+    def post_process(self, x, sample_rate, f0, pad_to):
+        f0 = (
+            torch.from_numpy(f0).float().to(x.device)
+            if isinstance(f0, np.ndarray)
+            else f0
+        )
+        f0 = self.repeat_expand(f0, pad_to) if pad_to is not None else f0
+
+        vuv_vector = torch.zeros_like(f0)
+        vuv_vector[f0 > 0.0] = 1.0
+        vuv_vector[f0 <= 0.0] = 0.0
+
+        nzindex = torch.nonzero(f0).squeeze()
+        f0 = torch.index_select(f0, dim=0, index=nzindex).cpu().numpy()
+        time_org = self.hop_length / sample_rate * nzindex.cpu().numpy()
+        time_frame = np.arange(pad_to) * self.hop_length / sample_rate
+
+        vuv_vector = F.interpolate(vuv_vector[None, None, :], size=pad_to)[0][0]
+
+        if f0.shape[0] <= 0:
+            return np.zeros(pad_to), vuv_vector.cpu().numpy()
+        if f0.shape[0] == 1:
+            return np.ones(pad_to) * f0[0], vuv_vector.cpu().numpy()
+
+        f0 = np.interp(time_frame, time_org, f0, left=f0[0], right=f0[-1])
+        return f0, vuv_vector.cpu().numpy()
+
+    def compute_f0(self, wav, p_len=None):
+        x = torch.FloatTensor(wav).to(self.dtype).to(self.device)
+        p_len = x.shape[0] // self.hop_length if p_len is None else p_len
+        f0 = self.fcpe(x, sr=self.sample_rate, threshold=self.threshold)[0, :, 0]
+        if torch.all(f0 == 0):
+            return f0.cpu().numpy() if p_len is None else np.zeros(p_len), (
+                f0.cpu().numpy() if p_len is None else np.zeros(p_len)
+            )
+        return self.post_process(x, self.sample_rate, f0, p_len)[0]
+
+    def compute_f0_uv(self, wav, p_len=None):
+        x = torch.FloatTensor(wav).to(self.dtype).to(self.device)
+        p_len = x.shape[0] // self.hop_length if p_len is None else p_len
+        f0 = self.fcpe(x, sr=self.sample_rate, threshold=self.threshold)[0, :, 0]
+        if torch.all(f0 == 0):
+            return f0.cpu().numpy() if p_len is None else np.zeros(p_len), (
+                f0.cpu().numpy() if p_len is None else np.zeros(p_len)
+            )
+        return self.post_process(x, self.sample_rate, f0, p_len)

programs/applio_code/rvc/lib/predictors/RMVPE.py

@@ -0,0 +1,569 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+from librosa.filters import mel
+from typing import List
+
+# Constants for readability
+N_MELS = 128
+N_CLASS = 360
+
+
+# Define a helper function for creating convolutional blocks
+class ConvBlockRes(nn.Module):
+    """
+    A convolutional block with residual connection.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        momentum (float): Momentum for batch normalization.
+    """
+
+    def __init__(self, in_channels, out_channels, momentum=0.01):
+        super(ConvBlockRes, self).__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=(3, 3),
+                stride=(1, 1),
+                padding=(1, 1),
+                bias=False,
+            ),
+            nn.BatchNorm2d(out_channels, momentum=momentum),
+            nn.ReLU(),
+            nn.Conv2d(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                kernel_size=(3, 3),
+                stride=(1, 1),
+                padding=(1, 1),
+                bias=False,
+            ),
+            nn.BatchNorm2d(out_channels, momentum=momentum),
+            nn.ReLU(),
+        )
+        if in_channels != out_channels:
+            self.shortcut = nn.Conv2d(in_channels, out_channels, (1, 1))
+            self.is_shortcut = True
+        else:
+            self.is_shortcut = False
+
+    def forward(self, x):
+        if self.is_shortcut:
+            return self.conv(x) + self.shortcut(x)
+        else:
+            return self.conv(x) + x
+
+
+# Define a class for residual encoder blocks
+class ResEncoderBlock(nn.Module):
+    """
+    A residual encoder block.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        kernel_size (tuple): Size of the average pooling kernel.
+        n_blocks (int): Number of convolutional blocks in the block.
+        momentum (float): Momentum for batch normalization.
+    """
+
+    def __init__(
+        self, in_channels, out_channels, kernel_size, n_blocks=1, momentum=0.01
+    ):
+        super(ResEncoderBlock, self).__init__()
+        self.n_blocks = n_blocks
+        self.conv = nn.ModuleList()
+        self.conv.append(ConvBlockRes(in_channels, out_channels, momentum))
+        for _ in range(n_blocks - 1):
+            self.conv.append(ConvBlockRes(out_channels, out_channels, momentum))
+        self.kernel_size = kernel_size
+        if self.kernel_size is not None:
+            self.pool = nn.AvgPool2d(kernel_size=kernel_size)
+
+    def forward(self, x):
+        for i in range(self.n_blocks):
+            x = self.conv[i](x)
+        if self.kernel_size is not None:
+            return x, self.pool(x)
+        else:
+            return x
+
+
+# Define a class for the encoder
+class Encoder(nn.Module):
+    """
+    The encoder part of the DeepUnet.
+
+    Args:
+        in_channels (int): Number of input channels.
+        in_size (int): Size of the input tensor.
+        n_encoders (int): Number of encoder blocks.
+        kernel_size (tuple): Size of the average pooling kernel.
+        n_blocks (int): Number of convolutional blocks in each encoder block.
+        out_channels (int): Number of output channels for the first encoder block.
+        momentum (float): Momentum for batch normalization.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        in_size,
+        n_encoders,
+        kernel_size,
+        n_blocks,
+        out_channels=16,
+        momentum=0.01,
+    ):
+        super(Encoder, self).__init__()
+        self.n_encoders = n_encoders
+        self.bn = nn.BatchNorm2d(in_channels, momentum=momentum)
+        self.layers = nn.ModuleList()
+        self.latent_channels = []
+        for i in range(self.n_encoders):
+            self.layers.append(
+                ResEncoderBlock(
+                    in_channels, out_channels, kernel_size, n_blocks, momentum=momentum
+                )
+            )
+            self.latent_channels.append([out_channels, in_size])
+            in_channels = out_channels
+            out_channels *= 2
+            in_size //= 2
+        self.out_size = in_size
+        self.out_channel = out_channels
+
+    def forward(self, x: torch.Tensor):
+        concat_tensors: List[torch.Tensor] = []
+        x = self.bn(x)
+        for i in range(self.n_encoders):
+            t, x = self.layers[i](x)
+            concat_tensors.append(t)
+        return x, concat_tensors
+
+
+# Define a class for the intermediate layer
+class Intermediate(nn.Module):
+    """
+    The intermediate layer of the DeepUnet.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        n_inters (int): Number of convolutional blocks in the intermediate layer.
+        n_blocks (int): Number of convolutional blocks in each intermediate block.
+        momentum (float): Momentum for batch normalization.
+    """
+
+    def __init__(self, in_channels, out_channels, n_inters, n_blocks, momentum=0.01):
+        super(Intermediate, self).__init__()
+        self.n_inters = n_inters
+        self.layers = nn.ModuleList()
+        self.layers.append(
+            ResEncoderBlock(in_channels, out_channels, None, n_blocks, momentum)
+        )
+        for _ in range(self.n_inters - 1):
+            self.layers.append(
+                ResEncoderBlock(out_channels, out_channels, None, n_blocks, momentum)
+            )
+
+    def forward(self, x):
+        for i in range(self.n_inters):
+            x = self.layers[i](x)
+        return x
+
+
+# Define a class for residual decoder blocks
+class ResDecoderBlock(nn.Module):
+    """
+    A residual decoder block.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        stride (tuple): Stride for transposed convolution.
+        n_blocks (int): Number of convolutional blocks in the block.
+        momentum (float): Momentum for batch normalization.
+    """
+
+    def __init__(self, in_channels, out_channels, stride, n_blocks=1, momentum=0.01):
+        super(ResDecoderBlock, self).__init__()
+        out_padding = (0, 1) if stride == (1, 2) else (1, 1)
+        self.n_blocks = n_blocks
+        self.conv1 = nn.Sequential(
+            nn.ConvTranspose2d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=(3, 3),
+                stride=stride,
+                padding=(1, 1),
+                output_padding=out_padding,
+                bias=False,
+            ),
+            nn.BatchNorm2d(out_channels, momentum=momentum),
+            nn.ReLU(),
+        )
+        self.conv2 = nn.ModuleList()
+        self.conv2.append(ConvBlockRes(out_channels * 2, out_channels, momentum))
+        for _ in range(n_blocks - 1):
+            self.conv2.append(ConvBlockRes(out_channels, out_channels, momentum))
+
+    def forward(self, x, concat_tensor):
+        x = self.conv1(x)
+        x = torch.cat((x, concat_tensor), dim=1)
+        for i in range(self.n_blocks):
+            x = self.conv2[i](x)
+        return x
+
+
+# Define a class for the decoder
+class Decoder(nn.Module):
+    """
+    The decoder part of the DeepUnet.
+
+    Args:
+        in_channels (int): Number of input channels.
+        n_decoders (int): Number of decoder blocks.
+        stride (tuple): Stride for transposed convolution.
+        n_blocks (int): Number of convolutional blocks in each decoder block.
+        momentum (float): Momentum for batch normalization.
+    """
+
+    def __init__(self, in_channels, n_decoders, stride, n_blocks, momentum=0.01):
+        super(Decoder, self).__init__()
+        self.layers = nn.ModuleList()
+        self.n_decoders = n_decoders
+        for _ in range(self.n_decoders):
+            out_channels = in_channels // 2
+            self.layers.append(
+                ResDecoderBlock(in_channels, out_channels, stride, n_blocks, momentum)
+            )
+            in_channels = out_channels
+
+    def forward(self, x, concat_tensors):
+        for i in range(self.n_decoders):
+            x = self.layers[i](x, concat_tensors[-1 - i])
+        return x
+
+
+# Define a class for the DeepUnet architecture
+class DeepUnet(nn.Module):
+    """
+    The DeepUnet architecture.
+
+    Args:
+        kernel_size (tuple): Size of the average pooling kernel.
+        n_blocks (int): Number of convolutional blocks in each encoder/decoder block.
+        en_de_layers (int): Number of encoder/decoder layers.
+        inter_layers (int): Number of convolutional blocks in the intermediate layer.
+        in_channels (int): Number of input channels.
+        en_out_channels (int): Number of output channels for the first encoder block.
+    """
+
+    def __init__(
+        self,
+        kernel_size,
+        n_blocks,
+        en_de_layers=5,
+        inter_layers=4,
+        in_channels=1,
+        en_out_channels=16,
+    ):
+        super(DeepUnet, self).__init__()
+        self.encoder = Encoder(
+            in_channels, 128, en_de_layers, kernel_size, n_blocks, en_out_channels
+        )
+        self.intermediate = Intermediate(
+            self.encoder.out_channel // 2,
+            self.encoder.out_channel,
+            inter_layers,
+            n_blocks,
+        )
+        self.decoder = Decoder(
+            self.encoder.out_channel, en_de_layers, kernel_size, n_blocks
+        )
+
+    def forward(self, x):
+        x, concat_tensors = self.encoder(x)
+        x = self.intermediate(x)
+        x = self.decoder(x, concat_tensors)
+        return x
+
+
+# Define a class for the end-to-end model
+class E2E(nn.Module):
+    """
+    The end-to-end model.
+
+    Args:
+        n_blocks (int): Number of convolutional blocks in each encoder/decoder block.
+        n_gru (int): Number of GRU layers.
+        kernel_size (tuple): Size of the average pooling kernel.
+        en_de_layers (int): Number of encoder/decoder layers.
+        inter_layers (int): Number of convolutional blocks in the intermediate layer.
+        in_channels (int): Number of input channels.
+        en_out_channels (int): Number of output channels for the first encoder block.
+    """
+
+    def __init__(
+        self,
+        n_blocks,
+        n_gru,
+        kernel_size,
+        en_de_layers=5,
+        inter_layers=4,
+        in_channels=1,
+        en_out_channels=16,
+    ):
+        super(E2E, self).__init__()
+        self.unet = DeepUnet(
+            kernel_size,
+            n_blocks,
+            en_de_layers,
+            inter_layers,
+            in_channels,
+            en_out_channels,
+        )
+        self.cnn = nn.Conv2d(en_out_channels, 3, (3, 3), padding=(1, 1))
+        if n_gru:
+            self.fc = nn.Sequential(
+                BiGRU(3 * 128, 256, n_gru),
+                nn.Linear(512, N_CLASS),
+                nn.Dropout(0.25),
+                nn.Sigmoid(),
+            )
+        else:
+            self.fc = nn.Sequential(
+                nn.Linear(3 * N_MELS, N_CLASS), nn.Dropout(0.25), nn.Sigmoid()
+            )
+
+    def forward(self, mel):
+        mel = mel.transpose(-1, -2).unsqueeze(1)
+        x = self.cnn(self.unet(mel)).transpose(1, 2).flatten(-2)
+        x = self.fc(x)
+        return x
+
+
+# Define a class for the MelSpectrogram extractor
+class MelSpectrogram(torch.nn.Module):
+    """
+    Extracts Mel-spectrogram features from audio.
+
+    Args:
+        is_half (bool): Whether to use half-precision floating-point numbers.
+        n_mel_channels (int): Number of Mel-frequency bands.
+        sample_rate (int): Sampling rate of the audio.
+        win_length (int): Length of the window function in samples.
+        hop_length (int): Hop size between frames in samples.
+        n_fft (int, optional): Length of the FFT window. Defaults to None, which uses win_length.
+        mel_fmin (int, optional): Minimum frequency for the Mel filter bank. Defaults to 0.
+        mel_fmax (int, optional): Maximum frequency for the Mel filter bank. Defaults to None.
+        clamp (float, optional): Minimum value for clamping the Mel-spectrogram. Defaults to 1e-5.
+    """
+
+    def __init__(
+        self,
+        is_half,
+        n_mel_channels,
+        sample_rate,
+        win_length,
+        hop_length,
+        n_fft=None,
+        mel_fmin=0,
+        mel_fmax=None,
+        clamp=1e-5,
+    ):
+        super().__init__()
+        n_fft = win_length if n_fft is None else n_fft
+        self.hann_window = {}
+        mel_basis = mel(
+            sr=sample_rate,
+            n_fft=n_fft,
+            n_mels=n_mel_channels,
+            fmin=mel_fmin,
+            fmax=mel_fmax,
+            htk=True,
+        )
+        mel_basis = torch.from_numpy(mel_basis).float()
+        self.register_buffer("mel_basis", mel_basis)
+        self.n_fft = win_length if n_fft is None else n_fft
+        self.hop_length = hop_length
+        self.win_length = win_length
+        self.sample_rate = sample_rate
+        self.n_mel_channels = n_mel_channels
+        self.clamp = clamp
+        self.is_half = is_half
+
+    def forward(self, audio, keyshift=0, speed=1, center=True):
+        factor = 2 ** (keyshift / 12)
+        n_fft_new = int(np.round(self.n_fft * factor))
+        win_length_new = int(np.round(self.win_length * factor))
+        hop_length_new = int(np.round(self.hop_length * speed))
+        keyshift_key = str(keyshift) + "_" + str(audio.device)
+        if keyshift_key not in self.hann_window:
+            self.hann_window[keyshift_key] = torch.hann_window(win_length_new).to(
+                audio.device
+            )
+
+        # Zluda, fall-back to CPU for FFTs since HIP SDK has no cuFFT alternative
+        source_device = audio.device
+        if audio.device.type == "cuda" and torch.cuda.get_device_name().endswith(
+            "[ZLUDA]"
+        ):
+            audio = audio.to("cpu")
+            self.hann_window[keyshift_key] = self.hann_window[keyshift_key].to("cpu")
+
+        fft = torch.stft(
+            audio,
+            n_fft=n_fft_new,
+            hop_length=hop_length_new,
+            win_length=win_length_new,
+            window=self.hann_window[keyshift_key],
+            center=center,
+            return_complex=True,
+        ).to(source_device)
+
+        magnitude = torch.sqrt(fft.real.pow(2) + fft.imag.pow(2))
+        if keyshift != 0:
+            size = self.n_fft // 2 + 1
+            resize = magnitude.size(1)
+            if resize < size:
+                magnitude = F.pad(magnitude, (0, 0, 0, size - resize))
+            magnitude = magnitude[:, :size, :] * self.win_length / win_length_new
+        mel_output = torch.matmul(self.mel_basis, magnitude)
+        if self.is_half:
+            mel_output = mel_output.half()
+        log_mel_spec = torch.log(torch.clamp(mel_output, min=self.clamp))
+        return log_mel_spec
+
+
+# Define a class for the RMVPE0 predictor
+class RMVPE0Predictor:
+    """
+    A predictor for fundamental frequency (F0) based on the RMVPE0 model.
+
+    Args:
+        model_path (str): Path to the RMVPE0 model file.
+        is_half (bool): Whether to use half-precision floating-point numbers.
+        device (str, optional): Device to use for computation. Defaults to None, which uses CUDA if available.
+    """
+
+    def __init__(self, model_path, is_half, device=None):
+        self.resample_kernel = {}
+        model = E2E(4, 1, (2, 2))
+        ckpt = torch.load(model_path, map_location="cpu")
+        model.load_state_dict(ckpt)
+        model.eval()
+        if is_half:
+            model = model.half()
+        self.model = model
+        self.resample_kernel = {}
+        self.is_half = is_half
+        self.device = device
+        self.mel_extractor = MelSpectrogram(
+            is_half, N_MELS, 16000, 1024, 160, None, 30, 8000
+        ).to(device)
+        self.model = self.model.to(device)
+        cents_mapping = 20 * np.arange(N_CLASS) + 1997.3794084376191
+        self.cents_mapping = np.pad(cents_mapping, (4, 4))
+
+    def mel2hidden(self, mel):
+        """
+        Converts Mel-spectrogram features to hidden representation.
+
+        Args:
+            mel (torch.Tensor): Mel-spectrogram features.
+        """
+        with torch.no_grad():
+            n_frames = mel.shape[-1]
+            mel = F.pad(
+                mel, (0, 32 * ((n_frames - 1) // 32 + 1) - n_frames), mode="reflect"
+            )
+            hidden = self.model(mel)
+            return hidden[:, :n_frames]
+
+    def decode(self, hidden, thred=0.03):
+        """
+        Decodes hidden representation to F0.
+
+        Args:
+            hidden (np.ndarray): Hidden representation.
+            thred (float, optional): Threshold for salience. Defaults to 0.03.
+        """
+        cents_pred = self.to_local_average_cents(hidden, thred=thred)
+        f0 = 10 * (2 ** (cents_pred / 1200))
+        f0[f0 == 10] = 0
+        return f0
+
+    def infer_from_audio(self, audio, thred=0.03):
+        """
+        Infers F0 from audio.
+
+        Args:
+            audio (np.ndarray): Audio signal.
+            thred (float, optional): Threshold for salience. Defaults to 0.03.
+        """
+        audio = torch.from_numpy(audio).float().to(self.device).unsqueeze(0)
+        mel = self.mel_extractor(audio, center=True)
+        hidden = self.mel2hidden(mel)
+        hidden = hidden.squeeze(0).cpu().numpy()
+        if self.is_half == True:
+            hidden = hidden.astype("float32")
+        f0 = self.decode(hidden, thred=thred)
+        return f0
+
+    def to_local_average_cents(self, salience, thred=0.05):
+        """
+        Converts salience to local average cents.
+
+        Args:
+            salience (np.ndarray): Salience values.
+            thred (float, optional): Threshold for salience. Defaults to 0.05.
+        """
+        center = np.argmax(salience, axis=1)
+        salience = np.pad(salience, ((0, 0), (4, 4)))
+        center += 4
+        todo_salience = []
+        todo_cents_mapping = []
+        starts = center - 4
+        ends = center + 5
+        for idx in range(salience.shape[0]):
+            todo_salience.append(salience[:, starts[idx] : ends[idx]][idx])
+            todo_cents_mapping.append(self.cents_mapping[starts[idx] : ends[idx]])
+        todo_salience = np.array(todo_salience)
+        todo_cents_mapping = np.array(todo_cents_mapping)
+        product_sum = np.sum(todo_salience * todo_cents_mapping, 1)
+        weight_sum = np.sum(todo_salience, 1)
+        devided = product_sum / weight_sum
+        maxx = np.max(salience, axis=1)
+        devided[maxx <= thred] = 0
+        return devided
+
+
+# Define a class for BiGRU (bidirectional GRU)
+class BiGRU(nn.Module):
+    """
+    A bidirectional GRU layer.
+
+    Args:
+        input_features (int): Number of input features.
+        hidden_features (int): Number of hidden features.
+        num_layers (int): Number of GRU layers.
+    """
+
+    def __init__(self, input_features, hidden_features, num_layers):
+        super(BiGRU, self).__init__()
+        self.gru = nn.GRU(
+            input_features,
+            hidden_features,
+            num_layers=num_layers,
+            batch_first=True,
+            bidirectional=True,
+        )
+
+    def forward(self, x):
+        return self.gru(x)[0]

programs/applio_code/rvc/lib/tools/analyzer.py

@@ -0,0 +1,76 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import librosa.display
+import librosa
+
+
+def calculate_features(y, sr):
+    stft = np.abs(librosa.stft(y))
+    duration = librosa.get_duration(y=y, sr=sr)
+    cent = librosa.feature.spectral_centroid(S=stft, sr=sr)[0]
+    bw = librosa.feature.spectral_bandwidth(S=stft, sr=sr)[0]
+    rolloff = librosa.feature.spectral_rolloff(S=stft, sr=sr)[0]
+    return stft, duration, cent, bw, rolloff
+
+
+def plot_title(title):
+    plt.suptitle(title, fontsize=16, fontweight="bold")
+
+
+def plot_spectrogram(y, sr, stft, duration, cmap="inferno"):
+    plt.subplot(3, 1, 1)
+    plt.imshow(
+        librosa.amplitude_to_db(stft, ref=np.max),
+        origin="lower",
+        extent=[0, duration, 0, sr / 1000],
+        aspect="auto",
+        cmap=cmap,  # Change the colormap here
+    )
+    plt.colorbar(format="%+2.0f dB")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Frequency (kHz)")
+    plt.title("Spectrogram")
+
+
+def plot_waveform(y, sr, duration):
+    plt.subplot(3, 1, 2)
+    librosa.display.waveshow(y, sr=sr)
+    plt.xlabel("Time (s)")
+    plt.ylabel("Amplitude")
+    plt.title("Waveform")
+
+
+def plot_features(times, cent, bw, rolloff, duration):
+    plt.subplot(3, 1, 3)
+    plt.plot(times, cent, label="Spectral Centroid (kHz)", color="b")
+    plt.plot(times, bw, label="Spectral Bandwidth (kHz)", color="g")
+    plt.plot(times, rolloff, label="Spectral Rolloff (kHz)", color="r")
+    plt.xlabel("Time (s)")
+    plt.title("Spectral Features")
+    plt.legend()
+
+
+def analyze_audio(audio_file, save_plot_path="logs/audio_analysis.png"):
+    y, sr = librosa.load(audio_file)
+    stft, duration, cent, bw, rolloff = calculate_features(y, sr)
+
+    plt.figure(figsize=(12, 10))
+
+    plot_title("Audio Analysis" + " - " + audio_file.split("/")[-1])
+    plot_spectrogram(y, sr, stft, duration)
+    plot_waveform(y, sr, duration)
+    plot_features(librosa.times_like(cent), cent, bw, rolloff, duration)
+
+    plt.tight_layout()
+
+    if save_plot_path:
+        plt.savefig(save_plot_path, bbox_inches="tight", dpi=300)
+    plt.close()
+
+    audio_info = f"""Sample Rate: {sr}\nDuration: {(
+            str(round(duration, 2)) + " seconds"
+            if duration < 60
+            else str(round(duration / 60, 2)) + " minutes"
+    )}\nNumber of Samples: {len(y)}\nBits per Sample: {librosa.get_samplerate(audio_file)}\nChannels: {"Mono (1)" if y.ndim == 1 else "Stereo (2)"}"""
+
+    return audio_info, save_plot_path

programs/applio_code/rvc/lib/tools/gdown.py

@@ -0,0 +1,354 @@
+import os
+import re
+import six
+import sys
+import json
+import tqdm
+import time
+import shutil
+import warnings
+import tempfile
+import textwrap
+import requests
+from six.moves import urllib_parse
+
+
+def indent(text, prefix):
+    """Indent each non-empty line of text with the given prefix."""
+    return "".join(
+        (prefix + line if line.strip() else line) for line in text.splitlines(True)
+    )
+
+
+class FileURLRetrievalError(Exception):
+    pass
+
+
+class FolderContentsMaximumLimitError(Exception):
+    pass
+
+
+def parse_url(url, warning=True):
+    """Parse URLs especially for Google Drive links.
+
+    Args:
+        url: URL to parse.
+        warning: Whether to warn if the URL is not a download link.
+
+    Returns:
+        A tuple (file_id, is_download_link), where file_id is the ID of the
+        file on Google Drive, and is_download_link is a flag indicating
+        whether the URL is a download link.
+    """
+    parsed = urllib_parse.urlparse(url)
+    query = urllib_parse.parse_qs(parsed.query)
+    is_gdrive = parsed.hostname in ("drive.google.com", "docs.google.com")
+    is_download_link = parsed.path.endswith("/uc")
+
+    if not is_gdrive:
+        return None, is_download_link
+
+    file_id = query.get("id", [None])[0]
+    if file_id is None:
+        for pattern in (
+            r"^/file/d/(.*?)/(edit|view)$",
+            r"^/file/u/[0-9]+/d/(.*?)/(edit|view)$",
+            r"^/document/d/(.*?)/(edit|htmlview|view)$",
+            r"^/document/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
+            r"^/presentation/d/(.*?)/(edit|htmlview|view)$",
+            r"^/presentation/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
+            r"^/spreadsheets/d/(.*?)/(edit|htmlview|view)$",
+            r"^/spreadsheets/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
+        ):
+            match = re.match(pattern, parsed.path)
+            if match:
+                file_id = match.group(1)
+                break
+
+    if warning and not is_download_link:
+        warnings.warn(
+            "You specified a Google Drive link that is not the correct link "
+            "to download a file. You might want to try `--fuzzy` option "
+            f"or the following url: https://drive.google.com/uc?id={file_id}"
+        )
+
+    return file_id, is_download_link
+
+
+CHUNK_SIZE = 512 * 1024  # 512KB
+HOME = os.path.expanduser("~")
+
+
+def get_url_from_gdrive_confirmation(contents):
+    """Extract the download URL from a Google Drive confirmation page."""
+    for pattern in (
+        r'href="(\/uc\?export=download[^"]+)',
+        r'href="/open\?id=([^"]+)"',
+        r'"downloadUrl":"([^"]+)',
+    ):
+        match = re.search(pattern, contents)
+        if match:
+            url = match.group(1)
+            if pattern == r'href="/open\?id=([^"]+)"':
+                uuid = re.search(
+                    r'<input\s+type="hidden"\s+name="uuid"\s+value="([^"]+)"',
+                    contents,
+                ).group(1)
+                url = (
+                    "https://drive.usercontent.google.com/download?id="
+                    + url
+                    + "&confirm=t&uuid="
+                    + uuid
+                )
+            elif pattern == r'"downloadUrl":"([^"]+)':
+                url = url.replace("\\u003d", "=").replace("\\u0026", "&")
+            else:
+                url = "https://docs.google.com" + url.replace("&", "&")
+            return url
+
+    match = re.search(r'<p class="uc-error-subcaption">(.*)</p>', contents)
+    if match:
+        error = match.group(1)
+        raise FileURLRetrievalError(error)
+
+    raise FileURLRetrievalError(
+        "Cannot retrieve the public link of the file. "
+        "You may need to change the permission to "
+        "'Anyone with the link', or have had many accesses."
+    )
+
+
+def _get_session(proxy, use_cookies, return_cookies_file=False):
+    """Create a requests session with optional proxy and cookie handling."""
+    sess = requests.session()
+    sess.headers.update(
+        {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)"}
+    )
+
+    if proxy is not None:
+        sess.proxies = {"http": proxy, "https": proxy}
+        print("Using proxy:", proxy, file=sys.stderr)
+
+    cookies_file = os.path.join(HOME, ".cache/gdown/cookies.json")
+    if os.path.exists(cookies_file) and use_cookies:
+        with open(cookies_file) as f:
+            cookies = json.load(f)
+        for k, v in cookies:
+            sess.cookies[k] = v
+
+    return (sess, cookies_file) if return_cookies_file else sess
+
+
+def download(
+    url=None,
+    output=None,
+    quiet=False,
+    proxy=None,
+    speed=None,
+    use_cookies=True,
+    verify=True,
+    id=None,
+    fuzzy=True,
+    resume=False,
+    format=None,
+):
+    """Download file from URL.
+
+    Parameters
+    ----------
+    url: str
+        URL. Google Drive URL is also supported.
+    output: str
+        Output filename. Default is basename of URL.
+    quiet: bool
+        Suppress terminal output. Default is False.
+    proxy: str
+        Proxy.
+    speed: float
+        Download byte size per second (e.g., 256KB/s = 256 * 1024).
+    use_cookies: bool
+        Flag to use cookies. Default is True.
+    verify: bool or string
+        Either a bool, in which case it controls whether the server's TLS
+        certificate is verified, or a string, in which case it must be a path
+        to a CA bundle to use. Default is True.
+    id: str
+        Google Drive's file ID.
+    fuzzy: bool
+        Fuzzy extraction of Google Drive's file Id. Default is False.
+    resume: bool
+        Resume the download from existing tmp file if possible.
+        Default is False.
+    format: str, optional
+        Format of Google Docs, Spreadsheets and Slides. Default is:
+            - Google Docs: 'docx'
+            - Google Spreadsheet: 'xlsx'
+            - Google Slides: 'pptx'
+
+    Returns
+    -------
+    output: str
+        Output filename.
+    """
+    if not (id is None) ^ (url is None):
+        raise ValueError("Either url or id has to be specified")
+    if id is not None:
+        url = f"https://drive.google.com/uc?id={id}"
+
+    url_origin = url
+
+    sess, cookies_file = _get_session(
+        proxy=proxy, use_cookies=use_cookies, return_cookies_file=True
+    )
+
+    gdrive_file_id, is_gdrive_download_link = parse_url(url, warning=not fuzzy)
+
+    if fuzzy and gdrive_file_id:
+        # overwrite the url with fuzzy match of a file id
+        url = f"https://drive.google.com/uc?id={gdrive_file_id}"
+        url_origin = url
+        is_gdrive_download_link = True
+
+    while True:
+        res = sess.get(url, stream=True, verify=verify)
+
+        if url == url_origin and res.status_code == 500:
+            # The file could be Google Docs or Spreadsheets.
+            url = f"https://drive.google.com/open?id={gdrive_file_id}"
+            continue
+
+        if res.headers["Content-Type"].startswith("text/html"):
+            title = re.search("<title>(.+)</title>", res.text)
+            if title:
+                title = title.group(1)
+                if title.endswith(" - Google Docs"):
+                    url = f"https://docs.google.com/document/d/{gdrive_file_id}/export?format={'docx' if format is None else format}"
+                    continue
+                if title.endswith(" - Google Sheets"):
+                    url = f"https://docs.google.com/spreadsheets/d/{gdrive_file_id}/export?format={'xlsx' if format is None else format}"
+                    continue
+                if title.endswith(" - Google Slides"):
+                    url = f"https://docs.google.com/presentation/d/{gdrive_file_id}/export?format={'pptx' if format is None else format}"
+                    continue
+        elif (
+            "Content-Disposition" in res.headers
+            and res.headers["Content-Disposition"].endswith("pptx")
+            and format not in (None, "pptx")
+        ):
+            url = f"https://docs.google.com/presentation/d/{gdrive_file_id}/export?format={'pptx' if format is None else format}"
+            continue
+
+        if use_cookies:
+            os.makedirs(os.path.dirname(cookies_file), exist_ok=True)
+            with open(cookies_file, "w") as f:
+                cookies = [
+                    (k, v)
+                    for k, v in sess.cookies.items()
+                    if not k.startswith("download_warning_")
+                ]
+                json.dump(cookies, f, indent=2)
+
+        if "Content-Disposition" in res.headers:
+            # This is the file
+            break
+        if not (gdrive_file_id and is_gdrive_download_link):
+            break
+
+        # Need to redirect with confirmation
+        try:
+            url = get_url_from_gdrive_confirmation(res.text)
+        except FileURLRetrievalError as e:
+            message = (
+                "Failed to retrieve file url:\n\n"
+                "{}\n\n"
+                "You may still be able to access the file from the browser:"
+                f"\n\n\t{url_origin}\n\n"
+                "but Gdown can't. Please check connections and permissions."
+            ).format(indent("\n".join(textwrap.wrap(str(e))), prefix="\t"))
+            raise FileURLRetrievalError(message)
+
+    if gdrive_file_id and is_gdrive_download_link:
+        content_disposition = urllib_parse.unquote(res.headers["Content-Disposition"])
+        filename_from_url = (
+            re.search(r"filename\*=UTF-8''(.*)", content_disposition)
+            or re.search(r'filename=["\']?(.*?)["\']?$', content_disposition)
+        ).group(1)
+        filename_from_url = filename_from_url.replace(os.path.sep, "_")
+    else:
+        filename_from_url = os.path.basename(url)
+
+    output = output or filename_from_url
+
+    output_is_path = isinstance(output, six.string_types)
+    if output_is_path and output.endswith(os.path.sep):
+        os.makedirs(output, exist_ok=True)
+        output = os.path.join(output, filename_from_url)
+
+    if output_is_path:
+        temp_dir = os.path.dirname(output) or "."
+        prefix = os.path.basename(output)
+        existing_tmp_files = [
+            os.path.join(temp_dir, file)
+            for file in os.listdir(temp_dir)
+            if file.startswith(prefix)
+        ]
+        if resume and existing_tmp_files:
+            if len(existing_tmp_files) > 1:
+                print(
+                    "There are multiple temporary files to resume:",
+                    file=sys.stderr,
+                )
+                for file in existing_tmp_files:
+                    print(f"\t{file}", file=sys.stderr)
+                print(
+                    "Please remove them except one to resume downloading.",
+                    file=sys.stderr,
+                )
+                return
+            tmp_file = existing_tmp_files[0]
+        else:
+            resume = False
+            tmp_file = tempfile.mktemp(
+                suffix=tempfile.template, prefix=prefix, dir=temp_dir
+            )
+        f = open(tmp_file, "ab")
+    else:
+        tmp_file = None
+        f = output
+
+    if tmp_file is not None and f.tell() != 0:
+        headers = {"Range": f"bytes={f.tell()}-"}
+        res = sess.get(url, headers=headers, stream=True, verify=verify)
+
+    if not quiet:
+        if resume:
+            print("Resume:", tmp_file, file=sys.stderr)
+        print(
+            "To:",
+            os.path.abspath(output) if output_is_path else output,
+            file=sys.stderr,
+        )
+
+    try:
+        total = int(res.headers.get("Content-Length", 0))
+        if not quiet:
+            pbar = tqdm.tqdm(total=total, unit="B", unit_scale=True)
+        t_start = time.time()
+        for chunk in res.iter_content(chunk_size=CHUNK_SIZE):
+            f.write(chunk)
+            if not quiet:
+                pbar.update(len(chunk))
+            if speed is not None:
+                elapsed_time_expected = 1.0 * pbar.n / speed
+                elapsed_time = time.time() - t_start
+                if elapsed_time < elapsed_time_expected:
+                    time.sleep(elapsed_time_expected - elapsed_time)
+        if not quiet:
+            pbar.close()
+        if tmp_file:
+            f.close()
+            shutil.move(tmp_file, output)
+    finally:
+        sess.close()
+
+    return output

programs/applio_code/rvc/lib/tools/launch_tensorboard.py

@@ -0,0 +1,21 @@
+import time
+import logging
+from tensorboard import program
+
+log_path = "logs"
+
+
+def launch_tensorboard_pipeline():
+    logging.getLogger("root").setLevel(logging.WARNING)
+    logging.getLogger("tensorboard").setLevel(logging.WARNING)
+
+    tb = program.TensorBoard()
+    tb.configure(argv=[None, "--logdir", log_path])
+    url = tb.launch()
+
+    print(
+        f"Access the tensorboard using the following link:\n{url}?pinnedCards=%5B%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Ftotal%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fd%2Ftotal%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Fkl%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Fmel%22%7D%5D"
+    )
+
+    while True:
+        time.sleep(600)

programs/applio_code/rvc/lib/tools/model_download.py

@@ -0,0 +1,385 @@
+import os
+import re
+import six
+import sys
+import wget
+import shutil
+import zipfile
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import unquote, urlencode, parse_qs, urlparse
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+from programs.applio_code.rvc.lib.utils import format_title
+from programs.applio_code.rvc.lib.tools import gdown
+
+
+def find_folder_parent(search_dir, folder_name):
+    for dirpath, dirnames, _ in os.walk(search_dir):
+        if folder_name in dirnames:
+            return os.path.abspath(dirpath)
+    return None
+
+
+file_path = find_folder_parent(now_dir, "logs")
+zips_path = os.path.join(file_path, "zips")
+
+
+def search_pth_index(folder):
+    pth_paths = [
+        os.path.join(folder, file)
+        for file in os.listdir(folder)
+        if os.path.isfile(os.path.join(folder, file)) and file.endswith(".pth")
+    ]
+    index_paths = [
+        os.path.join(folder, file)
+        for file in os.listdir(folder)
+        if os.path.isfile(os.path.join(folder, file)) and file.endswith(".index")
+    ]
+
+    return pth_paths, index_paths
+
+
+def get_mediafire_download_link(url):
+    response = requests.get(url)
+    response.raise_for_status()
+    soup = BeautifulSoup(response.text, "html.parser")
+    download_button = soup.find(
+        "a", {"class": "input popsok", "aria-label": "Download file"}
+    )
+    if download_button:
+        download_link = download_button.get("href")
+        return download_link
+    else:
+        return None
+
+
+def download_from_url(url):
+    os.makedirs(zips_path, exist_ok=True)
+    if url != "":
+        if "drive.google.com" in url:
+            if "file/d/" in url:
+                file_id = url.split("file/d/")[1].split("/")[0]
+            elif "id=" in url:
+                file_id = url.split("id=")[1].split("&")[0]
+            else:
+                return None
+
+            if file_id:
+                os.chdir(zips_path)
+                try:
+                    gdown.download(
+                        f"https://drive.google.com/uc?id={file_id}",
+                        quiet=True,
+                        fuzzy=True,
+                    )
+                except Exception as error:
+                    error_message = str(
+                        f"An error occurred downloading the file: {error}"
+                    )
+                    if (
+                        "Too many users have viewed or downloaded this file recently"
+                        in error_message
+                    ):
+                        os.chdir(now_dir)
+                        return "too much use"
+                    elif (
+                        "Cannot retrieve the public link of the file." in error_message
+                    ):
+                        os.chdir(now_dir)
+                        return "private link"
+                    else:
+                        print(error_message)
+                        os.chdir(now_dir)
+                        return None
+        elif "disk.yandex.ru" in url:
+            base_url = "https://cloud-api.yandex.net/v1/disk/public/resources/download?"
+            public_key = url
+            final_url = base_url + urlencode(dict(public_key=public_key))
+            response = requests.get(final_url)
+            download_url = response.json()["href"]
+            download_response = requests.get(download_url)
+
+            if download_response.status_code == 200:
+                filename = parse_qs(urlparse(unquote(download_url)).query).get(
+                    "filename", [""]
+                )[0]
+                if filename:
+                    os.chdir(zips_path)
+                    with open(filename, "wb") as f:
+                        f.write(download_response.content)
+            else:
+                print("Failed to get filename from URL.")
+                return None
+
+        elif "pixeldrain.com" in url:
+            try:
+                file_id = url.split("pixeldrain.com/u/")[1]
+                os.chdir(zips_path)
+                print(file_id)
+                response = requests.get(f"https://pixeldrain.com/api/file/{file_id}")
+                if response.status_code == 200:
+                    file_name = (
+                        response.headers.get("Content-Disposition")
+                        .split("filename=")[-1]
+                        .strip('";')
+                    )
+                    os.makedirs(zips_path, exist_ok=True)
+                    with open(os.path.join(zips_path, file_name), "wb") as newfile:
+                        newfile.write(response.content)
+                        os.chdir(file_path)
+                        return "downloaded"
+                else:
+                    os.chdir(file_path)
+                    return None
+            except Exception as error:
+                print(f"An error occurred downloading the file: {error}")
+                os.chdir(file_path)
+                return None
+
+        elif "cdn.discordapp.com" in url:
+            file = requests.get(url)
+            os.chdir(zips_path)
+            if file.status_code == 200:
+                name = url.split("/")
+                with open(os.path.join(name[-1]), "wb") as newfile:
+                    newfile.write(file.content)
+            else:
+                return None
+        elif "/blob/" in url or "/resolve/" in url:
+            os.chdir(zips_path)
+            if "/blob/" in url:
+                url = url.replace("/blob/", "/resolve/")
+
+            response = requests.get(url, stream=True)
+            if response.status_code == 200:
+                content_disposition = six.moves.urllib_parse.unquote(
+                    response.headers["Content-Disposition"]
+                )
+                m = re.search(r'filename="([^"]+)"', content_disposition)
+                file_name = m.groups()[0]
+                file_name = file_name.replace(os.path.sep, "_")
+                total_size_in_bytes = int(response.headers.get("content-length", 0))
+                block_size = 1024
+                progress_bar_length = 50
+                progress = 0
+
+                with open(os.path.join(zips_path, file_name), "wb") as file:
+                    for data in response.iter_content(block_size):
+                        file.write(data)
+                        progress += len(data)
+                        progress_percent = int((progress / total_size_in_bytes) * 100)
+                        num_dots = int(
+                            (progress / total_size_in_bytes) * progress_bar_length
+                        )
+                        progress_bar = (
+                            "["
+                            + "." * num_dots
+                            + " " * (progress_bar_length - num_dots)
+                            + "]"
+                        )
+                        print(
+                            f"{progress_percent}% {progress_bar} {progress}/{total_size_in_bytes}  ",
+                            end="\r",
+                        )
+                        if progress_percent == 100:
+                            print("\n")
+
+            else:
+                os.chdir(now_dir)
+                return None
+        elif "/tree/main" in url:
+            os.chdir(zips_path)
+            response = requests.get(url)
+            soup = BeautifulSoup(response.content, "html.parser")
+            temp_url = ""
+            for link in soup.find_all("a", href=True):
+                if link["href"].endswith(".zip"):
+                    temp_url = link["href"]
+                    break
+            if temp_url:
+                url = temp_url
+                url = url.replace("blob", "resolve")
+                if "huggingface.co" not in url:
+                    url = "https://huggingface.co" + url
+
+                    wget.download(url)
+            else:
+                os.chdir(now_dir)
+                return None
+        elif "applio.org" in url:
+            parts = url.split("/")
+            id_with_query = parts[-1]
+            id_parts = id_with_query.split("?")
+            id_number = id_parts[0]
+
+            url = "https://cjtfqzjfdimgpvpwhzlv.supabase.co/rest/v1/models"
+            headers = {
+                "apikey": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNqdGZxempmZGltZ3B2cHdoemx2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE2OTUxNjczODgsImV4cCI6MjAxMDc0MzM4OH0.7z5WMIbjR99c2Ooc0ma7B_FyGq10G8X-alkCYTkKR10"
+            }
+
+            params = {"id": f"eq.{id_number}"}
+            response = requests.get(url, headers=headers, params=params)
+            if response.status_code == 200:
+                json_response = response.json()
+                print(json_response)
+                if json_response:
+                    link = json_response[0]["link"]
+                    verify = download_from_url(link)
+                    if verify == "downloaded":
+                        return "downloaded"
+                    else:
+                        return None
+            else:
+                return None
+        else:
+            try:
+                os.chdir(zips_path)
+                wget.download(url)
+            except Exception as error:
+                os.chdir(now_dir)
+                print(f"An error occurred downloading the file: {error}")
+                return None
+
+        for currentPath, _, zipFiles in os.walk(zips_path):
+            for Files in zipFiles:
+                filePart = Files.split(".")
+                extensionFile = filePart[len(filePart) - 1]
+                filePart.pop()
+                nameFile = "_".join(filePart)
+                realPath = os.path.join(currentPath, Files)
+                os.rename(realPath, nameFile + "." + extensionFile)
+
+        os.chdir(now_dir)
+        return "downloaded"
+
+    os.chdir(now_dir)
+    return None
+
+
+def extract_and_show_progress(zipfile_path, unzips_path):
+    try:
+        with zipfile.ZipFile(zipfile_path, "r") as zip_ref:
+            for file_info in zip_ref.infolist():
+                zip_ref.extract(file_info, unzips_path)
+        os.remove(zipfile_path)
+        return True
+    except Exception as error:
+        print(f"An error occurred extracting the zip file: {error}")
+        return False
+
+
+def unzip_file(zip_path, zip_file_name):
+    zip_file_path = os.path.join(zip_path, zip_file_name + ".zip")
+    extract_path = os.path.join(file_path, zip_file_name)
+    with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
+        zip_ref.extractall(extract_path)
+    os.remove(zip_file_path)
+
+
+def model_download_pipeline(url: str):
+    try:
+        verify = download_from_url(url)
+        if verify == "downloaded":
+            extract_folder_path = ""
+            for filename in os.listdir(zips_path):
+                if filename.endswith(".zip"):
+                    zipfile_path = os.path.join(zips_path, filename)
+                    print("Proceeding with the extraction...")
+
+                    model_zip = os.path.basename(zipfile_path)
+                    model_name = format_title(model_zip.split(".zip")[0])
+                    extract_folder_path = os.path.join(
+                        "logs",
+                        os.path.normpath(model_name),
+                    )
+                    success = extract_and_show_progress(
+                        zipfile_path, extract_folder_path
+                    )
+
+                    macosx_path = os.path.join(extract_folder_path, "__MACOSX")
+                    if os.path.exists(macosx_path):
+                        shutil.rmtree(macosx_path)
+
+                    subfolders = [
+                        f
+                        for f in os.listdir(extract_folder_path)
+                        if os.path.isdir(os.path.join(extract_folder_path, f))
+                    ]
+                    if len(subfolders) == 1:
+                        subfolder_path = os.path.join(
+                            extract_folder_path, subfolders[0]
+                        )
+                        for item in os.listdir(subfolder_path):
+                            s = os.path.join(subfolder_path, item)
+                            d = os.path.join(extract_folder_path, item)
+                            shutil.move(s, d)
+                        os.rmdir(subfolder_path)
+
+                    for item in os.listdir(extract_folder_path):
+                        if ".pth" in item:
+                            file_name = item.split(".pth")[0]
+                            if file_name != model_name:
+                                os.rename(
+                                    os.path.join(extract_folder_path, item),
+                                    os.path.join(
+                                        extract_folder_path, model_name + ".pth"
+                                    ),
+                                )
+                        else:
+                            if "v2" not in item:
+                                if "_nprobe_1_" in item and "_v1" in item:
+                                    file_name = item.split("_nprobe_1_")[1].split(
+                                        "_v1"
+                                    )[0]
+                                    if file_name != model_name:
+                                        new_file_name = (
+                                            item.split("_nprobe_1_")[0]
+                                            + "_nprobe_1_"
+                                            + model_name
+                                            + "_v1"
+                                        )
+                                        os.rename(
+                                            os.path.join(extract_folder_path, item),
+                                            os.path.join(
+                                                extract_folder_path,
+                                                new_file_name + ".index",
+                                            ),
+                                        )
+                            else:
+                                if "_nprobe_1_" in item and "_v2" in item:
+                                    file_name = item.split("_nprobe_1_")[1].split(
+                                        "_v2"
+                                    )[0]
+                                    if file_name != model_name:
+                                        new_file_name = (
+                                            item.split("_nprobe_1_")[0]
+                                            + "_nprobe_1_"
+                                            + model_name
+                                            + "_v2"
+                                        )
+                                        os.rename(
+                                            os.path.join(extract_folder_path, item),
+                                            os.path.join(
+                                                extract_folder_path,
+                                                new_file_name + ".index",
+                                            ),
+                                        )
+
+                    if success:
+                        print(f"Model {model_name} downloaded!")
+                    else:
+                        print(f"Error downloading {model_name}")
+                        return "Error"
+            if extract_folder_path == "":
+                print("Zip file was not found.")
+                return "Error"
+            result = search_pth_index(extract_folder_path)
+            return result
+        else:
+            return "Error"
+    except Exception as error:
+        print(f"An unexpected error occurred: {error}")
+        return "Error"

programs/applio_code/rvc/lib/tools/prerequisites_download.py

@@ -0,0 +1,164 @@
+import os
+from concurrent.futures import ThreadPoolExecutor
+from tqdm import tqdm
+import requests
+
+url_base = "https://huggingface.co/IAHispano/Applio/resolve/main/Resources"
+
+pretraineds_v1_list = [
+    (
+        "pretrained_v1/",
+        [
+            "D32k.pth",
+            "D40k.pth",
+            "D48k.pth",
+            "G32k.pth",
+            "G40k.pth",
+            "G48k.pth",
+            "f0D32k.pth",
+            "f0D40k.pth",
+            "f0D48k.pth",
+            "f0G32k.pth",
+            "f0G40k.pth",
+            "f0G48k.pth",
+        ],
+    )
+]
+pretraineds_v2_list = [
+    (
+        "pretrained_v2/",
+        [
+            "D32k.pth",
+            "D40k.pth",
+            "D48k.pth",
+            "G32k.pth",
+            "G40k.pth",
+            "G48k.pth",
+            "f0D32k.pth",
+            "f0D40k.pth",
+            "f0D48k.pth",
+            "f0G32k.pth",
+            "f0G40k.pth",
+            "f0G48k.pth",
+        ],
+    )
+]
+models_list = [("predictors/", ["rmvpe.pt", "fcpe.pt"])]
+embedders_list = [("embedders/contentvec/", ["pytorch_model.bin", "config.json"])]
+linux_executables_list = [("formant/", ["stftpitchshift"])]
+executables_list = [
+    ("", ["ffmpeg.exe", "ffprobe.exe"]),
+    ("formant/", ["stftpitchshift.exe"]),
+]
+
+folder_mapping_list = {
+    "pretrained_v1/": "programs/applio_code/rvc/models/pretraineds/pretrained_v1/",
+    "pretrained_v2/": "programs/applio_code/rvc/models/pretraineds/pretrained_v2/",
+    "embedders/contentvec/": "programs/applio_code/rvc/models/embedders/contentvec/",
+    "predictors/": "programs/applio_code/rvc/models/predictors/",
+    "formant/": "programs/applio_code/rvc/models/formant/",
+}
+
+
+def get_file_size_if_missing(file_list):
+    """
+    Calculate the total size of files to be downloaded only if they do not exist locally.
+    """
+    total_size = 0
+    for remote_folder, files in file_list:
+        local_folder = folder_mapping_list.get(remote_folder, "")
+        for file in files:
+            destination_path = os.path.join(local_folder, file)
+            if not os.path.exists(destination_path):
+                url = f"{url_base}/{remote_folder}{file}"
+                response = requests.head(url)
+                total_size += int(response.headers.get("content-length", 0))
+    return total_size
+
+
+def download_file(url, destination_path, global_bar):
+    """
+    Download a file from the given URL to the specified destination path,
+    updating the global progress bar as data is downloaded.
+    """
+
+    dir_name = os.path.dirname(destination_path)
+    if dir_name:
+        os.makedirs(dir_name, exist_ok=True)
+    response = requests.get(url, stream=True)
+    block_size = 1024
+    with open(destination_path, "wb") as file:
+        for data in response.iter_content(block_size):
+            file.write(data)
+            global_bar.update(len(data))
+
+
+def download_mapping_files(file_mapping_list, global_bar):
+    """
+    Download all files in the provided file mapping list using a thread pool executor,
+    and update the global progress bar as downloads progress.
+    """
+    with ThreadPoolExecutor() as executor:
+        futures = []
+        for remote_folder, file_list in file_mapping_list:
+            local_folder = folder_mapping_list.get(remote_folder, "")
+            for file in file_list:
+                destination_path = os.path.join(local_folder, file)
+                if not os.path.exists(destination_path):
+                    url = f"{url_base}/{remote_folder}{file}"
+                    futures.append(
+                        executor.submit(
+                            download_file, url, destination_path, global_bar
+                        )
+                    )
+        for future in futures:
+            future.result()
+
+
+def calculate_total_size(pretraineds_v1, pretraineds_v2, models, exe):
+    """
+    Calculate the total size of all files to be downloaded based on selected categories.
+    """
+    total_size = 0
+    if models:
+        total_size += get_file_size_if_missing(models_list)
+        total_size += get_file_size_if_missing(embedders_list)
+    if exe:
+        total_size += get_file_size_if_missing(
+            executables_list if os.name == "nt" else linux_executables_list
+        )
+    if pretraineds_v1:
+        total_size += get_file_size_if_missing(pretraineds_v1_list)
+    if pretraineds_v2:
+        total_size += get_file_size_if_missing(pretraineds_v2_list)
+    return total_size
+
+
+def prequisites_download_pipeline(pretraineds_v1, pretraineds_v2, models, exe):
+    """
+    Manage the download pipeline for different categories of files.
+    """
+    total_size = calculate_total_size(pretraineds_v1, pretraineds_v2, models, exe)
+
+    if total_size > 0:
+        with tqdm(
+            total=total_size, unit="iB", unit_scale=True, desc="Downloading all files"
+        ) as global_bar:
+            if models:
+                download_mapping_files(models_list, global_bar)
+                download_mapping_files(embedders_list, global_bar)
+            if exe:
+                download_mapping_files(
+                    executables_list if os.name == "nt" else linux_executables_list,
+                    global_bar,
+                )
+            if pretraineds_v1:
+                download_mapping_files(pretraineds_v1_list, global_bar)
+            if pretraineds_v2:
+                download_mapping_files(pretraineds_v2_list, global_bar)
+    else:
+        pass
+
+
+if __name__ == "__main__":
+    prequisites_download_pipeline(False, False, True, False)

programs/applio_code/rvc/lib/tools/pretrained_selector.py

@@ -0,0 +1,63 @@
+def pretrained_selector(pitch_guidance):
+    if pitch_guidance == True:
+        return {
+            "v1": {
+                32000: (
+                    "rvc/models/pretraineds/pretrained_v1/f0G32k.pth",
+                    "rvc/models/pretraineds/pretrained_v1/f0D32k.pth",
+                ),
+                40000: (
+                    "rvc/models/pretraineds/pretrained_v1/f0G40k.pth",
+                    "rvc/models/pretraineds/pretrained_v1/f0D40k.pth",
+                ),
+                48000: (
+                    "rvc/models/pretraineds/pretrained_v1/f0G48k.pth",
+                    "rvc/models/pretraineds/pretrained_v1/f0D48k.pth",
+                ),
+            },
+            "v2": {
+                32000: (
+                    "rvc/models/pretraineds/pretrained_v2/f0G32k.pth",
+                    "rvc/models/pretraineds/pretrained_v2/f0D32k.pth",
+                ),
+                40000: (
+                    "rvc/models/pretraineds/pretrained_v2/f0G40k.pth",
+                    "rvc/models/pretraineds/pretrained_v2/f0D40k.pth",
+                ),
+                48000: (
+                    "rvc/models/pretraineds/pretrained_v2/f0G48k.pth",
+                    "rvc/models/pretraineds/pretrained_v2/f0D48k.pth",
+                ),
+            },
+        }
+    elif pitch_guidance == False:
+        return {
+            "v1": {
+                32000: (
+                    "rvc/models/pretraineds/pretrained_v1/G32k.pth",
+                    "rvc/models/pretraineds/pretrained_v1/D32k.pth",
+                ),
+                40000: (
+                    "rvc/models/pretraineds/pretrained_v1/G40k.pth",
+                    "rvc/models/pretraineds/pretrained_v1/D40k.pth",
+                ),
+                48000: (
+                    "rvc/models/pretraineds/pretrained_v1/G48k.pth",
+                    "rvc/models/pretraineds/pretrained_v1/D48k.pth",
+                ),
+            },
+            "v2": {
+                32000: (
+                    "rvc/models/pretraineds/pretrained_v2/G32k.pth",
+                    "rvc/models/pretraineds/pretrained_v2/D32k.pth",
+                ),
+                40000: (
+                    "rvc/models/pretraineds/pretrained_v2/G40k.pth",
+                    "rvc/models/pretraineds/pretrained_v2/D40k.pth",
+                ),
+                48000: (
+                    "rvc/models/pretraineds/pretrained_v2/G48k.pth",
+                    "rvc/models/pretraineds/pretrained_v2/D48k.pth",
+                ),
+            },
+        }

programs/applio_code/rvc/lib/tools/split_audio.py

@@ -0,0 +1,107 @@
+from pydub.silence import detect_nonsilent
+from pydub import AudioSegment
+import numpy as np
+import re
+import os
+
+from programs.applio_code.rvc.lib.utils import format_title
+
+
+def process_audio(file_path):
+    try:
+        # load audio file
+        song = AudioSegment.from_file(file_path)
+
+        # set silence threshold and duration
+        silence_thresh = -70  # dB
+        min_silence_len = 750  # ms, adjust as needed
+
+        # detect nonsilent parts
+        nonsilent_parts = detect_nonsilent(
+            song, min_silence_len=min_silence_len, silence_thresh=silence_thresh
+        )
+
+        # Create a new directory to store chunks
+        file_dir = os.path.dirname(file_path)
+        file_name = os.path.basename(file_path).split(".")[0]
+        file_name = format_title(file_name)
+        new_dir_path = os.path.join(file_dir, file_name)
+        os.makedirs(new_dir_path, exist_ok=True)
+
+        # Check if timestamps file exists, if so delete it
+        timestamps_file = os.path.join(file_dir, f"{file_name}_timestamps.txt")
+        if os.path.isfile(timestamps_file):
+            os.remove(timestamps_file)
+
+        # export chunks and save start times
+        segment_count = 0
+        for i, (start_i, end_i) in enumerate(nonsilent_parts):
+            chunk = song[start_i:end_i]
+            chunk_file_path = os.path.join(new_dir_path, f"chunk{i}.wav")
+            chunk.export(chunk_file_path, format="wav")
+
+            print(f"Segment {i} created!")
+            segment_count += 1
+
+            # write start times to file
+            with open(timestamps_file, "a", encoding="utf-8") as f:
+                f.write(f"{chunk_file_path} starts at {start_i} ms\n")
+
+        print(f"Total segments created: {segment_count}")
+        print(f"Split all chunks for {file_path} successfully!")
+
+        return "Finish", new_dir_path
+
+    except Exception as error:
+        print(f"An error occurred splitting the audio: {error}")
+        return "Error", None
+
+
+def merge_audio(timestamps_file):
+    try:
+        # Extract prefix from the timestamps filename
+        prefix = os.path.basename(timestamps_file).replace("_timestamps.txt", "")
+        timestamps_dir = os.path.dirname(timestamps_file)
+
+        # Open the timestamps file
+        with open(timestamps_file, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        # Initialize empty list to hold audio segments
+        audio_segments = []
+        last_end_time = 0
+
+        print(f"Processing file: {timestamps_file}")
+
+        for line in lines:
+            # Extract filename and start time from line
+            match = re.search(r"(chunk\d+.wav) starts at (\d+) ms", line)
+            if match:
+                filename, start_time = match.groups()
+                start_time = int(start_time)
+
+                # Construct the complete path to the chunk file
+                chunk_file = os.path.join(timestamps_dir, prefix, filename)
+
+                # Add silence from last_end_time to start_time
+                silence_duration = max(start_time - last_end_time, 0)
+                silence = AudioSegment.silent(duration=silence_duration)
+                audio_segments.append(silence)
+
+                # Load audio file and append to list
+                audio = AudioSegment.from_wav(chunk_file)
+                audio_segments.append(audio)
+
+                # Update last_end_time
+                last_end_time = start_time + len(audio)
+
+                print(f"Processed chunk: {chunk_file}")
+
+        # Concatenate all audio_segments and export
+        merged_audio = sum(audio_segments)
+        merged_audio_np = np.array(merged_audio.get_array_of_samples())
+        # print(f"Exported merged file: {merged_filename}\n")
+        return merged_audio.frame_rate, merged_audio_np
+
+    except Exception as error:
+        print(f"An error occurred splitting the audio: {error}")

programs/applio_code/rvc/lib/tools/tts.py

@@ -0,0 +1,20 @@
+import sys
+import asyncio
+import edge_tts
+
+
+async def main():
+    # Parse command line arguments
+    text = str(sys.argv[1])
+    voice = str(sys.argv[2])
+    rate = int(sys.argv[3])
+    output_file = str(sys.argv[4])
+
+    rates = f"+{rate}%" if rate >= 0 else f"{rate}%"
+
+    await edge_tts.Communicate(text, voice, rate=rates).save(output_file)
+    print(f"TTS with {voice} completed. Output TTS file: '{output_file}'")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

programs/applio_code/rvc/lib/utils.py

@@ -0,0 +1,116 @@
+import os, sys
+import librosa
+import soundfile as sf
+import re
+import unicodedata
+import wget
+from torch import nn
+
+import logging
+from transformers import HubertModel
+import warnings
+
+# Remove this to see warnings about transformers models
+warnings.filterwarnings("ignore")
+
+logging.getLogger("fairseq").setLevel(logging.ERROR)
+logging.getLogger("faiss.loader").setLevel(logging.ERROR)
+logging.getLogger("transformers").setLevel(logging.ERROR)
+logging.getLogger("torch").setLevel(logging.ERROR)
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+base_path = os.path.join(now_dir, "rvc", "models", "formant", "stftpitchshift")
+stft = base_path + ".exe" if sys.platform == "win32" else base_path
+
+
+class HubertModelWithFinalProj(HubertModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.final_proj = nn.Linear(config.hidden_size, config.classifier_proj_size)
+
+
+def load_audio(file, sample_rate):
+    try:
+        file = file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+        audio, sr = sf.read(file)
+        if len(audio.shape) > 1:
+            audio = librosa.to_mono(audio.T)
+        if sr != sample_rate:
+            audio = librosa.resample(audio, orig_sr=sr, target_sr=sample_rate)
+    except Exception as error:
+        raise RuntimeError(f"An error occurred loading the audio: {error}")
+
+    return audio.flatten()
+
+
+def load_audio_infer(file, sample_rate):
+    file = file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+    if not os.path.isfile(file):
+        raise FileNotFoundError(f"File not found: {file}")
+    audio, sr = sf.read(file)
+    if len(audio.shape) > 1:
+        audio = librosa.to_mono(audio.T)
+    if sr != sample_rate:
+        audio = librosa.resample(audio, orig_sr=sr, target_sr=sample_rate)
+    return audio.flatten()
+
+
+def format_title(title):
+    formatted_title = (
+        unicodedata.normalize("NFKD", title).encode("ascii", "ignore").decode("utf-8")
+    )
+    formatted_title = re.sub(r"[\u2500-\u257F]+", "", formatted_title)
+    formatted_title = re.sub(r"[^\w\s.-]", "", formatted_title)
+    formatted_title = re.sub(r"\s+", "_", formatted_title)
+    return formatted_title
+
+
+def load_embedding(embedder_model, custom_embedder=None):
+    embedder_root = os.path.join(
+        now_dir, "programs", "applio_code", "rvc", "models", "embedders"
+    )
+    embedding_list = {
+        "contentvec": os.path.join(embedder_root, "contentvec"),
+        "chinese-hubert-base": os.path.join(embedder_root, "chinese_hubert_base"),
+        "japanese-hubert-base": os.path.join(embedder_root, "japanese_hubert_base"),
+        "korean-hubert-base": os.path.join(embedder_root, "korean_hubert_base"),
+    }
+
+    online_embedders = {
+        "contentvec": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/contentvec/pytorch_model.bin",
+        "chinese-hubert-base": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/chinese_hubert_base/pytorch_model.bin",
+        "japanese-hubert-base": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/japanese_hubert_base/pytorch_model.bin",
+        "korean-hubert-base": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/korean_hubert_base/pytorch_model.bin",
+    }
+
+    config_files = {
+        "contentvec": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/contentvec/config.json",
+        "chinese-hubert-base": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/chinese_hubert_base/config.json",
+        "japanese-hubert-base": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/japanese_hubert_base/config.json",
+        "korean-hubert-base": "https://huggingface.co/IAHispano/Applio/resolve/main/Resources/embedders/korean_hubert_base/config.json",
+    }
+
+    if embedder_model == "custom":
+        if os.path.exists(custom_embedder):
+            model_path = custom_embedder
+        else:
+            print(f"Custom embedder not found: {custom_embedder}, using contentvec")
+            model_path = embedding_list["contentvec"]
+    else:
+        model_path = embedding_list[embedder_model]
+        bin_file = os.path.join(model_path, "pytorch_model.bin")
+        json_file = os.path.join(model_path, "config.json")
+        os.makedirs(model_path, exist_ok=True)
+        if not os.path.exists(bin_file):
+            url = online_embedders[embedder_model]
+            print(f"Downloading {url} to {model_path}...")
+            wget.download(url, out=bin_file)
+        if not os.path.exists(json_file):
+            url = config_files[embedder_model]
+            print(f"Downloading {url} to {model_path}...")
+            wget.download(url, out=json_file)
+
+    models = HubertModelWithFinalProj.from_pretrained(model_path)
+    return models

programs/applio_code/rvc/models/embedders/contentvec/config.json

@@ -0,0 +1,71 @@
+{
+  "activation_dropout": 0.1,
+  "apply_spec_augment": true,
+  "architectures": [
+    "HubertModelWithFinalProj"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "conv_bias": false,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "sum",
+  "ctc_zero_infinity": false,
+  "do_stable_layer_norm": false,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.0,
+  "feat_proj_layer_norm": true,
+  "final_dropout": 0.1,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.1,
+  "mask_feature_length": 10,
+  "mask_feature_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_prob": 0.05,
+  "model_type": "hubert",
+  "num_attention_heads": 12,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "torch_dtype": "float32",
+  "transformers_version": "4.27.3",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 32
+}

programs/applio_code/rvc/models/embedders/contentvec/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8dd400e054ddf4e6be75dab5a2549db748cc99e756a097c496c099f65a4854e
+size 378342945

programs/applio_code/rvc/models/predictors/fcpe.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3a8dd2dbd51baf19ed295006f2ac25dba6dd60adc7ec578ae5fbd94970951da
+size 69005189

programs/applio_code/rvc/models/predictors/rmvpe.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d62215f4306e3ca278246188607209f09af3dc77ed4232efdd069798c4ec193
+size 181184272

programs/music_separation_code/ensemble.py

@@ -0,0 +1,183 @@
+# coding: utf-8
+__author__ = "Roman Solovyev (ZFTurbo): https://github.com/ZFTurbo/"
+
+import os
+import librosa
+import soundfile as sf
+import numpy as np
+import argparse
+
+
+def stft(wave, nfft, hl):
+    wave_left = np.asfortranarray(wave[0])
+    wave_right = np.asfortranarray(wave[1])
+    spec_left = librosa.stft(wave_left, n_fft=nfft, hop_length=hl)
+    spec_right = librosa.stft(wave_right, n_fft=nfft, hop_length=hl)
+    spec = np.asfortranarray([spec_left, spec_right])
+    return spec
+
+
+def istft(spec, hl, length):
+    spec_left = np.asfortranarray(spec[0])
+    spec_right = np.asfortranarray(spec[1])
+    wave_left = librosa.istft(spec_left, hop_length=hl, length=length)
+    wave_right = librosa.istft(spec_right, hop_length=hl, length=length)
+    wave = np.asfortranarray([wave_left, wave_right])
+    return wave
+
+
+def absmax(a, *, axis):
+    dims = list(a.shape)
+    dims.pop(axis)
+    indices = np.ogrid[tuple(slice(0, d) for d in dims)]
+    argmax = np.abs(a).argmax(axis=axis)
+    indices.insert((len(a.shape) + axis) % len(a.shape), argmax)
+    return a[tuple(indices)]
+
+
+def absmin(a, *, axis):
+    dims = list(a.shape)
+    dims.pop(axis)
+    indices = np.ogrid[tuple(slice(0, d) for d in dims)]
+    argmax = np.abs(a).argmin(axis=axis)
+    indices.insert((len(a.shape) + axis) % len(a.shape), argmax)
+    return a[tuple(indices)]
+
+
+def lambda_max(arr, axis=None, key=None, keepdims=False):
+    idxs = np.argmax(key(arr), axis)
+    if axis is not None:
+        idxs = np.expand_dims(idxs, axis)
+        result = np.take_along_axis(arr, idxs, axis)
+        if not keepdims:
+            result = np.squeeze(result, axis=axis)
+        return result
+    else:
+        return arr.flatten()[idxs]
+
+
+def lambda_min(arr, axis=None, key=None, keepdims=False):
+    idxs = np.argmin(key(arr), axis)
+    if axis is not None:
+        idxs = np.expand_dims(idxs, axis)
+        result = np.take_along_axis(arr, idxs, axis)
+        if not keepdims:
+            result = np.squeeze(result, axis=axis)
+        return result
+    else:
+        return arr.flatten()[idxs]
+
+
+def average_waveforms(pred_track, weights, algorithm):
+    """
+    :param pred_track: shape = (num, channels, length)
+    :param weights: shape = (num, )
+    :param algorithm: One of avg_wave, median_wave, min_wave, max_wave, avg_fft, median_fft, min_fft, max_fft
+    :return: averaged waveform in shape (channels, length)
+    """
+
+    pred_track = np.array(pred_track)
+    final_length = pred_track.shape[-1]
+
+    mod_track = []
+    for i in range(pred_track.shape[0]):
+        if algorithm == "avg_wave":
+            mod_track.append(pred_track[i] * weights[i])
+        elif algorithm in ["median_wave", "min_wave", "max_wave"]:
+            mod_track.append(pred_track[i])
+        elif algorithm in ["avg_fft", "min_fft", "max_fft", "median_fft"]:
+            spec = stft(pred_track[i], nfft=2048, hl=1024)
+            if algorithm in ["avg_fft"]:
+                mod_track.append(spec * weights[i])
+            else:
+                mod_track.append(spec)
+    pred_track = np.array(mod_track)
+
+    if algorithm in ["avg_wave"]:
+        pred_track = pred_track.sum(axis=0)
+        pred_track /= np.array(weights).sum().T
+    elif algorithm in ["median_wave"]:
+        pred_track = np.median(pred_track, axis=0)
+    elif algorithm in ["min_wave"]:
+        pred_track = np.array(pred_track)
+        pred_track = lambda_min(pred_track, axis=0, key=np.abs)
+    elif algorithm in ["max_wave"]:
+        pred_track = np.array(pred_track)
+        pred_track = lambda_max(pred_track, axis=0, key=np.abs)
+    elif algorithm in ["avg_fft"]:
+        pred_track = pred_track.sum(axis=0)
+        pred_track /= np.array(weights).sum()
+        pred_track = istft(pred_track, 1024, final_length)
+    elif algorithm in ["min_fft"]:
+        pred_track = np.array(pred_track)
+        pred_track = lambda_min(pred_track, axis=0, key=np.abs)
+        pred_track = istft(pred_track, 1024, final_length)
+    elif algorithm in ["max_fft"]:
+        pred_track = np.array(pred_track)
+        pred_track = absmax(pred_track, axis=0)
+        pred_track = istft(pred_track, 1024, final_length)
+    elif algorithm in ["median_fft"]:
+        pred_track = np.array(pred_track)
+        pred_track = np.median(pred_track, axis=0)
+        pred_track = istft(pred_track, 1024, final_length)
+    return pred_track
+
+
+def ensemble_files(args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--files",
+        type=str,
+        required=True,
+        nargs="+",
+        help="Path to all audio-files to ensemble",
+    )
+    parser.add_argument(
+        "--type",
+        type=str,
+        default="avg_wave",
+        help="One of avg_wave, median_wave, min_wave, max_wave, avg_fft, median_fft, min_fft, max_fft",
+    )
+    parser.add_argument(
+        "--weights",
+        type=float,
+        nargs="+",
+        help="Weights to create ensemble. Number of weights must be equal to number of files",
+    )
+    parser.add_argument(
+        "--output",
+        default="res.wav",
+        type=str,
+        help="Path to wav file where ensemble result will be stored",
+    )
+    if args is None:
+        args = parser.parse_args()
+    else:
+        args = parser.parse_args(args)
+
+    print("Ensemble type: {}".format(args.type))
+    print("Number of input files: {}".format(len(args.files)))
+    if args.weights is not None:
+        weights = args.weights
+    else:
+        weights = np.ones(len(args.files))
+    print("Weights: {}".format(weights))
+    print("Output file: {}".format(args.output))
+    data = []
+    for f in args.files:
+        if not os.path.isfile(f):
+            print("Error. Can't find file: {}. Check paths.".format(f))
+            exit()
+        print("Reading file: {}".format(f))
+        wav, sr = librosa.load(f, sr=None, mono=False)
+        # wav, sr = sf.read(f)
+        print("Waveform shape: {} sample rate: {}".format(wav.shape, sr))
+        data.append(wav)
+    data = np.array(data)
+    res = average_waveforms(data, weights, args.type)
+    print("Result shape: {}".format(res.shape))
+    sf.write(args.output, res.T, sr, "FLOAT")
+
+
+if __name__ == "__main__":
+    ensemble_files(None)