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

neverlib/filter/core.py

@@ -0,0 +1,339 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-04 16:25:00
+Description: EQ滤波器
+type(fc, gain, Q) 
+
+enum IIR_BIQUARD_TYPE {
+    IIR_BIQUARD_PASS = 0,   // pass through
+    IIR_BIQUARD_RAW,        // raw filter
+    IIR_BIQUARD_LPF,        // 低通滤波器 low pass filter
+    IIR_BIQUARD_HPF,        // 高通滤波器 high pass filter
+    IIR_BIQUARD_BPF0,       // 带通滤波器 band pass filter, constant skirt gain, peak gain = Q
+    IIR_BIQUARD_BPF1,       // 带通滤波器 band pass filter, const 0 dB peak gain
+    IIR_BIQUARD_NOTCH,      // 陷波滤波器 notch filter
+    IIR_BIQUARD_APF,        // 全通滤波器 allpass filter
+    IIR_BIQUARD_PEAKINGEQ,  // 峰值滤波器 peakingEQ
+    IIR_BIQUARD_LOWSHELF,   // 低切滤波器 low shelf filter
+    IIR_BIQUARD_HIGHSHELF,  // 高切滤波器 high shelf filter
+    IIR_BIQUARD_QTY         // number of biquard types
+};
+'''
+import random
+import numpy as np
+from scipy import signal
+
+
+class EQFilter():
+    def __init__(self, fs=16000):
+        self.fs = fs
+
+    def LowpassFilter(self, fc, Q=1 / np.sqrt(2.0)):
+        """ 低通滤波器(Low Pass Filter) 
+        LPF: H(s) = 1 / (s^2 + s/Q + 1)
+
+        b0 = (1 - cos(w0))/2;
+        b1 = 1 - cos(w0);
+        b2 = (1 - cos(w0))/2;
+        a0 = 1 + alpha;
+        a1 = -2*cos(w0);
+        a2 = 1 - alpha;
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = (1.0 - cos_w0) / 2.0
+        b1 = 1.0 - cos_w0
+        b2 = (1.0 - cos_w0) / 2.0
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def HighpassFilter(self, fc, Q=1 / np.sqrt(2)):
+        """ 高通滤波器(High Pass Filter) 
+        HPF: $H(s)=\frac{s^2}{s^2 + s/Q + 1}$
+            b0 = (1 + cos(w0))/2
+            b1 = -(1 + cos(w0))
+            b2 = (1 + cos(w0))/2
+            a0 = 1 + alpha
+            a1 = -2*cos(w0)
+            a2 = 1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = (1.0 + cos_w0) / 2.0
+        b1 = -(1.0 + cos_w0)
+        b2 = (1.0 + cos_w0) / 2.0
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def BandpassFilter_Q(self, fc, Q):
+        """带通 Band Pass Filter (增益 = Q)
+        BPF: H(s) = s / (s^2 + s/Q + 1) (constant skirt gain, peak gain = Q)
+            b0 =   sin(w0)/2  =   Q*alpha
+            b1 =   0
+            b2 =  -sin(w0)/2  =  -Q*alpha
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = sin_w0 / 2.0  # Q*alpha
+        b1 = 0.0
+        b2 = -sin_w0 / 2.0  # -Q*alpha
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def BandpassFilter_0dB(self, fc, Q=1 / np.sqrt(2)):
+        """带通 Band Pass Filter(0 db增益)
+        BPF: H(s) = (s/Q) / (s^2 + s/Q + 1) (constant 0 dB peak gain)
+            b0 =   alpha
+            b1 =   0
+            b2 =  -alpha
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = alpha
+        b1 = 0.0
+        b2 = -alpha
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def NotchFilter(self, fc, Q=1 / np.sqrt(2)):
+        """Notch滤波器
+        notch: H(s) = (s^2 + 1) / (s^2 + s/Q + 1)$
+            b0 =   1
+            b1 =  -2*cos(w0)
+            b2 =   1
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = 1.0
+        b1 = -2.0 * cos_w0
+        b2 = 1.0
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def AllpassFilter(self, fc, Q=1 / np.sqrt(2)):
+        """全通 All Pass Filter
+        APF: H(s) = (s^2 - s/Q + 1) / (s^2 + s/Q + 1)$
+            b0 =   1 - alpha
+            b1 =  -2*cos(w0)
+            b2 =   1 + alpha
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = 1.0 - alpha
+        b1 = -2.0 * cos_w0
+        b2 = 1.0 + alpha
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def PeakingFilter(self, fc, dBgain, Q=1 / np.sqrt(2)):
+        """峰值滤波器
+        peakingEQ: H(s) = (s^2 + s*(A/Q) + 1) / (s^2 + s/(A*Q) + 1)
+            b0 =   1 + alpha*A
+            b1 =  -2*cos(w0)
+            b2 =   1 - alpha*A
+            a0 =   1 + alpha/A
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha/A
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        # cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # gain、A 仅用于峰值和shelf滤波器
+        dBgain = round(float(dBgain), 3)
+        A = 10 ** (dBgain / 40)
+        # ---------------------------------------------
+        b0 = 1 + alpha * A
+        b1 = -2 * np.cos(w0)
+        b2 = 1 - alpha * A
+        a0 = 1 + alpha / A
+        a1 = -2 * np.cos(w0)
+        a2 = 1 - alpha / A
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def LowshelfFilter(self, fc, dBgain, Q=1 / np.sqrt(2)):
+        """低切滤波器
+        lowShelf: H(s) = A * (s^2 + (sqrt(A)/Q)*s + A)/(A*s^2 + (sqrt(A)/Q)*s + 1)
+            b0 =    A*( (A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha )
+            b1 =  2*A*( (A-1) - (A+1)*cos(w0)                   )
+            b2 =    A*( (A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha )
+            a0 =        (A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha
+            a1 =   -2*( (A-1) + (A+1)*cos(w0)                   )
+            a2 =        (A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # gain、A 仅用于峰值和shelf滤波器
+        dBgain = round(float(dBgain), 3)
+        A = 10.0 ** (dBgain / 40.0)
+        # ---------------------------------------------
+        b0 = A * ((A + 1) - (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha)
+        b1 = 2 * A * ((A - 1) - (A + 1) * cos_w0)
+        b2 = A * ((A + 1) - (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha)
+        a0 = (A + 1) + (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha
+        a1 = -2 * ((A - 1) + (A + 1) * cos_w0)
+        a2 = (A + 1) + (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def HighshelfFilter(self, fc, dBgain, Q=1 / np.sqrt(2)):
+        """高切滤波器
+        highShelf: H(s) = A * (A*s^2 + (sqrt(A)/Q)*s + 1)/(s^2 + (sqrt(A)/Q)*s + A)
+            b0 =    A*( (A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha )
+            b1 = -2*A*( (A-1) + (A+1)*cos(w0)                   )
+            b2 =    A*( (A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha )
+            a0 =        (A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha
+            a1 =    2*( (A-1) - (A+1)*cos(w0)                   )
+            a2 =        (A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # gain、A 仅用于峰值和shelf滤波器
+        dBgain = round(float(dBgain), 3)
+        A = 10.0 ** (dBgain / 40.0)
+        # ---------------------------------------------
+        b0 = A * ((A + 1) + (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha)
+        b1 = -2 * A * ((A - 1) + (A + 1) * cos_w0)
+        b2 = A * ((A + 1) + (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha)
+        a0 = (A + 1) - (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha
+        a1 = 2 * ((A - 1) - (A + 1) * cos_w0)
+        a2 = (A + 1) - (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+
+def eq_process(sig, b_list, a_list, ratio):
+    """ psap eq增强
+    :param sig: input signal with size [T] or [T, C]
+    :param b_list: 滤波器系数列表
+    :param a_list: 滤波器系数列表
+    :param ratio: 0-1, processing ratio
+    :return: [T] when ipt.shape is [T]; [T, C] when ipt.shape is [T, C]
+    """
+    if len(sig.shape) == 1:
+        sig.shape = -1, 1
+    assert len(sig.shape) == 2, f"input signal's shape must be 2, but {sig.shape} now!"
+    sig_eq = sig.copy()
+    if random.random() < ratio:
+        # 逐个应用滤波器
+        for b, a in zip(b_list, a_list):
+            sig_eq = signal.lfilter(b, a, sig_eq, axis=0)
+    return sig_eq
+
+
+def eq_process_test():
+    import soundfile as sf
+
+    EQ_Coef = [
+        ([1.5023072, -1.0912886, 0.1981803], [1., -1.3417218, 0.4500543]),  # f0 = 80, gain = -20, q = 1
+        ([1.2288871, -1.173879, 0.18292512], [1., -1.173879, 0.4118123]),  # f0 = 100, gain = -10, q = 1
+    ]
+
+    wav, wav_sr = sf.read("./white.wav", dtype="float32", always_2d=True)
+
+    wav = eq_process(wav, EQ_Coef, ratio=1)
+
+    sf.write("./white_eq.wav", wav, wav_sr)
+
+
+def EQ_test():
+    """
+    lowshelf滤波器 freq=1.5kHz, gain=15dB, Q=0.5
+    b: [ 1.5023072 -1.0912886  0.1981803]
+    a: [ 1.        -1.3417218  0.4500543]
+
+    peak freq=1.5kHz, gain=5dB, Q=0.5
+    b: [ 1.2288871  -1.173879    0.18292512]
+    a: [ 1.        -1.173879   0.4118123]
+    """
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from scipy import signal
+
+    fs = 16000
+
+    # b, a = LowshelfFilter(1500, 15, Q=0.5)
+    b, a = PeakingFilter(1500, 5, Q=0.5)
+    print(b)
+    print(a)
+
+    w, h = signal.freqz(b, a)  # 根据系数计算滤波器的频率响应, w是角频率, h是频率响应
+    plt.plot(0.5 * fs * w / np.pi, 20 * np.log10(h))  # 0.5*fs*w/np.pi 为频率
+    plt.title('Butterworth filter frequency response')
+    plt.xlabel('Frequency [Hz]')
+    plt.ylabel('Amplitude [dB]')
+    plt.grid(which='both', axis='both')  # 显示网格
+    # 画红色的垂直线, 标记截止频率
+    plt.xscale('log')  # x轴对数化
+    plt.show()

neverlib/metrics/dnsmos.py

@@ -0,0 +1,117 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-06 10:00:00
+Description: 
+要计算个性化 MOS 分数（干扰说话者受到惩罚），请提供“-p”参数，例如：python dnsmos.py -t ./SampleClips -o sample.csv -p
+要计算常规 MOS 分数，请省略“-p”参数。例如：python dnsmos.py -t ./SampleClips -o sample.csv
+'''
+import argparse
+import concurrent.futures
+import glob
+import os
+import librosa
+import numpy as np
+import onnxruntime as ort
+import pandas as pd
+import soundfile as sf
+from tqdm import tqdm
+from neverlib.utils import get_path_list
+
+
+class ComputeScore:
+    def __init__(self, is_personalized_MOS, sr, input_length) -> None:
+        self.sr = sr
+        self.input_length = input_length
+        self.is_personalized_MOS = is_personalized_MOS
+        p808_model_path = "./DNSMOS/model_v8.onnx"
+        if is_personalized_MOS:
+            primary_model_path = "./pDNSMOS/sig_bak_ovr.onnx"
+        else:
+            primary_model_path = "./DNSMOS/sig_bak_ovr.onnx"
+
+        self.onnx_sess = ort.InferenceSession(primary_model_path)
+        self.p808_onnx_sess = ort.InferenceSession(p808_model_path)
+
+    def audio_melspec(self, audio, n_mels=120, frame_size=320, hop_length=160, to_db=True):
+        mel_spec = librosa.feature.melspectrogram(y=audio, sr=self.sr, n_fft=frame_size + 1, hop_length=hop_length, n_mels=n_mels)
+        if to_db:
+            mel_spec = (librosa.power_to_db(mel_spec, ref=np.max) + 40) / 40
+        return mel_spec.T
+
+    def get_polyfit_val(self, sig, bak, ovr):
+        if self.is_personalized_MOS:
+            p_ovr = np.poly1d([-0.00533021, 0.005101, 1.18058466, -0.11236046])
+            p_sig = np.poly1d([-0.01019296, 0.02751166, 1.19576786, -0.24348726])
+            p_bak = np.poly1d([-0.04976499, 0.44276479, -0.1644611, 0.96883132])
+        else:
+            p_ovr = np.poly1d([-0.06766283, 1.11546468, 0.04602535])
+            p_sig = np.poly1d([-0.08397278, 1.22083953, 0.0052439])
+            p_bak = np.poly1d([-0.13166888, 1.60915514, -0.39604546])
+
+        sig_poly, bak_poly, ovr_poly = p_sig(sig), p_bak(bak), p_ovr(ovr)
+
+        return sig_poly, bak_poly, ovr_poly
+
+    def __call__(self, wav_path):
+        wav, wav_sr = sf.read(wav_path, dtype='float32')
+        if wav_sr != self.sr:
+            wav = librosa.resample(wav, wav_sr, self.sr)
+        else:
+            wav = wav
+        len_samples = int(self.input_length * self.sr)
+        while len(wav) < len_samples:
+            wav = np.append(wav, wav)
+
+        num_hops = int(np.floor(len(wav) / self.sr) - self.input_length) + 1
+        hop_len_samples = self.sr
+        predicted_mos_sig_seg_raw = []
+        predicted_mos_bak_seg_raw = []
+        predicted_mos_ovr_seg_raw = []
+        predicted_mos_sig_seg = []
+        predicted_mos_bak_seg = []
+        predicted_mos_ovr_seg = []
+        predicted_p808_mos = []
+
+        for idx in range(num_hops):
+            wav_seg = wav[int(idx * hop_len_samples): int((idx + self.input_length) * hop_len_samples)]
+            if len(wav_seg) < len_samples:
+                continue
+
+            input_features = np.array(wav_seg)[np.newaxis, :]
+            p808_input_features = np.array(self.audio_melspec(audio=wav_seg[:-160]))[np.newaxis, :, :]
+            oi = {'input_1': input_features}
+            p808_oi = {'input_1': p808_input_features}
+            p808_mos = self.p808_onnx_sess.run(None, p808_oi)[0][0][0]
+            mos_sig_raw, mos_bak_raw, mos_ovr_raw = self.onnx_sess.run(None, oi)[0][0]
+            mos_sig, mos_bak, mos_ovr = self.get_polyfit_val(mos_sig_raw, mos_bak_raw, mos_ovr_raw)
+            predicted_mos_sig_seg_raw.append(mos_sig_raw)
+            predicted_mos_bak_seg_raw.append(mos_bak_raw)
+            predicted_mos_ovr_seg_raw.append(mos_ovr_raw)
+            predicted_mos_sig_seg.append(mos_sig)
+            predicted_mos_bak_seg.append(mos_bak)
+            predicted_mos_ovr_seg.append(mos_ovr)
+            predicted_p808_mos.append(p808_mos)
+        out_dict = {}
+        out_dict['OVRL_raw'] = np.mean(predicted_mos_ovr_seg_raw)
+        out_dict['SIG_raw'] = np.mean(predicted_mos_sig_seg_raw)
+        out_dict['BAK_raw'] = np.mean(predicted_mos_bak_seg_raw)
+        out_dict['OVRL'] = np.mean(predicted_mos_ovr_seg)
+        out_dict['SIG'] = np.mean(predicted_mos_sig_seg)
+        out_dict['BAK'] = np.mean(predicted_mos_bak_seg)
+        out_dict['P808_MOS'] = np.mean(predicted_p808_mos)
+        return out_dict
+
+
+def main():
+    SAMPLING_RATE = 16000
+    INPUT_LENGTH = 9.01
+    is_personalized_MOS = False
+    testset_dir = "../data/vad_example.wav"
+
+    compute_score = ComputeScore(is_personalized_MOS, SAMPLING_RATE, INPUT_LENGTH)
+    data = compute_score(testset_dir)
+    print(data)
+
+
+if __name__ == "__main__":
+    main()

