update

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Jingyi Li
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

app-slice.py

@@ -1,135 +0,0 @@
-import os
-import gradio as gr
-import edge_tts
-from pathlib import Path
-import inference.infer_tool as infer_tool
-import utils
-from inference.infer_tool import Svc
-import logging
-import webbrowser
-import argparse
-import asyncio
-import librosa
-import soundfile
-import gradio.processing_utils as gr_processing_utils
-logging.getLogger('numba').setLevel(logging.WARNING)
-logging.getLogger('markdown_it').setLevel(logging.WARNING)
-logging.getLogger('urllib3').setLevel(logging.WARNING)
-logging.getLogger('matplotlib').setLevel(logging.WARNING)
-
-limitation = os.getenv("SYSTEM") == "spaces"  # limit audio length in huggingface spaces
-
-audio_postprocess_ori = gr.Audio.postprocess
-
-def audio_postprocess(self, y):
-    data = audio_postprocess_ori(self, y)
-    if data is None:
-        return None
-    return gr_processing_utils.encode_url_or_file_to_base64(data["name"])
-
-
-gr.Audio.postprocess = audio_postprocess
-def create_vc_fn(model, sid):
-    def vc_fn(input_audio, vc_transform, auto_f0, slice_db, noise_scale, pad_seconds, tts_text, tts_voice, tts_mode):
-        if tts_mode:
-            if len(tts_text) > 100 and limitation:
-                return "Text is too long", None
-            if tts_text is None or tts_voice is None:
-                return "You need to enter text and select a voice", None
-            asyncio.run(edge_tts.Communicate(tts_text, "-".join(tts_voice.split('-')[:-1])).save("tts.mp3"))
-            audio, sr = librosa.load("tts.mp3")
-            soundfile.write("tts.wav", audio, 24000, format="wav")
-            wav_path = "tts.wav"
-        else:
-            if input_audio is None:
-                return "You need to select an audio", None
-            raw_audio_path = f"raw/{input_audio}"
-            if "." not in raw_audio_path:
-                raw_audio_path += ".wav"
-            infer_tool.format_wav(raw_audio_path)
-            wav_path = Path(raw_audio_path).with_suffix('.wav')
-        _audio = model.slice_inference(
-            wav_path, sid, vc_transform, slice_db,
-            cluster_infer_ratio=0,
-            auto_predict_f0=auto_f0,
-            noice_scale=noise_scale,
-            pad_seconds=pad_seconds)
-        model.clear_empty()
-        return "Success", (44100, _audio)
-    return vc_fn
-
-def refresh_raw_wav():
-    return gr.Dropdown.update(choices=os.listdir("raw"))
-
-def change_to_tts_mode(tts_mode):
-    if tts_mode:
-        return gr.Audio.update(visible=False), gr.Button.update(visible=False), gr.Textbox.update(visible=True), gr.Dropdown.update(visible=True)
-    else:
-        return gr.Audio.update(visible=True), gr.Button.update(visible=True), gr.Textbox.update(visible=False), gr.Dropdown.update(visible=False)
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--device', type=str, default='cpu')
-    parser.add_argument('--api', action="store_true", default=False)
-    parser.add_argument("--share", action="store_true", default=False, help="share gradio app")
-    parser.add_argument("--colab", action="store_true", default=False, help="share gradio app")
-    args = parser.parse_args()
-    hubert_model = utils.get_hubert_model().to(args.device)
-    models = []
-    voices = []
-    tts_voice_list = asyncio.get_event_loop().run_until_complete(edge_tts.list_voices())
-    for r in tts_voice_list:
-        voices.append(f"{r['ShortName']}-{r['Gender']}")
-    raw = os.listdir("raw")
-    for f in os.listdir("models"):
-        name = f
-        model = Svc(fr"models/{f}/{f}.pth", f"models/{f}/config.json", device=args.device)
-        cover = f"models/{f}/cover.png" if os.path.exists(f"models/{f}/cover.png") else None
-        models.append((name, cover, create_vc_fn(model, name)))
-    with gr.Blocks() as app:
-        gr.Markdown(
-            "# <center> Sovits Models\n"
-            "## <center> The input audio should be clean and pure voice without background music.\n"
-            "![visitor badge](https://visitor-badge.glitch.me/badge?page_id=sayashi.Sovits-Umamusume)\n\n"
-            "[Open In Colab](https://colab.research.google.com/drive/1wfsBbMzmtLflOJeqc5ZnJiLY7L239hJW?usp=share_link)"
-            " without queue and length limitation.\n\n"
-            "[Original Repo](https://github.com/svc-develop-team/so-vits-svc)\n\n"
-            "Other models:\n"
-            "[rudolf](https://huggingface.co/spaces/sayashi/sovits-rudolf)\n"
-            "[teio](https://huggingface.co/spaces/sayashi/sovits-teio)\n"
-            "[goldship](https://huggingface.co/spaces/sayashi/sovits-goldship)\n"
-            "[tannhauser](https://huggingface.co/spaces/sayashi/sovits-tannhauser)\n"
-
-        )
-        with gr.Tabs():
-            for (name, cover, vc_fn) in models:
-                with gr.TabItem(name):
-                    with gr.Row():
-                        gr.Markdown(
-                            '<div align="center">'
-                            f'<img style="width:auto;height:300px;" src="file/{cover}">' if cover else ""
-                            '</div>'
-                        )
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Row():
-                                vc_input = gr.Dropdown(label="Input audio", choices=raw)
-                                vc_refresh = gr.Button("🔁", variant="primary")
-                            vc_transform = gr.Number(label="vc_transform", value=0)
-                            slice_db = gr.Number(label="slice_db", value=-40)
-                            noise_scale = gr.Number(label="noise_scale", value=0.4)
-                            pad_seconds = gr.Number(label="pad_seconds", value=0.5)
-                            auto_f0 = gr.Checkbox(label="auto_f0", value=False)
-                            tts_mode = gr.Checkbox(label="tts (use edge-tts as input)", value=False)
-                            tts_text = gr.Textbox(visible=False,label="TTS text (100 words limitation)" if limitation else "TTS text")
-                            tts_voice = gr.Dropdown(choices=voices, visible=False)
-                            vc_submit = gr.Button("Generate", variant="primary")
-                        with gr.Column():
-                            vc_output1 = gr.Textbox(label="Output Message")
-                            vc_output2 = gr.Audio(label="Output Audio")
-                vc_submit.click(vc_fn, [vc_input, vc_transform, auto_f0, slice_db,  noise_scale, pad_seconds, tts_text, tts_voice, tts_mode], [vc_output1, vc_output2])
-                vc_refresh.click(refresh_raw_wav, [], [vc_input])
-                tts_mode.change(change_to_tts_mode, [tts_mode], [vc_input, vc_refresh, tts_text, tts_voice])
-        if args.colab:
-            webbrowser.open("http://127.0.0.1:7860")
-        app.queue(concurrency_count=1, api_open=args.api).launch(share=args.share)

