如何用Python脚本消除音频提取中的串音（Audio Spillage）

我用Claude AI和Whisper开发了一套转录与音频提取Python脚本，但提取出的音频存在首尾串音问题（即截图首尾的波形部分）。一款微弱声音杂音检测器无法解决此问题，求可移除音频串音的脚本方案。

优化后的串音消除脚本 #

针对首尾串音问题，通过精准的能量分析与首尾截断逻辑，可有效移除这类微弱杂音：

import os
import numpy as np
from pydub import AudioSegment
from pydub.silence import detect_nonsilent

def analyze_audio_levels(audio_file):
    """分析音频以建议最优阈值"""
    audio = AudioSegment.from_file(audio_file)

    # 转换为numpy数组进行分析
    samples = np.array(audio.get_array_of_samples())
    if audio.channels == 2:
        samples = samples.reshape((-1, 2))
        samples = samples.mean(axis=1)

    # 转换为浮点数并归一化
    samples = samples.astype(np.float32)
    samples = samples / (2**15)  # 归一化16位音频

    # 滑动窗口计算RMS
    window_size = int(audio.frame_rate * 0.1)  # 100ms窗口
    rms_values = []

    for i in range(0, len(samples) - window_size, window_size):
        window = samples[i:i + window_size]
        rms = np.sqrt(np.mean(window ** 2))
        if rms > 0:
            rms_db = 20 * np.log10(rms)
            rms_values.append(rms_db)

    if rms_values:
        # 基于分析结果建议阈值
        noise_floor = np.percentile(rms_values, 20)  # 20分位数作为噪声底
        suggested_threshold = noise_floor + 10  # 噪声底以上10dB

        print(f"\n📊 音频分析结果:")
        print(f"   噪声底: {noise_floor:.1f} dB")
        print(f"   建议阈值: {suggested_threshold:.1f} dB")
        print(f"   RMS范围: {min(rms_values):.1f} 到 {max(rms_values):.1f} dB")

        return suggested_threshold

    return -40  # 默认回退值

def remove_leading_trailing_crosstalk(audio_file, silence_thresh=-45, min_silence_len=200, 
                                     min_sound_len=800, start_trim_padding=50, end_trim_padding=50):
    """
    移除音频首尾串音，保留有效音频内容
    Args:
        audio_file (str): 音频文件路径
        silence_thresh (int): 静音阈值（dB），更负值更激进
        min_silence_len (int): 最小静音时长（ms）
        min_sound_len (int): 最小有效音频时长（ms）
        start_trim_padding (int): 首尾截断时保留的缓冲时长（ms）
        end_trim_padding (int): 首尾截断时保留的缓冲时长（ms）
    """
    print(f"🔍 分析音频: {os.path.basename(audio_file)}")

    # 加载音频
    audio = AudioSegment.from_file(audio_file)
    original_duration = len(audio) / 1000

    # 检测非静音片段
    nonsilent_chunks = detect_nonsilent(
        audio,
        min_silence_len=min_silence_len,
        silence_thresh=silence_thresh
    )

    if not nonsilent_chunks:
        print(f"   ❌ 未检测到有效音频内容")
        return None

    print(f"   检测到 {len(nonsilent_chunks)} 个音频片段")

    # 过滤出有效片段（排除过短/过弱的串音）
    valid_chunks = []
    for start_time, end_time in nonsilent_chunks:
        segment_duration = end_time - start_time
        segment = audio[start_time:end_time]
        
        # 计算片段RMS值
        samples = np.array(segment.get_array_of_samples(), dtype=np.float32)
        if segment.channels == 2:
            samples = samples.reshape((-1, 2)).mean(axis=1)
        
        rms = np.sqrt(np.mean((samples / 32768) ** 2))
        segment_db = 20 * np.log10(rms) if rms > 0 else -float('inf')
        
        if segment_duration >= min_sound_len and segment_db > silence_thresh:
            valid_chunks.append((start_time, end_time))

    if not valid_chunks:
        print(f"   ❌ 无符合条件的有效音频片段")
        return None

    # 合并连续有效片段
    merged_chunks = []
    for start, end in sorted(valid_chunks):
        if merged_chunks and start <= merged_chunks[-1][1]:
            merged_chunks[-1] = (merged_chunks[-1][0], max(merged_chunks[-1][1], end))
        else:
            merged_chunks.append((start, end))

    # 处理首尾截断，保留缓冲避免生硬切割
    final_start = max(0, merged_chunks[0][0] - start_trim_padding)
    final_end = min(len(audio), merged_chunks[-1][1] + end_trim_padding)
    cleaned_audio = audio[final_start:final_end]

    # 添加首尾淡入淡出，优化过渡效果
    cleaned_audio = cleaned_audio.fade_in(50).fade_out(100)

    final_duration = len(cleaned_audio) / 1000
    removed_time = original_duration - final_duration

    print(f"   📊 处理结果:")
    print(f"      原时长: {original_duration:.1f}s")
    print(f"      清理后时长: {final_duration:.1f}s")
    print(f"      移除时长: {removed_time:.1f}s ({removed_time/original_duration*100:.1f}%)")

    return cleaned_audio

