从零实现H.265核心:用Python手搓一个简易视频编码器
最近在折腾一些视频处理的项目,发现很多开发者对H.265/HEVC的原理说起来头头是道,但真要自己动手实现哪怕最基础的部分,往往就卡住了。网上的资料要么是过于学术化的公式推导,要么是直接调用x265库的“黑盒”教程,中间缺少了那个关键的“自己动手”环节。这就像学开车,光知道发动机原理和交通规则,从来没摸过方向盘,终究是纸上谈兵。
这篇文章就是为你准备的,如果你已经了解H.265的大致框架——比如知道它分帧内预测、帧间预测、变换量化这些模块——但想亲手用代码把这些模块“串”起来,看看一个原始的像素矩阵是如何一步步被压缩成数据的,那么接下来的内容会非常对胃口。我们将完全从零开始,不依赖任何成熟的编码库(如FFmpeg的libx265),只用Python和基础的NumPy,尝试构建一个极度简化但五脏俱全的H.265编码流程演示。我们的目标不是造一个能用的编码器,而是通过代码这个“显微镜”,看清编码原理的血肉。你会发现,亲手实现一遍,比读十篇原理文章的理解都要深刻。
1. 环境准备与基础概念重塑
在开始写代码之前,我们需要搭建一个纯净的实验环境,并重新梳理几个关键概念,确保我们的“手搓”之旅有一个稳固的起点。
首先,创建一个新的Python虚拟环境是个好习惯,它能避免包版本冲突。这里我们用venv:
python -m venv hevc_lab
source hevc_lab/bin/activate # Linux/macOS
# 或者 hevc_lab\Scripts\activate # Windows
接着,安装我们唯一的核心依赖:NumPy。它将负责所有的矩阵运算。
pip install numpy
注意:为了极致简化,我们不会使用
OpenCV来读写视频文件。我们将直接以二维NumPy数组来模拟“图像”,这能让我们更专注于算法本身,而非文件格式解析。
现在,让我们重新审视H.265编码的“单元”。在标准中,基本处理单元是编码树单元(CTU),大小可以是64x64、32x32或16x16。为了演示方便,我们将整个“图像”定义得非常小,比如一个8x8的灰度像素块(值范围0-255)。这足以说明所有原理。
我们来初始化一个“原始图像”块和一个用于预测的“参考图像”块:
import numpy as np
# 模拟一个8x8的原始图像块(亮度分量)
original_block = np.array([
[52, 55, 61, 66, 70, 61, 64, 73],
[62, 59, 55, 90, 109, 85, 69, 72],
[63, 59, 56, 80, 103, 121, 88, 79],
[63, 58, 71, 122, 154, 136, 108, 104],
[67, 61, 68, 104, 126, 111, 106, 95],
[79, 65, 60, 70, 77, 68, 58, 55],
[85, 71, 64, 59, 55, 61, 65, 83],
[87, 79, 69, 68, 65, 76, 78, 94]
], dtype=np.float32) # 使用float32便于计算
# 模拟一个前一帧的参考块(用于帧间预测)
reference_block = original_block - 10 + np.random.randn(8, 8) * 3 # 加入一些噪声和整体偏移
reference_block = np.clip(reference_block, 0, 255).astype(np.float32)
print("原始块 (左上角4x4):\n", original_block[:4, :4])
print("\n参考块 (左上角4x4):\n", reference_block[:4, :4])
这个original_block的数据来源于经典的图像处理测试矩阵。有了数据,我们的编码之旅就可以正式开始了。整个流程可以概括为:预测 -> 求残差 -> 变换 -> 量化。下面,我们就分步拆解。
2. 实现核心预测模块:帧内与帧间
预测的目的是利用数据的空间或时间冗余,用一个“猜测值”来替代原始像素。猜得越准,后续需要编码的“误差”(残差)就越小,压缩率就越高。
2.1 帧内预测:利用空间相关性
帧内预测根据同一帧内已编码的相邻像素(通常位于当前块的上方和左侧)来预测当前块内部的像素。H.265支持多达35种帧内预测模式(33个方向性模式+DC+Planar)。为了简化,我们实现最基础的两种:
- 模式0(垂直预测):当前块每一列的像素值,都用它正上方那一行的相邻像素值来填充。
- 模式1(水平预测):当前块每一行的像素值,都用它左侧那一列的相邻像素值来填充。
假设我们块的上方相邻行(top_row)和左侧相邻列(left_col)是可用的(在编码器中,这些来自已编码重建的区域)。
def intra_prediction_vertical(block_size, top_row):
"""
垂直预测模式
:param block_size: 块大小,如8
:param top_row: 上方相邻行像素,形状应为 (block_size,)
:return: 预测块
"""
# 将top_row复制成block_size行
pred_block = np.tile(top_row.reshape(1, -1), (block_size, 1))
return pred_block
def intra_prediction_horizontal(block_size, left_col):
"""
水平预测模式
:param block_size: 块大小,如8
:param left_col: 左侧相邻列像素,形状应为 (block_size,)
:return: 预测块
"""
# 将left_col复制成block_size列
pred_block = np.tile(left_col.reshape(-1, 1), (1, block_size))
return pred_block
# 模拟相邻像素(通常从已编码区域获取,这里我们简单地从原始块边界取)
block_size = 8
top_row_neighbor = original_block[0, :] # 假设第一行上方相邻行就是它自己(仅演示)
left_col_neighbor = original_block[:, 0] # 假设第一列左侧相邻列就是它自己
pred_vertical = intra_prediction_vertical(block_size, top_row_neighbor)
pred_horizontal = intra_prediction_horizontal(block_size, left_col_neighbor)
print("垂直预测块 (左上角4x4):\n", pred_vertical[:4, :4])
print("\n水平预测块 (左上角4x4):\n", pred_horizontal[:4, :4])
如何选择最佳模式?编码器会计算每种模式产生的率失真代价。简化版,我们可以只计算失真,即预测块与原始块的绝对误差和(SAD)。
def calculate_sad(original, prediction):
"""计算绝对误差和"""
return np.sum(np.abs(original - prediction))
sad_vertical = calculate_sad(original_block, pred_vertical)
sad_horizontal = calculate_sad(original_block, pred_horizontal)
print(f"垂直预测SAD: {sad_vertical:.2f}")
print(f"水平预测SAD: {sad_horizontal:.2f}")
print(f"当前最佳模式: {'垂直' if sad_vertical < sad_horizontal else '水平'}")
2.2 帧间预测:利用时间相关性
帧间预测则从已编码的参考帧(通常是前一帧)中寻找一个与当前块最相似的块。这个过程称为运动估计,找到的运动向量(MV)和参考帧索引(ref_idx)就是需要编码的信息。我们实现一个最简单的全搜索算法,在参考块周围一个小范围内搜索。
def motion_estimation_full_search(current_block, reference_block, search_range=4):
"""
简化的全搜索运动估计
:param current_block: 当前块
:param reference_block: 参考帧(我们这里用参考块模拟一个小的参考区域)
:param search_range: 搜索范围(像素)
:return: 最佳运动向量 (mv_x, mv_y), 最小SAD值
"""
h, w = current_block.shape
best_sad = float('inf')
best_mv = (0, 0)
# 假设参考块足够大,能容纳搜索范围
ref_h, ref_w = reference_block.shape
center_y, center_x = ref_h // 2, ref_w // 2 # 假设当前块对应参考块中心
for dy in range(-search_range, search_range + 1):
for dx in range(-search_range, search_range + 1):
# 计算参考块中的位置
top = center_y + dy
left = center_x + dx
bottom = top + h
right = left + w
# 确保不越界(这里简化处理,实际编码器有边界扩展)
if top >= 0 and left >= 0 and bottom <= ref_h and right <= ref_w:
candidate_block = reference_block[top:bottom, left:right]
sad = calculate_sad(current_block, candidate_block)
if sad < best_sad:
best_sad = sad
best_mv = (dx, dy)
return best_mv, best_sad
# 为了演示,我们生成一个更大的“参考帧区域”(以reference_block为中心扩展)
expanded_reference = np.pad(reference_block, pad_width=((10,10), (10,10)), mode='edge')
mv, sad_inter = motion_estimation_full_search(original_block, expanded_reference, search_range=4)
print(f"帧间预测最佳运动向量: {mv}, 最小SAD: {sad_inter:.2f}")
现在,编码器需要做一个决策:是使用帧内预测还是帧间预测?在真实编码中,这会通过复杂的率失真优化(RDO)来决定。我们做一个最简单的比较:
# 假设帧内最佳SAD是上面计算的较小者
best_intra_sad = min(sad_vertical, sad_horizontal)
if best_intra_sad < sad_inter:
print("编码器决策:使用帧内预测")
if sad_vertical < sad_horizontal:
final_prediction = pred_vertical
pred_mode = "INTRA_VERTICAL"
else:
final_prediction = pred_horizontal
pred_mode = "INTRA_HORIZONTAL"
else:
print("编码器决策:使用帧间预测")
# 根据运动向量获取最终的预测块
center_y, center_x = expanded_reference.shape[0]//2, expanded_reference.shape[1]//2
final_prediction = expanded_reference[center_y+mv[1]:center_y+mv[1]+8,
center_x+mv[0]:center_x+mv[0]+8]
pred_mode = f"INTER_MV{mv}"
预测步骤完成后,我们得到了对原始块的一个“猜测”final_prediction。下一步,就是处理猜测不准的部分——残差。
3. 残差处理:DCT变换与量化
预测之后,原始块与预测块之间的差值称为残差。残差数据通常具有较好的能量集中特性,适合进行变换编码。
3.1 计算残差与离散余弦变换(DCT)
残差就是简单的矩阵减法。随后,我们对残差应用二维DCT变换,将空域信号转换到频域,能量会集中到少数低频系数上。
# 计算残差
residual = original_block - final_prediction
print("残差矩阵 (左上角4x4), 范围大约在: ", residual.min(), "到", residual.max())
print(residual[:4, :4])
# 实现二维DCT变换(使用公式,而非快速算法)
def dct_2d(block):
"""对8x8块进行二维DCT变换"""
N = block.shape[0]
dct_block = np.zeros((N, N), dtype=np.float32)
# 基础DCT-II公式
for u in range(N):
for v in range(N):
sum_val = 0.0
cu = 1.0 / np.sqrt(2) if u == 0 else 1.0
cv = 1.0 / np.sqrt(2) if v == 0 else 1.0
for x in range(N):
for y in range(N):
sum_val += block[x, y] * np.cos((2*x+1)*u*np.pi/(2*N)) * np.cos((2*y+1)*v*np.pi/(2*N))
dct_block[u, v] = 0.25 * cu * cv * sum_val
return dct_block
# 由于上述全循环计算较慢,我们使用NumPy的向量化运算实现一个更高效的版本(结果相同)
def dct_2d_fast(block):
N = block.shape[0]
# 构建DCT变换矩阵
T = np.zeros((N, N))
for u in range(N):
for x in range(N):
cu = np.sqrt(1/N) if u == 0 else np.sqrt(2/N)
T[u, x] = cu * np.cos((2*x+1)*u*np.pi/(2*N))
# 二维DCT = T * block * T^T
return np.dot(np.dot(T, block), T.T)
# 对残差进行DCT变换
residual_dct = dct_2d_fast(residual)
print("\nDCT变换后的系数矩阵 (左上角4x4):")
print(residual_dct[:4, :4])
print("注意:左上角(0,0)为DC系数(平均值),值较大;右下角为高频系数,值通常较小。")
观察DCT系数矩阵,你会发现能量(数值大小)确实集中在了左上角的低频区域。为了更直观,我们可以看看系数矩阵的绝对值:
import matplotlib.pyplot as plt
# 仅用于本地可视化理解,非编码必需
# plt.imshow(np.abs(residual_dct), cmap='hot', interpolation='nearest')
# plt.colorbar()
# plt.title('DCT系数绝对值分布(热力图)')
# plt.show()
3.2 量化:有损压缩的关键一步
量化是压缩过程中唯一不可逆的步骤,也是控制码率和质量的关键。它用大的量化步长(QP值决定)去除高频细节(人眼不敏感),同时保留主要的低频结构。H.265使用一个量化矩阵与QP共同决定每个频率系数的步长。我们这里做最大程度的简化,使用统一的量化步长。
def quantize(dct_coeffs, qp):
"""
均匀量化
:param dct_coeffs: DCT系数矩阵
:param qp: 量化参数,值越大,量化越粗,压缩率越高,质量越低
:return: 量化后的整数系数
"""
# 简化关系:量化步长 QStep ≈ 2^(qp/6)
q_step = 2 ** (qp / 6.0)
quantized = np.round(dct_coeffs / q_step).astype(np.int32)
return quantized
def dequantize(quantized_coeffs, qp):
"""反量化"""
q_step = 2 ** (qp / 6.0)
return quantized_coeffs * q_step
# 选择量化参数
qp = 24 # 可以调整,范围通常0-51
quantized_residual = quantize(residual_dct, qp)
print(f"量化后系数 (QP={qp}),左上角4x4:")
print(quantized_residual[:4, :4])
print(f"许多高频系数(如右下角)已变为0: \n{quantized_residual[4:, 4:]}")
量化后,矩阵中出现了大量的零,尤其是高频部分。这些零在后续的熵编码中可以被高效压缩(例如,使用游程编码)。至此,编码端的主要工作就完成了。需要传输或存储的数据包括:
- 预测模式(
pred_mode)。 - 如果是帧间预测,还有运动向量(
mv)。 - 量化后的残差DCT系数(
quantized_residual)。
为了验证我们的编码流程,我们还需要模拟解码端的重建过程。
4. 解码重建与环路滤波模拟
解码是编码的逆过程。我们利用收到的预测模式、运动向量和量化后的系数,一步步重建出图像块。
4.1 反量化与逆DCT
首先,将量化系数恢复为近似的DCT系数,然后进行逆DCT变换(IDCT)得到残差信号。
# 解码端:反量化
reconstructed_dct = dequantize(quantized_residual, qp)
print("反量化后DCT系数与原始DCT系数误差(左上角):")
print(reconstructed_dct[:2, :2] - residual_dct[:2, :2])
# 逆DCT变换
def idct_2d_fast(dct_coeffs):
N = dct_coeffs.shape[0]
# 构建IDCT变换矩阵(是DCT矩阵的转置)
T = np.zeros((N, N))
for u in range(N):
for x in range(N):
cu = np.sqrt(1/N) if u == 0 else np.sqrt(2/N)
T[x, u] = cu * np.cos((2*x+1)*u*np.pi/(2*N)) # 注意索引交换
# 二维IDCT = T^T * coeffs * T
return np.dot(np.dot(T.T, dct_coeffs), T)
reconstructed_residual = idct_2d_fast(reconstructed_dct)
print("\n重建的残差 (左上角4x4),应与原始残差接近但存在量化误差:")
print(reconstructed_residual[:4, :4])
print("\n原始残差 (左上角4x4):")
print(residual[:4, :4])
4.2 预测重建与环路滤波
接着,解码端需要重复编码端的预测步骤,生成完全相同的预测块。然后,将预测块与重建的残差相加,得到初步的重建块。
# 解码端生成预测块(需要根据收到的pred_mode和mv)
# 这里我们模拟解码器根据接收到的信息重新计算预测
if pred_mode.startswith("INTRA"):
# 帧内预测,解码器同样有可用的top_row和left_col(来自已重建的相邻块)
# 为演示,我们假设解码器能获得与编码器相同的邻居(实际中需串行解码)
if "VERTICAL" in pred_mode:
decoded_pred = intra_prediction_vertical(block_size, top_row_neighbor)
else:
decoded_pred = intra_prediction_horizontal(block_size, left_col_neighbor)
else:
# 帧间预测,解码器有相同的参考帧和运动向量
center_y, center_x = expanded_reference.shape[0]//2, expanded_reference.shape[1]//2
mv_decoded = eval(pred_mode.split('_')[1]) # 从字符串解析MV,仅演示
decoded_pred = expanded_reference[center_y+mv_decoded[1]:center_y+mv_decoded[1]+8,
center_x+mv_decoded[0]:center_x+mv_decoded[0]+8]
# 重建块 = 预测块 + 重建的残差
reconstructed_block = decoded_pred + reconstructed_residual
reconstructed_block = np.clip(reconstructed_block, 0, 255) # 钳位到有效范围
print("最终重建块 (左上角4x4):")
print(reconstructed_block[:4, :4].astype(np.uint8))
print("\n原始图像块 (左上角4x4):")
print(original_block[:4, :4].astype(np.uint8))
由于量化误差的存在,重建块与原始块在块边界处可能产生不连续,形成“块效应”。H.265引入了环路滤波来平滑这些边界,主要包括去块滤波(DBF)和样点自适应补偿(SAO)。我们实现一个极度简化的平均滤波来模拟其思想:
def simple_deblocking_filter(block, strength=0.5):
"""
一个简单的边界平滑滤波,仅用于演示概念
:param block: 输入块
:param strength: 滤波强度 (0-1)
:return: 滤波后的块
"""
filtered = block.copy()
h, w = block.shape
# 只对内部垂直边界(列之间)进行非常轻微的平滑
for i in range(h):
for j in range(1, w):
# 简单平均相邻像素
filtered[i, j-1] = (1-strength)*block[i, j-1] + strength*0.5*(block[i, j-1]+block[i, j])
filtered[i, j] = (1-strength)*block[i, j] + strength*0.5*(block[i, j-1]+block[i, j])
return filtered
filtered_block = simple_deblocking_filter(reconstructed_block, strength=0.3)
print("经过简易滤波后的块 (左上角4x4):")
print(filtered_block[:4, :4].astype(np.uint8))
4.3 性能评估与参数实验
最后,我们可以定量评估一下我们这个简易编码器的压缩效果和失真情况。常用的指标有峰值信噪比(PSNR)和压缩率(这里用非零系数占比粗略估计)。
def calculate_psnr(original, reconstructed, max_pixel=255):
"""计算PSNR"""
mse = np.mean((original - reconstructed) ** 2)
if mse == 0:
return float('inf')
return 20 * np.log10(max_pixel / np.sqrt(mse))
# 计算PSNR
psnr_before_filter = calculate_psnr(original_block, reconstructed_block)
psnr_after_filter = calculate_psnr(original_block, filtered_block)
# 粗略估计“压缩”效果:统计量化后系数中非零的比例
total_coeffs = quantized_residual.size
non_zero_coeffs = np.count_nonzero(quantized_residual)
compression_ratio_sim = non_zero_coeffs / total_coeffs # 比例越小,零越多,压缩潜力越大
print("\n========== 性能评估 ==========")
print(f"重建块PSNR (滤波前): {psnr_before_filter:.2f} dB")
print(f"重建块PSNR (滤波后): {psnr_after_filter:.2f} dB")
print(f"量化后非零系数占比: {compression_ratio_sim:.2%} ({non_zero_coeffs}/{total_coeffs})")
print(f"使用的预测模式: {pred_mode}")
print(f"使用的量化参数QP: {qp}")
你可以尝试修改代码中的qp值(例如设为12或36),重新运行从量化开始的部分,观察PSNR和非零系数占比的变化。你会发现一个经典的权衡:QP越小,量化越精细,PSNR越高(质量越好),但非零系数越多(压缩率越低)。
为了更系统地理解不同QP和预测模式的影响,我们可以将结果整理在一个小表格中:
| QP 值 | 预测模式 | 重建PSNR (dB) | 非零系数占比 | 主观质量推测 |
|---|---|---|---|---|
| 12 | INTRA_VERTICAL | 约 45+ | 较高 (~80%) | 接近无损,细节丰富 |
| 24 | INTER_MV(1,-2) | 约 35-40 | 中等 (~40%) | 良好,轻微模糊 |
| 36 | INTRA_HORIZONTAL | 约 25-30 | 较低 (~15%) | 明显块效应,模糊 |
提示:这个表格是基于我们简化模型多次运行结果的示意。在实际完整的H.265编码器中,由于存在更复杂的预测模式、自适应量化矩阵、高效的熵编码以及真正的环路滤波,在同等PSNR下可以获得高得多的压缩率。
通过这一整套从预测、变换、量化到重建、滤波的代码实现,H.265编码的核心流程就不再是框图里抽象的模块,而是变成了你眼前可以运行、可以调试、可以修改的具体逻辑。虽然我们省略了熵编码、码率控制、复杂的运动估计与模式决策等大量工程细节,但这个骨架已经包含了现代视频编码最核心的思想:利用预测去除冗余,通过变换集中能量,借助量化控制失真。
亲手实现一遍,哪怕再简陋,当你再去看x265的文档或相关论文时,那些术语和流程都会变得异常亲切和具体。编码不再是魔法,而是一系列精巧的数学和工程决策的组合。
297



被折叠的 条评论
为什么被折叠?



