从基础到高级详解Python音频提取全攻略

pip install librosa pydub ffmpeg-python soundfile noisereduce speechrecognition

import librosa
from pydub import audiosegment

# 使用librosa读取（适合分析）
audio, sr = librosa.load('input.mp3', sr=16000)  # 采样率设为16khz

# 使用pydub读取（适合编辑）
audio_pydub = audiosegment.from_file('input.wav', format='wav')

def convert_audio(input_path, output_path, output_format='wav'):
    """转换音频格式并标准化参数"""
    audio = audiosegment.from_file(input_path)
    
    # 设置标准参数：单声道、16khz采样率、16bit深度
    audio = audio.set_channels(1)  # 单声道
    audio = audio.set_frame_rate(16000)  # 16khz
    audio = audio.set_sample_width(2)  # 16bit = 2字节
    
    audio.export(output_path, format=output_format)
    print(f"已转换: {input_path} -> {output_path}")

# 示例：mp3转wav
convert_audio('speech.mp3', 'speech_16k.wav')

import noisereduce as nr
from scipy.io import wavfile

# 加载音频
rate, audio = wavfile.read("mixed_audio.wav")

# 提取背景噪声片段（前500ms）
noise_clip = audio[:int(rate*0.5)]

# 降噪处理
reduced_noise = nr.reduce_noise(
    y=audio, 
    sr=rate,
    y_noise=noise_clip,
    stationary=true,
    prop_decrease=0.9
)

# 保存结果
wavfile.write("cleaned_voice.wav", rate, reduced_noise)

import spleeter
from spleeter.separator import separator

# 初始化分离器（2轨：人声/伴奏）
separator = separator('spleeter:2stems')

# 分离音频
separator.separate_to_file('song_with_vocals.mp3', 'output_folder/')

# 结果路径：
#   output_folder/song_with_vocals/vocals.wav
#   output_folder/song_with_vocals/accompaniment.wav

import numpy as np
from scipy.signal import butter, filtfilt

def extract_bass(input_path, output_path, lowcut=60, highcut=250):
    """提取低频声音（低音部分）"""
    rate, audio = wavfile.read(input_path)
    
    # 设计带通滤波器
    nyquist = 0.5 * rate
    low = lowcut / nyquist
    high = highcut / nyquist
    b, a = butter(4, [low, high], btype='band')
    
    # 应用滤波器
    bass_audio = filtfilt(b, a, audio)
    
    wavfile.write(output_path, rate, bass_audio.astype(np.int16))

# 提取60-250hz的低音
extract_bass('electronic_music.wav', 'bass_only.wav')

import librosa
import numpy as np

y, sr = librosa.load('speech.wav')

# 提取mfcc（语音识别关键特征）
mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
print("mfcc形状:", mfcc.shape)  # (13, 帧数)

# 提取色度特征（音乐分析）
chroma = librosa.feature.chroma_stft(y=y, sr=sr)
print("色度特征形状:", chroma.shape)  # (12, 帧数)

# 提取节拍信息
tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
beat_times = librosa.frames_to_time(beat_frames, sr=sr)
print(f"节拍: {tempo} bpm, 节拍时间点: {beat_times[:5]}")

# 生成频谱图
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 4))
d = librosa.amplitude_to_db(np.abs(librosa.stft(y)), ref=np.max)
librosa.display.specshow(d, sr=sr, x_axis='time', y_axis='log')
plt.colorbar(format='%+2.0f db')
plt.title('频谱图')
plt.savefig('spectrogram.png', dpi=300)

import speech_recognition as sr

def speech_to_text(audio_path):
    r = sr.recognizer()
    
    with sr.audiofile(audio_path) as source:
        audio_data = r.record(source)
        
        try:
            text = r.recognize_google(audio_data, language='zh-cn')
            return text
        except sr.unknownvalueerror:
            return "无法识别音频"
        except sr.requesterror as e:
            return f"api请求失败: {str(e)}"

# 提取中文语音内容
text_content = speech_to_text('chinese_speech.wav')
print("识别结果:", text_content)