neverlib/metrics/lpc_lsp.py

@@ -0,0 +1,118 @@
+'''
+  功能描述
+
+  计算参考语音和测试语音之间的线性预测编码-线谱对(LPC-LSP)参
+  数失真度
+
+  主要组件
+
+  预处理函数:
+  - pre_emphasis(): 预加重滤波，增强高频成分
+  - framing(): 分帧处理并应用汉明窗
+
+  LPC分析:
+  - lpc_analysis(): 使用librosa.lpc进行线性预测分析
+  - lpc_to_lsp(): LPC系数转换为线谱对参数
+
+  距离计算:
+  - lsp_mse(): 计算LSP向量间的均方误差
+  - lpc_lsp_distance(): 主函数，返回平均失真度和逐帧失真列表
+
+  技术特点
+
+  - 使用soundfile读取音频（支持多种格式）
+  - librosa进行LPC分析（替代了自定义算法）
+  - 基于LSP的频域失真测量，对量化误差敏感度更低
+  - 逐帧分析捕捉语音时变特性
+
+  应用场景
+
+  语音编码器质量评估、语音增强效果测量、语音合成质量分析
+'''
+import numpy as np
+import librosa
+import soundfile as sf
+from neverlib.vad.PreProcess import pre_emphasis
+
+
+def framing(signal, frame_size, frame_stride, fs):
+    """分帧 + 汉明窗"""
+    frame_length = int(round(frame_size * fs))
+    frame_step = int(round(frame_stride * fs))
+    
+    # 使用 librosa 进行分帧
+    frames = librosa.util.frame(signal, frame_length=frame_length, hop_length=frame_step, axis=0)
+    
+    # frames的形状是(num_frames, frame_length)
+    hamming_window = np.hamming(frame_length)
+    frames = frames * hamming_window  # 直接广播
+    
+    return frames
+
+
+def lpc_to_lsp(a, num_points=512):
+    """
+    LPC -> LSP 转换（简易近似版，零点搜索法）
+    """
+    p = len(a) - 1
+    a = np.array(a)
+    # 构造P(z) Q(z)
+    P = np.zeros(p+1)
+    Q = np.zeros(p+1)
+    for i in range(p+1):
+        if i == 0:
+            P[i] = 1 + a[i]
+            Q[i] = 1 - a[i]
+        else:
+            P[i] = a[i] + a[p - i]
+            Q[i] = a[i] - a[p - i]
+    # 频域采样找过零点
+    w = np.linspace(0, np.pi, num_points)
+    Pw = np.polyval(P[::-1], np.cos(w))
+    Qw = np.polyval(Q[::-1], np.cos(w))
+    
+    # 找零点近似位置
+    roots_P = w[np.where(np.diff(np.sign(Pw)) != 0)]
+    roots_Q = w[np.where(np.diff(np.sign(Qw)) != 0)]
+    lsp = np.sort(np.concatenate([roots_P, roots_Q]))
+    return lsp
+
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    ref_sig, fs_r = sf.read(ref_wav, dtype='float32')
+    test_sig, fs_t = sf.read(test_wav, dtype='float32')
+
+    # 预加重
+    ref_sig = pre_emphasis(ref_sig)
+    test_sig = pre_emphasis(test_sig)
+
+    # 分帧
+    ref_frames = framing(ref_sig, frame_size, frame_stride, fs_r)
+    test_frames = framing(test_sig, frame_size, frame_stride, fs_t)
+
+    # 对齐帧数（简单切到最短）
+    num_frames = min(len(ref_frames), len(test_frames))
+    ref_frames = ref_frames[:num_frames]
+    test_frames = test_frames[:num_frames]
+
+    distances = []
+    for i in range(num_frames):
+        a_ref = librosa.lpc(ref_frames[i], order=order)
+        a_test = librosa.lpc(test_frames[i], order=order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        # 计算两个 LSP 向量的均方差
+        dist = np.mean((lsp_ref[:min_len] - lsp_test[:min_len]) ** 2)
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+if __name__ == "__main__":
+    ref_file = "../data/vad_example.wav"   # 参考语音文件路径
+    test_file = "../data/vad_example.wav" # 测试语音文件路径
+
+    avg_dist, dist_list = lpc_lsp_distance(ref_file, test_file)
+    print(f"平均 LSP MSE 失真: {avg_dist}")