Integrate Fish-Audio's audio preprocess into

GPT-SoVits, adding loudness normalization and maximum
audio length control.

requirements.txt

@@ -26,3 +26,4 @@ jieba
 LangSegment>=0.2.0
 Faster_Whisper
 wordsegment
+pyloudnorm

tools/loudness_norm.py

@@ -0,0 +1,132 @@
+# modifiled from https://github.com/fishaudio/audio-preprocess/blob/main/fish_audio_preprocess/cli/loudness_norm.py
+
+from pathlib import Path
+from typing import Union
+import numpy as np
+import pyloudnorm as pyln
+import soundfile as sf
+from tqdm import tqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import argparse
+import os
+
+
+def loudness_norm_(
+    input_dir: str,
+    peak: float,
+    loudness: float,
+    block_size: float,
+    num_workers: int,
+):
+    """Perform loudness normalization (ITU-R BS.1770-4) on audio files."""
+    
+    if isinstance(input_dir, str):
+        path = Path(input_dir)
+    input_dir, output_dir = Path(input_dir), Path(input_dir)
+    
+    if not path.exists():
+        raise FileNotFoundError(f"Directory {path} does not exist.")
+    files = (
+       [f for f in path.glob("*") if f.is_file() and f.suffix == ".wav"]
+    )
+    
+
+    print(f"Found {len(files)} files, normalizing loudness")
+
+
+    with ProcessPoolExecutor(max_workers=num_workers) as executor:
+        tasks = []
+
+        for file in tqdm(files, desc="Preparing tasks"):
+            # Get relative path to input_dir
+            relative_path = file.relative_to(input_dir)
+            new_file = output_dir / relative_path
+
+            if new_file.parent.exists() is False:
+                new_file.parent.mkdir(parents=True)
+            
+            tasks.append(
+                executor.submit(
+                    loudness_norm_file, file, new_file, peak, loudness, block_size
+                )
+            )
+
+        for i in tqdm(as_completed(tasks), total=len(tasks), desc="Processing"):
+            assert i.exception() is None, i.exception()
+
+    print("Done!")
+
+
+
+def loudness_norm_file(
+    input_file: Union[str, Path],
+    output_file: Union[str, Path],
+    peak=-1.0,
+    loudness=-23.0,
+    block_size=0.400,
+) -> None:
+    """
+    Perform loudness normalization (ITU-R BS.1770-4) on audio files.
+
+    Args:
+        input_file: input audio file
+        output_file: output audio file
+        peak: peak normalize audio to N dB. Defaults to -1.0.
+        loudness: loudness normalize audio to N dB LUFS. Defaults to -23.0.
+        block_size: block size for loudness measurement. Defaults to 0.400. (400 ms)
+    """
+
+    # Thanks to .against's feedback
+    # https://github.com/librosa/librosa/issues/1236
+
+    input_file, output_file = str(input_file), str(output_file)
+
+    audio, rate = sf.read(input_file)
+    audio = loudness_norm(audio, rate, peak, loudness, block_size)
+    sf.write(output_file, audio, rate)
+
+
+
+
+def loudness_norm(
+    audio: np.ndarray, rate: int, peak=-1.0, loudness=-23.0, block_size=0.400
+) -> np.ndarray:
+    """
+    Perform loudness normalization (ITU-R BS.1770-4) on audio files.
+
+    Args:
+        audio: audio data
+        rate: sample rate
+        peak: peak normalize audio to N dB. Defaults to -1.0.
+        loudness: loudness normalize audio to N dB LUFS. Defaults to -23.0.
+        block_size: block size for loudness measurement. Defaults to 0.400. (400 ms)
+
+    Returns:
+        loudness normalized audio
+    """
+
+    # peak normalize audio to [peak] dB
+    audio = pyln.normalize.peak(audio, peak)
+
+    # measure the loudness first
+    meter = pyln.Meter(rate, block_size=block_size)  # create BS.1770 meter
+    _loudness = meter.integrated_loudness(audio)
+
+    return pyln.normalize.loudness(audio, _loudness, loudness)
+
+
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-i","--input_dir",help="匹配响度输入文件夹")
+parser.add_argument("-l","--loudness",help="响度")
+parser.add_argument("-p","--peak",help="响度峰值")
+parser.add_argument("-n","--num_worker")
+args = parser.parse_args()
+input_dir = args.input_dir
+loudness = float(args.loudness)
+peak = float(args.peak)
+num_worker = int(args.num_worker) 
+
+if __name__ == "__main__":
+    loudness_norm_(input_dir=input_dir,peak=peak,loudness=loudness,block_size=0.4,num_workers=num_worker)

tools/slice_audio.py

@@ -1,48 +1,478 @@
-import os,sys,numpy as np
+# modified from https://github.com/fishaudio/audio-preprocess/blob/main/fish_audio_preprocess/cli/slice_audio.py
-import traceback
+
-from scipy.io import wavfile
+from pathlib import Path
-# parent_directory = os.path.dirname(os.path.abspath(__file__))
+from typing import Union, Iterable
-# sys.path.append(parent_directory)
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from tqdm import tqdm
+import librosa
+import numpy as np
+import soundfile as sf
+import math
 from my_utils import load_audio
-from slicer2 import Slicer
+import argparse
+import os
 
