详解Python标准库之多媒体服务

详解 Python 标准库之多媒体服务

在音频处理、语音交互、多媒体数据采集等场景中，基础的音频格式解析、数据操作与设备交互是核心需求。Python 3.13.7 标准库提供了 6 个核心多媒体模块，覆盖音频文件类型检测（sndhdr）、主流格式读写（wave/aifc/sunau）、音频数据操作（audioop）、系统音频设备接口（ossaudiodev） 等能力，无需依赖pyaudio、soundfile等第三方库即可满足简单音频处理需求。本文基于官方文档，从模块功能、核心 API、实战示例三方面深入解析，同时梳理跨平台兼容性与最佳实践，为音频相关开发提供清晰指引。

一、音频文件 “身份识别”：sndhdr 模块

sndhdr模块通过分析音频文件的文件头（Header） 信息，自动检测文件的类型、采样率、位深度、声道数等关键参数，是音频处理的 “前置工具”—— 在读取或处理音频文件前，先用sndhdr判断格式，可避免格式不兼容导致的错误。

1. 核心功能与 API

sndhdr支持检测 8 种常见音频格式，包括 WAV、AIFF、AU（Sun 音频）、SND（NeXT 音频）等，核心函数仅有 2 个，用法简洁：

函数	作用	返回值说明
sndhdr.what(filename)	检测指定文件的音频格式与参数	返回SoundFile对象（含filetype/framerate/nchannels/sampwidth等属性），未知格式返回None
sndhdr.whathdr(fileobj)	检测已打开文件对象的音频格式	与what()一致，适用于已读取文件流的场景

关键属性说明（SoundFile 对象）

• filetype：音频格式标识（如'wav'/'aiff'/'au'）；
• framerate：采样率（每秒采样次数，如 44100Hz，音频质量核心参数）；
• nchannels：声道数（1 = 单声道，2 = 立体声）；
• sampwidth：位深度（每个采样点的字节数，如 1=8 位，2=16 位，值越大动态范围越广）；
• nframes：总采样帧数（可计算音频时长：nframes / framerate）；
• comptype：压缩类型（仅 WAV/AIFF 支持，如'NONE'表示未压缩 PCM）。

2. 实战示例：批量检测音频文件

需求：遍历指定文件夹，批量检测所有音频文件的格式与核心参数，输出异常文件（非音频或未知格式）。

import sndhdr
import os
from pathlib import Path


def batch_detect_audio(folder_path):
   """批量检测文件夹中的音频文件"""

   # 支持的音频文件扩展名（用于初步过滤，提高效率）
   audio_extensions = (".wav", ".aiff", ".aif", ".au", ".snd")

   # 初始化结果列表
   valid_audios = []
   invalid_files = []

   # 遍历文件夹
   for file_path in Path(folder_path).rglob("*"):
       # 跳过目录，仅处理文件
       if not file_path.is_file():
           continue

       # 初步过滤：仅处理指定扩展名的文件
       if file_path.suffix.lower() not in audio_extensions:
           continue

       # 检测音频格式
       try:
           audio_info = sndhdr.what(str(file_path))
           if audio_info:
               # 计算音频时长（秒），保留2位小数
               duration = round(audio_info.nframes / audio_info.framerate, 2)

               # 整理信息
               valid_audios.append({
                   "path": str(file_path),
                   "type": audio_info.filetype,
                   "sample_rate": audio_info.framerate,
                   "channels": audio_info.nchannels,
                   "bit_depth": audio_info.sampwidth * 8,  # 字节数转位深度（1字节=8位）
                   "duration": duration,
                   "compression": audio_info.comptype
               })

           else:
               invalid_files.append(f"未知格式：{str(file_path)}")
       except Exception as e:
           invalid_files.append(f"检测失败：{str(file_path)} → 错误：{str(e)}")

   # 输出结果

   print("=" * 80)
   print(f"批量检测完成：共找到 {len(valid_audios)} 个有效音频文件，{len(invalid_files)} 个异常文件")
   print("=" * 80)

   if valid_audios:
       print("\n【有效音频文件列表】")
       for idx, audio in enumerate(valid_audios, 1):
           print(f"{idx}. 路径：{audio['path']}")
           print(f"   格式：{audio['type']} | 采样率：{audio['sample_rate']}Hz | 声道：{audio['channels']} | 位深度：{audio['bit_depth']}位 | 时长：{audio['duration']}秒 | 压缩：{audio['compression']}")
           print()

   if invalid_files:
       print("【异常文件列表】")
       for err in invalid_files:
           print(f"× {err}")



