音频编解码 on 苏三有春的博客

如何在Windows中使用opuslib库

Fri, 07 Nov 2025 20:09:00 +0800

前言

Hi,everyone，本周笔者在Windows环境下使用python开发上位机时，意外发现需要解码opus音频数据，因此笔者需要在上位机中加入opus的编解码器，在opus官网下载的解码器需要在Linux环境下运行，编译出来是一个ELF文件，而笔者的上位机是基于python开发的，且目标用户都使用Windows环境，因此笔者理所当然地就要解决如何在Windows环境下使用python开发opus编解码器这个问题，笔者使用opuslib + opus.dll的形式解决问题，笔者会提供笔者使用的opus.dll下载链接和配置方式。

你是否需要opuslib

opuslib是一个为libopus音频编码库提供Python绑定的工具包，能够让使用者在Python项目中使用Opus音频编解码器。其核心价值就在于，它将Opus编解码器的强大功能以易于使用的Python接口形式提供出来。很重要的一点是：在opuslib中，无论是将PCM音频流数据编码成Opus数据，还是将Opus数据解码成PCM音频流进行播放，其Opus数据包是裸的，即纯粹的Opus数据，为何要强调这一点？因为有些opus编解码，例如ffmpeg是会在Opus数据外套一层ogg格式，而如果读者正是想要该封装格式的可以使用ffmpeg来编码或解码数据。

所以：

你需要使用python来程序来编解码opus音频数据
你需要在Windows环境下使用
你想要解码或编码纯粹的opus数据，而不是被ogg（或其它）封装后的数据

那么这篇文章可以帮到你，文章不长，可以读读。

下载opuslib

在你的python虚拟环境下使用命令下载opuslib库:

1

pip install opuslib

此命令会在你当前使用的python虚拟环境下安装opuslib库，但请注意，此时如果你尝试使用导入该库并使用，会报错。

opuslib使用异常

例如：

1
2
3


import opuslib # 导入opuslib库

decoder = opuslib.Decoder(48000, 960) # 初始化解码器

从报错信息中可以看到，当你初始化一个opus解码器对象时，会抛出异常，异常信息显示Could not find Opus library. Make sure it is installed.，索引到最后报错的文件可以看到：

可以看到，当没有在lib_location这个变量没有找到库时，就会抛出该异常，提示你它并没有找到相应的opus库。你可以将opuslib理解为一个封装，它本质上没有opus编解码器，而是调用写好的opus编解码器，转换成python形式的接口，方便你在python中调用，因此我们需要手动添加一个可以在Windows环境下运行的opus库进去。

顺便提一嘴：这个__init__.py文件是在虚拟环境\Lib\site-packages\opuslib\api\__init__.py，虚拟环境是你的虚拟环境名称，笔者这里叫做venv，因此笔者这里的完整路径是:D:\HugoBlog\dev\content\post\useOpuslibInWindows\testopuslib\.venv\lib\site-packages\opuslib\api\__init__.py要提这一嘴是因为在python中__init__.py文件特别多，与api同级下还有个__init__.py，别弄混了。

下载opus.dll

笔者找到了一个可以在Windows下运行的opus动态库（opus.dll），将其放在CSDN资源和百度网盘中，附上链接，大家可以随意下载使用。

【免费】Windows下使用的opus编解码动态库资源-CSDN下载

百度网盘分享-opus.dll提取码: 7aed

配置opus动态库

还记得上面笔者提到的__init__.py文件中的lib_location变量吗，该变量实质上是一个地址，你当然可以使用绝对地址的形式将opus.dll的位置直接写入lib_location，如下所示：

但考虑代码健壮性，也可以这么写：

1
2
3
4
5
6


lib_location = find_library('opus')
current_dir = os.path.dirname(os.path.abspath(__file__)) # 获取当前文件所在目录
lib_location = os.path.join(current_dir, 'opus.dll') # 构建 opus.dll 的完整路径（在同一目录下）
if lib_location is None:
 raise Exception(
 'Could not find Opus library. Make sure it is installed.')

这段代码的作用是：

current_dir：获取当前文件的目录，即：__init__.py的目录
lib_location：将current_dir与opus.dll拼接在一起

使用这段代码，读者仅需将opus.dll放在与__init__.py同一目录下即可，如上图所示。

小结

读到这里，读者们应该可以自行使用opuslib来编写opus音频编解码库了，我们来做个小结：

使用pip包管理器下载opuslib，但opuslib无法在Windows中直接使用
下载opus.dll动态库
将opus.dll的地址赋值给opuslib库中的初始化函数，笔者提供相对地址与绝对地址两种方式

那么接下来，笔者再提供一些笔者在编写语音编解码器时踩过的一些坑

pyinstaller无法打包第三方库

笔者目的是使用pyqt做一个上位机，可视化地展示语音解码的波形与播放。关于如何使用pyqt做一个语音播放器，可以看笔者下面这几篇文章

PyAudio库基本知识详解

基于PyQt开发的脚本集合包（十三）

基于PyQt开发的脚本集合包（十四）

在使用pyqt做完了语音播放器后，使用pyinstaller工具，将程序打包成.exe可执行文件，在运行时报错：

这个报错显示exe文件在运行时没有找到一个名为opuslib的库，由于我是用pyinstaller的时候并没有将所有东西压缩成一个单独的exe文件，pyinstaller会将我导入的一些第三方库比如PyQt5、numpy、matplotlib等放在一个名为_internal的目录下，检查该目录发现，并没有opuslib，这个_internal目录与你在编程时的虚拟环境目录很像，存放了你使用pip下载的第三方库。

