当前位置：首页 > news >正文

音视频学习（五十八）：STAP-A模式

news 2025/8/26 11:00:15

什么是 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 48class 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 负载中分离出所有 NALUNalUnitList 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.265uint8_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. 循环读取每个 NALUwhile (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;// 检查剩余数据是否足够读取整个 NALUif (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}; // 示例 SPSstd::vector<uint8_t> h264_pps = {0x68, 0xee, 0x01, 0x32}; // 示例 PPSh264_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}; // 示例 VPSstd::vector<uint8_t> h265_sps = {0x42, 0x01, 0x01}; // 示例 SPSstd::vector<uint8_t> h265_pps = {0x44, 0x01, 0x01}; // 示例 PPSh265_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;
}