【音视频】H265解码Nalu后封装rtp包

概述

基于ZLM流媒体框架以及简单RTSP服务器开源项目分析总结，相关源码参考以下链接

H265-rtp提取Nalu逻辑

通过rtsp流地址我们可以获取视频流中的多个rtp包，其中每个RTP包中又会包含一个或者多个Nalu，将其提取处理

总体逻辑分析

核心逻辑在于对H265 RTP解复用器的使用，从RTP包中提取出来完整Nalu或者分片的Nalu

• 接收RTP数据包
• 识别负载数据，然后处理RTP拓展头部信息
• 识别NALU的类型，主要用于区分其是单一的Nalu还是分片的Nalu（FU类型为49）
• 单一Nalu处理逻辑
  • 添加起始码，通过回调函数传递Nalu
• 分片Nalu的处理
  • 重组Nalu：首先会在缓冲区中存储来自多个rtp包的分片数据，然后逐步重组完整的Nalu
  • 通过FU头部标志（S,E）识别起始、中间和结束分片
    • 在起始分片中，从FU头部恢复原始的Nalu类型
    • 结束分片的时候，添加起始码和重组的Nalu头部，并通过回调函数传递完整的Nalu数据
• 最后通过回调函数进一步对H265的Nalu进行处理

参考（RTP）

 *    0                   1                   2                   3*    0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7*   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+*   |V=2|P|X|  CC   |M|     PT      |       sequence number         |*   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+*   |                           timestamp                           |*   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+*   |           synchronization source (SSRC) identifier            |*   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+*   |            contributing source (CSRC) identifiers             |*   :                             ....                              :*   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+**/

代码实现分析

• 开始处理H265的RTP包，然后计算RTP包的负载数据的起始地址以及负载数据的长度
• 计算的主要方法就是跳过RTP头部大小

struct RtpHeader *header = (struct RtpHeader *)data;
int payload_type = header->payloadType;
if(payload_type != payload_){return;
}
const uint8_t* payload = data + sizeof(struct RtpHeader);
size_t payload_len = size - sizeof(struct RtpHeader);

• 处理RTP拓展头部，首先需要判断其拓展头部是否存在
• 存在拓展头部的处理
  • 计算拓展头部的长度
  • 然后通过偏移量跳过RTP的头部和拓展头部，从而使得负载数据指向争取的位置
  • 目的是保证其提取正确的Nalu数据

if (header->extension){const uint8_t *extension_data = payload;size_t extension_length = 4 * (extension_data[2] << 8 | extension_data[3]);size_t payload_offset = 4 + extension_length;payload = payload + payload_offset;payload_len = payload_len - payload_offset;
}

• 判断Nalu的头部和分片类型
  • 如果是49分片类型，那么需要对分片数据进行特别处理

struct H265NaluHeader *h265_header = (struct H265NaluHeader *)payload;
if(h265_header->type == 49){ // 分片 (Fragmentation Unit - FU)struct H265FUHeader *fu_header = (struct H265FUHeader *)&payload[2];// ... 分片 NALU 的处理逻辑 ...
}
else{ // 单一封包 (Single NAL Unit)// ... 单一 NALU 的处理逻辑 ...
}

• 首先访问负载数据的头部
• 处理起始分片
• 然后将起始分片后的分片放入缓冲区
• 最后遇到结束分片的时候，将其统一封装成一个Nalu即可

struct H265FUHeader *fu_header = (struct H265FUHeader *)&payload[2];
if(fu_header->s == 1){ // 起始分片 (Start fragment)find_start_ = true;if(pos_buffer_ == 0){ // 首次接收到起始分片struct H265NaluHeader header = *h265_header;header.type =  fu_header->type; // 从 FU 头部恢复原始 NALU 类型buffer_[0] = 0;buffer_[1] = 0;buffer_[2] = 0;buffer_[3] = 1; // NALU 起始码前缀memcpy(buffer_ + 4, &header, sizeof(struct H265NaluHeader)); // 复制 NALU 头部pos_buffer_ += 4 + sizeof(struct H265NaluHeader);}memcpy(buffer_ + pos_buffer_, payload + 3, payload_len - 3); // 复制分片数据pos_buffer_ += payload_len - 3;
}
else if(fu_header->e == 1){ // 结束分片 (End fragment)if(find_start_ == false){ // 尚未接收到起始分片return;}memcpy(buffer_ + pos_buffer_, payload + 3, payload_len - 3); // 复制分片数据pos_buffer_ += payload_len - 3;if(call_back_){ // 调用回调函数，传递完整的 NALUcall_back_->OnVideoData(ntohl(header->timestamp),  buffer_, pos_buffer_);}find_start_ = false; // 重置状态，准备接收下一个 NALUpos_buffer_ = 0;
}
else { // 中间分片 (Middle fragment)if (!find_start_) { // 尚未接收到起始分片return;}memcpy(buffer_ + pos_buffer_, payload + 3, payload_len - 3); // 复制分片数据pos_buffer_ += payload_len - 3;
}

• 处理单一封包的Nalu
  • 直接跳过起始码即可提取出RTP包中的Nalu

else{ // 单一封包 (Single NAL Unit)buffer_[0] = 0;buffer_[1] = 0;buffer_[2] = 0;buffer_[3] = 1;memcpy(buffer_ + 4, payload, payload_len);if(call_back_){call_back_->OnVideoData(ntohl(header->timestamp),  buffer_, payload_len + 4);}
}

H265-Nalu组成RTP包

逻辑分析

核心流程

• 确定 RTP 负载类型 (Payload Type, PT)
  • 参考SDP协商出来的信息
• 构建 RTP 头部 (RTP Header)
  • 版本 (Version, V): RTP 版本号，通常为 2
  • 填充 (Padding, P): 指示 RTP 包末尾是否有填充字节。通常为 0
  • 扩展 (Extension, X): 指示 RTP 头部后面是否有扩展头部。通常为 0，除非你需要添加扩展信息
  • CSRC 计数器 (CSRC Count, CC): CSRC 标识符的数目。通常为 0，除非有贡献源
  • 标记位 (Marker, M): 标记 RTP 包的事件，例如，可以用来标记帧的结束。对于视频，可以用来标记每个帧的最后一个 RTP 包
  • 负载类型 (Payload Type, PT): 你选择的负载类型，例如 96
  • 序列号 (Sequence Number): 每个 RTP 包的序列号，从一个随机值开始，然后每个包递增 1。用于检测包丢失和重排序
  • 时间戳 (Timestamp): 指示 RTP 包中第一个字节的采样时间。对于视频，时间戳应该反映视频帧的显示时间。时间戳时钟频率需要根据视频编码的帧率来确定
  • 同步源标识符 (Synchronization Source Identifier, SSRC): 标识 RTP 流的源，为一个 32 位的随机数，在 RTP 会话中应保持唯一