因此，这里可能是pyinstaller出于某种原因，并没有将虚拟环境目录下的opuslib一起打包进来，笔者在网上找了许多方法，都比较复杂，笔者在这里提供一个简单的，直接将你使用的opuslib库拖到_internal目录下即可。

这样就能解决No module named 'opuslib'的问题。

Opus解码器样例

这里笔者给出一个opus的解码器样例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


import opuslib

class OpusDecoder:
 def __init__(self):
 # 配置参数
 SAMPLE_RATE = 48000 # Opus 标准采样率（支持 8000, 12000, 16000, 24000, 48000）
 CHANNELS = 1 # 声道数（1=单声道，2=立体声）
 FRAME_SIZE_MS = 20 # 每帧时长（毫秒，Opus 常用 20ms 的帧）

 # 计算每帧的样本数（如 48000Hz * 20ms = 960 样本/帧）
 self.FRAME_SIZE = int(SAMPLE_RATE * FRAME_SIZE_MS / 1000)
 # 初始化 Opus 解码器
 self.decoder = opuslib.Decoder(SAMPLE_RATE, CHANNELS)
 pass
 def decode_opus_to_pcm(self,opusfile,pcmfile):
 self.INPUT_OPUS_FILE = opusfile
 self.OUTPUT_PCM_FILE = pcmfile
 # 打开文件并解码
 with open(self.INPUT_OPUS_FILE, "rb") as opus_file, open(self.OUTPUT_PCM_FILE, "wb") as pcm_file:
 while True:
 # 读取 Opus 帧（注意：这里假设文件是裸 Opus 流，无 Ogg 封装）
 opus_frame = opus_file.read(40) # 40 是经验值，需根据实际帧大小调整

 # 无更多数据时退出循环
 if not opus_frame:
 break

 # 解码为 PCM
 pcm_data = self.decoder.decode(opus_frame, self.FRAME_SIZE)

 # 写入 PCM 文件
 pcm_file.write(pcm_data)

 # print("解码完成！输出文件:", self.OUTPUT_PCM_FILE)
 # return self.OUTPUT_PCM_FILE
# 测试样例
OpusDecoder().decode_opus_to_pcm("input.opus","output.pcm")

输入input.opus的opus数据（裸的opus数据，二进制文件），即可解码得到output.pcm音频流数据(裸的pcm数据，二进制文件，可直接在adobe之类的软件播放)

好啦，如果本文有一点点帮助你，那荣幸之至，后续笔者也会考虑出一文解释一下opus的数据，其实从opus的数据包中可以逆推出一些信息，如果想看的话点赞留言催更，笔者会尽快出文，祝你变得更强！

PyAudio库基本知识详解

Thu, 19 Dec 2024 20:03:00 +0800

前言

结合前段时间我们做的音频编解码器，这样我们就可以将获取到的ADPCM数据，转换成PCM数据，然后播放出来，得到一个完整的音频数据，因此，接下来几篇文章中，我们想做一个播放PCM格式的音频播放器。待到音频编解码器完成，播放器完成，或许我们就能做一个语音识别功能模块，通过一个小收音器的BLE蓝牙连接，连接到电脑上，实时完成音频传输，解码，以及识别的整套流程。可以完成语音写入文本，不仅彻底解放双手，还能解放双脚，让你离开电脑桌也能输入文本（不过也是作者的美好幻想，先挖个坑，距离实现遥遥无期，尽请期待！）

在此之前呢，我们先脚踏实地的，了解一下我们必要的第三方库，PyAudio。

前置知识

在介绍PyAudio库之前我们需要先了解一点点前置内容

采样率：采样率是指机器每秒采样的次数，是音频处理中的重要参数。如：采样率为44100，即1秒钟采样44100次，常见的采样率为44100、48000，在小型设备中，如只专注语音的识别，不在乎音质，通常会选用更小的采样率，如8000、16000等，换取硬件设备的成本优势
音频格式：指的是每个采样点的长度，如：paInt16，表示每个采样点为16比特，一次采样获取的数据为16比特，常见的采样点大小为8、16、32等。单位为比特。通常采样率与采样点大小即可确定一定时间内，采样获取的数据大小，如：当音频格式为paInt16，采样率为8KHz，那么1s中，将采样到 8000 * 16bit = 128kb的数据。
通道：指的是声道，麦克风拾音的过程。分为单声道，多声道，立体声，联合立体声等。
块：块是指数据块，在PyAudio可以实时处理动态音频数据，也就是音频流，而处理音频流实际上也是将连续的（实际上并非连续）输入以数据块的形式处理，并不是来一个字节处理一个字节，可以理解为缓冲区buffer的概念。

稍稍理解这些概念，以便后续阅读中看懂PyAudio的参数，如果没懂，可以返回来反复阅读。

PyAudio

PyAudio 是一个用于在 Python 中进行音频处理的库，它为我们提供了跨平台的接口，用于录音、播放和处理音频流。PyAudio 封装了 PortAudio 库，PortAudio 是一个跨平台的音频库，支持多种操作系统（如 Windows、macOS、Linux）。

PyAudio的常见用途

录音（Recording Audio）：可以从麦克风获取音频数据。
播放音频（Playing Audio）：可以播放 WAV 或其他格式的音频文件。
实时音频处理：处理音频数据流（例如，分析麦克风输入，实时音效等）。

安装 PyAudio

