neverlib 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

neverlib/metrics/spec.py

@@ -0,0 +1,45 @@
+"""
+频域的客观评价指标
+LSD: 对数谱距离
+"""
+import sys
+sys.path.append("..")
+import numpy as np
+import librosa
+from utils import EPS
+
+
+def lsd(reference, estimate, n_fft=2048, hop_length=512, win_length=None):
+    """
+    计算两个一维音频信号之间的对数谱距离 (Log-Spectral Distance, LSD)。
+    该实现遵循标准的LSD定义: 整体均方根误差。
+
+    Args:
+        reference (np.ndarray): 原始的、干净的参考信号 (一维数组)。
+        estimate (np.ndarray): 模型估计或处理后的信号 (一维数组)。
+        n_fft (int): FFT点数, 决定了频率分辨率。
+        hop_length (int): 帧移, 决定了时间分辨率。
+        win_length (int, optional): 窗长。如果为None, 则默认为n_fft。
+        epsilon (float): 一个非常小的数值, 用于防止对零取对数, 保证数值稳定性。
+
+    Returns:
+        float: 对数谱距离值, 单位为分贝 (dB)。
+    """
+    assert reference.ndim == 1 and estimate.ndim == 1, "输入信号必须是一维数组。"
+    
+    if win_length is None:
+        win_length = n_fft
+
+    reference_stft = librosa.stft(reference, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
+    estimate_stft = librosa.stft(estimate, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
+
+    reference_power_spec = np.abs(reference_stft) ** 2 # (F,T)
+    estimate_power_spec = np.abs(estimate_stft) ** 2 # (F,T)
+
+    reference_log_power_spec = 10 * np.log10(reference_power_spec + EPS)
+    estimate_log_power_spec = 10 * np.log10(estimate_power_spec + EPS)
+
+    squared_error = (reference_log_power_spec - estimate_log_power_spec) ** 2
+    lsd_val = np.sqrt(np.mean(squared_error))
+
+    return lsd_val

neverlib/metrics/test_pesq.py

@@ -0,0 +1,35 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-05 23:37:31
+Description: 
+
+PESQ 包含 3 种类型的值：NB PESQ MOS、NB MOS LQO、WB MOS LQO。此包仅返回NB PESQ MOS代表 的Raw MOS分数narrowband handset listening。
+'''
+import pesq
+import pypesq
+import librosa
+import os
+import numpy as np
+
+fs = 16000
+clean = librosa.load("../data/000_short.wav", sr=fs)[0]
+enhance = librosa.load("../data/000_short_enhance.wav", sr=fs)[0]
+
+print(pesq.pesq(fs, clean, enhance, 'wb'))  # 3.5920536518096924
+print(pypesq.pesq(clean, enhance, fs=fs))  # 3.817176103591919
+# os.system("./pesq_c/PESQ +16000 ../data/000_short.wav ../data/000_short_enhance.wav")   # WB PESQ_MOS = 3.518
+# os.system("./pesq_c/PESQ +8000 ../data/000_short.wav ../data/000_short_enhance.wav")   # NB PESQ_MOS = 3.477
+
+
+def pesq2mos(pesq):
+    """ 将PESQ值[-0.5, 4.5]映射到MOS-LQO得分[1, 4.5]上，映射函数来源于：P.862.1 """
+    return 0.999 + (4.999 - 0.999) / (1 + np.exp(-1.4945 * pesq + 4.6607))
+
+
+def mos2pesq(mos):
+    """ 将MOS-LQO得分[1, 4.5]映射到PESQ值[-0.5, 4.5]上，映射函数来源于：P.862.1"""
+    inlog = (4.999 - mos) / (mos - 0.999)
+    return (4.6607 - np.log(inlog)) / 1.4945
+
+
+# print(mos2pesq(3.518))

neverlib/metrics/time.py

@@ -0,0 +1,68 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-05 16:44:41
+Description: 
+'''
+"""
+音频数据分析基础工具模块
+Basic Utilities for Audio Data Analysis
+
+提供音频分析的基础工具函数
+"""
+
+import numpy as np
+import librosa
+
+
+def peak_amplitude(wav):
+    """计算峰值幅度
+
+    Args:
+        wav: 音频信号 (*, ch)
+
+    Returns:
+        峰值幅度 (dB)
+    """
+    peak_amp = np.max(np.abs(wav))
+    return peak_amp
+
+
+def rms_amplitude(wav):
+    """计算RMS幅度
+
+    Args:
+        wav: 音频信号 (*, ch)
+
+    Returns:
+        RMS幅度
+    """
+    return np.sqrt(np.mean(np.square(wav)))
+
+
+def mean_rms_amplitude(wav, frame_length=512, hop_length=256):
+    """计算分帧平均RMS幅度
+
+    Args:
+        wav: 音频信号 (*, ch)
+        frame_length: 帧长度
+        hop_length: 跳跃长度
+
+    Returns:
+        平均RMS幅度
+    """
+    # 分帧
+    frame = librosa.util.frame(wav.flatten(), frame_length=frame_length, hop_length=hop_length)
+    rms_amp = np.sqrt(np.mean(np.square(frame), axis=0))
+    return np.mean(rms_amp)
+
+
+def dc_offset(wav):
+    """计算直流分量
+
+    Args:
+        wav: 音频信号 (*, ch)
+
+    Returns:
+        直流分量
+    """
+    return np.mean(wav)

neverlib/tests/test_vad.py

@@ -0,0 +1,21 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-05 17:29:43
+Description: 
+'''
+import os
+import sys
+sys.path.append("../")
+from vad.utils import vad2nad
+
+
+def test_vad2nad():
+    """测试vad2nad函数"""
+    vad = [{'start': 100, 'end': 1000}, {'start': 2000, 'end': 3000}]
+    total_length = 4000
+    nad = vad2nad(vad, total_length)
+    print(nad)
+
+
+if __name__ == "__main__":
+    test_vad2nad()

neverlib/utils/audio_split.py

@@ -14,7 +14,7 @@ from pydub import AudioSegment
 
 
 def audio_split_ffmpeg(source_path, target_path, sr, channel_num, duration, endwith="*.pcm"):
-    """ 切割音频切不准，会留点尾巴0.016s
+    """ 切割音频切不准, 会留点尾巴0.016s
     使用ffmpeg分割音频, 分割为短音频(单位:秒), 似乎无法非常准确的分割到指定长度
     :param source_path: 源音频路径
     :param target_path: 目标音频路径
@@ -94,6 +94,7 @@ def audio_split_np(source_path, target_path, sr, channel_num, duration, endwith=
 
         # 注意读取时使用正确的dtype(例如int16表示16位PCM)
         pcm_data = np.fromfile(wav_path, dtype=np.int16)
+        pcm_data = pcm_data[:(len(pcm_data) // channel_num) * channel_num]
         pcm_data = pcm_data.reshape(-1, channel_num)
 
         # 计算分割的数量

neverlib/utils/message.py

@@ -57,7 +57,7 @@ def send_QQEmail_with_images(title, content, from_name, from_email, from_passwor
     :param from_email: 发件人邮箱
     :param from_password: 发件人邮箱SMTP授权码
     :param to_email: 收件人邮箱
-    :param image_paths: 图片文件路径列表，应为PNG格式
+    :param image_paths: 图片文件路径列表, 应为PNG格式
     """
     # 设置邮箱的域名
     HOST = "smtp.qq.com"
@@ -87,10 +87,10 @@ def send_QQEmail_with_images(title, content, from_name, from_email, from_passwor
             # 使用 MIMEImage 添加图片
             image_part = MIMEImage(img_data)
 
-            # 设置Content-ID，以便在正文中引用图片
+            # 设置Content-ID, 以便在正文中引用图片
             image_part.add_header('Content-ID', cid)
 
-            # 设置为 inline 显示，避免附件处理
+            # 设置为 inline 显示, 避免附件处理
             image_part.add_header('Content-Disposition', 'inline', filename=os.path.basename(image_path))
 
             # 添加图片到邮件
@@ -115,7 +115,7 @@ def send_QQEmail_with_images(title, content, from_name, from_email, from_passwor
 
 
 if __name__ == "__main__":
-    send_QQEmail("实验跑完", "实验跑完了，快去看看吧！",
+    send_QQEmail("实验跑完", "实验跑完了, 快去看看吧！",
                  from_email="1786088386@qq.com", from_password="xxxx",
                  to_email="1786088386@qq.com")
     pass

neverlib/utils/utils.py

@@ -12,6 +12,7 @@ from tqdm import tqdm
 from datetime import datetime
 import soundfile as sf
 import numpy as np
+EPS = np.finfo(float).eps
 
 
 def get_path_list(source_path, end="*.wav", shuffle=False):
@@ -49,10 +50,10 @@ def rename_files_and_folders(directory, replace='_-', replacement='_'):
 def get_file_time(file_path):
     # 获取最后修改时间
     mod_time = os.path.getmtime(file_path)
-    # 转为data_time格式：年-月-日-时-分-秒
+    # 转为data_time格式: 年-月-日-时-分-秒
     datetime_dt = datetime.fromtimestamp(mod_time)
 
-    # 如果时间早于2024-09-04 02:00:00，则删除
+    # 如果时间早于2024-09-04 02:00:00, 则删除
     # if datetime_dt < datetime(2024, 9, 4, 2, 0, 0):
     #     print(file_path)
     return datetime_dt
@@ -97,38 +98,38 @@ def TrainValTestSplit(dataset_dir, train_dir, val_dir, test_dir, percentage=[0.8
     :param percentage: 分割百分比
     """
     assert sum(percentage) == 1.0, "百分比总和必须等于1.0"
-    
+
     wav_path_list = sorted(get_path_list(dataset_dir, end="*.wav"))
     random.seed(10086)
     random.shuffle(wav_path_list)  # 打乱列表的顺序
     total_wav_num = len(wav_path_list)
-    
+
     # 计算训练集、验证集和测试集的分割点
     train_split_idx = int(total_wav_num * percentage[0])
     val_split_idx = train_split_idx + int(total_wav_num * percentage[1])
-    
+
     train_path_list = wav_path_list[:train_split_idx]
     val_path_list = wav_path_list[train_split_idx:val_split_idx]
     test_path_list = wav_path_list[val_split_idx:]
-    
+
     for train_wavpath in tqdm(train_path_list, desc="复制训练集音频"):
         target_path = train_wavpath.replace(dataset_dir, train_dir)
         if not os.path.exists(os.path.split(target_path)[0]):
             os.makedirs(os.path.split(target_path)[0])
         shutil.copy(train_wavpath, target_path)
-    
+
     for val_wavpath in tqdm(val_path_list, desc="复制验证集音频"):
         target_path = val_wavpath.replace(dataset_dir, val_dir)
         if not os.path.exists(os.path.split(target_path)[0]):
             os.makedirs(os.path.split(target_path)[0])
         shutil.copy(val_wavpath, target_path)
-    
+
     for test_wavpath in tqdm(test_path_list, desc="复制测试集音频"):
         target_path = test_wavpath.replace(dataset_dir, test_dir)
         if not os.path.exists(os.path.split(target_path)[0]):
             os.makedirs(os.path.split(target_path)[0])
         shutil.copy(test_wavpath, target_path)
-    
+
     print(f"完成! 训练集: {len(train_path_list)}个文件, 验证集: {len(val_path_list)}个文件, 测试集: {len(test_path_list)}个文件")
 
 
@@ -141,15 +142,31 @@ def get_leaf_folders(directory):
     return leaf_folders
 
 
+def del_empty_folders(path):
+    """ 递归删除空文件夹"""
+    assert os.path.isdir(path), f"{path} 不是一个有效的目录"
+
+    # os.walk(path, topdown=False) 会从最深的子目录开始向上遍历
+    for dirpath, dirnames, filenames in os.walk(path, topdown=False):
+        # 如果一个目录内既没有子目录, 也没有文件, 说明它是空的
+        if not dirnames and not filenames:
+            try:
+                os.rmdir(dirpath)
+                print(f"删除空文件夹: {dirpath}")
+            except OSError as e:
+                # 捕获可能的错误, 如权限不足或目录不是真的“空”（例如有隐藏文件）
+                print(f"删除失败: {dirpath} - {e}")
+
+
 def DatasetSubfloderSplit(source_dir, split_dirs, percentage=None):
     """
     将一个数据集按照子文件夹数量分割成train/val/test数据集
     Args:
         source_dir (str): 源数据集目录
-        split_dirs (list): 目标目录列表，如 [train_dir, val_dir] 或 [train_dir, val_dir, test_dir]
-        percentage (list, optional): 分割比例，如 [0.9, 0.1] 或 [0.8, 0.1, 0.1]。默认为 None，此时：
-            - 如果是两路分割，默认为 [0.9, 0.1]
-            - 如果是三路分割，默认为 [0.8, 0.1, 0.1]
+        split_dirs (list): 目标目录列表, 如 [train_dir, val_dir] 或 [train_dir, val_dir, test_dir]
+        percentage (list, optional): 分割比例, 如 [0.9, 0.1] 或 [0.8, 0.1, 0.1]。默认为 None, 此时: 
+            - 如果是两路分割, 默认为 [0.9, 0.1]
+            - 如果是三路分割, 默认为 [0.8, 0.1, 0.1]
     Example:
         # 两路分割示例
         DatasetSplit(
@@ -247,11 +264,11 @@ def save_weight_histogram(model, save_dir, mode=["params", "buffers"], ignore_na
     Args:
         model: PyTorch模型
         save_dir: 保存路径
-        mode: 保存模式，可选值为["params", "buffers"]
+        mode: 保存模式, 可选值为["params", "buffers"]
         bins: 直方图bin数量
     """
     import matplotlib.pyplot as plt
-    # 如果路径存在，则删除
+    # 如果路径存在, 则删除
     if os.path.exists(save_dir):
         shutil.rmtree(save_dir)
 

neverlib/vad/PreProcess.py

@@ -9,7 +9,7 @@ Description:
 # Author:凌逆战 | Never
 # Date: 2024/9/14
 """
-通过一些预处理方法，来提高VAD的准确率
+通过一些预处理方法, 来提高VAD的准确率
 """
 import numpy as np
 import noisereduce as nr

neverlib/vad/README.md

@@ -1,7 +1,7 @@
 ## energy-vad
 
 https://pypi.org/project/energy-vad/
-误差比较大，而且连着的语音没必要分割，但是该方法还是分割了
+误差比较大, 而且连着的语音没必要分割, 但是该方法还是分割了
 
 ## Funasr
 
@@ -23,12 +23,12 @@ API文档：https://github.com/snakers4/silero-vad/blob/master/utils_vad.py
 
 https://github.com/eesungkim/Voice_Activity_Detector
 基于统计方法的VAD, 效果还可以
-语间细节把握的很好，但是有时候会吞掉一个字
+语间细节把握的很好, 但是有时候会吞掉一个字
 
 ## vad
 
 https://pypi.org/project/vad/
-也还行，稍微有点过削
+也还行, 稍微有点过削
 
 ## webrtcvad
 
@@ -38,18 +38,18 @@ https://pypi.org/project/vad/
 
 mode 0~3
 
-0: 最低的语音检测敏感度，
+0: 最低的语音检测敏感度, 
 
-- 认为背景噪声不是语音，适合环境较安静，背景噪声少的情况。
-- 适合环境较安静，背景噪声少的情况。
+- 认为背景噪声不是语音, 适合环境较安静, 背景噪声少的情况。
+- 适合环境较安静, 背景噪声少的情况。
 
-3: 最高的语音检测敏感度，
+3: 最高的语音检测敏感度, 
 
-- VAD 会非常积极地尝试将任何噪声过滤掉，只有明确的语音才会被认为是语音。
-- 适合环境较吵，背景噪声多的情况。
+- VAD 会非常积极地尝试将任何噪声过滤掉, 只有明确的语音才会被认为是语音。
+- 适合环境较吵, 背景噪声多的情况。
 
 ## whisper
 
 whisper 检测的 词与词之间的VAD 都是连着的。但其实音频不是
 
-而且Whisper的VAD并没有直接提供调参接口，所以无法调整VAD的参数
+而且Whisper的VAD并没有直接提供调参接口, 所以无法调整VAD的参数

neverlib/vad/VAD_Energy.py

@@ -47,7 +47,7 @@ if __name__ == "__main__":
     sr = 16000
     wav_path = "../wav_data/000_short.wav"
     wav, wav_sr = sf.read(wav_path, always_2d=False, dtype="float32")
-    assert wav_sr == sr, f"音频采样率为{wav_sr}，期望{sr}"
+    assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望{sr}"
     wav = HPFilter(wav, sr=sr, order=6, cutoff=100)
     wav = volume_norm(wav)
 

neverlib/vad/VAD_Silero.py

@@ -41,7 +41,7 @@ if __name__ == "__main__":
     sr = 16000
     wav_path = "../../wav_data/000_short.wav"
     wav, wav_sr = sf.read(wav_path, always_2d=False, dtype="float32")
-    assert wav_sr == sr, f"音频采样率为{wav_sr}，期望{sr}"
+    assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望{sr}"
     wav = HPFilter(wav, sr=sr, order=6, cutoff=100)
     wav = volume_norm(wav)
 

neverlib/vad/VAD_WebRTC.py

@@ -40,7 +40,7 @@ if __name__ == "__main__":
     sr = 16000
     wav_path = "../../wav_data/000_short.wav"
     wav, wav_sr = sf.read(wav_path, always_2d=False, dtype="float32")
-    assert wav_sr == sr, f"音频采样率为{wav_sr}，期望{sr}"
+    assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望{sr}"
     wav = HPFilter(wav, sr=sr, order=6, cutoff=100)
     wav = volume_norm(wav)
 

neverlib/vad/VAD_funasr.py

@@ -33,7 +33,7 @@ if __name__ == "__main__":
     sr = 16000
     wav_path = "../../wav_data/000_short.wav"
     wav, wav_sr = sf.read(wav_path, always_2d=False, dtype="float32")
-    assert wav_sr == sr, f"音频采样率为{wav_sr}，期望{sr}"
+    assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望{sr}"
     wav = HPFilter(wav, sr=sr, order=6, cutoff=100)
     wav = volume_norm(wav)
 

neverlib/vad/VAD_statistics.py

@@ -4,7 +4,7 @@
 """
 https://github.com/eesungkim/Voice_Activity_Detector
 基于统计方法的VAD, 效果还可以
-语间细节把握的很好，但是有时候会吞掉一个字
+语间细节把握的很好, 但是有时候会吞掉一个字
 该文件用于作为库调用
 """
 import os
@@ -256,11 +256,11 @@ class Statistics_VAD():
         starts = np.where((vad_array[:-1] == 0) & (vad_array[1:] == 1))[0] + 1
         ends = np.where((vad_array[:-1] == 1) & (vad_array[1:] == 0))[0]
 
-        # 如果活动段以1开始但没有以0结束，则需要手动添加结束点
+        # 如果活动段以1开始但没有以0结束, 则需要手动添加结束点
         if vad_array[-1] == 1:
             ends = np.append(ends, len(vad_array) - 1)
 
-        # 如果活动段以0开始但没有以1结束，则需要手动添加起始点
+        # 如果活动段以0开始但没有以1结束, 则需要手动添加起始点
         if vad_array[0] == 1:
             starts = np.insert(starts, 0, 0)
 

neverlib/vad/VAD_vadlib.py

@@ -30,7 +30,7 @@ class Vadlib_C():
 
     def process(self, wav):
         assert wav.ndim == 1, f"wav shape为{wav.shape}, 期望1D"
-        # 返回布尔阵列，指示框架是否是语音
+        # 返回布尔阵列, 指示框架是否是语音
         voice_activity = self.vad(wav)  # (115,) [1,1,0,0,1,,1,0,0....]
 
         window_len = int(self.frame_length / 1000 * self.sr)
@@ -49,7 +49,7 @@ if __name__ == "__main__":
     sr = 16000
     wav_path = "../../wav_data/000_short.wav"
     wav, wav_sr = sf.read(wav_path, always_2d=False, dtype="float32")
-    assert wav_sr == sr, f"音频采样率为{wav_sr}，期望{sr}"
+    assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望{sr}"
     wav = HPFilter(wav, sr=sr, order=6, cutoff=100)
     wav = volume_norm(wav)
 

neverlib/vad/VAD_whisper.py

@@ -45,7 +45,7 @@ if __name__ == "__main__":
     sr = 16000
     wav_path = "../../wav_data/000_short.wav"
     wav, wav_sr = sf.read(wav_path, always_2d=False, dtype="float32")
-    assert wav_sr == sr, f"音频采样率为{wav_sr}，期望{sr}"
+    assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望{sr}"
     wav = HPFilter(wav, sr=sr, order=6, cutoff=100)
     wav = volume_norm(wav)
 

neverlib/vad/__init__.py

@@ -15,4 +15,4 @@ from .VAD_statistics import Statistics_VAD
 from .VAD_vadlib import Vadlib_C
 from .VAD_WebRTC import WebRTC_VAD_C
 from .VAD_whisper import Whisper_VAD_C
-from .utils import from_vadArray_to_vadEndpoint
+from .utils import from_vadArray_to_vadEndpoint, vad2nad

neverlib/vad/class_get_speech.py

@@ -2,7 +2,7 @@
 # Author:凌逆战 | Never
 # Date: 2024/9/3
 """
-获取纯净语音，删除静音
+获取纯净语音, 删除静音
 """
 import os
 import numpy as np
@@ -28,9 +28,9 @@ class getSpeech():
         wav, wav_sr = sf.read(wav_path, always_2d=True, dtype='float32')
         assert wav_sr == self.sr, f"音频采样率应为{self.sr}"
         # wav = wav / np.abs(wav).max()  # 归一化
-        # voice_activity = self.vad(wav)  # 返回一个布尔数组，指示帧是否为语音
+        # voice_activity = self.vad(wav)  # 返回一个布尔数组, 指示帧是否为语音
 
-        # 获取语音，删除静音
+        # 获取语音, 删除静音
         speech_signal = self.vad.apply_vad(wav.T).T
         return speech_signal
 
@@ -43,7 +43,7 @@ class getSpeech():
                                     keep_silence=False,  # 在开头和结尾部分保留静音
                                     )
 
-        output_audio = AudioSegment.empty()  # 创建一个空的音频段，用于存储非静音部分
+        output_audio = AudioSegment.empty()  # 创建一个空的音频段, 用于存储非静音部分
 
         # 将非静音段添加到输出音频中
         for segment in segments:

neverlib/vad/class_vad.py

@@ -60,7 +60,7 @@ class VADClass():
         assert wav.ndim == 1, "wav must be 1D"
         res_list = self.model.generate(input=wav)
         # 注：VAD模型的输出格式为：[[beg1, end1], [beg2, end2], ..., [begN, endN]]
-        # 其中begN/endN表示有效音频段的起点/终点N-th，以毫秒为单位
+        # 其中begN/endN表示有效音频段的起点/终点N-th, 以毫秒为单位
         # print(res_list) # [{'key': 'rand_key_2yW4Acq9GFz6Y', 'value': [[0, 2140(ms)]]}]
         endpint = []
         for res in res_list:

neverlib/vad/utils.py

@@ -8,18 +8,60 @@ import numpy as np
 
 
 def from_vadArray_to_vadEndpoint(vad_array):
+    """
+    将VAD数组转换为VAD时间戳列表
+    Args:
+        vad_array: 1D VAD数组
+            # vad_array = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1])
+
+    Returns:
+        Timestamps: [{start:xxx, end:xxx}, ...]
+    """
     # 计算活动段的起始点和结束点
-    # vad_array = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1])
     # 返回 [(2320, 8079), (8400, 8719), (8880, 10959), (11600, 25039), (25840, 27439), (29040, 29359), (29520, 31759), (32240, 32399)]
     starts = np.where((vad_array[:-1] == 0) & (vad_array[1:] == 1))[0] + 1    # +1是因为提前了一个点
     ends = np.where((vad_array[:-1] == 1) & (vad_array[1:] == 0))[0] + 1  # + 1是因为不取最后一个点
 
-    # 如果最后一个点还是1，则需要手动添加结束点
-    if vad_array[-1] == 1: ends = np.append(ends, len(vad_array))
+    # 如果最后一个点还是1, 则需要手动添加结束点
+    if vad_array[-1] == 1:
+        ends = np.append(ends, len(vad_array))
     # 如果第一个点就是1, 则需要手动添加起始点
-    if vad_array[0] == 1: starts = np.insert(starts, 0, 0)
+    if vad_array[0] == 1:
+        starts = np.insert(starts, 0, 0)
     assert len(starts) == len(ends), "starts and ends must have the same length"
 
     Timestamps = [{"start": int(start), "end": int(end)} for start, end in zip(starts, ends)]
 
-    return Timestamps
+    return Timestamps
+
+
+def vad2nad(vad, total_length):
+    """根据语音时间戳, 提取噪声时间戳 (优化版)
+    Args:
+        vad: [{start:xxx, end:xxx}, ...]
+        total_length: 音频总长度（样本数）
+    Returns:
+        nad: [{start:xxx, end:xxx}, ...] 噪声时间戳列表
+    """
+    assert total_length > 0, "音频总长度必须大于0"
+    assert isinstance(vad, list), "vad必须是列表"
+
+    # 按开始时间排序, 确保VAD段是有序的
+    vad_sorted = sorted(vad, key=lambda x: x['start'])
+
+    nad = []
+    last_end = 0
+    for segment in vad_sorted:
+        start = segment['start']
+        # 检查当前语音段和上一个语音段/音频开头的间隙
+        if start > last_end:
+            nad.append({'start': last_end, 'end': start})
+
+        # 使用max是为了处理可能重叠的VAD段
+        last_end = max(last_end, segment['end'])
+
+    # 检查最后一个语音段到音频结尾的间隙
+    if last_end < total_length:
+        nad.append({'start': last_end, 'end': total_length})
+
+    return nad