def split_on_silence(input_path, output_folder, min_silence_len=500, silence_thresh=-40):
    """根据静音自动分割音频文件"""
    from pydub import audiosegment
    from pydub.silence import split_on_silence
    
    audio = audiosegment.from_file(input_path)
    
    # 分割音频
    chunks = split_on_silence(
        audio,
        min_silence_len=min_silence_len,  # 静音最小长度(ms)
        silence_thresh=silence_thresh,    # 静音阈值(dbfs)
        keep_silence=300                  # 保留静音段(ms)
    )
    
    # 导出片段
    for i, chunk in enumerate(chunks):
        chunk.export(f"{output_folder}/segment_{i}.wav", format="wav")
    
    print(f"分割完成: 共{len(chunks)}个片段")
    
# 示例：分割长语音为短句
split_on_silence("long_lecture.mp3", "lecture_segments")

def extract_time_range(input_path, output_path, start_sec, end_sec):
    """提取指定时间段的音频"""
    from pydub import audiosegment
    
    audio = audiosegment.from_file(input_path)
    start_ms = start_sec * 1000
    end_ms = end_sec * 1000
    
    segment = audio[start_ms:end_ms]
    segment.export(output_path, format="wav")
    print(f"已提取 {start_sec}-{end_sec}秒的音频")

# 提取1分30秒到2分钟的片段
extract_time_range("podcast.mp3", "highlight.wav", 90, 120)

import os
from moviepy.editor import videofileclip

def extract_audio_from_videos(video_folder, output_folder):
    """批量提取视频中的音频"""
    os.makedirs(output_folder, exist_ok=true)
    
    for file in os.listdir(video_folder):
        if file.endswith(('.mp4', '.mov', '.avi')):
            video_path = os.path.join(video_folder, file)
            output_path = os.path.join(output_folder, f"{os.path.splitext(file)[0]}.mp3")
            
            try:
                video = videofileclip(video_path)
                video.audio.write_audiofile(output_path, verbose=false)
                print(f"成功提取: {file}")
            except exception as e:
                print(f"处理失败 {file}: {str(e)}")

# 提取整个文件夹的视频音频
extract_audio_from_videos("videos/", "extracted_audio/")

import numpy as np
import soundfile as sf

def embed_watermark(input_path, output_path, watermark_text):
    """将文本水印嵌入音频"""
    audio, sr = sf.read(input_path)
    
    # 将文本转为二进制
    binary_msg = ''.join(format(ord(c), '08b') for c in watermark_text)
    binary_msg += '00000000'  # 结束标志
    
    # 嵌入到最低有效位(lsb)
    max_bit = len(audio) // 8
    if len(binary_msg) > max_bit:
        raise valueerror("水印过长")
    
    for i, bit in enumerate(binary_msg):
        idx = i * 8
        audio[idx] = int(audio[idx]) & 0xfe | int(bit)
    
    sf.write(output_path, audio, sr)
    print(f"水印嵌入成功: {watermark_text}")

def extract_watermark(audio_path):
    """从音频中提取水印"""
    audio, _ = sf.read(audio_path)
    binary_msg = ""
    
    for i in range(0, len(audio), 8):
        bit = str(int(audio[i]) & 1)
        binary_msg += bit
        
        # 检测结束标志
        if len(binary_msg) % 8 == 0 and binary_msg[-8:] == '00000000':
            break
    
    # 二进制转文本
    watermark = ""
    for i in range(0, len(binary_msg)-8, 8):  # 忽略结束标志
        byte = binary_msg[i:i+8]
        watermark += chr(int(byte, 2))
    
    return watermark

# 使用示例
embed_watermark("original.wav", "watermarked.wav", "copyright@2024")
extracted = extract_watermark("watermarked.wav")
print("提取的水印:", extracted)  # 输出: copyright@2024

import soundfile as sf

def process_large_audio(input_path, output_path, chunk_size=1024):
    """流式处理大音频文件"""
    with sf.soundfile(input_path) as infile:
        with sf.soundfile(output_path, 'w', 
                         samplerate=infile.samplerate,
                         channels=infile.channels,
                         subtype=infile.subtype) as outfile:
            
            while true:
                data = infile.read(chunk_size)
                if len(data) == 0:
                    break
                
                # 在此处进行数据处理（示例：音量增大）
                processed = data * 1.5
                
                outfile.write(processed)