首先需要安装 PyAudio。可以使用 pip 来安装：

1

pip install pyaudio

PyAudio的核心概念

流（Stream）： PyAudio 的核心概念是“流”（Stream）。流是数据的一个持续流动的通道，用于音频输入或输出。你可以创建一个输入流（录音）或输出流（播放音频），然后使用流来传输音频数据。
音频格式和数据： PyAudio 支持多种音频格式，例如 paInt16（16 位整数格式）和 paFloat32（32 位浮点格式）。音频数据通常是原始的字节流数据，可以通过 NumPy 数组或其他方式进行处理。
回调函数：在实时音频流的场景中，通常使用回调函数来处理音频数据。回调函数会在每次采集到一块音频数据时被调用。

主要功能

录音示例：以下是一个使用 PyAudio 录音的简单示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


import pyaudio
import wave

# 设置录音参数
FORMAT = pyaudio.paInt16 # 音频格式
CHANNELS = 1 # 单声道
RATE = 44100 # 采样率
CHUNK = 1024 # 每次读取的数据块大小
RECORD_SECONDS = 5 # 录音时长
OUTPUT_FILENAME = "output.wav" # 输出文件

p = pyaudio.PyAudio()

# 开启输入流
stream = p.open(format=FORMAT,
 channels=CHANNELS,
 rate=RATE,
 input=True,
 frames_per_buffer=CHUNK)

print("开始录音...")

frames = []

# 录制数据
for _ in range(0, int(RATE * RECORD_SECONDS / CHUNK)):
 data = stream.read(CHUNK)
 frames.append(data)

print("录音结束...")

# 停止流并关闭
stream.stop_stream()
stream.close()
p.terminate()