# 调用函数（替换为实际文件夹路径）
if __name__ == "__main__":
   target_folder = "./audio_files"
   batch_detect_audio(target_folder)

关键说明：

• sndhdr通过文件头的 “魔法数字”（如 WAV 文件以RIFF开头，AIFF 以FORM开头）识别格式，无需读取完整文件，效率高；
• 位深度计算：sampwidth是每个采样点的字节数，需乘以 8 转换为位（如sampwidth=2 → 16 位音频）；
• 时长计算：总帧数（nframes）除以采样率（framerate），得到音频时长（秒）。

二、主流音频格式读写：wave/aifc/sunau 模块

Python 标准库针对三种主流无压缩音频格式提供了专用读写模块，三者 API 设计高度一致（均基于 “文件对象 + 读写类” 模式），但适用场景不同：

• wave：处理 WAV 格式（Windows 主导，最通用，支持 PCM 等压缩类型）；
• aifc：处理 AIFF/AIFC 格式（苹果主导，常用于专业音频软件）；
• sunau：处理 AU 格式（Sun/NeXT 主导，旧系统常用，现在较少见）。

以下以最通用的wave模块为核心解析，aifc/sunau仅补充差异点。

1. wave 模块：WAV 格式核心处理

WAV 是目前最通用的音频格式，支持未压缩 PCM（脉冲编码调制）与多种压缩格式，wave模块是 Python 标准库处理 WAV 的首选工具，支持 “读取音频参数→提取 PCM 数据→修改后写入新文件” 的全流程。

（1）核心 API 与概念

wave模块的核心是两个类：Wave_read（读取 WAV 文件）和Wave_write（写入 WAV 文件），均通过wave.open()创建：

核心操作	API 调用流程	关键方法 / 属性
读取 WAV 文件	wf = wave.open("input.wav", "rb") → 创建Wave_read对象	getparams()：获取音频参数；readframes(n)：读取 n 帧 PCM 数据；rewind()：重置读取指针
写入 WAV 文件	wf = wave.open("output.wav", "wb") → 创建Wave_write对象	setparams(params)：设置音频参数；writeframes(data)：写入 PCM 数据；close()：关闭文件（必调用）

关键参数说明（getparams()返回的元组）：

(nchannels, sampwidth, framerate, nframes, comptype, compname)

• nchannels：声道数（1 = 单声道，2 = 立体声）；
• sampwidth：位深度字节数（1=8 位，2=16 位，4=32 位）；
• framerate：采样率（如 22050Hz、44100Hz、48000Hz）；
• nframes：总采样帧数；
• comptype：压缩类型（'NONE'= 未压缩 PCM，'ALAW'/'ULAW'= 压缩格式）；
• compname：压缩格式名称（与comptype对应）。

（2）实战示例 1：读取 WAV 文件并提取关键信息

需求：读取一个 WAV 文件，提取其格式参数、PCM 数据，并计算音频的平均音量（基于 PCM 数据）。

import wave
import struct
import numpy as np

