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

neverlib/.history/metrics/lpc_lsp_metric_20250816020600.py

@@ -0,0 +1,125 @@
+'''
+  功能描述
+
+  计算参考语音和测试语音之间的线性预测编码-线谱对(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
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+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_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    a = librosa.lpc(frame, order=order)
+    return a
+
+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 = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], 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}")

neverlib/.history/metrics/lpc_lsp_metric_20250816020631.py

@@ -0,0 +1,120 @@
+'''
+  功能描述
+
+  计算参考语音和测试语音之间的线性预测编码-线谱对(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
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+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}")

neverlib/.history/metrics/lpc_lsp_metric_20250816020746.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}")

neverlib/.history/metrics/lpc_me_20250816013129.py

@@ -0,0 +1,121 @@
+import numpy as np
+import scipy.signal
+import scipy.io.wavfile as wav
+from python_speech_features import sigproc
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+def framing(signal, frame_size, frame_stride, fs):
+    """分帧 + 汉明窗"""
+    frame_length = int(round(frame_size * fs))
+    frame_step = int(round(frame_stride * fs))
+    frames = sigproc.framesig(signal, frame_length, frame_step, winfunc=np.hamming)
+    return frames
+
+def levinson_durbin(r, order):
+    """Levinson-Durbin 算法求 LPC 系数"""
+    a = np.zeros(order + 1)
+    e = r[0]
+    a[0] = 1.0
+
+    for i in range(1, order + 1):
+        acc = r[i]
+        for j in range(1, i):
+            acc += a[j] * r[i - j]
+        k = -acc / e
+        a_new = a.copy()
+        a_new[i] = k
+        for j in range(1, i):
+            a_new[j] += k * a[i - j]
+        a = a_new
+        e *= 1.0 - k * k
+    return a, e
+
+def lpc_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    autocorr = np.correlate(frame, frame, mode='full')
+    r = autocorr[len(frame)-1:len(frame)+order]
+    a, e = levinson_durbin(r, order)
+    return a
+
+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 lsp_mse(lsp1, lsp2):
+    """计算两个 LSP 向量的均方差"""
+    return np.mean((lsp1 - lsp2) ** 2)
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    fs_r, ref_sig = wav.read(ref_wav)
+    fs_t, test_sig = wav.read(test_wav)
+    
+    if fs_r != fs_t:
+        raise ValueError("采样率不一致！")
+
+    # 转 float + 单声道
+    if ref_sig.ndim > 1:
+        ref_sig = ref_sig[:,0]
+    if test_sig.ndim > 1:
+        test_sig = test_sig[:,0]
+    ref_sig = ref_sig.astype(np.float64)
+    test_sig = test_sig.astype(np.float64)
+
+    # 预加重
+    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 = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        dist = lsp_mse(lsp_ref[:min_len], lsp_test[:min_len])
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+if __name__ == "__main__":
+    ref_file = "ref.wav"   # 参考语音文件路径
+    test_file = "test.wav" # 测试语音文件路径
+
+    avg_dist, dist_list = lpc_lsp_distance(ref_file, test_file)
+    print(f"平均 LSP MSE 失真: {avg_dist}")

neverlib/.history/metrics/lpc_me_20250816015430.py

@@ -0,0 +1,103 @@
+import numpy as np
+import librosa
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+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)
+    
+    # 应用汉明窗
+    hamming_window = np.hamming(frame_length)
+    frames = frames.T * hamming_window
+    
+    return frames
+
+
+def lpc_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    a = librosa.lpc(frame, order=order)
+    return a
+
+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 lsp_mse(lsp1, lsp2):
+    """计算两个 LSP 向量的均方差"""
+    return np.mean((lsp1 - lsp2) ** 2)
+
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    ref_sig, fs_r = librosa.load(ref_wav, sr=None)
+    test_sig, fs_t = librosa.load(test_wav, sr=None)
+    
+    if fs_r != fs_t:
+        raise ValueError("采样率不一致！")
+
+    # librosa 已经加载为 float32 单声道，转换为 float64
+    ref_sig = ref_sig.astype(np.float64)
+    test_sig = test_sig.astype(np.float64)
+
+    # 预加重
+    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 = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        dist = lsp_mse(lsp_ref[:min_len], lsp_test[:min_len])
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+if __name__ == "__main__":
+    ref_file = "ref.wav"   # 参考语音文件路径
+    test_file = "test.wav" # 测试语音文件路径
+
+    avg_dist, dist_list = lpc_lsp_distance(ref_file, test_file)
+    print(f"平均 LSP MSE 失真: {avg_dist}")

neverlib/.history/metrics/lpc_me_20250816015535.py

@@ -0,0 +1,96 @@
+import numpy as np
+import librosa
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+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)
+    
+    # 应用汉明窗
+    hamming_window = np.hamming(frame_length)
+    frames = frames.T * hamming_window
+    
+    return frames
+
+
+def lpc_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    a = librosa.lpc(frame, order=order)
+    return a
+
+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 lsp_mse(lsp1, lsp2):
+    """计算两个 LSP 向量的均方差"""
+    return np.mean((lsp1 - lsp2) ** 2)
+
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    ref_sig, fs_r = librosa.load(ref_wav, sr=None)
+    test_sig, fs_t = librosa.load(test_wav, sr=None)
+
+    # 预加重
+    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 = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        dist = lsp_mse(lsp_ref[:min_len], lsp_test[:min_len])
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+if __name__ == "__main__":
+    ref_file = "ref.wav"   # 参考语音文件路径
+    test_file = "test.wav" # 测试语音文件路径
+
+    avg_dist, dist_list = lpc_lsp_distance(ref_file, test_file)
+    print(f"平均 LSP MSE 失真: {avg_dist}")