# 将录音保存为WAV文件
wf = wave.open(OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()

这里有值得一提的一个点：
1
2
3
4
# 录制数据
for _ in range(0, int(RATE * RECORD_SECONDS / CHUNK)):
 data = stream.read(CHUNK)
 frames.append(data)
这个循环的主要目的是从流中读取数据，并添加到frams列表中，可以看到RATE * RECORD_SECONDS为采样率 * 录音时长，这可以得到在本次录音中一共采样的次数，/ CHUNK表明采样的数据被分块读取并写入frames。这里其实隐式的处理了采样格式，即paInt16。

播放音频示例：以下是一个播放 WAV 文件的简单示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import pyaudio
import wave

# 打开WAV文件
wf = wave.open('output.wav', 'rb')

p = pyaudio.PyAudio()

# 打开输出流
stream = p.open(format=pyaudio.paInt16,
 channels=wf.getnchannels(),
 rate=wf.getframerate(),
 output=True)

# 读取文件并播放
chunk = 1024
data = wf.readframes(chunk)
while data:
 stream.write(data)
 data = wf.readframes(chunk)

# 关闭流
stream.stop_stream()
stream.close()
p.terminate()

PyAudio的高级功能

回调模式（Callback Mode）： PyAudio 提供了回调模式来处理音频流。在这种模式下，你可以通过定义回调函数来实时处理录制或播放的音频数据。例如，你可以实时对音频数据进行处理或应用某些效果（如滤波、增益等）。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import pyaudio

def callback(in_data, frame_count, time_info, status):
 # 处理音频数据
 print("Recording...")
 return (in_data, pyaudio.paContinue)

p = pyaudio.PyAudio()

# 打开输入流
stream = p.open(format=pyaudio.paInt16,
 channels=1,
 rate=44100,
 input=True,
 frames_per_buffer=1024,
 stream_callback=callback)

stream.start_stream()

# 等待流结束
while stream.is_active():
 pass

stream.stop_stream()
stream.close()
p.terminate()

PyAudio的应用场景

音频录制与播放：用来创建简单的音频应用程序，进行声音的录制和回放。
语音识别：结合其他语音识别库（如 speech_recognition）可以实现语音识别功能。
实时音频处理：可以实时分析、修改或增强音频数据。
声音特效处理：可以在录制或播放过程中加入音效，如回声、变调等。

PyAudio与其他音频库对比

vs. wave: wave 模块主要用于处理静态的音频文件，而 PyAudio 支持音频流，能够进行实时录音与播放。
vs. soundfile: soundfile 更适用于处理已保存的音频文件的读写操作，而 PyAudio 更擅长实时音频流的处理。

注意事项

在不同平台上安装 PyAudio 可能需要额外的步骤。例如，Windows 上可能需要安装 PortAudio 的依赖项。
PyAudio 并不支持直接播放 MP3 等压缩音频格式。如果需要播放其他格式的音频，可能需要使用其他库如 pygame 或 pydub。

小结

总的来说，PyAudio 是一个非常强大的库，适合用于音频处理和实时音频应用，尤其在需要直接与麦克风或扬声器交互时，提供了非常简洁的接口。

stop_stream与start_stream

可能会有同学好奇，在上面的示例代码中，为什么只看见stream.stop_stream而没有看见stream.start_stream呢，如果只有停止流的操作，为什么没有开启流的操作，流在哪里被开启了呢？

PyAudio 中的 stream.start_stream() 和 stream.stop_stream() 是两个重要的流控制方法，用于控制音频流的开始和停止。

在 PyAudio 的流（Stream）中，start_stream() 和 stop_stream() 方法实际上是可选的，它们的行为是与音频流的实际使用场景有关的。让我们详细解释一下这两个方法，以及为什么在某些情况下，可能看不到显式调用 start_stream()。

1. stream.start_stream() 的作用

start_stream() 方法用于启动音频流，开始录制或播放音频。它是用来显式告诉程序 “现在开始处理音频数据”。

2. stream.stop_stream() 的作用

stop_stream() 方法用于停止音频流，表示录制或播放过程结束。这对于需要显式控制音频流的结束时机的程序非常有用。

为什么 `start_stream()` 有时没被显式调用

回调模式（Callback Mode）：如果使用了回调模式（即通过设置 stream_callback 参数来传递回调函数），那么在调用 open() 方法时，音频流已经自动开始了。回调机制会在后台处理音频数据的输入和输出。因此，在这种模式下，start_stream() 是不必要的，因为流会自动启动。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


import pyaudio

def callback(in_data, frame_count, time_info, status):
 # 处理音频数据
 print("Recording...")
 return (in_data, pyaudio.paContinue)

p = pyaudio.PyAudio()

# 打开输入流并设置回调函数
stream = p.open(format=pyaudio.paInt16,
 channels=1,
 rate=44100,
 input=True,
 frames_per_buffer=1024,
 stream_callback=callback)

# 注意: 这里不需要显式调用 start_stream()
stream.start_stream() # 这行可以省略，回调模式会自动启动

# 等待流结束
while stream.is_active():
 pass

stream.stop_stream()
stream.close()
p.terminate()

在这个例子中，start_stream() 虽然可以显式调用，但在使用回调模式时，可以省略，因为 PyAudio 会在底层自动处理流的启动和停止。

默认自动启动（在非回调模式下）：在非回调模式（例如通过 stream.read() 或 stream.write() 进行音频数据的读取和写入）中，start_stream() 也是隐式调用的。在创建音频流时，open() 方法会自动启动流，并开始数据的录制或播放。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import pyaudio

p = pyaudio.PyAudio()

# 设置流参数
stream = p.open(format=pyaudio.paInt16,
 channels=1,
 rate=44100,
 input=True,
 frames_per_buffer=1024)

# 此时，流已经自动启动
data = stream.read(1024) # 录音
stream.stop_stream()
stream.close()
p.terminate()

在这个例子中，open() 已经自动启动了流，调用 stream.read() 只是触发音频数据的读取过程，而不需要显式调用 start_stream()。

小结

回调模式：当你使用回调函数时，PyAudio 会自动管理音频流的开始和停止。因此，通常不需要显式调用 start_stream()，而只需要设置 stream_callback 并开始流的处理。
非回调模式：即便是非回调模式，open() 方法有时也会自动开始音频流，尤其是在调用 stream.read() 或 stream.write() 时，不需要显式调用 start_stream()。

但是，在一些场景下，尤其是自定义更复杂的音频控制时，start_stream() 和 stop_stream() 还是很有用的，特别是当你需要手动控制音频流的启动与停止时。

谁开启的麦克风或扬声器

在上面的示例代码中，敏锐的读者可能会发现，似乎没有发现那里调用了麦克风或扬声器，合理猜测，直接告诉我们，应该是PyAudio库调用了硬件设备，但真是如此吗，如果是，那么又是怎么调用的呢？

我们以上面的代码为例，究竟是谁调用了麦克风，开启了录音

音频的录制是通过 pyaudio 库来实现的，调用麦克风硬件的部分是由 pyaudio 库中的 PyAudio 类和它的 open() 方法来完成的。具体的过程是这样的：

调用麦克风硬件的关键步骤：

pyaudio.PyAudio(): 这个步骤创建了一个 PyAudio 对象。这个对象是与音频硬件交互的主要接口，它会管理音频流（包括录音流和播放流），并负责配置音频设备。
p.open(): open() 方法是用来打开一个音频流的，这个流可以是输入流（例如录音）或者输出流（例如播放音频）。在上面的代码中，p.open() 被用来打开一个输入流，用于录制音频。
1 2 3 4 5

stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK)
关键参数：
- format=FORMAT：指定音频数据的格式，通常为 16 位 PCM 编码（pyaudio.paInt16）。
- channels=CHANNELS：指定录音的通道数，1 表示单声道，2 表示立体声。
- rate=RATE：指定采样率，通常选择 44100 Hz，这是 CD 音质的标准采样率。
- input=True：这告诉 pyaudio 创建一个输入流，也就是通过麦克风录音。如果将其设置为 False，则会创建输出流，用于播放音频。
- frames_per_buffer=CHUNK：指定每次读取的音频块的大小，通常是 1024 或 2048。
此时，pyaudio 会通过系统的音频接口与麦克风硬件进行连接，并开始接收音频数据。具体而言，pyaudio 会通过操作系统调用音频驱动程序来访问麦克风硬件。操作系统（如 Windows、Linux、macOS）会提供接口给 pyaudio 来处理与硬件的交互。
stream.read(CHUNK): stream.read(CHUNK) 方法是用来从音频流中读取音频数据的。这里的 CHUNK 表示每次读取的音频数据的大小，也就是说它会以一定的时间间隔（根据 CHUNK 的大小）从麦克风捕捉音频数据。

通过连续调用 stream.read()，程序不断地从麦克风获取音频数据，并将这些数据存储到 frames 列表中。

总结：

谁调用了麦克风硬件？ 实际上是 pyaudio 库调用了麦克风硬件。pyaudio 作为一个高层的音频处理库，封装了与操作系统音频接口的交互。操作系统的音频驱动程序在幕后管理与麦克风硬件的连接和数据传输。
如何调用的？
- 通过 pyaudio.PyAudio() 创建的 PyAudio 实例。
- 使用 p.open() 方法创建音频输入流（input=True），并通过该流接收来自麦克风的音频数据。
- 最终使用 stream.read() 不断地从麦克风获取音频样本。

