快捷導(dǎo)航

Python實現(xiàn)音頻添加數(shù)字水印的示例詳解

更新時間：2025年04月02日 09:05:09 作者：mosquito_lover1

數(shù)字水印技術(shù)可以將隱藏信息嵌入到音頻文件中而不明顯影響音頻質(zhì)量,下面小編將介紹幾種在Python中實現(xiàn)音頻數(shù)字水印的方法,希望對大家有所幫助

方法一：LSB (最低有效位) 水印

import numpy as np
from scipy.io import wavfile
def embed_watermark_lsb(audio_path, watermark, output_path):
    # 讀取音頻文件
    sample_rate, audio_data = wavfile.read(audio_path)    
    # 確保是立體聲，如果是單聲道則轉(zhuǎn)換為立體聲
    if len(audio_data.shape) == 1:
        audio_data = np.column_stack((audio_data, audio_data))   
    # 將水印轉(zhuǎn)換為二進制
    watermark_bin = ''.join(format(ord(c), '08b') for c in watermark)
    watermark_bin += '00000000' # 添加結(jié)束標記   
    # 檢查水印是否適合音頻
    if len(watermark_bin) > audio_data.size:
        raise ValueError("水印太大，無法嵌入到音頻中")  
    # 嵌入水印到最低有效位
    watermark_index = 0
    for i in range(len(audio_data)):
        for j in range(len(audio_data[i])):
            if watermark_index < len(watermark_bin):
                # 替換最低有效位
                audio_data[i][j] = (audio_data[i][j] & 0xFE) | int(watermark_bin[watermark_index])
                watermark_index += 1
            else:
                break   
    # 保存帶水印的音頻
    wavfile.write(output_path, sample_rate, audio_data)
def extract_watermark_lsb(audio_path, watermark_length):
    # 讀取音頻文件
    sample_rate, audio_data = wavfile.read(audio_path)    
    # 提取最低有效位
    watermark_bits = []
    for i in range(len(audio_data)):
        for j in range(len(audio_data[i])):
            watermark_bits.append(str(audio_data[i][j] & 1))   
    # 將比特轉(zhuǎn)換為字節(jié)
    watermark = ''
    for i in range(0, len(watermark_bits), 8):
        byte = ''.join(watermark_bits[i:i+8])
        if byte == '00000000': # 遇到結(jié)束標記
            break
        watermark += chr(int(byte, 2))   
    return watermark[:watermark_length]
# 使用示例
embed_watermark_lsb('original.wav', '秘密消息', 'watermarked.wav')
extracted = extract_watermark_lsb('watermarked.wav', 4)
print("提取的水印:", extracted)

方法二：頻域水印 (DCT變換)

import numpy as np
from scipy.fftpack import dct, idct
from scipy.io import wavfile
def embed_watermark_dct(audio_path, watermark, output_path, alpha=0.01):
    # 讀取音頻
    sample_rate, audio_data = wavfile.read(audio_path)  
    # 如果是立體聲，只使用一個聲道
    if len(audio_data.shape) > 1:
        audio_data = audio_data[:, 0]   
    # 將水印轉(zhuǎn)換為二進制
    watermark_bin = ''.join(format(ord(c), '08b') for c in watermark)
    watermark_bin = [int(b) for b in watermark_bin]    
    # 分段處理音頻
    segment_size = 1024
    num_segments = len(audio_data) // segment_size
    watermark_length = len(watermark_bin)   
    if num_segments < watermark_length:
        raise ValueError("音頻太短，無法嵌入水印")   
    # 嵌入水印
    watermarked_audio = np.copy(audio_data)
    for i in range(watermark_length):
        start = i * segment_size
        end = start + segment_size        
        segment = audio_data[start:end]
        dct_coeffs = dct(segment, norm='ortho')       
        # 修改中頻系數(shù)嵌入水印
        coeff_index = 100 # 選擇一個中頻系數(shù)
        if watermark_bin[i] == 1:
            dct_coeffs[coeff_index] += alpha * np.abs(dct_coeffs[coeff_index])
        else:
            dct_coeffs[coeff_index] -= alpha * np.abs(dct_coeffs[coeff_index])      
        # 逆DCT變換
        watermarked_segment = idct(dct_coeffs, norm='ortho')
        watermarked_audio[start:end] = watermarked_segment   
    # 保存帶水印的音頻
    wavfile.write(output_path, sample_rate, watermarked_audio.astype(np.int16))
