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