这样，pyaudio 库就可以通过操作系统和驱动程序，控制麦克风硬件进行录音了。

ADPCM编解码器的实现

Thu, 12 Dec 2024 22:23:00 +0800

前言

从本篇文章开始，接下来的三篇文章，我们将实现音频编解码器功能模块，第一篇文章，也就是本文，我们将实现基于开源的IMA-ADPCM算法的音频编解码器，第二篇文章，我们将实现自定义的特色进度条以及简单介绍编码器的UI布局，在第三篇文章中，我们将实现编解码器的UI以及进度条与编解码器的消息传递。这三篇文章涉及到的知识点较多，比如ADPCM编解码的实现算法，python脚本使用subprocess调用C编译的exe可执行文件，python的多线程功能应用，线程之间的消息传递，还有特色进度条的实现等等。知识点很多，也是笔者自己一点一点摸索出来的，有许多不足的地方，还请多多指正批评。同时，模块的代码分布在三篇文章中，在第三篇文章的结尾，笔者会给出代码的存放的工程目录，这样大家就可以理解代码中的import模块导入。

本文开始讲述实现音频的编解码，目前笔者只写了一个算法，APDCM，产生笔者自写ADPCM的原因是笔者当初使用ffmpeg解一些经过ADPCM压缩后的数据，发现非常困难，不是因为ffmpeg没有ADPCM解码算法，而是它拥有太多ADPCM算法了，如果你安装了ffmpeg的话，使用命令ffmpeg -codecs可以查询ffmpeg内置的编解码库，关于ADPCM的就有如下：

我并没有完全看完这些ADPCM算法各有哪些不同，笔者只对比过一些变种，如微软的ADPCM，adpcm_ms，它生成的二进制文件前会增加一些头部信息，指明其是由adpcm_ms编码的，其编码算法究竟和开源的ADPCM究竟有何不同，本文没有做详细的对比，但就其加的头部信息，就让其无法解码经过经典开源ADPCM算法编码的音频数据。因此笔者就根据开源的ADPCM算法，自行编写编解码器。

ADPCM算法原理

本文不对ADPCM算法做非常详细的数学推导，只介绍大概思想原理，如想了解更详细的原理，可以推荐可以去看看ADPCM(自适应差分脉冲编码调制)的原理和计算_单片机使用adpcm音频编解码算法-CSDN博客这篇文章。关于原理部分，笔者对这篇文章做一些简单地整理。

ADPCM(Adaptive Differential Pulse Code Modulation)自适应差分脉冲编码调制

ADPCM是DPCM的进阶版本，而DPCM是改良PCM而来的，我们先介绍PCM

PCM，脉冲编码调制，是声音模拟信号数字化的一种基础技术，本质上是将时间连续取值的模拟信号转换成离散的数字信号，即模数转换，事实上，“连续”这个词在机器上是非常难以实现的，现在大多数的“连续”，实际上都是快速且频繁的“离散”组成的，包括音频，视频等。过程就是采样，量化和编码。首先由硬件机器采样，将采样得到的信号幅度转换成数字（ADC）。PCM实际上就是一个大数组，数组中的每个值，代表了当前时间点上的模拟量强度。

在量化过程中会产生误差，一般而言，ADC的精度越高，失真越小，常见的量化数位8比特，16比特，32比特。

DPCM，差分脉冲编码调制，PCM是原始采样数据，即不对数据做压缩，保存的是最原始采样结果，这样的是数据量是比较大的，尤其在嵌入式设备中，硬件规格较低，在存储空间以及功耗方面都有比较严格的要求，传输PCM数据显然是不合适的。因此，我们需要对PCM数据进行压缩。

对音频数据归纳时可以看到，数据值与相邻的值通常相差不大，即过渡得比较平滑，不会忽高忽低，因此两点之间得差值不会太大，所以我们可以使用差值来表示下一个数据，而这个差值，可以用很少的位数(比如4比特)来进行表示，这样，如果PCM的量化位数位16比特时（一般会采用16比特），那么使用差分法将会把数据缩小成原来的1/4。

以8K的采样率为例，即1秒钟，机器采样8000次，量化精度为16比特，则1秒钟的数据量为 8000 * 16bit = 8000 * 2 byte = 128 000 bit = 128kb，如果用4bit表示差值，则1秒钟的数据仅需存储32kb左右的数据量。

DPCM存在一个问题，虽然音频数据大多数时候是比较平滑的，但是还是存在差值较大的情况，如果差值超过了4比特(-15,15)，就无法很好地还原原来的数据，这时候如果增大差值宽度，例如将4比特调整为6比特或8比特，可以减少此问题的发送概率，但同样地，数据量增大了。

ADPCM的出发点就是解决DPCM的差值宽度问题，通过采用一个差值表（IMA ADPCM中使用89个固定差值，取值从7到32767），将差值的范围放宽到16bit，此时差值在数组中的编号只需要6bit就可以表示（0，88），再进一步只记录编号的变化值，就将变化量压缩到4bit。

16bit的 IMA ADPCM 编码产生的数据为一个数组, 数组中每个数都是4个bit(值范围为0x00到0x0F), 因为C语言编程中变量的最小单位是byte, 所以通常表示为 uint8_t 数组, 数组中每个元素存储2个 ADPCM 编码值, 或者对于32位系统使用 uint32_t, 每个元素存储8个 ADPCM 编码值.