def analyze_wav_file(file_path):
   """分析WAV文件的格式与音频数据"""

   try:
       # 1. 打开WAV文件（只读模式）
       with wave.open(file_path, "rb") as wf:
           # 2. 获取音频参数
           params = wf.getparams()
           nchannels, sampwidth, framerate, nframes, comptype, compname = params
           duration = round(nframes / framerate, 2)  # 时长（秒）
           bit_depth = sampwidth * 8  # 位深度

           # 输出格式信息
           print("【WAV文件格式信息】")
           print(f"文件路径：{file_path}")
           print(f"声道数：{nchannels}（{ '单声道' if nchannels == 1 else '立体声' }）")
           print(f"位深度：{bit_depth}位")
           print(f"采样率：{framerate}Hz")
           print(f"总帧数：{nframes}")
           print(f"时长：{duration}秒")
           print(f"压缩类型：{comptype}（{compname}）")
           print(f"数据大小：{nframes * nchannels * sampwidth} 字节")  # PCM数据总大小

           # 3. 读取PCM数据（一次性读取所有帧，小文件适用；大文件建议分块读取）
           pcm_data = wf.readframes(nframes)
           print(f"\n读取的PCM数据长度：{len(pcm_data)} 字节（与计算值一致则格式正常）")

           # 4. 解析PCM数据（转为数值数组，便于计算音量）
           # 根据位深度选择struct解包格式（8位无符号，16/32位有符号）
           if bit_depth == 8:
               # 8位PCM：无符号字符（0-255），需减去128转为有符号（-128\~127）
               fmt = f"{nframes * nchannels}B"  # B=无符号字符
               pcm_array = np.array(struct.unpack(fmt, pcm_data), dtype=np.int16) - 128

           elif bit_depth == 16:
               # 16位PCM：有符号短整型（-32768\~32767）
               fmt = f"{nframes * nchannels}h"  # h=有符号短整型
               pcm_array = np.array(struct.unpack(fmt, pcm_data), dtype=np.int16)

           elif bit_depth == 32:
               # 32位PCM：有符号整型（-2147483648\~2147483647）
               fmt = f"{nframes * nchannels}i"  # i=有符号整型
               pcm_array = np.array(struct.unpack(fmt, pcm_data), dtype=np.int32)

           else:
               raise ValueError(f"不支持的位深度：{bit_depth}位（仅支持8/16/32位）")

           # 5. 计算平均音量（基于绝对值的平均值，归一化到0-100）
           # 最大振幅：8位→127，16位→32767，32位→2147483647
           max_amplitude = (1 << (bit_depth - 1)) - 1  # 位运算计算最大振幅
           avg_volume = round(np.mean(np.abs(pcm_array)) / max_amplitude * 100, 2)

           print(f"平均音量：{avg_volume}%（基于PCM数据计算）")

           # 6. 提取单声道数据（若为立体声，取左声道）
           if nchannels == 2:
               left_channel = pcm_array[::2]  # 左声道：索引0,2,4...
               right_channel = pcm_array[1::2]  # 右声道：索引1,3,5...
               print(f"左声道数据长度：{len(left_channel)} 个采样点")
               print(f"右声道数据长度：{len(right_channel)} 个采样点")

       return params, pcm_array

   except wave.Error as e:
       print(f"WAV文件处理错误：{e}（可能是格式不支持或文件损坏）")
       return None, None

   except Exception as e:
       print(f"其他错误：{str(e)}")
       return None, None



# 调用函数（替换为实际WAV文件路径）
if __name__ == "__main__":
   analyze_wav_file("./test_audio.wav")

关键技术点：

• PCM 数据解析：WAV 文件的核心是 “裸 PCM 数据”，需根据位深度用struct模块解包为数值数组（8 位无符号需转有符号）；
• 音量计算：基于 PCM 数据的绝对值平均值，归一化到 0-100%（最大振幅由位深度决定）；
• 立体声处理：双声道数据按 “左→右→左→右” 顺序存储，可通过切片分离左右声道。

（3）实战示例 2：裁剪与合并 WAV 文件

需求：将一个长 WAV 文件裁剪为 “10-20 秒” 的片段，再与另一个 WAV 文件（需保证格式一致）合并为新文件。

import wave

def cut_wav(input_path, output_path, start_sec, end_sec):
   """裁剪WAV文件（从start_sec到end_sec秒）"""
   try:
       with wave.open(input_path, "rb") as wf_in:
           params = wf_in.getparams()
           nchannels, sampwidth, framerate, nframes, comptype, compname = params
           duration = nframes / framerate

           # 校验时间范围
           if start_sec < 0 or end_sec > duration or start_sec >= end_sec:
               raise ValueError(f"无效时间范围：start={start_sec}s, end={end_sec}s（总时长：{duration:.2f}s）")

           # 计算裁剪的起始帧和结束帧
           start_frame = int(start_sec * framerate)
           end_frame = int(end_sec * framerate)
           cut_frames = end_frame - start_frame

           # 移动读取指针到起始帧
           wf_in.setpos(start_frame)

           # 读取裁剪片段的PCM数据
           cut_pcm = wf_in.readframes(cut_frames)

           # 写入裁剪后的文件
           with wave.open(output_path, "wb") as wf_out:
               # 设置与原文件一致的参数（除总帧数外）
               wf_out.setparams(params)
               # 修改总帧数（避免播放器显示错误时长）
               wf_out.setnframes(cut_frames)
               # 写入PCM数据
               wf_out.writeframes(cut_pcm)

       print(f"裁剪完成：{input_path} → {output_path}（{start_sec}s-{end_sec}s，{cut_frames}帧）")

       return True

   except Exception as e:
       print(f"裁剪失败：{str(e)}")
       return False

