| | import multiprocessing
|
| | import os
|
| | import sys
|
| |
|
| | from scipy import signal
|
| |
|
| | now_dir = os.getcwd()
|
| | sys.path.append(now_dir)
|
| | print(*sys.argv[1:])
|
| | inp_root = sys.argv[1]
|
| | sr = int(sys.argv[2])
|
| | n_p = int(sys.argv[3])
|
| | exp_dir = sys.argv[4]
|
| | noparallel = sys.argv[5] == "True"
|
| | per = float(sys.argv[6])
|
| | import os
|
| | import traceback
|
| |
|
| | import librosa
|
| | import numpy as np
|
| | from scipy.io import wavfile
|
| |
|
| | from infer.lib.audio import load_audio
|
| | from infer.lib.slicer2 import Slicer
|
| |
|
| | f = open("%s/preprocess.log" % exp_dir, "a+")
|
| |
|
| |
|
| | def println(strr):
|
| | print(strr)
|
| | f.write("%s\n" % strr)
|
| | f.flush()
|
| |
|
| |
|
| | class PreProcess:
|
| | def __init__(self, sr, exp_dir, per=3.7):
|
| | self.slicer = Slicer(
|
| | sr=sr,
|
| | threshold=-42,
|
| | min_length=1500,
|
| | min_interval=400,
|
| | hop_size=15,
|
| | max_sil_kept=500,
|
| | )
|
| | self.sr = sr
|
| | self.bh, self.ah = 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 = 0.9
|
| | self.alpha = 0.75
|
| | self.exp_dir = exp_dir
|
| | self.gt_wavs_dir = "%s/0_gt_wavs" % exp_dir
|
| | self.wavs16k_dir = "%s/1_16k_wavs" % exp_dir
|
| | 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 norm_write(self, tmp_audio, idx0, idx1):
|
| | tmp_max = np.abs(tmp_audio).max()
|
| | if tmp_max > 2.5:
|
| | print("%s-%s-%s-filtered" % (idx0, idx1, tmp_max))
|
| | return
|
| | tmp_audio = (tmp_audio / tmp_max * (self.max * self.alpha)) + (
|
| | 1 - self.alpha
|
| | ) * tmp_audio
|
| | wavfile.write(
|
| | "%s/%s_%s.wav" % (self.gt_wavs_dir, idx0, idx1),
|
| | self.sr,
|
| | tmp_audio.astype(np.float32),
|
| | )
|
| | tmp_audio = librosa.resample(
|
| | tmp_audio, orig_sr=self.sr, target_sr=16000
|
| | )
|
| | wavfile.write(
|
| | "%s/%s_%s.wav" % (self.wavs16k_dir, idx0, idx1),
|
| | 16000,
|
| | tmp_audio.astype(np.float32),
|
| | )
|
| |
|
| | def pipeline(self, path, idx0):
|
| | try:
|
| | audio = load_audio(path, self.sr)
|
| |
|
| |
|
| | audio = signal.lfilter(self.bh, self.ah, audio)
|
| |
|
| | idx1 = 0
|
| | for audio in self.slicer.slice(audio):
|
| | i = 0
|
| | while 1:
|
| | start = int(self.sr * (self.per - self.overlap) * i)
|
| | i += 1
|
| | if len(audio[start:]) > self.tail * self.sr:
|
| | tmp_audio = audio[start : start + int(self.per * self.sr)]
|
| | self.norm_write(tmp_audio, idx0, idx1)
|
| | idx1 += 1
|
| | else:
|
| | tmp_audio = audio[start:]
|
| | idx1 += 1
|
| | break
|
| | self.norm_write(tmp_audio, idx0, idx1)
|
| | println("%s\t-> Success" % path)
|
| | except:
|
| | println("%s\t-> %s" % (path, traceback.format_exc()))
|
| |
|
| | def pipeline_mp(self, infos):
|
| | for path, idx0 in infos:
|
| | self.pipeline(path, idx0)
|
| |
|
| | def pipeline_mp_inp_dir(self, inp_root, n_p):
|
| | try:
|
| | infos = [
|
| | ("%s/%s" % (inp_root, name), idx)
|
| | for idx, name in enumerate(sorted(list(os.listdir(inp_root))))
|
| | ]
|
| | if noparallel:
|
| | for i in range(n_p):
|
| | self.pipeline_mp(infos[i::n_p])
|
| | else:
|
| | ps = []
|
| | for i in range(n_p):
|
| | p = multiprocessing.Process(
|
| | target=self.pipeline_mp, args=(infos[i::n_p],)
|
| | )
|
| | ps.append(p)
|
| | p.start()
|
| | for i in range(n_p):
|
| | ps[i].join()
|
| | except:
|
| | println("Fail. %s" % traceback.format_exc())
|
| |
|
| |
|
| | def preprocess_trainset(inp_root, sr, n_p, exp_dir, per):
|
| | pp = PreProcess(sr, exp_dir, per)
|
| | println("start preprocess")
|
| | pp.pipeline_mp_inp_dir(inp_root, n_p)
|
| | println("end preprocess")
|
| |
|
| |
|
| | if __name__ == "__main__":
|
| | preprocess_trainset(inp_root, sr, n_p, exp_dir, per)
|
| |
|