对于IMA ADPCM, 还需要了解两个码表, 一个是差值步长码表, 一个是差值步长下标变化量码表

差值步长码表: 下标从0到88, 共89个值, 从小到大, 非均匀分布, 下标越大, 值之间的间隔越大, 这个码表的具体计算方式不清楚, 通过多次项拟合需要至少4次方到5次方才能拟合。差值步长下标变化量码表: 下标从-7到7, ADPCM 队列中每个值可以通过这个直接查表得到下一个值的差值步长的下标变化量, 进而得到下一个值的差值步长. 值在 [-3, 3] 之间的, 变化都是-1, 也就是差值步长变小, 在[-4,-7]和[4,7]的, 变化是2,4,6,8, 可以看到对于-7和7, 差值步长会快速增大。

下面给出ADPCM解码和编码C程序

ADPCM解码代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97


#include <stdio.h>
#include "adpcm.h"

void adpcm_decoder(char indata[], short outdata[], int len, adpcm_state_t* state)
{

const static int indexTable[16] =
{
 -1, -1, -1, -1, 2, 4, 6, 8,
 -1, -1, -1, -1, 2, 4, 6, 8,
 };

const static int stepsizeTable[89] =
{
 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};
adpcm_state_t voice_adpcmState;

 signed char* inp;
 short* outp;
 int sign;
 int delta;
 int step;
 int valpred;
 int vpdiff;
 int index;
 int inputbuffer;
 int bufferstep;
 outp = outdata;
 inp = (signed char*)indata;
 valpred = state->valprev;
 index = state->index;
 step = stepsizeTable[index];
 bufferstep = 0;
 len *= 2;

 for ( ; len > 0 ; len-- )
 {

 if ( bufferstep )
 {
 delta = inputbuffer & 0xf;
 }
 else
 {
 inputbuffer = *inp++;
 delta = (inputbuffer >> 4) & 0xf;
 }

 bufferstep = !bufferstep;

 index += indexTable[delta];

 if ( index < 0 ) index = 0;

 if ( index > 88 ) index = 88;


 sign = delta & 8;
 delta = delta & 7;

 vpdiff = step >> 3;

 if ( delta & 4 ) vpdiff += step;

 if ( delta & 2 ) vpdiff += step>>1;

 if ( delta & 1 ) vpdiff += step>>2;

 if ( sign )
 valpred -= vpdiff;
 else
 valpred += vpdiff;


 if ( valpred > 32767 )
 valpred = 32767;
 else if ( valpred < -32768 )
 valpred = -32768;


 step = stepsizeTable[index];

 *outp++ = valpred;
 }

 state->valprev = valpred;
 state->index = index;
}

ADPCM编码代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119


#include "adpcm.h"
#include <stdio.h>

void adpcm_encoder(short indata[], char outdata[], int len, adpcm_state_t* state)
{

 const static int indexTable[16] =
 {
 -1, -1, -1, -1, 2, 4, 6, 8,
 -1, -1, -1, -1, 2, 4, 6, 8,
 };

 const static int stepsizeTable[89] =
 {
 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
 };
 adpcm_state_t voice_adpcmState;
 short* inp;
 signed char* outp;
 int val;
 int sign;
 int delta;
 int diff;
 int step;
 int valpred;
 int vpdiff;
 int index;
 int outputbuffer;
 int bufferstep;
 outp = (signed char*)outdata;
 inp = indata;
 valpred = state->valprev;
 index = state->index;
 step = stepsizeTable[index];
 bufferstep = 1;
 len /= 2;


 for ( ; len > 0 ; len-- )
 {
 val = *inp++;

 diff = val - valpred;
 sign = (diff < 0) ? 8 : 0;

 if ( sign ) diff = (-diff);

 delta = 0;
 vpdiff = (step >> 3);

 if ( diff >= step )
 {
 delta = 4;
 diff -= step;
 vpdiff += step;
 }

 step >>= 1;

 if ( diff >= step )
 {
 delta |= 2;
 diff -= step;
 vpdiff += step;
 }

 step >>= 1;

 if ( diff >= step )
 {
 delta |= 1;
 vpdiff += step;
 }

 if ( sign )
 valpred -= vpdiff;
 else
 valpred += vpdiff;

 if ( valpred > 32767 )
 valpred = 32767;
 else if ( valpred < -32768 )
 valpred = -32768;

 delta |= sign;
 index += indexTable[delta];

 if ( index < 0 ) index = 0;

 if ( index > 88 ) index = 88;

 step = stepsizeTable[index];

 if ( bufferstep )
 {
 outputbuffer = (delta << 4) & 0xf0;
 }
 else
 {
 *outp++ = (delta & 0x0f) | outputbuffer;
 }

 bufferstep = !bufferstep;
 }

 if ( !bufferstep )
 *outp++ = outputbuffer;

 state->valprev = valpred;
 state->index = index;
}

在代码中，已经把差分表以及步长表都放在了函数中

下面给出编码器与解码器共用的头文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#ifndef __ADPCM_H__
#define __ADPCM_H__

struct adpcm_state
{
 short valprev;
 char index;
};

typedef struct adpcm_state adpcm_state_t;
void adpcm_decoder(char [], short [], int, struct adpcm_state*);
void adpcm_encoder(short [], char [], int, struct adpcm_state*);

#endif

在这个头文件中，存放着一个结构体，adpcm_state，该结构体有两个变量，valprev表示预测值，index表示步长。

