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讀?。ㄟm合編輯）
audio_pydub = AudioSegment.from_file('input.wav', format='wav')

def convert_audio(input_path, output_path, output_format='wav'):
    """轉換音頻格式并標準化參數(shù)"""
    audio = AudioSegment.from_file(input_path)
    
    # 設置標準參數(shù)：單聲道、16kHz采樣率、16bit深度
    audio = audio.set_channels(1)  # 單聲道
    audio = audio.set_frame_rate(16000)  # 16kHz
    audio = audio.set_sample_width(2)  # 16bit = 2字節(jié)
    
    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, 幀數(shù))

# 提取色度特征（音樂分析）
chroma = librosa.feature.chroma_stft(y=y, sr=sr)
print("色度特征形狀:", chroma.shape)  # (12, 幀數(shù))

# 提取節(jié)拍信息
tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
beat_times = librosa.frames_to_time(beat_frames, sr=sr)
print(f"節(jié)拍: {tempo} BPM, 節(jié)拍時間點: {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):
    """根據(jù)靜音自動分割音頻文件"""
    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
                
                # 在此處進行數(shù)據(jù)處理（示例：音量增大）
                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)
    
    # 將數(shù)據(jù)轉移到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):
    """安全的音頻讀取函數(shù)"""
    try:
        if path.endswith('.mp3'):
            # PyDub處理MP3更穩(wěn)定
            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

# 讀取元數(shù)據(jù)
tags = mediainfo('song.mp3').get('TAG', {})
# 寫入元數(shù)據(jù)
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):
    """創(chuàng)建音頻指紋"""
    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處理結束")