def process_folder_crosstalk_removal(input_folder, output_folder=None, **kwargs):
    """批量处理文件夹中的音频文件，移除首尾串音"""
    if output_folder is None:
        output_folder = os.path.join(input_folder, "cleaned_no_crosstalk")

    os.makedirs(output_folder, exist_ok=True)

    audio_extensions = ['.mp3', '.wav', '.flac', '.m4a', '.ogg', '.wma']
    processed_count = 0
    skipped_count = 0

    for filename in os.listdir(input_folder):
        if any(filename.lower().endswith(ext) for ext in audio_extensions):
            input_path = os.path.join(input_folder, filename)
            try:
                cleaned_audio = remove_leading_trailing_crosstalk(input_path, **kwargs)
                if cleaned_audio is not None:
                    name, ext = os.path.splitext(filename)
                    output_filename = f"{name}_no_crosstalk{ext}"
                    output_path = os.path.join(output_folder, output_filename)

                    # 按原格式导出
                    if ext.lower() == '.mp3':
                        cleaned_audio.export(output_path, format="mp3", bitrate="192k")
                    elif ext.lower() == '.flac':
                        cleaned_audio.export(output_path, format="flac")
                    else:
                        cleaned_audio.export(output_path, format="wav")

                    print(f"   ✅ 已保存: {output_filename}")
                    processed_count += 1
                else:
                    print(f"   ⚠️ 跳过: {filename} (无有效内容)")
                    skipped_count += 1
            except Exception as e:
                print(f"   ❌ 处理失败 {filename}: {str(e)}")
                skipped_count += 1
        else:
            print(f"   ⚠️ 跳过: {filename} (不支持的格式)")
            skipped_count += 1

    print(f"\n📈 处理总结:")
    print(f"   已处理: {processed_count} 个文件")
    print(f"   已跳过: {skipped_count} 个文件")
    print(f"   输出文件夹: {output_folder}")

def main():
    print("=" * 70)
    print("     音频首尾串音移除工具")
    print("=" * 70)
    print("专门针对转录后音频的首尾串音问题进行精准清理")
    print()

    # 获取输入文件夹
    input_folder = input("请输入输入文件夹路径: ").strip().strip('"\'')
    if not os.path.exists(input_folder):
        print("❌ 文件夹不存在!")
        return

    # 获取输出文件夹
    output_input = input(f"请输入输出文件夹路径（回车使用默认）: ").strip().strip('"\'')
    output_folder = output_input if output_input else None

    print("\n🎛️ 参数设置:")
    print("针对首尾串音，推荐以下参数:")
    print()

    # 阈值设置
    print("静音阈值（dB）:")
    print("  -45 dB: 激进（推荐）")
    print("  -40 dB: 适中")
    thresh_input = input("请输入静音阈值（默认: -45）: ").strip()
    silence_thresh = -45 if not thresh_input else int(thresh_input)

    # 最小静音长度
    print("\n最小静音时长（ms）:")
    print("  200ms: 激进（推荐）")
    print("  300ms: 适中")
    silence_len_input = input("请输入最小静音时长（默认: 200）: ").strip()
    min_silence_len = 200 if not silence_len_input else int(silence_len_input)

    # 最小有效音频长度
    print("\n最小有效音频时长（ms）:")
    print("  800ms: 保留核心内容")
    print("  1000ms: 更严格筛选")
    sound_len_input = input("请输入最小有效音频时长（默认: 800）: ").strip()
    min_sound_len = 800 if not sound_len_input else int(sound_len_input)

    print(f"\n🚀 即将使用以下参数处理:")
    print(f"   静音阈值: {silence_thresh} dB")
    print(f"   最小静音时长: {min_silence_len} ms")
    print(f"   最小有效音频时长: {min_sound_len} ms")
    print()

    confirm = input("是否开始处理? (y/N): ").strip().lower()
    if confirm == 'y':
        process_folder_crosstalk_removal(
            input_folder,
            output_folder,
            silence_thresh=silence_thresh,
            min_silence_len=min_silence_len,
            min_sound_len=min_sound_len
        )
    else:
        print("❌ 已取消处理。")

if __name__ == "__main__":
    main()

使用说明 #

1. 安装依赖：pip install pydub numpy，并确保已安装ffmpeg（pydub依赖）
2. 运行脚本时，优先选择**-45dB的静音阈值和200ms最小静音时长**，精准捕捉首尾微弱串音
3. 批量处理时，脚本会自动将清理后的音频保存到指定文件夹

内容的提问来源于stack exchange，提问作者stanonstack