|
from multiprocessing import cpu_count
|
|
import os
|
|
import sys
|
|
|
|
from scipy import signal
|
|
from scipy.io import wavfile
|
|
import librosa
|
|
import numpy as np
|
|
|
|
now_directory = os.getcwd()
|
|
sys.path.append(now_directory)
|
|
|
|
from rvc.lib.utils import load_audio
|
|
from rvc.train.slicer import Slicer
|
|
|
|
experiment_directory = sys.argv[1]
|
|
input_root = sys.argv[2]
|
|
sampling_rate = int(sys.argv[3])
|
|
percentage = float(sys.argv[4])
|
|
num_processes = cpu_count()
|
|
|
|
import multiprocessing
|
|
|
|
|
|
class PreProcess:
|
|
def __init__(self, sr, exp_dir, per=3.0):
|
|
self.slicer = Slicer(
|
|
sr=sr,
|
|
threshold=-42,
|
|
min_length=1500,
|
|
min_interval=400,
|
|
hop_size=15,
|
|
max_sil_kept=500,
|
|
)
|
|
self.sr = sr
|
|
self.b_high, self.a_high = signal.butter(N=5, Wn=48, btype="high", fs=self.sr)
|
|
self.per = per
|
|
self.overlap = 0.3
|
|
self.tail = self.per + self.overlap
|
|
self.max_amplitude = 0.9
|
|
self.alpha = 0.75
|
|
self.exp_dir = exp_dir
|
|
self.gt_wavs_dir = f"{exp_dir}/0_gt_wavs"
|
|
self.wavs16k_dir = f"{exp_dir}/1_16k_wavs"
|
|
os.makedirs(self.exp_dir, exist_ok=True)
|
|
os.makedirs(self.gt_wavs_dir, exist_ok=True)
|
|
os.makedirs(self.wavs16k_dir, exist_ok=True)
|
|
|
|
def normalize_and_write(self, tmp_audio, idx0, idx1):
|
|
tmp_max = np.abs(tmp_audio).max()
|
|
if tmp_max > 2.5:
|
|
print(f"{idx0}-{idx1}-{tmp_max}-filtered")
|
|
return
|
|
tmp_audio = (tmp_audio / tmp_max * (self.max_amplitude * self.alpha)) + (
|
|
1 - self.alpha
|
|
) * tmp_audio
|
|
wavfile.write(
|
|
f"{self.gt_wavs_dir}/{idx0}_{idx1}.wav",
|
|
self.sr,
|
|
tmp_audio.astype(np.float32),
|
|
)
|
|
tmp_audio = librosa.resample(
|
|
tmp_audio, orig_sr=self.sr, target_sr=16000
|
|
)
|
|
wavfile.write(
|
|
f"{self.wavs16k_dir}/{idx0}_{idx1}.wav",
|
|
16000,
|
|
tmp_audio.astype(np.float32),
|
|
)
|
|
|
|
def process_audio(self, path, idx0):
|
|
try:
|
|
audio = load_audio(path, self.sr)
|
|
audio = signal.lfilter(self.b_high, self.a_high, audio)
|
|
|
|
idx1 = 0
|
|
for audio_segment in self.slicer.slice(audio):
|
|
i = 0
|
|
while 1:
|
|
start = int(self.sr * (self.per - self.overlap) * i)
|
|
i += 1
|
|
if len(audio_segment[start:]) > self.tail * self.sr:
|
|
tmp_audio = audio_segment[
|
|
start : start + int(self.per * self.sr)
|
|
]
|
|
self.normalize_and_write(tmp_audio, idx0, idx1)
|
|
idx1 += 1
|
|
else:
|
|
tmp_audio = audio_segment[start:]
|
|
idx1 += 1
|
|
break
|
|
self.normalize_and_write(tmp_audio, idx0, idx1)
|
|
except Exception as error:
|
|
print(f"{path}: {error}")
|
|
|
|
def process_audio_multiprocessing(self, infos):
|
|
for path, idx0 in infos:
|
|
self.process_audio(path, idx0)
|
|
|
|
def process_audio_multiprocessing_input_directory(self, input_root, num_processes):
|
|
try:
|
|
infos = [
|
|
(f"{input_root}/{name}", idx)
|
|
for idx, name in enumerate(sorted(list(os.listdir(input_root))))
|
|
]
|
|
processes = []
|
|
for i in range(num_processes):
|
|
p = multiprocessing.Process(
|
|
target=self.process_audio_multiprocessing,
|
|
args=(infos[i::num_processes],),
|
|
)
|
|
processes.append(p)
|
|
p.start()
|
|
for i in range(num_processes):
|
|
processes[i].join()
|
|
except Exception as error:
|
|
print(error)
|
|
|
|
|
|
def preprocess_training_set(input_root, sr, num_processes, exp_dir, per):
|
|
pp = PreProcess(sr, exp_dir, per)
|
|
print("Starting preprocessing...")
|
|
pp.process_audio_multiprocessing_input_directory(input_root, num_processes)
|
|
print("Preprocessing completed!")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
preprocess_training_set(
|
|
input_root, sampling_rate, num_processes, experiment_directory, percentage
|
|
)
|
|
|
