|
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 |
|
) |
|
|