def merge_wavs(input_paths, output_path):
   """合并多个WAV文件（需保证所有文件格式一致：声道数、位深度、采样率）"""
   if len(input_paths) < 2:
       print("至少需要2个输入文件")
       return False

   try:
       # 1. 校验所有文件格式一致性
       ref_params = None
       total_frames = 0
       all_pcm = b""  # 存储所有PCM数据（字节串）

       for idx, path in enumerate(input_paths):
           with wave.open(path, "rb") as wf:
               params = wf.getparams()

               # 用第一个文件的参数作为参考
               if idx == 0:
                   ref_params = params
                   nchannels, sampwidth, framerate, _, comptype, compname = ref_params
               else:
                   # 校验格式一致性（声道数、位深度、采样率、压缩类型必须相同）
                   if (params.nchannels != nchannels or
                       params.sampwidth != sampwidth or
                       params.framerate != framerate or
                       params.comptype != comptype):

                       raise ValueError(f"文件格式不一致：{path} 与 {input_paths[0]}")

               # 读取当前文件的PCM数据并累加总帧数
               pcm_data = wf.readframes(params.nframes)
               all_pcm += pcm_data
               total_frames += params.nframes

       # 2. 写入合并后的文件
       with wave.open(output_path, "wb") as wf_out:
           wf_out.setparams(ref_params)
           wf_out.setnframes(total_frames)
           wf_out.writeframes(all_pcm)

       merge_duration = round(total_frames / framerate, 2)
       print(f"合并完成：{len(input_paths)} 个文件 → {output_path}（总时长：{merge_duration}s）")

       return True

   except Exception as e:
       print(f"合并失败：{str(e)}")
       return False

# 调用函数
if __name__ == "__main__":
   # 1. 裁剪WAV（10-20秒）
   cut_wav("./long_audio.wav", "./cut_audio.wav", start_sec=10, end_sec=20)

   # 2. 合并两个WAV（需保证格式一致）
   merge_wavs(["./cut_audio.wav", "./short_audio.wav"], "./merged_audio.wav")

关键注意事项：

• 裁剪时需通过setpos()移动读取指针到起始帧，避免读取整个文件（节省内存）；
• 合并时必须保证所有文件的 “声道数、位深度、采样率、压缩类型” 完全一致，否则合并后的音频会出现杂音或播放错误；
• 大文件合并建议分块写入，避免all_pcm字节串过大导致内存溢出。

2. aifc 与 sunau 模块：格式差异补充

aifc和sunau的 API 与wave高度一致（均有open()、getparams()、readframes()等），但针对特定格式有细微差异：

（1）aifc 模块（AIFF/AIFC 格式）

• 支持 AIFF（未压缩）和 AIFC（支持压缩）格式，常用于 macOS 和专业音频软件；
• 额外功能：aifc.open()支持format参数指定压缩格式（如'ULAW'、'ALAW'）；
• 示例：将 AIFF 文件转为 WAV 文件（利用aifc读取，wave写入）：

import aifc
import wave


def aiff_to_wav(aiff_path, wav_path):
   with aifc.open(aiff_path, "rb") as aiff_file:
       # 获取AIFF参数（与wave参数结构一致）
       params = (
           aiff_file.getnchannels(),
           aiff_file.getsampwidth(),
           aiff_file.getframerate(),
           aiff_file.getnframes(),
           'NONE',  # 转为未压缩WAV
           'not compressed'
       )

       # 读取PCM数据
       pcm_data = aiff_file.readframes(aiff_file.getnframes())

       # 写入WAV文件
       with wave.open(wav_path, "wb") as wav_file:
           wav_file.setparams(params)
           wav_file.writeframes(pcm_data)

   print(f"AIFF转WAV完成：{aiff_path} → {wav_path}")