每次计算后，都会生成一个新的valprev和index，用以计算下一个值，因此，我们如果想要做一个编解码器，则必须向该程序中传递输入数组，adpcm_state以及数据长度。

上面是ADPCM的编码与解码算法，注意，上面的算法并不能直接构成一个可执行文件，因为没有main函数入口

因为我们的数据是通过python来进行读写的，因此我们要通过python将数据传入ADPCM编码器与解码器的入口，由入口对数据稍作处理，再传入ADPCM算法中进行运算，输出的结果由入口打印出来，打印的结果被python捕获并写入相应的文件中。

下面给出ADPCM编解码器的入口

AdpcmDecMain

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


#include<stdio.h>
#include<stdint.h>
#include<stdlib.h>
#include<errno.h>

#include "adpcm.h"
/******************************************************************
 ADPCM is a lossless data compression algorithm.
 it is used in video and audio compression.
 it is a type of adaptive differential pulse code modulation (ADPCM).
 ADPCM is a type of lossless data compression algorithm that uses a variable bit rate to encode audio or video data.
 in this example, adpcm has three five arguments: valprev, index, indata, outdata, len.
 len: the length of outdata which is the double of indata.But it is quadruple of data that was compress by adpcm,
 because the data type of indata is char(1 octet), the data type of outdata is short(2 octet).
 The compression ratio is 4:1
*/
int main(int argc, char *argv[])
{
 // 如果没有输入参数，则直接返回错误
 if(argc <= 1)
 {
 printf("No arguments provided\n");
 return 1;
 }
 errno = 0;
 // 获取参数，并将参数转换成十六进制，如果遇见非法参数，则返回错误
 char invalue[argc-1];
 for(int i = 1; i < argc; i++)
 {
 char * endptr;
 //argv[i]是字符串，需要转换成十六进制
 //endptr是一个指向char的指针，用于指向字符串的结尾
 //16 表示十六进制转换
 //strtol是一个标准库函数，用于将字符串转换成整数，他将返回一个long类型的值
 invalue[i-1] = (char)strtol(argv[i], &endptr, 16);
 if(*endptr != '\0' || endptr == argv[i] || errno == ERANGE)
 {
 printf("Invalid argument: %s\n", argv[i]);
 return 1;
 }
 }
 // 将参数中，index，prevalue和data的值提取出来
 // 定义变量
 char indata[argc-3];
 short valprex = 0;
 char index = 0;
 int len = argc-3; // 通过检查参数的长度来确定数据的长度
 // 提取data
 for(int i = 0; i<len; i++)
 {
 indata[i] = invalue[i+2];
 }

 // 提取valprex和index
 valprex = (short) invalue[0];
 index = invalue[1];
 adpcm_state_t voice_adpcmState;
 voice_adpcmState.valprev = valprex;
 voice_adpcmState.index = index;

 // 进行解码 outdata的长度冗余
 short outdata[276] = {0};
 adpcm_decoder(indata, outdata, len,&voice_adpcmState);
 // 循环打印结果，被python脚本捕获
 for(int i = 0; i < len * 2; i ++)
 {
 printf(" %04hx ",outdata[i]);
 }
 printf(" %04hx ",voice_adpcmState.valprev);
 printf(" %02x ",voice_adpcmState.index);
 return 0;
}

我们能以解码器入口为例来解释代码，编码器入口同理：

main函数接收参数，第一个参数无疑是函数名，第二个参数是valprev，第三个参数是index，第四个参数往后是待解码的数据。
解释一下strtol函数，argv[i]是输入参数，&endptr是一个指向char*的指针，它将在解析后指向第一个不属于数字部分的字符（如果整个字符串都是有效数字，它将指向字符串的末尾）。16是十六进制。
strtol函数会返回一个long类型的整数值，它是从字符串中解析出来的，如果字符串中包含无效字符，strtol将会在该字符串处停止解析，endptr将会指向该处。
outdata做了冗余处理，根据经验，一语音帧最大138个字节。len是传入的待解码的数据长度，如若供有20个字节的待解码数据，则len=20
有同学能猜出为什么循环打印outdata要乘以2吗？总结时会给出解释。
将outdata打印出来，被python脚本捕获，将valprev与index一起打印，被python脚本捕获，在下一轮数据来临时，带上valprev和index。
在这里敏锐的同学可能会注意到，我们在输入时，valprev和index参数是放在数据前面的，而在输出时，则是放在数据后面的，使用的同学需注意这一点，并没有什么特殊含义，只是笔者当初脚本先传的valprev和index，而编解码器后给出这两个值，笔者没改过来而已。
在此轮解码结束后，编码器将结束生命周期，此时内存将全部释放，valprev与index将会丢失，因此必须抛出给python脚本，以供下一次解码时使用

AdpcmEncMain

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71


#include<stdio.h>
#include<stdint.h>
#include<stdlib.h>
#include<errno.h>