-def slice(inp,opt_root,threshold,min_length,min_interval,hop_size,max_sil_kept,_max,alpha,i_part,all_part):
+
-    os.makedirs(opt_root,exist_ok=True)
+AUDIO_EXTENSIONS = {
-    if os.path.isfile(inp):
+    ".mp3",
-        input=[inp]
+    ".wav",
-    elif os.path.isdir(inp):
+    ".flac",
-        input=[os.path.join(inp, name) for name in sorted(list(os.listdir(inp)))]
+    ".ogg",
+    ".m4a",
+    ".wma",
+    ".aac",
+    ".aiff",
+    ".aif",
+    ".aifc",
+}
+
+
+def list_files(
+    path: Union[Path, str],
+    extensions: set[str] = None,
+    sort: bool = True,
+) -> list[Path]:
+    """List files in a directory.
+
+    Args:
+        path (Path): Path to the directory.
+        extensions (set, optional): Extensions to filter. Defaults to None.
+        sort (bool, optional): Whether to sort the files. Defaults to True.
+
+    Returns:
+        list: List of files.
+    """
+
+    if isinstance(path, str):
+        path = Path(path)
+
+    if not path.exists():
+        raise FileNotFoundError(f"Directory {path} does not exist.")
+
+    files = [f for f in path.glob("*") if f.is_file()]
+
+    if extensions is not None:
+        files = [f for f in files if f.suffix in extensions]
+
+    if sort:
+        files = sorted(files)
+    
+    return files
+
+
+def make_dirs(path: Union[Path, str]):
+    """Make directories.
+
+    Args:
+        path (Union[Path, str]): Path to the directory.
+    """
+    if isinstance(path, str):
+        path = Path(path)
+
+    if path.exists():
+       print(f"Output directory already exists: {path}")
+
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def slice_audio_v2_(
+    input_path: str,
+    output_dir: str,
+    num_workers: int,
+    min_duration: float,
+    max_duration: float,
+    min_silence_duration: float,
+    top_db: int,
+    hop_length: int,
+    max_silence_kept: float,
+    merge_short:bool
+):
+    """(OpenVPI version) Slice audio files into smaller chunks by silence."""
+
+    input_path_, output_dir_ = Path(input_path), Path(output_dir)
+    if not input_path_.exists():
+        raise RuntimeError("You input a wrong audio path that does not exists, please fix it!")
+    make_dirs(output_dir_)
+    if input_path_.is_dir():
+        files = list_files(input_path_, extensions=AUDIO_EXTENSIONS)
+    elif input_path_.is_file() and input_path_.suffix in AUDIO_EXTENSIONS:
+        files = [input_path_]
+        input_path_ = input_path_.parent
     else:
-        return "输入路径存在但既不是文件也不是文件夹"
+        raise RuntimeError("The input path is not file or dir, please fixes it")     
-    slicer = Slicer(
+    print(f"Found {len(files)} files, processing...")
-        sr=32000,  # 长音频采样率
+
-        threshold=      int(threshold),  # 音量小于这个值视作静音的备选切割点
+
-        min_length=     int(min_length),  # 每段最小多长，如果第一段太短一直和后面段连起来直到超过这个值
+    with ProcessPoolExecutor(max_workers=num_workers) as executor:
-        min_interval=   int(min_interval),  # 最短切割间隔
+        tasks = []
-        hop_size=       int(hop_size),  # 怎么算音量曲线，越小精度越大计算量越高（不是精度越大效果越好）
+
-        max_sil_kept=   int(max_sil_kept),  # 切完后静音最多留多长
+        for file in tqdm(files, desc="Preparing tasks"):
-    )
+            # Get relative path to input_dir
-    _max=float(_max)
+            relative_path = file.relative_to(input_path_)
-    alpha=float(alpha)
+            save_path = output_dir_ / relative_path.parent / relative_path.stem
-    for inp_path in input[int(i_part)::int(all_part)]:
+
-        # print(inp_path)
+            tasks.append(
-        try:
+                executor.submit(
-            name = os.path.basename(inp_path)
+                    slice_audio_file_v2,
-            audio = load_audio(inp_path, 32000)
+                    input_file=str(file),
-            # print(audio.shape)
+                    output_dir=save_path,
-            for chunk, start, end in slicer.slice(audio):  # start和end是帧数
+                    min_duration=min_duration,
-                tmp_max = np.abs(chunk).max()
+                    max_duration=max_duration,
-                if(tmp_max>1):chunk/=tmp_max
+                    min_silence_duration=min_silence_duration,
-                chunk = (chunk / tmp_max * (_max * alpha)) + (1 - alpha) * chunk
+                    top_db=top_db,
-                wavfile.write(
+                    hop_length=hop_length,
-                    "%s/%s_%010d_%010d.wav" % (opt_root, name, start, end),
+                    max_silence_kept=max_silence_kept,
-                    32000,
+                    merge_short=merge_short
-                    # chunk.astype(np.float32),
-                    (chunk * 32767).astype(np.int16),
                 )
-        except:
+            )
-            print(inp_path,"->fail->",traceback.format_exc())
-    return "执行完毕，请检查输出文件"
 
-print(slice(*sys.argv[1:]))
+        for i in tqdm(as_completed(tasks), total=len(tasks), desc="Processing"):
+            assert i.exception() is None, i.exception()
 
+    print("Done!")
+    print(f"Total: {len(files)}")
+    print(f"Output directory: {output_dir}")
+
+
+def slice_audio_file_v2(
+    input_file: Union[str, Path],
+    output_dir: Union[str, Path],
+    min_duration: float = 4.0,
+    max_duration: float = 12.0,
+    min_silence_duration: float = 0.3,
+    top_db: int = -40,
+    hop_length: int = 10,
+    max_silence_kept: float = 0.4,
+    merge_short: bool = False
+) -> None:
+    """
+    Slice audio by silence and save to output folder
+
+    Args:
+        input_file: input audio file
+        output_dir: output folder
+        min_duration: minimum duration of each slice
+        max_duration: maximum duration of each slice
+        min_silence_duration: minimum duration of silence
+        top_db: threshold to detect silence
+        hop_length: hop length to detect silence
+        max_silence_kept: maximum duration of silence to be kept
+    """
+
+    output_dir = Path(output_dir)
+
+    audio = load_audio(str(input_file),32000)
+    rate = 32000
+    for idx, sliced in enumerate(
+        slice_audio_v2(
+            audio,
+            rate,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            min_silence_duration=min_silence_duration,
+            top_db=top_db,
+            hop_length=hop_length,
+            max_silence_kept=max_silence_kept,
+            merge_short=merge_short
+        )
+    ):
+        if len(sliced) <= 3*rate: continue
+        max_audio=np.abs(sliced).max()#防止爆音,懒得搞混合了,后面有响度匹配
+        if max_audio>1: 
+            sliced/=max_audio
+        sf.write(str(output_dir) + f"_{idx:04d}.wav", sliced, rate)
+
+
+def slice_audio_v2(
+    audio: np.ndarray,
+    rate: int,
+    min_duration: float = 4.0,
+    max_duration: float = 12.0,
+    min_silence_duration: float = 0.3,
+    top_db: int = -40,
+    hop_length: int = 10,
+    max_silence_kept: float = 0.5,
+    merge_short: bool = False
+) -> Iterable[np.ndarray]:
+    """Slice audio by silence
+
+    Args:
+        audio: audio data, in shape (samples, channels)
+        rate: sample rate
+        min_duration: minimum duration of each slice
+        max_duration: maximum duration of each slice
+        min_silence_duration: minimum duration of silence
+        top_db: threshold to detect silence
+        hop_length: hop length to detect silence
+        max_silence_kept: maximum duration of silence to be kept
+        merge_short: merge short slices automatically
+
+    Returns:
+        Iterable of sliced audio
+    """
+
+    if len(audio) / rate < min_duration:
+        sliced_by_max_duration_chunk = slice_by_max_duration(audio, max_duration, rate)
+        yield from merge_short_chunks(
+            sliced_by_max_duration_chunk, max_duration, rate
+        ) if merge_short else sliced_by_max_duration_chunk
+        return
+
+    slicer = Slicer(
+        sr=rate,
+        threshold=top_db,
+        min_length=min_duration * 1000,
+        min_interval=min_silence_duration * 1000,
+        hop_size=hop_length,
+        max_sil_kept=max_silence_kept * 1000,
+    )
+
+    sliced_audio = slicer.slice(audio)
+    if merge_short:
+        sliced_audio = merge_short_chunks(sliced_audio, max_duration, rate)
+
+    for chunk in sliced_audio:
+        sliced_by_max_duration_chunk = slice_by_max_duration(chunk, max_duration, rate)
+        yield from sliced_by_max_duration_chunk
+
+
+def slice_by_max_duration(
+    gen: np.ndarray, slice_max_duration: float, rate: int
+) -> Iterable[np.ndarray]:
+    """Slice audio by max duration
+
+    Args:
+        gen: audio data, in shape (samples, channels)
+        slice_max_duration: maximum duration of each slice
+        rate: sample rate
+
+    Returns:
+        generator of sliced audio data
+    """
+
+    if len(gen) > slice_max_duration * rate:
+        # Evenly split _gen into multiple slices
+        n_chunks = math.ceil(len(gen) / (slice_max_duration * rate))
+        chunk_size = math.ceil(len(gen) / n_chunks)
+
+        for i in range(0, len(gen), chunk_size):
+            yield gen[i : i + chunk_size]
+    else:
+        yield gen
+
+
+class Slicer:
+    def __init__(
+        self,
+        sr: int,
+        threshold: float = -40.0,
+        min_length: int = 4000,
+        min_interval: int = 300,
+        hop_size: int = 10,
+        max_sil_kept: int = 5000,
+    ):
+        if not min_length >= min_interval >= hop_size:
+            raise ValueError(
+                "The following condition must be satisfied: min_length >= min_interval >= hop_size"
+            )
+
+        if not max_sil_kept >= hop_size:
+            raise ValueError(
+                "The following condition must be satisfied: max_sil_kept >= hop_size"
+            )
+
+        min_interval = sr * min_interval / 1000
+        self.threshold = 10 ** (threshold / 20.0)
+        self.hop_size = round(sr * hop_size / 1000)
+        self.win_size = min(round(min_interval), 4 * self.hop_size)
+        self.min_length = round(sr * min_length / 1000 / self.hop_size)
+        self.min_interval = round(min_interval / self.hop_size)
+        self.max_sil_kept = round(sr * max_sil_kept / 1000 / self.hop_size)
+
+    def _apply_slice(self, waveform, begin, end):
+        if len(waveform.shape) > 1:
+            return waveform[
+                :, begin * self.hop_size : min(waveform.shape[1], end * self.hop_size)
+            ]
+        else:
+            return waveform[
+                begin * self.hop_size : min(waveform.shape[0], end * self.hop_size)
+            ]
+
+    def slice(self, waveform):
+        if len(waveform.shape) > 1:
+            samples = waveform.mean(axis=0)
+        else:
+            samples = waveform
+
+        if samples.shape[0] <= self.min_length:
+            return [waveform]
+
+        rms_list = librosa.feature.rms(
+            y=samples, frame_length=self.win_size, hop_length=self.hop_size
+        ).squeeze(0)
+        sil_tags = []
+        silence_start = None
+        clip_start = 0
+
+        for i, rms in enumerate(rms_list):
+            # Keep looping while frame is silent.
+            if rms < self.threshold:
+                # Record start of silent frames.
+                if silence_start is None:
+                    silence_start = i
+                continue
+
+            # Keep looping while frame is not silent and silence start has not been recorded.
+            if silence_start is None:
+                continue
+
+            # Clear recorded silence start if interval is not enough or clip is too short
+            is_leading_silence = silence_start == 0 and i > self.max_sil_kept
+            need_slice_middle = (
+                i - silence_start >= self.min_interval
+                and i - clip_start >= self.min_length
+            )
+
+            if not is_leading_silence and not need_slice_middle:
+                silence_start = None
+                continue
+
+            # Need slicing. Record the range of silent frames to be removed.
+            if i - silence_start <= self.max_sil_kept:
+                pos = rms_list[silence_start : i + 1].argmin() + silence_start
+
+                if silence_start == 0:
+                    sil_tags.append((0, pos))
+                else:
+                    sil_tags.append((pos, pos))
+
+                clip_start = pos
+            elif i - silence_start <= self.max_sil_kept * 2:
+                pos = rms_list[
+                    i - self.max_sil_kept : silence_start + self.max_sil_kept + 1
+                ].argmin()
+                pos += i - self.max_sil_kept
+                pos_l = (
+                    rms_list[
+                        silence_start : silence_start + self.max_sil_kept + 1
+                    ].argmin()
+                    + silence_start
+                )
+                pos_r = (
+                    rms_list[i - self.max_sil_kept : i + 1].argmin()
+                    + i
+                    - self.max_sil_kept
+                )
+
+                if silence_start == 0:
+                    sil_tags.append((0, pos_r))
+                    clip_start = pos_r
+                else:
+                    sil_tags.append((min(pos_l, pos), max(pos_r, pos)))
+                    clip_start = max(pos_r, pos)
+            else:
+                pos_l = (
+                    rms_list[
+                        silence_start : silence_start + self.max_sil_kept + 1
+                    ].argmin()
+                    + silence_start
+                )
+                pos_r = (
+                    rms_list[i - self.max_sil_kept : i + 1].argmin()
+                    + i
+                    - self.max_sil_kept
+                )
+
+                if silence_start == 0:
+                    sil_tags.append((0, pos_r))
+                else:
+                    sil_tags.append((pos_l, pos_r))
+
+                clip_start = pos_r
+            silence_start = None
+
+        # Deal with trailing silence.
+        total_frames = rms_list.shape[0]
+        if (
+            silence_start is not None
+            and total_frames - silence_start >= self.min_interval
+        ):
+            silence_end = min(total_frames, silence_start + self.max_sil_kept)
+            pos = rms_list[silence_start : silence_end + 1].argmin() + silence_start
+            sil_tags.append((pos, total_frames + 1))
+
+        # Apply and return slices.
+        if len(sil_tags) == 0:
+            return [waveform]
+        else:
+            chunks = []
+
+            if sil_tags[0][0] > 0:
+                chunks.append(self._apply_slice(waveform, 0, sil_tags[0][0]))
+
+            for i in range(len(sil_tags) - 1):
+                chunks.append(
+                    self._apply_slice(waveform, sil_tags[i][1], sil_tags[i + 1][0])
+                )
+
+            if sil_tags[-1][1] < total_frames:
+                chunks.append(
+                    self._apply_slice(waveform, sil_tags[-1][1], total_frames)
+                )
+
+            return chunks
+        
+
+def merge_short_chunks(chunks, max_duration, rate):
+    merged_chunks = []
+    buffer, length = [], 0
+
+    for chunk in chunks:
+        if length + len(chunk) > max_duration * rate and len(buffer) > 0:
+            merged_chunks.append(np.concatenate(buffer))
+            buffer, length = [], 0
+        else:
+            buffer.append(chunk)
+            length += len(chunk)
+
+    if len(buffer) > 0:
+        merged_chunks.append(np.concatenate(buffer))
+
+    return merged_chunks
+
+
+
+
+
+
+
+
+        
+parser = argparse.ArgumentParser()
+parser.add_argument("-i","--input_dir",help="切割输入文件夹")
+parser.add_argument("-o","--output_dir",help="切割输入文件夹")
+parser.add_argument("--threshold",default=-40,help="音量小于这个值视作静音的备选切割点")
+parser.add_argument("--min_duration",default=4,help="每段最短多长，如果第一段太短一直和后面段连起来直到超过这个值")
+parser.add_argument("--max_duration",default=12,help="每段最长多长")
+parser.add_argument("--min_interval",default=0.3,help="最短切割间隔")
+parser.add_argument("--hop_size",default=10,help="怎么算音量曲线，越小精度越大计算量越高（不是精度越大效果越好）")
+parser.add_argument("--max_sil_kept",default=0.4,help="切完后静音最多留多长")
+parser.add_argument("--num_worker",default=os.cpu_count(),help="切使用的进程数")
+parser.add_argument("--merge_short",default="False",help="响割使用的进程数")
+
+
+args = parser.parse_args()
+input_path = args.input_dir
+output_dir =  args.output_dir
+threshold = float(args.threshold)
+min_duration = float(args.min_duration)
+max_duration = float(args.max_duration)
+min_interval = float(args.min_interval)
+hop_size = float(args.hop_size)
+max_sil_kept = float(args.max_sil_kept)
+num_worker = int(args.num_worker)
+merge_short = bool(args.merge_short)
+
+if __name__ == "__main__":
+    slice_audio_v2_(input_path, output_dir, num_worker, min_duration, max_duration, min_interval, threshold, hop_size, max_sil_kept,merge_short)

tools/slicer2.py

@@ -1,261 +0,0 @@
-import numpy as np
-
-
-# This function is obtained from librosa.
-def get_rms(
-    y,
-    frame_length=2048,
-    hop_length=512,
-    pad_mode="constant",
-):
-    padding = (int(frame_length // 2), int(frame_length // 2))
-    y = np.pad(y, padding, mode=pad_mode)
-
-    axis = -1
-    # put our new within-frame axis at the end for now
-    out_strides = y.strides + tuple([y.strides[axis]])
-    # Reduce the shape on the framing axis
-    x_shape_trimmed = list(y.shape)
-    x_shape_trimmed[axis] -= frame_length - 1
-    out_shape = tuple(x_shape_trimmed) + tuple([frame_length])
-    xw = np.lib.stride_tricks.as_strided(y, shape=out_shape, strides=out_strides)
-    if axis < 0:
-        target_axis = axis - 1
-    else:
-        target_axis = axis + 1
-    xw = np.moveaxis(xw, -1, target_axis)
-    # Downsample along the target axis
-    slices = [slice(None)] * xw.ndim
-    slices[axis] = slice(0, None, hop_length)
-    x = xw[tuple(slices)]
-
-    # Calculate power
-    power = np.mean(np.abs(x) ** 2, axis=-2, keepdims=True)
-
-    return np.sqrt(power)
-
-
-class Slicer:
-    def __init__(
-        self,
-        sr: int,
-        threshold: float = -40.0,
-        min_length: int = 5000,
-        min_interval: int = 300,
-        hop_size: int = 20,
-        max_sil_kept: int = 5000,
-    ):
-        if not min_length >= min_interval >= hop_size:
-            raise ValueError(
-                "The following condition must be satisfied: min_length >= min_interval >= hop_size"
-            )
-        if not max_sil_kept >= hop_size:
-            raise ValueError(
-                "The following condition must be satisfied: max_sil_kept >= hop_size"
-            )
-        min_interval = sr * min_interval / 1000
-        self.threshold = 10 ** (threshold / 20.0)
-        self.hop_size = round(sr * hop_size / 1000)
-        self.win_size = min(round(min_interval), 4 * self.hop_size)
-        self.min_length = round(sr * min_length / 1000 / self.hop_size)
-        self.min_interval = round(min_interval / self.hop_size)
-        self.max_sil_kept = round(sr * max_sil_kept / 1000 / self.hop_size)
-
-    def _apply_slice(self, waveform, begin, end):
-        if len(waveform.shape) > 1:
-            return waveform[
-                :, begin * self.hop_size : min(waveform.shape[1], end * self.hop_size)
-            ]
-        else:
-            return waveform[
-                begin * self.hop_size : min(waveform.shape[0], end * self.hop_size)
-            ]
-
-    # @timeit
-    def slice(self, waveform):
-        if len(waveform.shape) > 1:
-            samples = waveform.mean(axis=0)
-        else:
-            samples = waveform
-        if samples.shape[0] <= self.min_length:
-            return [waveform]
-        rms_list = get_rms(
-            y=samples, frame_length=self.win_size, hop_length=self.hop_size
-        ).squeeze(0)
-        sil_tags = []
-        silence_start = None
-        clip_start = 0
-        for i, rms in enumerate(rms_list):
-            # Keep looping while frame is silent.
-            if rms < self.threshold:
-                # Record start of silent frames.
-                if silence_start is None:
-                    silence_start = i
-                continue
-            # Keep looping while frame is not silent and silence start has not been recorded.
-            if silence_start is None:
-                continue
-            # Clear recorded silence start if interval is not enough or clip is too short
-            is_leading_silence = silence_start == 0 and i > self.max_sil_kept
-            need_slice_middle = (
-                i - silence_start >= self.min_interval
-                and i - clip_start >= self.min_length
-            )
-            if not is_leading_silence and not need_slice_middle:
-                silence_start = None
-                continue
-            # Need slicing. Record the range of silent frames to be removed.
-            if i - silence_start <= self.max_sil_kept:
-                pos = rms_list[silence_start : i + 1].argmin() + silence_start
-                if silence_start == 0:
-                    sil_tags.append((0, pos))
-                else:
-                    sil_tags.append((pos, pos))
-                clip_start = pos
-            elif i - silence_start <= self.max_sil_kept * 2:
-                pos = rms_list[
-                    i - self.max_sil_kept : silence_start + self.max_sil_kept + 1
-                ].argmin()
-                pos += i - self.max_sil_kept
-                pos_l = (
-                    rms_list[
-                        silence_start : silence_start + self.max_sil_kept + 1
-                    ].argmin()
-                    + silence_start
-                )
-                pos_r = (
-                    rms_list[i - self.max_sil_kept : i + 1].argmin()
-                    + i
-                    - self.max_sil_kept
-                )
-                if silence_start == 0:
-                    sil_tags.append((0, pos_r))
-                    clip_start = pos_r
-                else:
-                    sil_tags.append((min(pos_l, pos), max(pos_r, pos)))
-                    clip_start = max(pos_r, pos)
-            else:
-                pos_l = (
-                    rms_list[
-                        silence_start : silence_start + self.max_sil_kept + 1
-                    ].argmin()
-                    + silence_start
-                )
-                pos_r = (
-                    rms_list[i - self.max_sil_kept : i + 1].argmin()
-                    + i
-                    - self.max_sil_kept
-                )
-                if silence_start == 0:
-                    sil_tags.append((0, pos_r))
-                else:
-                    sil_tags.append((pos_l, pos_r))
-                clip_start = pos_r
-            silence_start = None
-        # Deal with trailing silence.
-        total_frames = rms_list.shape[0]
-        if (
-            silence_start is not None
-            and total_frames - silence_start >= self.min_interval
-        ):
-            silence_end = min(total_frames, silence_start + self.max_sil_kept)
-            pos = rms_list[silence_start : silence_end + 1].argmin() + silence_start
-            sil_tags.append((pos, total_frames + 1))
-        # Apply and return slices.
-        ####音频+起始时间+终止时间
-        if len(sil_tags) == 0:
-            return [[waveform,0,int(total_frames*self.hop_size)]]
-        else:
-            chunks = []
-            if sil_tags[0][0] > 0:
-                chunks.append([self._apply_slice(waveform, 0, sil_tags[0][0]),0,int(sil_tags[0][0]*self.hop_size)])
-            for i in range(len(sil_tags) - 1):
-                chunks.append(
-                    [self._apply_slice(waveform, sil_tags[i][1], sil_tags[i + 1][0]),int(sil_tags[i][1]*self.hop_size),int(sil_tags[i + 1][0]*self.hop_size)]
-                )
-            if sil_tags[-1][1] < total_frames:
-                chunks.append(
-                    [self._apply_slice(waveform, sil_tags[-1][1], total_frames),int(sil_tags[-1][1]*self.hop_size),int(total_frames*self.hop_size)]
-                )
-            return chunks
-
-
-def main():
-    import os.path
-    from argparse import ArgumentParser
-
-    import librosa
-    import soundfile
-
-    parser = ArgumentParser()
-    parser.add_argument("audio", type=str, help="The audio to be sliced")
-    parser.add_argument(
-        "--out", type=str, help="Output directory of the sliced audio clips"
-    )
-    parser.add_argument(
-        "--db_thresh",
-        type=float,
-        required=False,
-        default=-40,
-        help="The dB threshold for silence detection",
-    )
-    parser.add_argument(
-        "--min_length",
-        type=int,
-        required=False,
-        default=5000,
-        help="The minimum milliseconds required for each sliced audio clip",
-    )
-    parser.add_argument(
-        "--min_interval",
-        type=int,
-        required=False,
-        default=300,
-        help="The minimum milliseconds for a silence part to be sliced",
-    )
-    parser.add_argument(
-        "--hop_size",
-        type=int,
-        required=False,
-        default=10,
-        help="Frame length in milliseconds",
-    )
-    parser.add_argument(
-        "--max_sil_kept",
-        type=int,
-        required=False,
-        default=500,
-        help="The maximum silence length kept around the sliced clip, presented in milliseconds",
-    )
-    args = parser.parse_args()
-    out = args.out
-    if out is None:
-        out = os.path.dirname(os.path.abspath(args.audio))
-    audio, sr = librosa.load(args.audio, sr=None, mono=False)
-    slicer = Slicer(
-        sr=sr,
-        threshold=args.db_thresh,
-        min_length=args.min_length,
-        min_interval=args.min_interval,
-        hop_size=args.hop_size,
-        max_sil_kept=args.max_sil_kept,
-    )
-    chunks = slicer.slice(audio)
-    if not os.path.exists(out):
-        os.makedirs(out)
-    for i, chunk in enumerate(chunks):
-        if len(chunk.shape) > 1:
-            chunk = chunk.T
-        soundfile.write(
-            os.path.join(
-                out,
-                f"%s_%d.wav"
-                % (os.path.basename(args.audio).rsplit(".", maxsplit=1)[0], i),
-            ),
-            chunk,
-            sr,
-        )
-
-
-if __name__ == "__main__":
-    main()

webui.py

@@ -119,6 +119,7 @@ p_label=None
 p_uvr5=None
 p_asr=None
 p_denoise=None
+p_loudness_norm=None
 p_tts_inference=None
 
 def kill_proc_tree(pid, including_parent=True):  
@@ -246,6 +247,31 @@ def close_denoise():
         p_denoise=None
     return "已终止语音降噪进程",{"__type__":"update","visible":True},{"__type__":"update","visible":False}
 
+def open_loudness_norm(loudness_norm_inp_dir,loudness,peak,num_worker):
+    global p_loudness_norm
+    if(p_loudness_norm == None):
+        loudness_norm_inp_dir=my_utils.clean_path(loudness_norm_inp_dir)
+        cmd = '"%s" tools/loudness_norm.py -i "%s" -l "%s" -p "%s" -n "%s"'%(python_exec,loudness_norm_inp_dir,loudness,peak,num_worker)
+
+        yield "响度匹配任务开启：%s"%cmd,{"__type__":"update","visible":False},{"__type__":"update","visible":True}
+        print(cmd)
+        p_loudness_morm = Popen(cmd, shell=True)
+        p_loudness_morm.wait()
+        p_loudness_morm=None
+        yield f"响度匹配任务完成, 查看终端进行下一步",{"__type__":"update","visible":True},{"__type__":"update","visible":False}
+    else:
+        yield "已有正在进行的响度匹配任务，需先终止才能开启下一次任务", {"__type__": "update", "visible": False}, {"__type__": "update", "visible": True}
+
+
+def close_loudness_norm():
+    global p_loudness_norm
+    if(p_loudness_norm!=None):
+        try:
+            kill_process(p_loudness_norm.pid)
+        except:
+            traceback.print_exc()
+    return "已终止响度匹配进程",{"__type__":"update","visible":True},{"__type__":"update","visible":False}
+
 p_train_SoVITS=None
 def open1Ba(batch_size,total_epoch,exp_name,text_low_lr_rate,if_save_latest,if_save_every_weights,save_every_epoch,gpu_numbers1Ba,pretrained_s2G,pretrained_s2D):
     global p_train_SoVITS
@@ -337,42 +363,56 @@ def close1Bb():
         p_train_GPT=None
     return "已终止GPT训练",{"__type__":"update","visible":True},{"__type__":"update","visible":False}
 
-ps_slice=[]
+p_slice=None
-def open_slice(inp,opt_root,threshold,min_length,min_interval,hop_size,max_sil_kept,_max,alpha,n_parts):
+def open_slice(input_path, output_dir, num_worker, min_duration, max_duration, min_interval, threshold, hop_size, max_sil_kept, merge_short, loudness_norm,loudness, peak):
-    global ps_slice
+    global p_slice
-    inp = my_utils.clean_path(inp)
+    input_path = my_utils.clean_path(input_path)
-    opt_root = my_utils.clean_path(opt_root)
+    output_dir = my_utils.clean_path(output_dir)
-    if(os.path.exists(inp)==False):
+    if(os.path.exists(input_path)==False):
         yield "输入路径不存在",{"__type__":"update","visible":True},{"__type__":"update","visible":False}
         return
-    if os.path.isfile(inp):n_parts=1
+    if os.path.isfile(input_path):num_worker=1
-    elif os.path.isdir(inp):pass
+    elif os.path.isdir(input_path):pass
     else:
         yield "输入路径存在但既不是文件也不是文件夹",{"__type__":"update","visible":True},{"__type__":"update","visible":False}
         return
-    if (ps_slice == []):
+    if (p_slice == None):
-        for i_part in range(n_parts):
+        cmd = f'"{python_exec}" tools/slice_audio.py -i "{input_path}" -o "{output_dir}" --threshold {threshold} --min_duration {min_duration} --max_duration {max_duration} --min_interval {min_interval} --hop_size {hop_size} --max_sil_kept {max_sil_kept} --num_worker {num_worker} --merge_short {merge_short}'''
-            cmd = '"%s" tools/slice_audio.py "%s" "%s" %s %s %s %s %s %s %s %s %s''' % (python_exec,inp, opt_root, threshold, min_length, min_interval, hop_size, max_sil_kept, _max, alpha, i_part, n_parts)
+        print(cmd)
-            print(cmd)
+        p_slice = Popen(cmd, shell=True)
-            p = Popen(cmd, shell=True)
-            ps_slice.append(p)
         yield "切割执行中", {"__type__": "update", "visible": False}, {"__type__": "update", "visible": True}
-        for p in ps_slice:
+        p_slice.wait()
-            p.wait()
+        p_slice=None
-        ps_slice=[]
+        if loudness_norm:
+            loudness_norm_inp_dir = output_dir
+            global p_loudness_norm
+            if(p_loudness_norm == None):
+                loudness_norm_inp_dir=my_utils.clean_path(loudness_norm_inp_dir)
+                cmd = '"%s" tools/loudness_norm.py -i "%s" -l "%s" -p "%s" -n "%s"'%(python_exec,loudness_norm_inp_dir,loudness,peak,num_worker)
+                print("响度匹配任务开启")
+                print(cmd)
+                p_loudness_morm = Popen(cmd, shell=True)
+                p_loudness_morm.wait()
+                p_loudness_morm=None
+        print("响度匹配任务完成, 查看终端进行下一步")
+
         yield "切割结束",{"__type__":"update","visible":True},{"__type__":"update","visible":False}
     else:
         yield "已有正在进行的切割任务，需先终止才能开启下一次任务", {"__type__": "update", "visible": False}, {"__type__": "update", "visible": True}
 
 def close_slice():
-    global ps_slice
+    global p_slice
-    if (ps_slice != []):
+    if (p_slice != None):
-        for p_slice in ps_slice:
+        try:
-            try:
+            kill_process(p_slice.pid)
-                kill_process(p_slice.pid)
+        except:
-            except:
+            traceback.print_exc()
-                traceback.print_exc()
+        p_slice=None
-        ps_slice=[]
+    if (p_loudness_norm != None):
+        global p_denoise
+        if(p_denoise!=None):
+            kill_process(p_denoise.pid)
+            p_denoise=None
     return "已终止所有切割进程", {"__type__": "update", "visible": True}, {"__type__": "update", "visible": False}
 
 ps1a=[]
@@ -692,16 +732,19 @@ with gr.Blocks(title="GPT-SoVITS WebUI") as app:
                     slice_inp_path=gr.Textbox(label=i18n("音频自动切分输入路径，可文件可文件夹"),value="")
                     slice_opt_root=gr.Textbox(label=i18n("切分后的子音频的输出根目录"),value="output/slicer_opt")
                     threshold=gr.Textbox(label=i18n("threshold:音量小于这个值视作静音的备选切割点"),value="-34")
-                    min_length=gr.Textbox(label=i18n("min_length:每段最小多长，如果第一段太短一直和后面段连起来直到超过这个值"),value="4000")
+                    min_duration=gr.Textbox(label=i18n("min_duration:每段最短多长，如果第一段太短一直和后面段连起来直到超过这个值"),value="4.0")
-                    min_interval=gr.Textbox(label=i18n("min_interval:最短切割间隔"),value="300")
+                    max_duration=gr.Textbox(label=i18n("max_duration:每段最长多长"),value="10.0")
+                    min_interval=gr.Textbox(label=i18n("min_interval:最短切割间隔"),value="0.3")
+                    max_sil_kept=gr.Textbox(label=i18n("max_sil_kept:切完后静音最多留多长"),value="0.5")
                     hop_size=gr.Textbox(label=i18n("hop_size:怎么算音量曲线，越小精度越大计算量越高（不是精度越大效果越好）"),value="10")
-                    max_sil_kept=gr.Textbox(label=i18n("max_sil_kept:切完后静音最多留多长"),value="500")
+                    if_merge_short = gr.Checkbox(label=i18n("对于过短音频的处理方法,勾选则合并,不勾选则抛弃"),show_label=True)         
                 with gr.Row():
+                    loudness=gr.Textbox(label=i18n("目标响度"),value="-23")
+                    peak=gr.Textbox(label=i18n("峰值响度"),value="-1")       
+                    if_loudness_norm = gr.Checkbox(label=i18n("是否匹配响度"),show_label=True,value=True)         
+                    num_worker=gr.Slider(minimum=1,maximum=n_cpu,step=1,label=i18n("切割使用的进程数"),value=4,interactive=True) 
                     open_slicer_button=gr.Button(i18n("开启语音切割"), variant="primary",visible=True)
                     close_slicer_button=gr.Button(i18n("终止语音切割"), variant="primary",visible=False)
-                    _max=gr.Slider(minimum=0,maximum=1,step=0.05,label=i18n("max:归一化后最大值多少"),value=0.9,interactive=True)
-                    alpha=gr.Slider(minimum=0,maximum=1,step=0.05,label=i18n("alpha_mix:混多少比例归一化后音频进来"),value=0.25,interactive=True)
-                    n_process=gr.Slider(minimum=1,maximum=n_cpu,step=1,label=i18n("切割使用的进程数"),value=4,interactive=True)
                     slicer_info = gr.Textbox(label=i18n("语音切割进程输出信息"))
             gr.Markdown(value=i18n("0bb-语音降噪工具"))
             with gr.Row():
@@ -770,8 +813,7 @@ with gr.Blocks(title="GPT-SoVITS WebUI") as app:
             if_uvr5.change(change_uvr5, [if_uvr5], [uvr5_info])
             open_asr_button.click(open_asr, [asr_inp_dir, asr_opt_dir, asr_model, asr_size, asr_lang], [asr_info,open_asr_button,close_asr_button])
             close_asr_button.click(close_asr, [], [asr_info,open_asr_button,close_asr_button])
-            open_slicer_button.click(open_slice, [slice_inp_path,slice_opt_root,threshold,min_length,min_interval,hop_size,max_sil_kept,_max,alpha,n_process], [slicer_info,open_slicer_button,close_slicer_button])
+            open_slicer_button.click(open_slice, [slice_inp_path, slice_opt_root, num_worker, min_duration, max_duration, min_interval, threshold, hop_size, max_sil_kept,if_merge_short, if_loudness_norm, loudness, peak], [slicer_info,open_slicer_button,close_slicer_button])
-            close_slicer_button.click(close_slice, [], [slicer_info,open_slicer_button,close_slicer_button])
             open_denoise_button.click(open_denoise, [denoise_input_dir,denoise_output_dir], [denoise_info,open_denoise_button,close_denoise_button])
             close_denoise_button.click(close_denoise, [], [denoise_info,open_denoise_button,close_denoise_button])
 
@@ -785,7 +827,7 @@ with gr.Blocks(title="GPT-SoVITS WebUI") as app:
             with gr.TabItem(i18n("1A-训练集格式化工具")):
                 gr.Markdown(value=i18n("输出logs/实验名目录下应有23456开头的文件和文件夹"))
                 with gr.Row():
-                    inp_text = gr.Textbox(label=i18n("*文本标注文件"),value=r"D:\RVC1006\GPT-SoVITS\raw\xxx.list",interactive=True)
+                    inp_text = gr.Textbox(label=i18n("*文本标注文件"),value=r"output/asr_opt/slicer_opt.list",interactive=True)
                     inp_wav_dir = gr.Textbox(
                         label=i18n("*训练集音频文件目录"),
                         # value=r"D:\RVC1006\GPT-SoVITS\raw\xxx",