aiff_to_wav("./test.aiff", "./test.wav")

（2）sunau 模块（AU 格式）

• 支持 AU（Sun 音频）格式，常见于 Linux 旧系统，文件头简洁（仅 24 字节）；
• 限制：默认仅支持未压缩 PCM，压缩格式兼容性差；
• 示例：读取 AU 文件参数：

import sunau

with sunau.open("./test.au", "rb") as au_file:
   print("AU文件参数：")
   print(f"声道数：{au_file.getnchannels()}")
   print(f"采样率：{au_file.getframerate()}Hz")
   print(f"位深度：{au_file.getsampwidth() * 8}位")
   print(f"总帧数：{au_file.getnframes()}")

三、音频数据 “手术刀”：audioop 模块

audioop模块是 Python 标准库中专门处理原始 PCM 音频数据的工具，支持格式转换（位深度、采样率、声道数）、音量调整、混音、降噪等核心操作，相当于音频数据的 “手术刀”—— 无需依赖复杂的音频处理库，即可实现基础音频特效。

1. 核心功能与 API 分类

audioop的函数均以 “输入 PCM 数据” 为参数，返回 “处理后的 PCM 数据”，核心功能可分为 5 类：

功能类别	关键函数	作用说明
格式转换	audioop.lin2lin(data, width, newwidth)	位深度转换（如 16 位→8 位）
	audioop.tomono(data, width, lfactor, rfactor)	立体声转单声道（加权混合左右声道）
	audioop.tostereo(data, width, lfactor, rfactor)	单声道转立体声（复制到左右声道）
采样率转换	audioop.ratecv(data, width, nchannels, inrate, outrate, state)	调整采样率（如 44100Hz→22050Hz）
音量处理	audioop.max(data, width)	计算 PCM 数据的最大振幅（用于音量归一化）
	audioop.mul(data, width, factor)	音量放大 / 缩小（factor 为放大倍数，如 1.5 = 放大 50%）
	audioop.avg(data, width)	计算平均振幅（用于音量检测）
混音与叠加	audioop.add(data1, data2, width)	两段 PCM 数据叠加（混音，需保证格式一致）
降噪与滤波	audioop.bias(data, width, bias)	去除直流偏移（降噪预处理）
	audioop.cross(data, width)	检测音频交叉点（用于音频分割）

关键参数说明：

• data：输入 PCM 数据（字节串）；
• width：输入 PCM 数据的位深度字节数（如 1=8 位，2=16 位）；
• factor：音量放大倍数（mul函数），小于 1 为缩小，大于 1 为放大；
• state：采样率转换的状态对象（ratecv函数专用，需初始化None）。

2. 实战示例：音频批量处理工具

需求：实现一个批量音频处理工具，支持 “位深度转换（16 位→8 位）、采样率降低（44100Hz→22050Hz）、音量归一化（最大振幅占比 90%）” 三个功能，处理后输出为新的 WAV 文件。

import wave
import audioop
import os
from pathlib import Path

def normalize_volume(pcm_data, width):
   """音量归一化：将最大振幅调整到目标占比（默认90%）"""
   target_ratio = 0.9  # 目标最大振幅占比（避免过载失真）

   # 计算当前最大振幅
   max_amp = audioop.max(pcm_data, width)

   if max_amp == 0:
       return pcm_data  # 静音数据，无需处理

   # 计算放大倍数（目标振幅 = 最大可能振幅 * 目标占比）
   max_possible_amp = (1 << (width * 8 - 1)) - 1  # 如16位：32767
   target_amp = max_possible_amp * target_ratio
   factor = target_amp / max_amp

   # 放大音量（mul函数返回新的PCM数据）
   normalized_pcm = audioop.mul(pcm_data, width, factor)

   return normalized_pcm