app.py

@@ -17,7 +17,6 @@ logging.getLogger('markdown_it').setLevel(logging.WARNING)
 logging.getLogger('urllib3').setLevel(logging.WARNING)
 logging.getLogger('matplotlib').setLevel(logging.WARNING)
 
-limitation = os.getenv("SYSTEM") == "spaces"  # limit audio length in huggingface spaces
 sampling_rate = 44100
 
 

data_utils.py

@@ -1,184 +0,0 @@
-import time
-import os
-import random
-import numpy as np
-import torch
-import torch.utils.data
-
-import modules.commons as commons
-import utils
-from modules.mel_processing import spectrogram_torch, spec_to_mel_torch, spectrogram_torch
-from utils import load_wav_to_torch, load_filepaths_and_text
-
-# import h5py
-
-
-"""Multi speaker version"""
-
-
-class TextAudioSpeakerLoader(torch.utils.data.Dataset):
-    """
-        1) loads audio, speaker_id, text pairs
-        2) normalizes text and converts them to sequences of integers
-        3) computes spectrograms from audio files.
-    """
-
-    def __init__(self, audiopaths, hparams, all_in_mem: bool = False, vol_aug: bool = True):
-        self.audiopaths = load_filepaths_and_text(audiopaths)
-        self.hparams = hparams
-        self.max_wav_value = hparams.data.max_wav_value
-        self.sampling_rate = hparams.data.sampling_rate
-        self.filter_length = hparams.data.filter_length
-        self.hop_length = hparams.data.hop_length
-        self.win_length = hparams.data.win_length
-        self.sampling_rate = hparams.data.sampling_rate
-        self.use_sr = hparams.train.use_sr
-        self.spec_len = hparams.train.max_speclen
-        self.spk_map = hparams.spk
-        self.vol_emb = hparams.model.vol_embedding
-        self.vol_aug = hparams.train.vol_aug and vol_aug
-        random.seed(1234)
-        random.shuffle(self.audiopaths)
-        
-        self.all_in_mem = all_in_mem
-        if self.all_in_mem:
-            self.cache = [self.get_audio(p[0]) for p in self.audiopaths]
-
-    def get_audio(self, filename):
-        filename = filename.replace("\\", "/")
-        audio, sampling_rate = load_wav_to_torch(filename)
-        if sampling_rate != self.sampling_rate:
-            raise ValueError("{} SR doesn't match target {} SR".format(
-                sampling_rate, self.sampling_rate))
-        audio_norm = audio / self.max_wav_value
-        audio_norm = audio_norm.unsqueeze(0)
-        spec_filename = filename.replace(".wav", ".spec.pt")
-
-        # Ideally, all data generated after Mar 25 should have .spec.pt
-        if os.path.exists(spec_filename):
-            spec = torch.load(spec_filename)
-        else:
-            spec = spectrogram_torch(audio_norm, self.filter_length,
-                                     self.sampling_rate, self.hop_length, self.win_length,
-                                     center=False)
-            spec = torch.squeeze(spec, 0)
-            torch.save(spec, spec_filename)
-
-        spk = filename.split("/")[-2]
-        spk = torch.LongTensor([self.spk_map[spk]])
-
-        f0, uv = np.load(filename + ".f0.npy",allow_pickle=True)
-        
-        f0 = torch.FloatTensor(np.array(f0,dtype=float))
-        uv = torch.FloatTensor(np.array(uv,dtype=float))
-
-        c = torch.load(filename+ ".soft.pt")
-        c = utils.repeat_expand_2d(c.squeeze(0), f0.shape[0])
-        if self.vol_emb:
-            volume_path = filename + ".vol.npy"
-            volume = np.load(volume_path)
-            volume = torch.from_numpy(volume).float()
-        else:
-            volume = None
-
-        lmin = min(c.size(-1), spec.size(-1))
-        assert abs(c.size(-1) - spec.size(-1)) < 3, (c.size(-1), spec.size(-1), f0.shape, filename)
-        assert abs(audio_norm.shape[1]-lmin * self.hop_length) < 3 * self.hop_length
-        spec, c, f0, uv = spec[:, :lmin], c[:, :lmin], f0[:lmin], uv[:lmin]
-        audio_norm = audio_norm[:, :lmin * self.hop_length]
-        if volume!= None:
-            volume = volume[:lmin]
-        return c, f0, spec, audio_norm, spk, uv, volume
-
-    def random_slice(self, c, f0, spec, audio_norm, spk, uv, volume):
-        # if spec.shape[1] < 30:
-        #     print("skip too short audio:", filename)
-        #     return None
-
-        if random.choice([True, False]) and self.vol_aug and volume!=None:
-            max_amp = float(torch.max(torch.abs(audio_norm))) + 1e-5
-            max_shift = min(1, np.log10(1/max_amp))
-            log10_vol_shift = random.uniform(-1, max_shift)
-            audio_norm = audio_norm * (10 ** log10_vol_shift)
-            volume = volume * (10 ** log10_vol_shift)
-            spec = spectrogram_torch(audio_norm,
-            self.hparams.data.filter_length,
-            self.hparams.data.sampling_rate,
-            self.hparams.data.hop_length,
-            self.hparams.data.win_length,
-            center=False)[0]
-
-        if spec.shape[1] > 800:
-            start = random.randint(0, spec.shape[1]-800)
-            end = start + 790
-            spec, c, f0, uv = spec[:, start:end], c[:, start:end], f0[start:end], uv[start:end]
-            audio_norm = audio_norm[:, start * self.hop_length : end * self.hop_length]
-            if volume !=None:
-                volume = volume[start:end]
-        return c, f0, spec, audio_norm, spk, uv,volume
-
-    def __getitem__(self, index):
-        if self.all_in_mem:
-            return self.random_slice(*self.cache[index])
-        else:
-            return self.random_slice(*self.get_audio(self.audiopaths[index][0]))
-
-    def __len__(self):
-        return len(self.audiopaths)
-
-
-class TextAudioCollate:
-
-    def __call__(self, batch):
-        batch = [b for b in batch if b is not None]
-
-        input_lengths, ids_sorted_decreasing = torch.sort(
-            torch.LongTensor([x[0].shape[1] for x in batch]),
-            dim=0, descending=True)
-
-        max_c_len = max([x[0].size(1) for x in batch])
-        max_wav_len = max([x[3].size(1) for x in batch])
-
-        lengths = torch.LongTensor(len(batch))
-
-        c_padded = torch.FloatTensor(len(batch), batch[0][0].shape[0], max_c_len)
-        f0_padded = torch.FloatTensor(len(batch), max_c_len)
-        spec_padded = torch.FloatTensor(len(batch), batch[0][2].shape[0], max_c_len)
-        wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
-        spkids = torch.LongTensor(len(batch), 1)
-        uv_padded = torch.FloatTensor(len(batch), max_c_len)
-        volume_padded = torch.FloatTensor(len(batch), max_c_len)
-
-        c_padded.zero_()
-        spec_padded.zero_()
-        f0_padded.zero_()
-        wav_padded.zero_()
-        uv_padded.zero_()
-        volume_padded.zero_()
-
-        for i in range(len(ids_sorted_decreasing)):
-            row = batch[ids_sorted_decreasing[i]]
-
-            c = row[0]
-            c_padded[i, :, :c.size(1)] = c
-            lengths[i] = c.size(1)
-
-            f0 = row[1]
-            f0_padded[i, :f0.size(0)] = f0
-
-            spec = row[2]
-            spec_padded[i, :, :spec.size(1)] = spec
-
-            wav = row[3]
-            wav_padded[i, :, :wav.size(1)] = wav
-
-            spkids[i, 0] = row[4]
-
-            uv = row[5]
-            uv_padded[i, :uv.size(0)] = uv
-            volume = row[6]
-            if volume != None:
-                volume_padded[i, :volume.size(0)] = volume
-            else :
-                volume_padded = None
-        return c_padded, f0_padded, spec_padded, wav_padded, spkids, lengths, uv_padded, volume_padded

utils.py

@@ -1,21 +1,16 @@
-import os
 import glob
-import re
-import sys
-import argparse
-import logging
 import json
+import logging
+import os
+import re
 import subprocess
-import warnings
-import random
-import functools
+import sys
+
 import librosa
 import numpy as np
-from scipy.io.wavfile import read
 import torch
+from scipy.io.wavfile import read
 from torch.nn import functional as F
-from modules.commons import sequence_mask
-import tqdm
 
 MATPLOTLIB_FLAG = False