import cupy as cp
import librosa

def gpu_mfcc(audio_path):
    """使用gpu加速计算mfcc"""
    y, sr = librosa.load(audio_path)
    
    # 将数据转移到gpu
    y_gpu = cp.asarray(y)
    
    # gpu加速的stft
    n_fft = 2048
    hop_length = 512
    window = cp.hanning(n_fft)
    
    stft = cp.array([cp.fft.rfft(window * y_gpu[i:i+n_fft])
                    for i in range(0, len(y_gpu)-n_fft, hop_length)])
    
    # 计算梅尔频谱
    mel_basis = librosa.filters.mel(sr, n_fft, n_mels=128)
    mel_basis_gpu = cp.asarray(mel_basis)
    mel_spectrogram = cp.dot(mel_basis_gpu, cp.abs(stft.t)**2)
    
    # 计算mfcc
    mfcc = cp.fft.dct(cp.log(mel_spectrogram), axis=0)[:13]
    
    return cp.asnumpy(mfcc)  # 转回cpu

def safe_audio_read(path):
    """安全的音频读取函数"""
    try:
        if path.endswith('.mp3'):
            # pydub处理mp3更稳定
            audio = audiosegment.from_file(path)
            samples = np.array(audio.get_array_of_samples())
            sr = audio.frame_rate
            return samples, sr
        else:
            return sf.read(path)
    except exception as e:
        print(f"音频读取失败: {str(e)}")
        # 尝试使用librosa作为后备方案
        try:
            return librosa.load(path, sr=none)
        except:
            raise runtimeerror(f"所有方法均失败: {path}")

import mutagen
from pydub.utils import mediainfo

# 读取元数据
tags = mediainfo('song.mp3').get('tag', {})
# 写入元数据
audio = mutagen.file('song.wav')
audio['title'] = 'new title'
audio.save()

from concurrent.futures import processpoolexecutor

def process_file(path):
    # 处理逻辑
    return result

with processpoolexecutor() as executor:
    results = list(executor.map(process_file, audio_files))

import hashlib

def create_audio_fingerprint(audio_path):
    """创建音频指纹"""
    y, sr = librosa.load(audio_path)
    
    # 提取关键点
    peaks = []
    s = np.abs(librosa.stft(y))
    for i in range(s.shape[1]):
        frame = s[:, i]
        max_idx = np.argmax(frame)
        peaks.append((max_idx, i))  # (频率bin, 时间帧)
    
    # 生成哈希指纹
    fingerprints = set()
    for i in range(len(peaks) - 1):
        f1, t1 = peaks[i]
        f2, t2 = peaks[i+1]
        delta_t = t2 - t1
        if 0 < delta_t <= 10:  # 限制时间差
            hash_val = hashlib.sha1(f"{f1}|{f2}|{delta_t}".encode()).hexdigest()
            fingerprints.add(hash_val)
    
    return fingerprints

# 对比两个音频
fp1 = create_audio_fingerprint("song1.mp3")
fp2 = create_audio_fingerprint("song2.mp3")
similarity = len(fp1 & fp2) / max(len(fp1), len(fp2))
print(f"音频相似度: {similarity:.2%}")

import pyaudio
import numpy as np

def real_time_audio_processing():
    """实时音频处理演示"""
    chunk = 1024
    format = pyaudio.paint16
    channels = 1
    rate = 16000
    
    p = pyaudio.pyaudio()
    stream = p.open(format=format,
                    channels=channels,
                    rate=rate,
                    input=true,
                    frames_per_buffer=chunk)
    
    print("开始实时处理... (按ctrl+c停止)")
    try:
        while true:
            data = stream.read(chunk)
            audio = np.frombuffer(data, dtype=np.int16)
            
            # 实时音量计算
            rms = np.sqrt(np.mean(audio**2))
            db = 20 * np.log10(rms / 32768)  # 16bit最大值为32768
            
            # 实时显示音量条
            bar = '#' * int(np.clip(db + 60, 0, 60))
            print(f"\r音量: [{bar:<60}] {db:.1f} db", end='')
            
    except keyboardinterrupt:
        stream.stop_stream()
        stream.close()
        p.terminate()
        print("\n处理结束")