def process_audio(input_path, output_path, new_width=1, new_rate=22050):

   """

   音频批量处理：位深度转换 + 采样率转换 + 音量归一化

   :param input_path: 输入WAV文件路径

   :param output_path: 输出WAV文件路径

   :param new_width: 目标位深度字节数（1=8位，2=16位）

   :param new_rate: 目标采样率（如22050Hz）

   """

   try:

       with wave.open(input_path, "rb") as wf_in:
           # 1. 读取原始参数与PCM数据
           nchannels, width, framerate, nframes, comptype, compname = wf_in.getparams()
           if comptype != "NONE":
               raise ValueError("仅支持未压缩PCM格式的WAV文件")

           pcm_data = wf_in.readframes(nframes)
           print(f"处理文件：{input_path}（原格式：{width*8}位，{framerate}Hz）")

           # 2. 音量归一化（处理前先归一化，避免后续转换失真）
           pcm_data = normalize_volume(pcm_data, width)
           print("✓ 音量归一化完成")

           # 3. 位深度转换（如16位→8位）
           if width != new_width:
               pcm_data = audioop.lin2lin(pcm_data, width, new_width)
               print(f"✓ 位深度转换完成：{width*8}位→{new_width*8}位")
           else:
               print("✓ 位深度无需转换")

           # 4. 采样率转换（如44100Hz→22050Hz）
           if framerate != new_rate:
               # ratecv函数需要状态对象，初始化为None
               state = None
               pcm_data, state = audioop.ratecv(
                   pcm_data, new_width, nchannels,
                   framerate, new_rate, state
               )

               # 计算转换后的总帧数（避免播放器显示错误时长）
               new_nframes = int(len(pcm_data) / (new_width * nchannels))
               print(f"✓ 采样率转换完成：{framerate}Hz→{new_rate}Hz（新帧数：{new_nframes}）")
           else:
               new_nframes = nframes
               print("✓ 采样率无需转换")

           # 5. 写入处理后的WAV文件
           with wave.open(output_path, "wb") as wf_out:
               new_params = (nchannels, new_width, new_rate, new_nframes, "NONE", "not compressed")
               wf_out.setparams(new_params)
               wf_out.writeframes(pcm_data)

       print(f"✓ 处理完成：{output_path}\n")

       return True

   except Exception as e:
       print(f"× 处理失败：{str(e)}\n")
       return False

def batch_process_audios(input_folder, output_folder, new_width=1, new_rate=22050):
   """批量处理文件夹中的WAV文件"""

   # 创建输出文件夹
   Path(output_folder).mkdir(parents=True, exist_ok=True)

   # 遍历输入文件夹中的WAV文件
   for file_path in Path(input_folder).rglob("*.wav"):
       # 构造输出路径（保持原文件名）
       output_path = Path(output_folder) / file_path.name
       # 处理当前文件
       process_audio(str(file_path), str(output_path), new_width, new_rate)




# 调用函数（批量将16位44100Hz的WAV转为8位22050Hz）
if __name__ == "__main__":
   batch_process_audios(
       input_folder="./raw_audios",
       output_folder="./processed_audios",
       new_width=1,  # 8位（1字节）
       new_rate=22050  # 22050Hz
   )

关键技术点：

• 音量归一化逻辑：先计算当前最大振幅，再根据目标占比（如 90%）计算放大倍数，避免放大过度导致失真；
• 采样率转换：audioop.ratecv需传入state对象（用于处理残差），转换后需重新计算总帧数（通过 PCM 数据长度 /（位深度字节数 × 声道数））；
• 处理顺序：建议先归一化音量，再进行格式转换，避免转换过程中因振幅过小丢失细节或过大导致裁剪失真。

四、系统音频设备交互：ossaudiodev 模块

ossaudiodev模块是 Python 标准库中唯一直接与系统音频设备交互的模块，基于 Linux 的 OSS（Open Sound System）接口，支持从麦克风录制音频、向扬声器播放音频。但需注意：该模块仅支持 Linux 系统，Windows 和 macOS 无此模块（需用第三方库如pyaudio替代）。

1. 核心功能与 API

ossaudiodev的核心是OSS Audio Device对象，通过ossaudiodev.open()创建，支持两种模式：

• mode='r'：录音模式（从麦克风读取音频数据）；
• mode='w'：播放模式（向扬声器写入音频数据）。

关键函数 / 方法	作用说明
ossaudiodev.open(mode, rate=44100, channels=2, fmt=ossaudiodev.AFMT_S16_LE)	打开音频设备，指定模式、采样率、声道数、格式
dev.setparameters(fmt, channels, rate)	动态设置音频参数（需在打开设备后调用）
dev.read(size)	录音模式：读取指定字节数的 PCM 数据
dev.write(data)	播放模式：写入 PCM 数据到扬声器
dev.close()	关闭音频设备（必调用，避免资源泄漏）