def extract_watermark_dct(audio_path, original_path, watermark_length):
    # 讀取帶水印音頻和原始音頻
    sample_rate, watermarked = wavfile.read(audio_path)
    _, original = wavfile.read(original_path)    
    # 如果是立體聲，只使用一個聲道
    if len(watermarked.shape) > 1:
        watermarked = watermarked[:, 0]
        original = original[:, 0]   
    segment_size = 1024
    watermark_bits = []    
    for i in range(watermark_length):
        start = i * segment_size
        end = start + segment_size       
        wm_segment = watermarked[start:end]
        orig_segment = original[start:end]        
        wm_dct = dct(wm_segment, norm='ortho')
        orig_dct = dct(orig_segment, norm='ortho')        
        coeff_index = 100
        if wm_dct[coeff_index] > orig_dct[coeff_index]:
            watermark_bits.append('1')
        else:
            watermark_bits.append('0')    
    # 將比特轉(zhuǎn)換為字符串
    watermark = ''
    for i in range(0, len(watermark_bits), 8):
        byte = ''.join(watermark_bits[i:i+8])
        watermark += chr(int(byte, 2))  
    return watermark
# 使用示例
embed_watermark_dct('original.wav', '秘密', 'watermarked_dct.wav', 0.02)
extracted = extract_watermark_dct('watermarked_dct.wav', 'original.wav', 16)
print("提取的水印:", extracted)

方法三：擴頻水印

import numpy as np
from scipy.io import wavfile
def generate_pn_sequence(length, seed=42):
    np.random.seed(seed)
    return np.random.choice([-1, 1], size=length)
def embed_watermark_spread_spectrum(audio_path, watermark, output_path, alpha=0.01):
    # 讀取音頻
    sample_rate, audio_data = wavfile.read(audio_path)    
    # 如果是立體聲，只使用一個聲道
    if len(audio_data.shape) > 1:
        audio_data = audio_data[:, 0]    
    # 將水印轉(zhuǎn)換為二進制
    watermark_bin = ''.join(format(ord(c), '08b') for c in watermark)
    watermark_bits = np.array([int(b) for b in watermark_bin])
    watermark_bits = 2 * watermark_bits - 1 # 轉(zhuǎn)換為±1   
    # 生成偽隨機序列
    pn_length = len(audio_data) // len(watermark_bits)
    pn_sequence = generate_pn_sequence(pn_length)   
    # 創(chuàng)建擴頻水印
    spread_watermark = np.repeat(watermark_bits, pn_length)
    spread_watermark = spread_watermark[:len(audio_data)] * pn_sequence[:len(audio_data)]   
    # 嵌入水印
    watermarked_audio = audio_data + alpha * spread_watermark * np.abs(audio_data)
    watermarked_audio = np.clip(watermarked_audio, -32768, 32767) # 確保在16位范圍內(nèi) 
    # 保存帶水印的音頻
    wavfile.write(output_path, sample_rate, watermarked_audio.astype(np.int16))
def extract_watermark_spread_spectrum(audio_path, original_path, watermark_length, pn_length):
    # 讀取音頻
    sample_rate, watermarked = wavfile.read(audio_path)
    _, original = wavfile.read(original_path)   
    # 如果是立體聲，只使用一個聲道
    if len(watermarked.shape) > 1:
        watermarked = watermarked[:, 0]
        original = original[:, 0]    
    # 計算差異
    diff = watermarked - original   
    # 生成相同的偽隨機序列
    num_bits = watermark_length * 8
    pn_sequence = generate_pn_sequence(pn_length)   
    extracted_bits = []
    for i in range(num_bits):
        start = i * pn_length
        end = start + pn_length       
        segment_diff = diff[start:end]
        segment_pn = pn_sequence[:len(segment_diff)]        
        correlation = np.sum(segment_diff * segment_pn)
        extracted_bits.append('1' if correlation > 0 else '0')    
    # 將比特轉(zhuǎn)換為字符串
    watermark = ''
    for i in range(0, len(extracted_bits), 8):
        byte = ''.join(extracted_bits[i:i+8])
        watermark += chr(int(byte, 2))    
    return watermark
# 使用示例
embed_watermark_spread_spectrum('original.wav', '秘密', 'watermarked_ss.wav', 0.01)
extracted = extract_watermark_spread_spectrum('watermarked_ss.wav', 'original.wav', 2, 1000)
print("提取的水印:", extracted)