什么是 STAP-A？
STAP-A 是一种特殊的 RTP 封装机制，专为 H.264 和 H.265 这类视频编码协议设计。它的核心目的只有一个：将多个小的 NALU（网络抽象层单元）打包进一个 RTP 包中，以此来减少网络开销，提高传输效率。
简单来说，STAP-A 就像一个大信封，可以把多封小信件（小的 NALU）装在一起，然后只贴一张邮票（一个 RTP 头部）寄出去。这比一封信贴一张邮票要划算得多。
在 RTSP、RTSP over HTTP、SRT 等基于 RTP 的流媒体协议中，STAP-A 的作用至关重要，尤其是在传输分辨率高、需要频繁发送参数集的视频流时。
为什么需要 STAP-A？
在视频编码的世界里，除了包含实际图像数据的视频帧（如 IDR、I、P、B 帧），还有许多用于描述编码参数的 NALU。这些参数通常非常小，比如：
VPS（Video Parameter Set）：视频参数集，描述多个序列的共享参数，特别是分层编码结构。
SPS (Sequence Parameter Set)：序列参数集，描述全局信息如分辨率、帧率、码流级别。
PPS (Picture Parameter Set)：图像参数集，描述单帧或多帧的共享参数。
AUD (Access Unit Delimiter)：访问单元分隔符，标记一帧的开始。
SEI (Supplemental Enhancement Information)：补充增强信息，包含时序等辅助数据。
这些 NALU 有时只有几十字节。如果不使用 STAP-A，每个 NALU 都需要独立封装。一个 RTP 包至少有 12 字节的 RTP 头部，加上 UDP/IP 头部，总开销通常超过 40 字节。对于一个 50 字节的 NALU 来说，协议开销甚至比数据本身还要大。
STAP-A 的出现完美解决了这个问题。它将这些小 NALU 聚合起来，只需一个 RTP 头部，就能传输多个 NALU，显著降低了协议开销（Protocol Overhead），从而节省了带宽。
STAP-A 的封装结构
一个使用 STAP-A 封装的 RTP 包，其负载（Payload）结构如下：
- RTP 头部：标准的 12 字节 RTP 头部，包含序列号、时间戳等信息。
- STAP-A 指示器：一个 1 字节的特殊头部，用于标识这是一个聚合包。
- 对于 H.264，其类型（Type）字段值为 24。
- 对于 H.265，其类型（Type）字段值为 48。
- 聚合 NALU 负载：由一个或多个 NALU 组成。特别的是，每个 NALU 在被放入负载之前，都会先加上一个 2 字节的大小字段。
下面是其结构示意图：
+-----------------------------------+
| RTP Header |
+-----------------------------------+
| STAP-A Indicator | <- H.264: Type 24 / H.265: Type 48
+-------------------+---------------+
| NALU 1 Size | (2 bytes) |
+-------------------+---------------+
| NALU 1 Data |
+-------------------+---------------+
| NALU 2 Size | (2 bytes) |
+-------------------+---------------+
| NALU 2 Data |
+-------------------+---------------+
| ... and so on ... |
+-------------------+---------------+
STAP-A 的工作原理
当一个视频流被编码后，视频发送端会有一个 RTP 封装模块。这个模块会缓冲所有新生成的 NALU。它会根据 NALU 的大小和类型，决定如何封装：
- 聚合判断：如果队列里有多个小的、非视频帧 NALU（如 SPS、PPS），并且将它们打包后总大小不超过 MTU（通常为 1500 字节），那么模块就会选择 STAP-A 模式。
- 构建负载：
- 首先，创建一个新的 RTP 包，并写入标准的 RTP 头部。
- 其次，写入 STAP-A 指示器（类型为 24 或 48）。
- 然后，对于每个要聚合的 NALU：
- 将该 NALU 的大小（2 字节，大端字节序）写入负载。
- 将该 NALU 的完整数据写入负载。
- 发送：当所有 NALU 都被封装进一个 RTP 包后，该包通过网络发送给接收端。
接收端的解析流程
接收端收到一个 RTP 包后，首先会解析其 RTP 头部。然后，它会检查负载的第一个字节来确定封装类型：
- 识别类型：如果负载的第一个字节（去除
F和NRI位）是 24 或 48，接收端就知道这是一个 STAP-A 包。 - 逐个解包：
- 接收端进入一个循环，从负载的第二个字节开始。
- 读取接下来的 2 个字节，得到第一个 NALU 的大小
L。 - 读取接下来的
L个字节，得到第一个完整的 NALU 数据。 - 重复上述步骤，直到 RTP 包的负载数据被全部读取完毕。
- 处理 NALU：接收端会将解包出的每个完整的 NALU 分发给相应的处理模块，例如将 SPS 和 PPS 送给解码器进行初始化。
STAP-A 的重要性与应用场景
STAP-A 是高效流媒体传输的关键，其应用场景主要有：
- 会话启动：在建立 RTSP/RTMP/SRT 等会话时，服务器通常会用 STAP-A 将 SPS 和 PPS 打包发送给客户端。这确保了客户端可以在第一时间获取所有必要的解码参数，无需等待数据流中的关键帧。
- 参数更新：如果编码参数在流媒体过程中发生变化（比如分辨率或帧率改变），新的 SPS/PPS 会被打包进 STAP-A 包中发送。
- 低开销数据传输：任何小的、零散的 NALU（如 AUD、SEI）都可以通过 STAP-A 封装，从而最大化网络利用率。
STAP-A 与 FU-A 的关系
STAP-A 和 FU-A 是两种互补而非竞争的机制。
- STAP-A 用于将多个小 NALU 聚合在一起，其目的是节省开销。
- FU-A 用于将一个大 NALU 分片成小块，其目的是适应 MTU 限制。
在实践中，一个完整的 RTP 视频流通常会同时使用这三种封装模式：
- 单 NALU 模式：传输大多数普通的视频帧（如 P/B 帧）。
- STAP-A 模式：传输 SPS/PPS 等参数集。
- FU-A 模式：传输大的关键帧（如 I/IDR 帧）。
STAP-A封包和解包示例
#include <iostream>
#include <vector>
#include <numeric>
#include <cstdint>
#include <stdexcept>
// 模拟 RTP 数据包的有效载荷
// 在实际应用中，这部分数据将跟在 RTP 头部之后
using RtpPayload = std::vector<uint8_t>;
// 模拟 NALU 列表
using NalUnitList = std::vector<std::vector<uint8_t>>;
// STAP-A H.264/H.265 类型值
#define H264_STAP_A_TYPE 24
#define H265_STAP_A_TYPE 48
class StapAPacker {
public:
// H.264 封装: 将多个 H.264 NALU 聚合为一个 STAP-A 负载
RtpPayload pack_h264_nalus(const NalUnitList& nalus) {
if (nalus.empty()) {
return RtpPayload();
}
RtpPayload payload;
// 1. 写入 STAP-A 指示器 (H.264: 类型 24)
// 这里的 RefIdc 位可以根据第一个 NALU 的 RefIdc 来设置
uint8_t stap_a_indicator = (nalus[0][0] & 0x60) | H264_STAP_A_TYPE;
payload.push_back(stap_a_indicator);
// 2. 写入每个 NALU 的大小和数据
for (const auto& nalu : nalus) {
// NALU 大小 (2 字节, 大端字节序)
uint16_t nalu_size = nalu.size();
payload.push_back(static_cast<uint8_t>((nalu_size >> 8) & 0xFF));
payload.push_back(static_cast<uint8_t>(nalu_size & 0xFF));
// NALU 数据
payload.insert(payload.end(), nalu.begin(), nalu.end());
}
return payload;
}
// H.265 封装: 将多个 H.265 NALU 聚合为一个 STAP-A 负载
RtpPayload pack_h265_nalus(const NalUnitList& nalus) {
if (nalus.empty()) {
return RtpPayload();
}
RtpPayload payload;
// 1. 写入 STAP-A 指示器 (H.265: 类型 48)
// 使用第一个 NALU 的 2 字节头部的 forbidden_zero_bit, layer_id, temporal_id 等
uint8_t stap_a_indicator_byte0 = (nalus[0][0] & 0x81) | (H265_STAP_A_TYPE << 1);
uint8_t stap_a_indicator_byte1 = nalus[0][1];
payload.push_back(stap_a_indicator_byte0);
payload.push_back(stap_a_indicator_byte1);
// 2. 写入每个 NALU 的大小和数据
for (const auto& nalu : nalus) {
// NALU 大小 (2 字节, 大端字节序)
uint16_t nalu_size = nalu.size();
payload.push_back(static_cast<uint8_t>((nalu_size >> 8) & 0xFF));
payload.push_back(static_cast<uint8_t>(nalu_size & 0xFF));
// NALU 数据
payload.insert(payload.end(), nalu.begin(), nalu.end());
}
return payload;
}
// 解包: 从一个 STAP-A 负载中分离出所有 NALU
NalUnitList unpack_stap_a(const RtpPayload& payload, bool is_h264) {
NalUnitList nalus;
size_t offset = 0;
if (payload.empty()) {
throw std::runtime_error("Payload is empty.");
}
// 1. 读取并验证 STAP-A 指示器
if (is_h264) {
uint8_t type = payload[0] & 0x1F;
if (type != H264_STAP_A_TYPE) {
throw std::runtime_error("Not a H.264 STAP-A packet.");
}
offset = 1;
} else { // H.265
uint8_t type = (payload[0] >> 1) & 0x3F;
if (type != H265_STAP_A_TYPE) {
throw std::runtime_error("Not a H.265 STAP-A packet.");
}
offset = 2; // H.265 STAP-A 头部是 2 字节
}
// 2. 循环读取每个 NALU
while (offset < payload.size()) {
// 检查剩余数据是否足够读取 NALU 大小字段
if (offset + 2 > payload.size()) {
throw std::runtime_error("Truncated STAP-A packet: missing NALU size.");
}
// 读取 NALU 大小
uint16_t nalu_size = (payload[offset] << 8) | payload[offset + 1];
offset += 2;
// 检查剩余数据是否足够读取整个 NALU
if (offset + nalu_size > payload.size()) {
throw std::runtime_error("Truncated STAP-A packet: NALU data incomplete.");
}
// 读取 NALU 数据
std::vector<uint8_t> nalu(payload.begin() + offset, payload.begin() + offset + nalu_size);
nalus.push_back(nalu);
offset += nalu_size;
}
return nalus;
}
};
void print_nalu_info(const std::vector<uint8_t>& nalu, bool is_h264) {
if (nalu.empty()) return;
uint8_t type = 0;
if (is_h264) {
type = nalu[0] & 0x1F;
std::cout << " - H.264 NALU, Type: " << (int)type << ", Size: " << nalu.size() << " bytes." << std::endl;
} else {
type = (nalu[0] >> 1) & 0x3F;
std::cout << " - H.265 NALU, Type: " << (int)type << ", Size: " << nalu.size() << " bytes." << std::endl;
}
}
int main() {
StapAPacker packer;
// --- 1. 模拟 H.264 NALU 聚合 ---
std::cout << "--- H.264 STAP-A Aggregation Example ---" << std::endl;
// 模拟 SPS (类型 7) 和 PPS (类型 8)
NalUnitList h264_nalus_to_pack;
std::vector<uint8_t> h264_sps = {0x67, 0x00, 0x40, 0x0a}; // 示例 SPS
std::vector<uint8_t> h264_pps = {0x68, 0xee, 0x01, 0x32}; // 示例 PPS
h264_nalus_to_pack.push_back(h264_sps);
h264_nalus_to_pack.push_back(h264_pps);
RtpPayload h264_stap_a_payload = packer.pack_h264_nalus(h264_nalus_to_pack);
std::cout << "H.264 Payload created, total size: " << h264_stap_a_payload.size() << " bytes." << std::endl;
// --- 2. 模拟 H.264 解包 ---
std::cout << "\n--- H.264 STAP-A Unpacking Example ---" << std::endl;
try {
NalUnitList unpacked_h264_nalus = packer.unpack_stap_a(h264_stap_a_payload, true);
std::cout << "Successfully unpacked " << unpacked_h264_nalus.size() << " NALUs." << std::endl;
for (const auto& nalu : unpacked_h264_nalus) {
print_nalu_info(nalu, true);
}
} catch (const std::exception& e) {
std::cerr << "Error unpacking H.264 payload: " << e.what() << std::endl;
}
// --- 3. 模拟 H.265 NALU 聚合 ---
std::cout << "\n--- H.265 STAP-A Aggregation Example ---" << std::endl;
// 模拟 VPS (类型 32), SPS (类型 33), PPS (类型 34)
NalUnitList h265_nalus_to_pack;
std::vector<uint8_t> h265_vps = {0x40, 0x01, 0x0a}; // 示例 VPS
std::vector<uint8_t> h265_sps = {0x42, 0x01, 0x01}; // 示例 SPS
std::vector<uint8_t> h265_pps = {0x44, 0x01, 0x01}; // 示例 PPS
h265_nalus_to_pack.push_back(h265_vps);
h265_nalus_to_pack.push_back(h265_sps);
h265_nalus_to_pack.push_back(h265_pps);
RtpPayload h265_stap_a_payload = packer.pack_h265_nalus(h265_nalus_to_pack);
std::cout << "H.265 Payload created, total size: " << h265_stap_a_payload.size() << " bytes." << std::endl;
// --- 4. 模拟 H.265 解包 ---
std::cout << "\n--- H.265 STAP-A Unpacking Example ---" << std::endl;
try {
NalUnitList unpacked_h265_nalus = packer.unpack_stap_a(h265_stap_a_payload, false);
std::cout << "Successfully unpacked " << unpacked_h265_nalus.size() << " NALUs." << std::endl;
for (const auto& nalu : unpacked_h265_nalus) {
print_nalu_info(nalu, false);
}
} catch (const std::exception& e) {
std::cerr << "Error unpacking H.265 payload: " << e.what() << std::endl;
}
return 0;
}