常用音频格式常量：

• AFMT_S8：8 位有符号 PCM；
• AFMT_S16_LE：16 位小端有符号 PCM（最常用，兼容多数设备）；
• AFMT_S16_BE：16 位大端有符号 PCM；
• AFMT_U8：8 位无符号 PCM。

2. 实战示例：简单录音与播放工具

需求：实现一个 Linux 下的简单工具，支持 “录音 5 秒并保存为 WAV 文件” 和 “播放指定 WAV 文件” 两个功能。

import ossaudiodev
import wave
import time


def record_audio(output_path, duration=5, rate=44100, channels=1, fmt=ossaudiodev.AFMT_S16_LE):
   """
   录音并保存为WAV文件（仅Linux）
   :param duration: 录音时长（秒）
   :param rate: 采样率（Hz）
   :param channels: 声道数（1=单声道，2=立体声）
   :param fmt: 音频格式（默认16位小端PCM）
   """

   # 计算音频格式对应的字节数（AFMT_S16_LE=2字节/采样点）
   width = ossaudiodev.formatwidth(fmt)
   if width == 0:
       raise ValueError("不支持的音频格式")

   try:
       # 1. 打开录音设备
       with ossaudiodev.open('r', rate=rate, channels=channels, fmt=fmt) as dev:
           print(f"开始录音：{duration}秒（采样率：{rate}Hz，声道：{channels}，位深度：{width*8}位）")
           start_time = time.time()
           recorded_pcm = b""

           # 2. 循环录音（按块读取，避免内存溢出）
           block_size = 1024  # 每次读取1024字节
           while time.time() - start_time < duration:
               # 读取PCM数据（可能小于block_size，需处理）
               pcm_block = dev.read(block_size)
               if not pcm_block:
                   break
               recorded_pcm += pcm_block

           print("录音完成，正在保存文件...")

       # 3. 保存为WAV文件
       with wave.open(output_path, "wb") as wf:
           nframes = len(recorded_pcm) // (width * channels)  # 总帧数
           wf.setparams((channels, width, rate, nframes, "NONE", "not compressed"))
           wf.writeframes(recorded_pcm)

       print(f"录音文件保存成功：{output_path}（大小：{len(recorded_pcm)}字节）")

       return True

   except ossaudiodev.error as e:
       print(f"音频设备错误：{e}（可能是设备被占用或无权限）")
       return False

   except Exception as e:
       print(f"录音失败：{str(e)}")
       return False

def play_audio(input_path):
   """播放WAV文件（仅Linux，需保证文件为PCM格式）"""

   try:
       # 1. 读取WAV文件参数与PCM数据
       with wave.open(input_path, "rb") as wf:
           nchannels, width, framerate, nframes, comptype, compname = wf.getparams()
           if comptype != "NONE":
               raise ValueError("仅支持未压缩PCM格式的WAV文件")

           pcm_data = wf.readframes(nframes)
           duration = round(nframes / framerate, 2)

           # 2. 映射WAV格式到OSS格式常量
           fmt_map = {
               1: ossaudiodev.AFMT_S8 if width == 1 else ossaudiodev.AFMT_U8,
               2: ossaudiodev.AFMT_S16_LE,
               4: ossaudiodev.AFMT_S32_LE
           }

           if width not in fmt_map:
               raise ValueError(f"不支持的位深度：{width*8}位")

           oss_fmt = fmt_map[width]

           # 3. 打开播放设备并设置参数
           with ossaudiodev.open('w') as dev:
               dev.setparameters(oss_fmt, nchannels, framerate)
               print(f"开始播放：{input_path}（时长：{duration}秒，格式：{width*8}位/{framerate}Hz/{nchannels}声道）")
               start_time = time.time()

               # 4. 分块播放（避免一次性写入过大数据）
               block_size = 4096
               for i in range(0, len(pcm_data), block_size):
                   block = pcm_data[i:i+block_size]
                   dev.write(block)

               # 等待播放完成（避免设备提前关闭）
               while time.time() - start_time < duration:
                   time.sleep(0.1)

           print("播放完成！")
           return True

   except ossaudiodev.error as e:
       print(f"音频设备错误：{e}")
       return False

   except Exception as e:
       print(f"播放失败：{str(e)}")
       return False