• Nalu分片与封装
  • 总结：如果一个Nalu的大小超过MTU（最大传输单元），那么就需要对其分片处理，打成多个RTP包
  • 首先判断是否需要分片
  • FU-A分片
    • 起始分片
      • RTP头部，同上
      • FU Indicator (1 字节): NALU 头部的前两个字节，但 NALU type 字段设置为 49 (FU 类型)
      • FU Header (1 字节)
        • S (Start bit): 设置为 1，表示是分片的开始
        • E (End bit): 设置为 0
        • R (Reserved bit): 必须为 0
        • FU type: 原始 NALU 类型的后 6 位 (从原始 NALU 头部中提取)
      • 分片数据：NALU的一部分数据
    • 中间分片
      • RTP头部信息
      • FU Indicator (1 字节):同起始分片
      • FU Header (1 字节)
        • S (Start bit): 设置为0
        • E (End bit): 设置为 0
        • R (Reserved bit): 必须为 0
        • FU type: 这里需要与起始分片相同
      • 分片数据：Nalu的一部分数据
    • 结束分片
      • RTP头部：序列号和时间戳递增，标记位 M 可以设置为 1，如果这是当前帧的最后一个 RTP 包
      • FU Indicator (1 字节):同起始分片
      • FU Header (1 字节)
        • S (Start bit): 设置为0
        • E (End bit): 设置为 1，表示分片的结束
        • R (Reserved bit): 必须为 0
        • FU type: 这里需要与起始分片相同
      • 分片数据：Nalu最后一部分的数据
• 单一分片封装
  • RTP头部，标记位M可以设置为1吗，当前帧是最后一个Nalu的时候
  • Nalu数据（这里是去除Nalu的起始码，直接放入Nalu头部+负载数据）
• 时间戳和序列号管理
  • 时间戳: 对于每个视频帧的第一个 RTP 包，设置时间戳为当前帧的显示时间。对于同一帧的后续分片包，时间戳保持不变。
    • 下一个视频帧的第一个 RTP 包使用新的时间戳，时间戳的增量应该与视频帧率和时钟频率一致
  • 序列号: 为每个 RTP 包分配递增的序列号，起始序列号随机选择

代码实现