#include "adpcm.h"
/******************************************************************
 ADPCM is a lossless data compression algorithm.
 it is used in video and audio compression.
 it is a type of adaptive differential pulse code modulation (ADPCM).
 ADPCM is a type of lossless data compression algorithm that uses a variable bit rate to encode audio or video data.
 in this example, adpcm has three five arguments: valprev, index, indata, outdata, len.
 len: the length of outdata which is the double of indata.But it is quadruple of data that was compress by adpcm,
 because the data type of indata is char(1 octet), the data type of outdata is short(2 octet).
 The compression ratio is 4:1
*/
int main(int argc, char *argv[])
{
 adpcm_state_t voice_adpcmState;
 short indata[argc-3];
 short valprex = 0;
 char index = 0;
 int len = (argc-3)*2;
 //如果没有输入参数，则直接返回错误
 if(argc <= 1)
 {
 printf("No arguments provided\n");
 return 1;
 }
 errno = 0;
 //获取参数，并将参数转换成十六进制，如果遇见非法参数，则返回错误
 for(int i = 1; i < argc; i++)
 {
 char * endptr;
 //argv[i]是字符串，需要转换成十六进制
 //endptr是一个指向char的指针，用于指向字符串的结尾
 //16 表示十六进制转换
 //strtol是一个标准库函数，用于将字符串转换成整数，他将返回一个long类型的值
 if( i == 1 )
 {
 valprex = (short)strtol(argv[i], &endptr, 16);
 }
 else if ( i == 2 )
 {
 index = (char)strtol(argv[i], &endptr, 16);
 }
 else
 {
 indata[i-3] = (short)strtol(argv[i], &endptr, 16);
 }
 if(*endptr != '\0' || endptr == argv[i] || errno == ERANGE)
 {
 printf("Invalid argument: %s\n", argv[i]);
 return 1;
 }
 }
 voice_adpcmState.valprev = valprex;
 voice_adpcmState.index = index;

 // 进行解码 outdata的长度冗余
 char outdata[276] = {0};
 adpcm_encoder(indata, outdata, len, &voice_adpcmState);
 // 循环打印结果，被python脚本捕获
 for(int i = 0; i < len / 4; i ++)
 {
 printf(" %02hhx ",(unsigned char)outdata[i]);
 }
 printf(" %04hx ",voice_adpcmState.valprev);
 printf(" %02x ",voice_adpcmState.index);
 return 0;
}

编码器入口与解码器入口大差不差，大家仔细阅读即可

编译

在本文中可以看到，我们采用了一个头文件，一个c文件存放编码算法，一个c文件存放程序入口这种形式来组织代码，这样的好处是方便整理代码，可读性更高，但同时呢，无法直接运行，因为编码算法的c文件与程序入口的c文件并没有链接到一起，因此程序入口无法找到adpcm_encoder和adpcm_decoder的函数实现，我们需要使用GCC命令来对文件进行手动编译。命令如下：

1

gcc AdpcmDecMain.c AdpcmDec.c -o AdpcmDecoder

这条命令的作用是：

将AdpcmDecMain.c文件与AdpcmDec.c文件编译并链接在一起，生成一个名为AdpcmDecoder.exe的可执行文件

总结

这篇文章总的来说笔者不是很满意，因为并没有仔细解释ADPCM的原理，笔者认为ADPCM(自适应差分脉冲编码调制)的原理和计算_单片机使用adpcm音频编解码算法-CSDN博客这篇文章已经给出的非常详细，笔者解释只是锦上添花，而笔者也没有想到更好的理解方法，如果笔者后续对这些音频算法有更深的理解时，笔者会做出整理。

现在给出上面的问题的解释，为什么循环打印outdata要乘以2，这是因为，我们解码前的数据存储的是前一个数据与后一个数据的差分，仅用4bit存储，而解码后的单个PCM数据就有16bit，但在C语言中，最小存储单位为uint8_t，即8个比特，在本程序中，解码前的数据用char存储，也是8个比特，也就是说，一个indata能存储两个差分数据，即两个解码前的数据，outdata数组的数据类型是short即16个比特，一个解码的indata，解码后需要两个outdata来存储才行，这样，outdata的长度就是indata的2倍

为什么编码器的循环要除以4呢，同理，ADPCM的压缩比为4：1，至于为什么是4倍而不是两倍，主要是因为编码器的len是输入参数的两倍，这与解码器不同，与adpcm算法内部的len有关。

python脚本将在下一篇文章中展现，本文到这里就结束啦，祝大家变得更强！

因为语音编解码器功能模块的实现较为复杂，而且也增加了一些新的UI设计，因此知识点与代码都无法在一篇文章中全部呈现，但将代码分散在不同的文章里又让一些基础比较薄弱的同学难以快速上手，因此，如若对此模块感兴趣的人比较多，笔者将在这三篇文章的基础上，单独开一篇新的博文，梳理代码的布局以及如何在自己的机器上跑起来，让新手小白也能复制即用。

音频编解码 on 苏三有春的博客

如何在Windows中使用opuslib库

前言

你是否需要opuslib

下载opuslib

opuslib使用异常

下载opus.dll

配置opus动态库

小结

pyinstaller无法打包第三方库

Opus解码器样例

PyAudio库基本知识详解

前言

前置知识

PyAudio

PyAudio的常见用途

安装 PyAudio

PyAudio的核心概念

主要功能

PyAudio的应用场景

PyAudio与其他音频库对比

注意事项

小结

stop_stream与start_stream

1. stream.start_stream() 的作用

2. stream.stop_stream() 的作用

为什么 start_stream() 有时没被显式调用

小结

谁开启的麦克风或扬声器

调用麦克风硬件的关键步骤：

总结：

ADPCM编解码器的实现

前言

ADPCM算法原理

ADPCM(Adaptive Differential Pulse Code Modulation)自适应差分脉冲编码调制

ADPCM解码代码

ADPCM编码代码

AdpcmDecMain

AdpcmEncMain

编译

总结

为什么 `start_stream()` 有时没被显式调用