# 调用函数（仅Linux运行）
if __name__ == "__main__":
   # 1. 录音5秒
   record_audio("./recorded.wav", duration=5)

   # 2. 播放录音文件
   play_audio("./recorded.wav")

关键注意事项：

• 权限问题：Linux 下访问音频设备需audio用户组权限，若报错 “Permission denied”，需执行sudo usermod -aG audio $USER并重启；
• 设备占用：若音频设备被其他程序占用（如浏览器、音乐播放器），会报错 “Device or resource busy”；
• 格式兼容性：播放时需保证 WAV 文件格式与设备支持的格式一致（优先用 16 位小端 PCM，兼容性最好）。

五、选型建议与注意事项

Python 标准库的多媒体模块功能聚焦于基础音频处理，无视频相关支持，需根据场景合理选型：

1. 模块选型指南

场景需求	推荐模块	不推荐 / 替代方案
音频文件类型检测	sndhdr	手动解析文件头（效率低、易出错）
WAV 格式读写与简单处理	wave	aifc/sunau（格式不兼容）
AIFF/AIFC 格式处理（macOS / 专业场景）	aifc	wave（不支持 AIFF）
AU 格式处理（旧 Linux 系统）	sunau	其他模块（格式不兼容）
PCM 数据操作（格式转换 / 音量 / 混音）	audioop	自定义算法（复杂度高、易失真）
Linux 音频设备交互（录音 / 播放）	ossaudiodev	第三方库pyaudio（跨平台）

2. 核心注意事项

（1）跨平台兼容性

• wave/aifc/sndhdr/audioop：全平台支持（Windows/macOS/Linux）；
• ossaudiodev：仅 Linux 支持，Windows/macOS 需用pyaudio替代；
• 格式差异：WAV 在 Windows/macOS 均通用，AIFF 在 macOS 更常见，AU 在旧 Linux 系统常见。

（2）性能与内存

• 大音频文件处理：避免一次性读取所有 PCM 数据（如wave.readframes(nframes)），建议分块读取（如每次读 1024 帧）；
• 采样率转换：audioop.ratecv效率较低，大文件建议用第三方库（如soundfile+libsox）；
• 内存占用：PCM 数据为字节串，1 分钟 16 位 44100Hz 立体声的音频约 50MB（44100×2×2×60=10,584,000 字节），需注意内存限制。

（3）格式限制

• 仅支持未压缩或简单压缩格式：wave支持 PCM、ALAW、ULAW，aifc支持 AIFF-C 压缩，不支持 MP3、AAC、FLAC 等主流压缩格式（需第三方库如pydub+ffmpeg）；
• 位深度支持：audioop主要支持 8/16/32 位 PCM，不支持 24 位（需自定义处理）。

3. 第三方库补充建议

当标准库功能无法满足需求时（如 MP3 解码、视频处理、实时音频流），可考虑以下第三方库：

• 音频处理：soundfile（高效读写多种格式）、pyaudio（跨平台音频设备接口）、pydub（简单音频编辑，依赖ffmpeg）；
• 视频处理：moviepy（视频剪辑、格式转换）、opencv-python（视频帧处理）；
• 高级特效：librosa（音频特征提取、降噪、节拍检测）、noisereduce（降噪）。

六、总结

Python 3.13.7 标准库的多媒体服务模块构建了 “音频检测→格式读写→数据操作→设备交互” 的基础音频处理链路，具备轻量、无依赖、易上手的优势，适合以下场景：

• 简单音频格式转换（如 WAV→AIFF、16 位→8 位）；
• 基础音频编辑（裁剪、合并、音量调整）；
• Linux 下的简单录音与播放；
• 音频文件批量检测与预处理。

但其局限性也明显（不支持主流压缩格式、跨平台设备交互弱、性能一般），复杂场景（如 MP3 解码、视频处理、实时音频流）需结合第三方库。掌握标准库的多媒体模块，不仅能满足基础需求，还能深入理解音频数据的底层表示（如 PCM 格式、采样率、位深度），为后续学习高级音频处理打下基础。