#include <iostream>
#include <vector>
#include <cstdint>
#include <cstring>
#include <iomanip>  // 用于十六进制输出格式化
#include <ctime>    // 用于日志中的时间戳
#include <sstream>  // 用于字符串流// --- 常量定义 ---
const uint8_t H265_PAYLOAD_TYPE = 96;
const uint16_t RTP_VERSION = 2;
const uint16_t VIDEO_STREAM_ID = 0xE0; // 视频流的 Stream ID 示例
const size_t MAX_RTP_PAYLOAD_SIZE = 1400; // RTP 负载最大尺寸示例，根据 MTU 和头部开销调整
const size_t MAX_PES_PAYLOAD_SIZE = 2048; // PES 负载最大尺寸示例，根据需要调整
const uint32_t PS_START_CODE_PREFIX = 0x000001BA;
const uint32_t PES_START_CODE_PREFIX = 0x000001;// --- 结构体定义 ---
#pragma pack(push, 1) // 确保结构体内部没有填充字节// 简化的 RTP 头部
struct RTPHeader {uint8_t version_padding_extension_csrc_count; // V, P, X, CCuint8_t marker_payload_type;                 // M, PTuint16_t sequence_number;uint32_t timestamp;uint32_t ssrc;RTPHeader() : version_padding_extension_csrc_count(0x80), marker_payload_type(H265_PAYLOAD_TYPE), sequence_number(0), timestamp(0), ssrc(0x12345678) {} // SSRC 示例
};// FU 头部 (Fragmentation Unit A, FU-A)
struct FUHeader {uint8_t fu_header; // S, E, R, FU TypeFUHeader() : fu_header(0) {}
};// FU 指示器 (Fragmentation Unit A, FU-A)
struct FUIndicator {uint8_t fu_indicator; // Type = 49 (FU), NALU type bitsFUIndicator() : fu_indicator(0) {}
};// 简化的 PES 头部 (关注 PTS)
struct PESHeader {uint32_t packet_start_code_prefix;uint8_t stream_id;uint16_t pes_packet_length; // 暂时设置为 0，之后计算uint8_t pes_scrambling_control_indicator_etc; // 标志位和指示器uint8_t pes_header_data_length;uint64_t pts_dts_flags_pts; // PTS 标志和 PTS 值 (简化示例)PESHeader() : packet_start_code_prefix(PES_START_CODE_PREFIX), stream_id(VIDEO_STREAM_ID), pes_packet_length(0),pes_scrambling_control_indicator_etc(0x80), // PTS_DTS_flags: 0b10 (仅 PTS)pes_header_data_length(5), // 仅 PTS 占用 5 字节pts_dts_flags_pts(0) {} // PTS 值稍后设置
};// 极简 PS 头部 (仅用于示例)
struct PSHeader {uint32_t packet_start_code_prefix;uint64_t system_clock_reference; // SCR (System Clock Reference) - 简化PSHeader() : packet_start_code_prefix(PS_START_CODE_PREFIX), system_clock_reference(0) {}
};#pragma pack(pop) // 恢复默认 packing// --- 全局计数器和变量 ---
static uint16_t rtp_sequence_number_counter = 0;
static uint32_t rtp_timestamp_counter = 0;
static uint64_t pes_pts_counter = 0; // PES PTS 计数器示例// --- 日志记录函数 ---
void Log(const std::string& message) {std::time_t now = std::time(nullptr);std::tm local_time;localtime_r(&now, &local_time);char timestamp_str[20];std::strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%d %H:%M:%S", &local_time);std::cout << "[" << timestamp_str << "] " << message << std::endl;
}// --- 辅助函数：将数据转换为十六进制字符串 ---
std::string ToHex(const uint8_t* data, size_t size) {std::stringstream hex_stream;hex_stream << std::hex << std::setfill('0');for (size_t i = 0; i < size; ++i) {hex_stream << std::setw(2) << static_cast<int>(data[i]) << " ";}return hex_stream.str();
}// --- 阶段 1: NALU 封装为 RTP 包 ---
std::vector<std::vector<uint8_t>> EncapsulateNALUtoRTP(const std::vector<uint8_t>& nalu_data, int nalu_type) {Log("--- 开始 NALU 到 RTP 的封装 ---");std::vector<std::vector<uint8_t>> rtp_packets;size_t nalu_size = nalu_data.size();const uint8_t* nalu_payload = nalu_data.data();size_t nalu_payload_offset = 0;if (nalu_size <= MAX_RTP_PAYLOAD_SIZE) {// 情况 1: NALU 足够小，可以放入单个 RTP 包Log("NALU 尺寸足够小，可以使用单个 RTP 包。");std::vector<uint8_t> rtp_packet_buffer(sizeof(RTPHeader) + nalu_size);RTPHeader rtp_header;rtp_header.sequence_number = htons(rtp_sequence_number_counter++);rtp_header.timestamp = htonl(rtp_timestamp_counter);rtp_header.marker_payload_type |= (1 << 7); // 设置 Marker 位 (示例，可能根据实际需求调整)memcpy(rtp_packet_buffer.data(), &rtp_header, sizeof(RTPHeader));memcpy(rtp_packet_buffer.data() + sizeof(RTPHeader), nalu_payload, nalu_size);Log("创建 RTP 头部: " + ToHex(rtp_packet_buffer.data(), sizeof(RTPHeader)));Log("RTP 负载 (NALU 数据): " + ToHex(rtp_packet_buffer.data() + sizeof(RTPHeader), nalu_size));rtp_packets.push_back(rtp_packet_buffer);} else {// 情况 2: NALU 太大，需要分片 (FU-A)Log("NALU 尺寸超过 RTP 负载限制，需要分片 (FU-A)。");int fragment_number = 0;bool first_fragment = true;bool last_fragment = false;while (nalu_payload_offset < nalu_size) {size_t fragment_size = std::min(MAX_RTP_PAYLOAD_SIZE - sizeof(FUIndicator) - sizeof(FUHeader), nalu_size - nalu_payload_offset);if (nalu_payload_offset + fragment_size == nalu_size) {last_fragment = true;}std::vector<uint8_t> rtp_packet_buffer(sizeof(RTPHeader) + sizeof(FUIndicator) + sizeof(FUHeader) + fragment_size);RTPHeader rtp_header;rtp_header.sequence_number = htons(rtp_sequence_number_counter++);rtp_header.timestamp = htonl(rtp_timestamp_counter);rtp_header.marker_payload_type &= ~(1 << 7); // 清除 Marker 位 (分片包通常不设置，除非是帧的最后一个分片)if (last_fragment) rtp_header.marker_payload_type |= (1 << 7); // 在最后一个分片包上设置 Marker 位 (示例)FUIndicator fu_indicator;fu_indicator.fu_indicator = 49 << 1; // FU 类型 = 49fu_indicator.fu_indicator |= ((nalu_type >> 5) & 0x01); // 复制原始 NALU 头部的 forbidden_zero_bitFUHeader fu_header;fu_header.fu_header = (nalu_type & 0x1F); // NAL 单元类型 (原始 NALU 类型的后 5 位)if (first_fragment) fu_header.fu_header |= (1 << 7); // 设置 S 位 (起始分片)if (last_fragment)  fu_header.fu_header |= (1 << 6); // 设置 E 位 (结束分片)memcpy(rtp_packet_buffer.data(), &rtp_header, sizeof(RTPHeader));memcpy(rtp_packet_buffer.data() + sizeof(RTPHeader), &fu_indicator, sizeof(FUIndicator));memcpy(rtp_packet_buffer.data() + sizeof(RTPHeader) + sizeof(FUIndicator), &fu_header, sizeof(FUHeader));memcpy(rtp_packet_buffer.data() + sizeof(RTPHeader) + sizeof(FUIndicator) + sizeof(FUHeader),nalu_payload + nalu_payload_offset, fragment_size);Log("创建 RTP 头部 (分片 " + std::to_string(fragment_number) + "): " + ToHex(rtp_packet_buffer.data(), sizeof(RTPHeader)));Log("FU 指示器: " + ToHex(rtp_packet_buffer.data() + sizeof(RTPHeader), sizeof(FUIndicator)));Log("FU 头部: " + ToHex(rtp_packet_buffer.data() + sizeof(RTPHeader) + sizeof(FUIndicator), sizeof(FUHeader)));Log("RTP 负载 (分片数据 " + std::to_string(fragment_number) + "): " + ToHex(rtp_packet_buffer.data() + sizeof(RTPHeader) + sizeof(FUIndicator) + sizeof(FUHeader), fragment_size));rtp_packets.push_back(rtp_packet_buffer);nalu_payload_offset += fragment_size;first_fragment = false;fragment_number++;}}rtp_timestamp_counter += 3600; // 时间戳递增示例 (90kHz 时钟, 约 40ms 帧时长)Log("--- NALU 到 RTP 封装完成，生成 " + std::to_string(rtp_packets.size()) + " 个 RTP 包。---\n");return rtp_packets;
}// --- 阶段 2: RTP 封装为 PES (更标准的做法应为 NALU 封装为 PES) ---
std::vector<uint8_t> EncapsulateRTPtoPES(const std::vector<std::vector<uint8_t>>& rtp_packets, const std::vector<uint8_t>& original_nalu_data) {Log("--- 开始 RTP (或 NALU) 到 PES 的封装 ---");std::vector<uint8_t> pes_packet_buffer;// 为了更符合 PS 流标准，理想情况下应该从 RTP 包中解封装出 NALU 数据，然后将 NALU 放入 PES。// 但为了演示 "组成 rtp 包后通过 PS 流发送出去" 的字面意思，这里我们将 *整个 RTP 包* 放入 PES 负载 (这不太标准，但在某些特定场景下可能可行)。// 在实际系统中，你可能更希望提取 RTP 中的 NALU 负载，然后放入 PES。PESHeader pes_header;pes_header.pts_dts_flags_pts = (static_cast<uint64_t>(pes_pts_counter++) << 3) | 0x02; // 仅设置 PTS 标志uint64_t pts_33_to_1 = (pes_pts_counter * 300) % 0x200000000LL; // 假设 300 ticks/ms, 90kHz clockuint32_t pts_32_to_2 = pts_33_to_1 & 0xFFFFFFFE0LL;uint8_t pts_byte0 = 0x20 | ((pts_32_to_2 >> 30) & 0x07) << 1 | 0x01;uint16_t pts_byte1_2 = (pts_32_to_2 >> 15) & 0xFFFF;uint16_t pts_byte3_4 = pts_32_to_2 & 0xFFFF;pes_header.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte0) << 40);pes_header.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte1_2) << 24);pes_header.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte3_4) >> 8);size_t pes_payload_size = 0;for (const auto& rtp_packet : rtp_packets) {pes_payload_size += rtp_packet.size();}pes_header.pes_packet_length = htons(sizeof(PESHeader) + pes_payload_size - 6); // PES 包长度不包括 包起始码前缀 和 长度字段自身pes_packet_buffer.resize(sizeof(PESHeader));memcpy(pes_packet_buffer.data(), &pes_header, sizeof(PESHeader));Log("创建 PES 头部: " + ToHex(pes_packet_buffer.data(), sizeof(PESHeader)));Log("PES PTS Value: " + std::to_string(pes_pts_counter));for (const auto& rtp_packet : rtp_packets) {pes_packet_buffer.insert(pes_packet_buffer.end(), rtp_packet.begin(), rtp_packet.end());}Log("PES Payload (RTP 包数据): Total size " + std::to_string(pes_payload_size) + " bytes.");Log("--- RTP to PES Encapsulation Complete. PES Packet Size: " + std::to_string(pes_packet_buffer.size()) + " bytes. ---\n");return pes_packet_buffer;
}// --- 阶段 3: 将 PES 包放入 PS 流 (简化示例，仅包含 PS 头部和 PES 包) ---
std::vector<uint8_t> CreatePSStream(const std::vector<uint8_t>& pes_packet) {Log("--- 开始创建 PS 流 ---");std::vector<uint8_t> ps_stream_buffer;PSHeader ps_header;// SCR (System Clock Reference) 示例 - 非常简化ps_header.system_clock_reference = (static_cast<uint64_t>(pes_pts_counter * 300) << 3) | 0x01; // 90kHz clock, marker_bits = '01'ps_stream_buffer.resize(sizeof(PSHeader));memcpy(ps_stream_buffer.data(), &ps_header, sizeof(PSHeader));Log("创建 PS 头部: " + ToHex(ps_stream_buffer.data(), sizeof(PSHeader)));ps_stream_buffer.insert(ps_stream_buffer.end(), pes_packet.begin(), pes_packet.end());Log("将 PES 包添加到 PS 流. PES Packet Size: " + std::to_string(pes_packet.size()) + " bytes.");Log("--- PS 流创建完成. Total PS Stream Size: " + std::to_string(ps_stream_buffer.size()) + " bytes. ---\n");return ps_stream_buffer;
}int main() {Log("--- 示例程序开始 ---");// 示例 H.265 NALU 数据 (这里用一些虚拟数据代替实际的 H.265 NALU)std::vector<uint8_t> h265_nalu_data = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,// ... 假设这里是真实的 H.265 NALU 负载数据 ...};int nalu_type = 32; // 示例 NALU 类型 (VPS)Log("原始 H.265 NALU 数据: Size = " + std::to_string(h265_nalu_data.size()) + " bytes, Type = " + std::to_string(nalu_type));Log(ToHex(h265_nalu_data.data(), h265_nalu_data.size()));// 阶段 1: NALU 封装成 RTP 包std::vector<std::vector<uint8_t>> rtp_packets = EncapsulateNALUtoRTP(h265_nalu_data, nalu_type);// 阶段 2: RTP 包封装成 PES 包std::vector<uint8_t> pes_packet = EncapsulateRTPtoPES(rtp_packets, h265_nalu_data);// 阶段 3: 创建 PS 流std::vector<uint8_t> ps_stream = CreatePSStream(pes_packet);Log("\n--- 最终 PES 包 (放入 PS 流之前) ---");Log("PES Packet Hex Data (First 64 bytes): \n" + ToHex(pes_packet.data(), std::min((size_t)64, pes_packet.size())));Log("PES Packet Size: " + std::to_string(pes_packet.size()) + " bytes.");Log("\n--- 最终 PS 流 (First 64 bytes) ---");Log("PS Stream Hex Data (First 64 bytes): \n" + ToHex(ps_stream.data(), std::min((size_t)64, ps_stream.size())));Log("PS Stream Size: " + std::to_string(ps_stream.size()) + " bytes.");Log("--- 示例程序结束 ---");return 0;
}

Nalu封装PS流

逻辑分析

PS 流是 MPEG-2 标准中用于存储程序内容的一种格式。它主要用于存储和传输已经复用的音视频基本流。要将 RTP 包放入 PS 流中，通常的做法是先将 RTP 包转换为 PES包，然后再将 PES 包复用进 PS 流，其中GB28181平台就是需要将视频封装成PS流进行传输

注意事项

之前自己在书写项目的时候，该处的逻辑有些混淆，认为应该先将Nalu封装成RTP包然后通过PS流发送出去。这里就涉及了严重的概念混淆的错误。真正的流程应该如下，后续补充对PS流基础概念和原理的认识

将RTP作为一个传输协议，最终PS流中应该包含的是音视频的PES包，所以还需要对其进行包装一层

主要流程分析

封装成PES等包，在开源社区有已经封装好的代码，该处只简单分析其逻辑 

• 从RTP包中解析出来Nalu
• NALU 封装成 PES 包 (Packetized Elementary Stream)
  • PES 头部 (PES Header)
    • 包起始码前缀：0x00 0x00 0x01
    • 流ID：主要用于标识流的类
    • PES包长度：指示 PES 包的长度，不包括包起始码前缀和自身长度字段。如果长度未知可以设置为 0，但通常应计算实际长度
    • PES头部标志位：指示其是否包含有PTS/DTS信息
    • PTS/DTS
      • PTS (显示时间戳): 指示 PES 包中数据的显示时间。应该从 RTP 包的时间戳转换过来
      • DTS (解码时间戳): 指示 PES 包中数据的解码时间。对于 I 帧，DTS 通常等于 PTS。对于 B 帧，DTS 可能早于 PTS。对于 H.265，如果只包含 P 和 I 帧，DTS 通常可以等于 PTS
  • PES负载
    • PES 负载 (PES Payload): 将一个或多个完整的 NALU 放入 PES 负载中。 你可以选择每个 PES 包放一个 NALU，或者将多个小的 NALU 组合到一个 PES 包中
• 构建PS流
  • PS 头部 (Program Stream Header): 每个 PS 包的开始
    • 包起始码前缀 (Packet Start Code Prefix)：0x00 0x00 0x01
    • 系统时钟参考 (System Clock Reference, SCR): 用于同步解码器时钟
    • 复用率 (Mux Rate): 指示 PS 流的比特率
  • 系统头部 (System Header): 描述整个 PS 流的系统级别信息，通常在 PS 流的开始处出现一次
    • 系统头部起始码 (System Header Start Code): 0x00 0x00 0x01 0xBB
    • 速率边界 (Rate Bound): 流的最大比特率
    • 音频边界 (Audio Bound): 音频流的数量
    • 视频边界 (Video Bound): 视频流的数量
    • 固定标志位 (Fixed Flag): 指示是否为固定比特率
    • CSPS_flag, System_audio_lock_flag, System_video_lock_flag: 同步标志
    • 视频和音频流的 PID (Program ID): 标识视频和音频流
  • 程序流映射 (Program Stream Map, PSM): 描述程序的内容，包括音频和视频流的类型和 PID
  • PES 包: 将封装好的 PES 包按时间顺序复用进 PS 流中。可以交错放置视频和音频 PES 包
• 时间戳处理（PTS/DTS）
  • 将 RTP 包的时间戳信息转换为 PES 包的 PTS/DTS
  • 要确保 PTS/DTS 值正确反映视频帧的显示和解码时间
  • 时间戳单位需要与 PS 流的标准时钟频率 (通常是 90kHz) 匹配

代码实现

下述代码只作为参考，详细封装参考下一个章节笔记

#include <iostream>
#include <vector>
#include <cstdint>
#include <cstring>
#include <iomanip>  // 用于十六进制输出格式化
#include <ctime>    // 用于日志中的时间戳
#include <sstream>  // 用于字符串流// --- 常量定义 ---
const uint16_t VIDEO_STREAM_ID = 0xE0; // 视频流的 Stream ID 示例
const size_t MAX_PES_PAYLOAD_SIZE = 2048; // PES 负载最大尺寸示例，根据需要调整
const uint32_t PS_START_CODE_PREFIX = 0x000001BA;
const uint32_t PES_START_CODE_PREFIX = 0x000001;
const uint8_t NAL_START_CODE_4_BYTE[] = {0x00, 0x00, 0x00, 0x01};// --- 结构体定义 ---
#pragma pack(push, 1) // 确保结构体内部没有填充字节// 简化的 PES 头部 (关注 PTS)
struct PESHeader {uint32_t packet_start_code_prefix;uint8_t stream_id;uint16_t pes_packet_length; // 暂时设置为 0，之后计算uint8_t pes_scrambling_control_indicator_etc; // 标志位和指示器uint8_t pes_header_data_length;uint64_t pts_dts_flags_pts; // PTS 标志和 PTS 值 (简化示例)PESHeader() : packet_start_code_prefix(PES_START_CODE_PREFIX), stream_id(VIDEO_STREAM_ID), pes_packet_length(0),pes_scrambling_control_indicator_etc(0x80), // PTS_DTS_flags: 0b10 (仅 PTS)pes_header_data_length(5), // 仅 PTS 占用 5 字节pts_dts_flags_pts(0) {} // PTS 值稍后设置
};// 极简 PS 头部 (仅用于示例)
struct PSHeader {uint32_t packet_start_code_prefix;uint64_t system_clock_reference; // SCR (System Clock Reference) - 简化PSHeader() : packet_start_code_prefix(PS_START_CODE_PREFIX), system_clock_reference(0) {}
};#pragma pack(pop) // 恢复默认 packing// --- 全局计数器和变量 ---
static uint64_t pes_pts_counter = 0; // PES PTS 计数器示例// --- 日志记录函数 ---
void Log(const std::string& message) {std::time_t now = std::time(nullptr);std::tm local_time;localtime_r(&now, &local_time);char timestamp_str[20];std::strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%d %H:%M:%S", &local_time);std::cout << "[" << timestamp_str << "] " << message << std::endl;
}// --- 辅助函数：将数据转换为十六进制字符串 ---
std::string ToHex(const uint8_t* data, size_t size) {std::stringstream hex_stream;hex_stream << std::hex << std::setfill('0');for (size_t i = 0; i < size; ++i) {hex_stream << std::setw(2) << static_cast<int>(data[i]) << " ";}return hex_stream.str();
}// --- 阶段 1: NALU 封装为 PES 包 ---
std::vector<uint8_t> EncapsulateNALUtoPES(const std::vector<uint8_t>& nalu_data) {Log("--- 开始 NALU 到 PES 的封装 ---");std::vector<uint8_t> pes_packet_buffer;PESHeader pes_header;pes_header.pts_dts_flags_pts = (static_cast<uint64_t>(pes_pts_counter++) << 3) | 0x02; // 仅设置 PTS 标志uint64_t pts_33_to_1 = (pes_pts_counter * 300) % 0x200000000LL; // 假设 300 ticks/ms, 90kHz clockuint32_t pts_32_to_2 = pts_33_to_1 & 0xFFFFFFFE0LL;uint8_t pts_byte0 = 0x20 | ((pts_32_to_2 >> 30) & 0x07) << 1 | 0x01;uint16_t pts_byte1_2 = (pts_32_to_2 >> 15) & 0xFFFF;uint16_t pts_byte3_4 = pts_32_to_2 & 0xFFFF;pes_header.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte0) << 40);pes_header.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte1_2) << 24);pes_header.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte3_4) >> 8);pes_header.pes_packet_length = htons(sizeof(PESHeader) + nalu_data.size() - 6); // PES 包长度不包括 包起始码前缀 和 长度字段自身pes_packet_buffer.resize(sizeof(PESHeader));memcpy(pes_packet_buffer.data(), &pes_header, sizeof(PESHeader));Log("创建 PES 头部: " + ToHex(pes_packet_buffer.data(), sizeof(PESHeader)));Log("PES PTS Value: " + std::to_string(pes_pts_counter));// 将 NALU 数据直接添加到 PES 负载pes_packet_buffer.insert(pes_packet_buffer.end(), nalu_data.begin(), nalu_data.end());Log("PES Payload (NALU 数据): Size " + std::to_string(nalu_data.size()) + " bytes.");Log("--- NALU 到 PES 封装完成. PES Packet Size: " + std::to_string(pes_packet_buffer.size()) + " bytes. ---\n");return pes_packet_buffer;
}// --- 阶段 2: 将 PES 包放入 PS 流 (简化示例，仅包含 PS 头部和 PES 包) ---
std::vector<uint8_t> CreatePSStream(const std::vector<uint8_t>& pes_packet) {Log("--- 开始创建 PS 流 ---");std::vector<uint8_t> ps_stream_buffer;PSHeader ps_header;// SCR (System Clock Reference) 示例 - 非常简化ps_header.system_clock_reference = (static_cast<uint64_t>(pes_pts_counter * 300) << 3) | 0x01; // 90kHz clock, marker_bits = '01'ps_stream_buffer.resize(sizeof(PSHeader));memcpy(ps_stream_buffer.data(), &ps_header, sizeof(PSHeader));Log("创建 PS 头部: " + ToHex(ps_stream_buffer.data(), sizeof(PSHeader)));ps_stream_buffer.insert(ps_stream_buffer.end(), pes_packet.begin(), pes_packet.end());Log("将 PES 包添加到 PS 流. PES Packet Size: " + std::to_string(pes_packet.size()) + " bytes.");Log("--- PS 流创建完成. Total PS Stream Size: " + std::to_string(ps_stream_buffer.size()) + " bytes. ---\n");return ps_stream_buffer;
}int main() {Log("--- 示例程序开始 ---");// 示例 H.265 NALU 数据 (这里用一些虚拟数据代替实际的 H.265 NALU)std::vector<uint8_t> h265_nalu_data = {0x00, 0x00, 0x00, 0x01, // NALU Start Code (4-byte) - 虽然 PS 流中通常不直接包含，这里为了更贴近NALU理解先加上，实际情况可能不需要0x40, // NALU Header (example type)0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,// ... 假设这里是真实的 H.265 NALU 负载数据 ...};int nalu_type = 32; // 示例 NALU 类型 (VPS)Log("原始 H.265 NALU 数据: Size = " + std::to_string(h265_nalu_data.size()) + " bytes, Type = " + std::to_string(nalu_type));Log(ToHex(h265_nalu_data.data(), h265_nalu_data.size()));// 阶段 1: NALU 封装成 PES 包std::vector<uint8_t> pes_packet = EncapsulateNALUtoPES(h265_nalu_data);// 阶段 2: 创建 PS 流std::vector<uint8_t> ps_stream = CreatePSStream(pes_packet);Log("\n--- 最终 PES 包 (放入 PS 流之前) ---");Log("PES Packet Hex Data (First 64 bytes): \n" + ToHex(pes_packet.data(), std::min((size_t)64, pes_packet.size())));Log("PES Packet Size: " + std::to_string(pes_packet.size()) + " bytes.");Log("\n--- 最终 PS 流 (First 64 bytes) ---");Log("PS Stream Hex Data (First 64 bytes): \n" + ToHex(ps_stream.data(), std::min((size_t)64, ps_stream.size())));Log("PS Stream Size: " + std::to_string(ps_stream.size()) + " bytes.");Log("--- 示例程序结束 ---");return 0;
}

GB28181平台下H265传输逻辑总结

代码实现

root@hcss-ecs-b4a9:/home/test/rtp/nalu# ./test7
[2025-02-23 21:37:20] --- 示例程序开始 ---
[2025-02-23 21:37:20] [process_request] 开始模拟推流, NALU 数量: 5
[2025-02-23 21:37:20] 处理 NALU, Type: 32, Keyframe: Yes, Size: 50 bytes.
[2025-02-23 21:37:20] RTP 分包数: 1
[2025-02-23 21:37:20] 发送网络包, 大小: 165 bytes.
[2025-02-23 21:37:20] Packet Data (First 64 bytes): 
80 e0 00 00 00 00 00 00 12 34 56 78 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 ba 01 
[2025-02-23 21:37:20] 处理 NALU, Type: 33, Keyframe: Yes, Size: 100 bytes.
[2025-02-23 21:37:20] RTP 分包数: 1
[2025-02-23 21:37:20] 发送网络包, 大小: 265 bytes.
[2025-02-23 21:37:20] Packet Data (First 64 bytes): 
80 e0 00 01 00 00 0e a6 12 34 56 78 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f 60 61 62 63 64 65 66 
[2025-02-23 21:37:20] 处理 NALU, Type: 34, Keyframe: Yes, Size: 30 bytes.
[2025-02-23 21:37:20] RTP 分包数: 1
[2025-02-23 21:37:20] 发送网络包, 大小: 125 bytes.
[2025-02-23 21:37:20] Packet Data (First 64 bytes): 
80 e0 00 02 00 00 1d 4c 12 34 56 78 97 98 99 9a 9b 9c 9d 9e 9f a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af b0 b1 b2 b3 b4 ba 01 00 00 4c 1d 00 00 00 00 00 00 00 00 bb 01 00 00 00 02 00 00 
[2025-02-23 21:37:20] 处理 NALU, Type: 19, Keyframe: Yes, Size: 2048 bytes.
[2025-02-23 21:37:20] RTP 分包数: 2
[2025-02-23 21:37:20] 发送网络包, 大小: 1412 bytes.
[2025-02-23 21:37:20] Packet Data (First 64 bytes): 
80 60 00 03 00 00 2b f2 12 34 56 78 ba 01 00 00 f2 2b 00 00 00 00 00 00 00 00 bb 01 00 00 00 02 00 00 bc 01 00 00 00 06 00 00 00 00 00 00 01 00 00 00 e0 08 0d 80 05 1e 00 00 00 00 21 00 00 00 
[2025-02-23 21:37:20] 发送网络包, 大小: 713 bytes.
[2025-02-23 21:37:20] Packet Data (First 64 bytes): 
80 e0 00 04 00 00 2b f2 12 34 56 78 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f 
[2025-02-23 21:37:21] 处理 NALU, Type: 1, Keyframe: No, Size: 1500 bytes.
[2025-02-23 21:37:21] RTP 分包数: 2
[2025-02-23 21:37:21] 发送网络包, 大小: 1412 bytes.
[2025-02-23 21:37:21] Packet Data (First 64 bytes): 
80 60 00 05 00 00 3a 98 12 34 56 78 ba 01 00 00 98 3a 00 00 00 00 00 00 00 00 01 00 00 00 e0 05 e9 80 05 27 00 00 00 00 21 00 00 00 00 98 99 9a 9b 9c 9d 9e 9f a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa 
[2025-02-23 21:37:21] 发送网络包, 大小: 145 bytes.
[2025-02-23 21:37:21] Packet Data (First 64 bytes): 
80 e0 00 06 00 00 3a 98 12 34 56 78 ef f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 
[2025-02-23 21:37:21] --- 示例程序结束 ---

#include <iostream>
#include <vector>
#include <cstdint>
#include <cstring>
#include <iomanip>  // 用于十六进制输出格式化
#include <ctime>    // 用于日志中的时间戳
#include <sstream>  // 用于字符串流
#include <netinet/in.h> // 包含 htons 的声明
#include <chrono>
#include <thread>
#include <numeric> // std::iota
#include <malloc.h>// --- 常量定义 ---
const uint16_t VIDEO_STREAM_ID = 0xE0; // 视频流的 Stream ID 示例
const size_t MAX_RTP_PAYLOAD_SIZE = 1400; // RTP 负载最大尺寸示例
const uint32_t PS_START_CODE_PREFIX = 0x000001BA;
const uint32_t PES_START_CODE_PREFIX = 0x000001;
const uint8_t NAL_START_CODE_4_BYTE[] = {0x00, 0x00, 0x00, 0x01};const int PS_HDR_LEN = 14; // 示例 PS Header Length
const int SYS_HDR_LEN = 8; // 示例 System Header Length
const int PSM_HDR_LEN = 12; // 示例 PSM Header Length
const int PES_HDR_LEN = 19; // 示例 PES Header Length
const int RTP_HDR_LEN = 12; // 示例 RTP Header Length// --- 结构体定义 ---
#pragma pack(push, 1) // 确保结构体内部没有填充字节// 简化的 PS 头部 (示例)
struct PSHeader {uint32_t packet_start_code_prefix;uint64_t system_clock_reference; // SCRPSHeader() : packet_start_code_prefix(PS_START_CODE_PREFIX), system_clock_reference(0) {}
};// 简化的系统头部 (示例)
struct SystemHeader {uint32_t system_header_start_code;uint16_t header_length;uint8_t rate_bound[3];uint8_t audio_bound;uint8_t fixed_flag_etc;SystemHeader() : system_header_start_code(0x000001BB), header_length(0), audio_bound(0), fixed_flag_etc(0) {rate_bound[0] = rate_bound[1] = rate_bound[2] = 0;}
};// 简化的 PSM 头部 (示例)
struct PSMHeader {uint32_t program_stream_map_start_code;uint16_t psm_length;uint8_t program_number[2];uint8_t version_current_next_indicator;uint8_t section_number;uint8_t last_section_number;uint8_t program_info_length[2];// ... (省略 Program Stream Info 和 ES Info 循环) ...PSMHeader() : program_stream_map_start_code(0x000001BC), psm_length(0), version_current_next_indicator(0), section_number(0), last_section_number(0) {program_number[0] = program_number[1] = 0;program_info_length[0] = program_info_length[1] = 0;}
};// 简化的 PES 头部 (关注 PTS)
struct PESHeader {uint32_t packet_start_code_prefix;uint8_t stream_id;uint16_t pes_packet_length;uint8_t pes_scrambling_control_indicator_etc;uint8_t pes_header_data_length;uint64_t pts_dts_flags_pts;PESHeader() : packet_start_code_prefix(PES_START_CODE_PREFIX), stream_id(VIDEO_STREAM_ID), pes_packet_length(0),pes_scrambling_control_indicator_etc(0x80), // PTS_DTS_flags: 0b10 (仅 PTS)pes_header_data_length(5),pts_dts_flags_pts(0) {}
};// 简化的 RTP 头部
struct RTPHeader {uint8_t version_padding_extension_csrc_count; // V, P, X, CCuint8_t marker_payload_type;                 // M, PTuint16_t sequence_number;uint32_t timestamp;uint32_t ssrc;RTPHeader() : version_padding_extension_csrc_count(0x80), marker_payload_type(96), sequence_number(0), timestamp(0), ssrc(0x12345678) {} // SSRC 示例
};// Nalu 结构体
struct Nalu {int type;int length;std::vector<uint8_t> packet;Nalu() : type(0), length(0) {}~Nalu() {}
};using NaluType = int;#pragma pack(pop) // 恢复默认 packing// --- 全局计数器和变量 ---
static uint64_t pes_pts_counter = 0; // PES PTS 计数器示例
static uint16_t rtp_seq_counter = 0;// --- 日志记录函数 ---
void Log(const std::string& message) {std::time_t now = std::time(nullptr);std::tm local_time;localtime_r(&now, &local_time);char timestamp_str[20];std::strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%d %H:%M:%S", &local_time);std::cout << "[" << timestamp_str << "] " << message << std::endl;
}// --- 辅助函数：将数据转换为十六进制字符串 ---
std::string ToHex(const uint8_t* data, size_t size) {std::stringstream hex_stream;hex_stream << std::hex << std::setfill('0');for (size_t i = 0; i < size; ++i) {hex_stream << std::setw(2) << static_cast<int>(data[i]) << " ";}return hex_stream.str();
}// --- 将 VPS, SPS, PPS 处理为一个流 ---
std::vector<uint8_t> vps_data;
std::vector<uint8_t> sps_data;
std::vector<uint8_t> pps_data;void out_nalu(char *buffer, int size, NaluType naluType) {if (naluType == 32) {  // VPSvps_data.resize(size);memcpy(vps_data.data(), buffer, size);} else if (naluType == 33) {  // SPSsps_data.resize(size);memcpy(sps_data.data(), buffer, size);} else if (naluType == 34) {  // PPSpps_data.resize(size);memcpy(pps_data.data(), buffer, size);} else {Nalu *nalu = new Nalu;bool is_i_frame = (naluType == 19);  // IDR framechar *packet = (char *)malloc(is_i_frame ? (size + vps_data.size() + sps_data.size() + pps_data.size()) : size);if (is_i_frame) {memcpy(packet, vps_data.data(), vps_data.size());memcpy(packet + vps_data.size(), sps_data.data(), sps_data.size());memcpy(packet + vps_data.size() + sps_data.size(), pps_data.data(), pps_data.size());memcpy(packet + vps_data.size() + sps_data.size() + pps_data.size(), buffer, size);size += (vps_data.size() + sps_data.size() + pps_data.size());} else {memcpy(packet, buffer, size);}nalu->packet = std::vector<uint8_t>(packet, packet + size);nalu->length = size;nalu->type = naluType;// 将 nalu 添加到 nalu_vector 或进行其他处理delete[] packet;}
}// --- 头部生成函数 ---
void gb28181_make_ps_header(char *header, long pts) {PSHeader ps_header_struct;ps_header_struct.system_clock_reference = pts; // 简化 SCRmemcpy(header, &ps_header_struct, sizeof(PSHeader));
}void gb28181_make_sys_header(char *header, int rate_bound) {SystemHeader sys_header_struct;sys_header_struct.header_length = htons(SYS_HDR_LEN - 6); // Length after header_length fieldsys_header_struct.rate_bound[0] = (rate_bound >> 16) & 0xFF;sys_header_struct.rate_bound[1] = (rate_bound >> 8) & 0xFF;sys_header_struct.rate_bound[2] = rate_bound & 0xFF;memcpy(header, &sys_header_struct, sizeof(SystemHeader));
}void gb28181_make_psm_header(char *header) {PSMHeader psm_header_struct;psm_header_struct.psm_length = htons(PSM_HDR_LEN - 6); // Length after psm_length fieldmemcpy(header, &psm_header_struct, sizeof(PSMHeader));
}void gb28181_make_pes_header(char *header, int stream_id, int data_len, long pts, long dts) {PESHeader pes_header_struct;pes_header_struct.stream_id = stream_id;pes_header_struct.pes_packet_length = htons(data_len + PES_HDR_LEN - 6); // Length after pes_packet_length fieldpes_header_struct.pts_dts_flags_pts = (static_cast<uint64_t>(pes_pts_counter++) << 3) | 0x02; // 仅设置 PTS 标志uint64_t pts_33_to_1 = (pes_pts_counter * 300) % 0x200000000LL; // 假设 300 ticks/ms, 90kHz clockuint32_t pts_32_to_2 = pts_33_to_1 & 0xFFFFFFFE0LL;uint8_t pts_byte0 = 0x20 | ((pts_32_to_2 >> 30) & 0x07) << 1 | 0x01;uint16_t pts_byte1_2 = (pts_32_to_2 >> 15) & 0xFFFF;uint16_t pts_byte3_4 = pts_32_to_2 & 0xFFFF;pes_header_struct.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte0) << 40);pes_header_struct.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte1_2) << 24);pes_header_struct.pts_dts_flags_pts |= (static_cast<uint64_t>(pts_byte3_4) >> 8);memcpy(header, &pes_header_struct, sizeof(PESHeader));
}void gb28181_make_rtp_header(char *header, int seq, long pts, int ssrc, bool marker) {RTPHeader rtp_header_struct;rtp_header_struct.sequence_number = htons(seq);rtp_header_struct.timestamp = htonl(pts);rtp_header_struct.ssrc = htonl(ssrc);if (marker) {rtp_header_struct.marker_payload_type |= (1 << 7); // Set marker bit}memcpy(header, &rtp_header_struct, sizeof(RTPHeader));
}// --- 发送网络数据包 ---
void send_network_packet(char *packet, int packet_size) {Log("发送网络包, 大小: " + std::to_string(packet_size) + " bytes.");// 模拟发送网络包，实际应用中替换为 socket send 操作Log("Packet Data (First 64 bytes): \n" + ToHex((uint8_t*)packet, std::min((size_t)64, (size_t)packet_size)));
}// --- 判断是否为关键帧 ---
bool is_keyframe(NaluType type) {// 这里可以根据 NALU 类型判断是否为关键帧// 例如，对于 H.264, IDR 帧 (type 5) 是关键帧，对于 H.265, IDR_W_RADL (type 19) 和 IDR_N_LP (type 20) 是关键帧// 在你的代码中，type 19 被认为是 IDR 帧return (type == 19 || type == 32 || type == 33 || type == 34); // 假设 VPS, SPS, PPS 也被视为关键帧，用于某些 header 的添加逻辑
}// --- 主程序 ---
int main() {Log("--- 示例程序开始 ---");// 模拟更真实的 NALU 数组，包含 VPS, SPS, PPS, IDR 关键帧, 普通帧std::vector<Nalu*> nalu_vector_sim;// 模拟 VPS, SPS, PPS (通常在 IDR 帧前)struct Nalu* vps_nalu = new Nalu();vps_nalu->type = 32; // VPS_NUTvps_nalu->length = 50;vps_nalu->packet.resize(vps_nalu->length);std::iota(vps_nalu->packet.begin(), vps_nalu->packet.end(), 1);nalu_vector_sim.push_back(vps_nalu);out_nalu((char*)vps_nalu->packet.data(), vps_nalu->length, 32);struct Nalu* sps_nalu = new Nalu();sps_nalu->type = 33; // SPS_NUTsps_nalu->length = 100;sps_nalu->packet.resize(sps_nalu->length);std::iota(sps_nalu->packet.begin(), sps_nalu->packet.end(), 51);nalu_vector_sim.push_back(sps_nalu);out_nalu((char*)sps_nalu->packet.data(), sps_nalu->length, 33);struct Nalu* pps_nalu = new Nalu();pps_nalu->type = 34; // PPS_NUTpps_nalu->length = 30;pps_nalu->packet.resize(pps_nalu->length);std::iota(pps_nalu->packet.begin(), pps_nalu->packet.end(), 151);nalu_vector_sim.push_back(pps_nalu);out_nalu((char*)pps_nalu->packet.data(), pps_nalu->length, 34);// 模拟 IDR 关键帧struct Nalu* idr_nalu = new Nalu();idr_nalu->type = 19; // IDR_W_RADL (示例 IDR 类型)idr_nalu->length = 2048;idr_nalu->packet.resize(idr_nalu->length);std::iota(idr_nalu->packet.begin(), idr_nalu->packet.end(), 201);nalu_vector_sim.push_back(idr_nalu);out_nalu((char*)idr_nalu->packet.data(), idr_nalu->length, 19);// 模拟 普通帧 (非关键帧)struct Nalu* non_idr_nalu = new Nalu();non_idr_nalu->type = 1; // TRAIL_R_NUT (示例 普通帧类型)non_idr_nalu->length = 1500;non_idr_nalu->packet.resize(non_idr_nalu->length);std::iota(non_idr_nalu->packet.begin(), non_idr_nalu->packet.end(), 2200);nalu_vector_sim.push_back(non_idr_nalu);out_nalu((char*)non_idr_nalu->packet.data(), non_idr_nalu->length, 1);// RTP 发送处理略...int time_base = 90000;int fps = 24;int send_packet_interval = 1000 / fps;int interval = time_base / fps;long pts = 0;int single_packet_max_length = 1400;int ssrc_val = 0x12345678; // 示例 SSRCstd::string rtp_protocol_type = "UDP/RTP/AVP"; // 或 "TCP/RTP/AVP"Log("[process_request] 开始模拟推流, NALU 数量: " + std::to_string(nalu_vector_sim.size()));for (auto* nalu : nalu_vector_sim) {const NaluType type = nalu->type;const int length = nalu->length;const uint8_t* packet = nalu->packet.data();const bool is_key = is_keyframe(type);Log("处理 NALU, Type: " + std::to_string(type) + ", Keyframe: " + (is_key ? "Yes" : "No") + ", Size: " + std::to_string(length) + " bytes.");// 在遇到 VPS、SPS、PPS 时，先进行封装char frame_buffer[1024 * 128]; // 帧数据缓冲区int frame_index = 0;char ps_header_buf[PS_HDR_LEN];char sys_header_buf[SYS_HDR_LEN];char psm_header_buf[PSM_HDR_LEN];char pes_header_buf[PES_HDR_LEN];char rtp_packet_buf[RTP_HDR_LEN + 1400];// 声明 rtp_header_bufchar rtp_header_buf[RTP_HDR_LEN];// 封装 VPS, SPS, PPSif (type == 32 || type == 33 || type == 34) { // VPS, SPS, PPSmemcpy(frame_buffer + frame_index, packet, length);frame_index += length;}// --- PS 封装 ---gb28181_make_ps_header(ps_header_buf, pts);memcpy(frame_buffer + frame_index, ps_header_buf, PS_HDR_LEN);frame_index += PS_HDR_LEN;if (is_key) {gb28181_make_sys_header(sys_header_buf, 0x3f); // 示例 rate_boundmemcpy(frame_buffer + frame_index, sys_header_buf, SYS_HDR_LEN);frame_index += SYS_HDR_LEN;gb28181_make_psm_header(psm_header_buf);memcpy(frame_buffer + frame_index, psm_header_buf, PSM_HDR_LEN);frame_index += PSM_HDR_LEN;}// --- PES 封装 ---gb28181_make_pes_header(pes_header_buf, 0xe0, length, pts, pts);memcpy(frame_buffer + frame_index, pes_header_buf, PES_HDR_LEN);frame_index += PES_HDR_LEN;memcpy(frame_buffer + frame_index, packet, length);frame_index += length;// --- RTP 分包发送 ---int rtp_packet_count = (frame_index + single_packet_max_length - 1) / single_packet_max_length;Log("RTP 分包数: " + std::to_string(rtp_packet_count));for (int i = 0; i < rtp_packet_count; ++i) {bool is_last_packet = (i == rtp_packet_count - 1);gb28181_make_rtp_header(rtp_header_buf, rtp_seq_counter, pts, ssrc_val, is_last_packet);int offset = i * single_packet_max_length;int data_size = std::min(single_packet_max_length, frame_index - offset);int rtp_start_index = 0;if (rtp_protocol_type == "TCP/RTP/AVP") {uint16_t packet_length = RTP_HDR_LEN + data_size;rtp_packet_buf[0] = (packet_length >> 8) & 0xFF;rtp_packet_buf[1] = packet_length & 0xFF;rtp_start_index = 2;}memcpy(rtp_packet_buf + rtp_start_index, rtp_header_buf, RTP_HDR_LEN);memcpy(rtp_packet_buf + rtp_start_index + RTP_HDR_LEN, frame_buffer + offset, data_size);send_network_packet(rtp_packet_buf, rtp_start_index + RTP_HDR_LEN + data_size);rtp_seq_counter++;}pts += interval;std::this_thread::sleep_for(std::chrono::milliseconds(send_packet_interval));delete nalu; // 模拟 Device::push_rtp_stream 中的 nalu delete}Log("--- 示例程序结束 ---");return 0;
}

基本逻辑

•  VPS/SPS/PPS 缓冲
  • out_nalu函数会将 buffer 中的数据分别复制到全局变量中，等待遇到关键帧的时候将其加入进入
• IDR 帧处理 (关键帧)
  • 将缓冲区中的VPS/PPS/SPS加入到Nalu之前
• 非 IDR 帧处理 (普通帧)
  • 直接分配内存进行发送