解 h264 rtp 包

参考：

• srs

1. 概述

本篇文章参考 srs，简单实现一个组帧的模块，用于记录学习。
关于 h264 码流打包 rtp，参考：https://www.cnblogs.com/moonwalk/p/15903760.html。

2. 组帧

伪代码如下，注意点已经通过注释标明：

enum class H264_PACK_TYPE {
  STAPA = 0,
  FUA = 1,
  SINGLE = 2,
};

struct RawData {
  char* data;
  int size;
};

struct H264Nalu {
  void append(char* data, int size);
};

struct RtpPacket {
  uint32_t get_timestamp();
  uint16_t get_sequence();
  bool get_marker();

  bool is_keyframe();
  bool is_empty_payload();
  H264_PACK_TYPE pack_type();

  std::vector<RawData*> rtp_nalus parse_payload_stapa();
  void parse_payload_fua();
  void parse_payload_single();
  uint8_t get_fua_header();
  RawData* get_fua_payload();
  RawData* get_sps();
  RawData* get_pps();
};

const static uint8_t H264_ANNEX_B_START_CODE[4] = {0x00, 0x00, 0x00, 0x01};

//
// gop 缓存
//
const static int gop_cache_capacity = 3000;
std::vector<RtpPacket*> gop_cache(gop_cache_capacity);

//
// 组帧时检查的起始 rtp 序列号
//
uint16_t frame_window_start;


//
// 一个 gop cache 内最早的, 还未接收到的 rtp 序列号
//
uint16_t lost_seq;

//
// @brief 判断序列号 prev 与 now 的相对大小
// @note 原理就是如果 now 领先于 prev, 那么:
//   如果没有发生回绕, 相减大于 0
//   如果发生了回绕, 回绕数值小于 0x10000 >> 1(即 uint16_t 最高位为 1), 相减还是大于 0
//
int16_t rtp_seq_distance(uint16_t prev, uint16_t now) {
  return (int16_t)(now - prev);
}

// 
// @brief 清理序列号在 sequence 之前的所有 rtp 包
//
void clear_gop_cache(uint16_t sequence) {
  for (int i = 0; i < gop_cache.size(); ++i) {
    GoRtpPacket* rtp_pkt = gop_cache[i];

    // 注意处理序列号回绕
    if (rtp_pkt && (rtp_seq_distance(rtp_pkt->get_sequence(), sequence) > 0)) {
      delete rtp_pkt;
      gop_cache[i] = nullptr;
    }
  }
}

void cache_packet(RtpPacket* rtp_pkt) {
  int index = rtp_pkt->get_sequence() % gop_cache_capacity;
  if (gop_cache[index]) {
    // warning: duplicate rtp package
    delete gop_cache[index];
  }
  gop_cache[index] = rtp_pkt;
}

void uncahce_packet(RtpPacket* rtp_pkt) {
  int index = rtp_pkt->get_sequence() % gop_cache_capacity;
  delete rtp_pkt;
  gop_cache[index] = nullptr;
}

//
// @berief 尝试组帧
// @return {uint16_t} start_seq 找到的帧起始序列号
// @return {uint16_t} end_seq 找到的帧结束序列号
// @return {bool} true 找到一个完整帧
// @note 此函数是一个非常关键的函数
//
bool get_complete_frame(uint16_t& start_seq, uint16_t& end_seq) {
  //
  // 从下一帧的起始 rtp 序列号开始找
  //
  RtpPacket* frame_rtp_pkt = gop_cache[frame_window_start % gop_cache_capacity];
  if (frame_rtp_pkt == nullptr) {
    lost_seq = frame_window_start;
    return false;
  }

  // 一个完整帧可以通过 rtp 时间戳和 mark 标志来判断
  uint32_t frame_ts = frame_rtp_pkt->get_timestamp();

  //
  // 尝试查找一个完整帧, 范围 [frame_window_start, frame_window_start + gop_cache_capacity]
  //
  for (int i = 0; i < gop_cache_capacity; ++i) {
    uint16_t seq = frame_window_start + i;
    int index = seq % gop_cache_capacity;
    RtpPacket* rtp_pkt = gop_cache[index];

    // rtp 缺失, 查找失败
    if (rtp_pkt == nullptr) {
      lost_seq = seq;
      return false;
    }

    // 找到 rtp mark 标记, 可以认为找到了一个完整帧
    if (rtp_pkt->get_marker()) {
      start = frame_window_start;
      end = seq;
      frame_window_start = seq + 1;
      return true;
    }

    // 当前 rtp packet 的 rtp timestamp 与起始的不同, 可以认为找到了一个完整帧
    // 实际上这里是一个兼容处理, 发送端应该正确打上 mark 标记
    if (rtp_pkt->get_timestamp() != frame_ts) {
      start = frame_window_start;
      end = seq - 1;
      frame_window_start = seq;
      return true;
    }
  }

  return false;
}

//
// @berief 输入一个包含 sps、pps、sei nalu 的 rtp packet, 组合 nalu 流后输出
// @param {RtpPacket*} rtp_pkt rtp 包
// @return {H264Nalu*} nalu annex-b 码流格式
// @note 一般 webrtc 发送 sps、pp、sei、idr 时, sps && pps && sei 会组合到 stap-a 一个 rtp 包发出, 
//    idr 紧接着以 fu-a 格式多个 rtp 包发出, 他们拥有相同的 timestamp
//
H264Nalu* on_spspps(RtpPacket* rtp_pkt) {
  RawData* sps = rtp_pkt->get_sps();
  RawData* pps = rtp_pkt->get_pps();
  if (sps == nullptr || pps == nullptr) {
    // error, 错误发生
    return nullptr;
  }

  H264Nalu* nalu = new H264Nalu;
  nalu->append(sps->data, sps->size);
  nalu->append(H264_ANNEX_B_START_CODE, sizeof(H264_ANNEX_B_START_CODE));
  nalu->append(pps->data, pps->size);

  return nalu;
}

//
// @brief 输入一个 rtp packet, 输出 nalu 数组
// @param {RtpPacket*} rtp_pkt rtp 包
// @return {std::vector<H264Nalu*>} nalu 数组
//
std::vector<H264Nalu*> on_rtp(RtpPacket* rtp_pkt) {
  std::vector<H264Nalu*> nalu_queue;

  //
  // 每次关键帧清理 gop cache
  //
  if (rtp_pkt->is_keyframe()) {
    clear_gop_cache(rtp_pkt->get_sequence());
    frame_window_start = rtp_pkt->get_sequence();
    lost_seq = frame_window_start + 1;
  }

  //
  // 缓存 rtp packet
  //
  cache_packet(rtp_pkt);

  //
  // 如果新来的 rtp packet 填充了 gop cache 中缺失的 rtp, 才尝试组帧, 否则继续等待
  //
  if (rtp_pkt->get_sequence() != lost_seq) {
    return nalu_queue;
  }

  uint16_t start_seq, end_seq;
  //
  // 不断尝试组帧
  //
  while (get_complete_frame(start_seq, end_seq)) {
    //
    // 每个完整帧前面可能会发一些 padding 空包, 需要先去掉
    // 注意处理序列号回绕
    //
    for (uint16_t seq = start_seq; seq != (uint16_t)(end_seq + 1); ++seq) {
      RtpPacket* frame_pkt = gop_cache[(int)seq % gop_cache_capacity];
      if (frame_pkt->is_empty_payload()) {
        uncache_packet(frame_pkt);
        start_seq = seq + 1;
      } else {
        break;
      }
    }

    H264Nalu* nalu = nullptr;
    bool fua_start = true;
    //
    // 遍历一个完整帧的起始序列号 [start_seq, end_seq]
    // 注意处理序列号回绕
    //
    for (uint16_t seq = start_seq; seq != (uint16_t)(end_seq + 1); ++seq) {
      RtpPacket* frame_pkt = gop_cache[(int)seq % gop_cache_capacity];

      //
      // 当前 rtp packet 是 stap-a 类型的
      //
      if (frame_pkt->pack_type() == H264_PACK_TYPE::STAPA) {
        if (frame_pkt->is_keyframe()) {
          // 找到一个 nalu(实际上是多个 nalus), 这里可以先不用插入到结果数组,
          // 因为一般 sps-pps-sei-idr 会组合在一起发送, 可以等待拼接 idr 后再插入到结果数组
          nalu = on_spspps(frame_pkt);
          if (nalu == nullptr) {
            // error, 发生错误
          }
        } else {
          std::vector<RawData*> rtp_nalus = frame_pkt->parse_payload_stapa();
          nalu = new H264Nalu;
          for (int j = 0; j < rtp_nalus.size(); ++j) {
            nalu->append(rtp_nalus[j]->data, rtp_nalus[j]->size);
            if (j != rtp_nalus.size() - 1) {
              nalu->append(H264_ANNEX_B_START_CODE, sizeof(H264_ANNEX_B_START_CODE));
            }
          }
          // 找到一个 nalu(实际上是多个 nalus), 插入到结果数组
          nalu_queue.push(nalu);
          nalu = nullptr;
        }
        uncache(frame_pkt);
        continue;
      }

      //
      // 当前 rtp packet 是 fu-a 类型的
      //
      if (frame_pkt->pack_type() == H264_PACK_TYPE::FUA) {
        frame_pkt->parse_payload_fua();

        if (fua_start == true) {
          if (nalu == nullptr) {
            nalu = new H264Nalu;
          } else {
            // 注意这里可能会组合上面 stap-a 的 nalu
            nalu->append(H264_ANNEX_B_START_CODE, sizeof(H264_ANNEX_B_START_CODE));
          }
          uint8_t nalu_header = frame_pkt->get_fua_header();
          nalu->append((char*)(&nalu_header), 1);
          fua_start = false;
        }

        RawData* rtp_nalu = frame_pkt->get_fua_payload();
        nalu->append(rtp_nalu->data, rtp_nalu->size);
        if (seq == end_seq) {
          // 找到一个 nalu(实际上可能是多个 nalus), 插入到结果数组
          nalu_queue.push(nalu);
          nalu = nullptr;
        }
        uncache(frame_pkt);
        continue;
      }

      //
      // 当前 rtp packet 是 single 类型的
      //
      if (frame_pkt->pack_type() == H264_PACK_TYPE::SINGLE) {
        frame_pkt->parse_payload_single();

        if (nalu == nullptr) {
          nalu = new H264Nalu;
        } else {
          // 注意这里可能会组合上面 stap-a 的 nalu
          nalu->append(H264_ANNEX_B_START_CODE, sizeof(H264_ANNEX_B_START_CODE));
        }
        RawData* rtp_nalu = frame_pkt->get_single_payload();
        nalu->append(rtp_nalu->data, rtp_nalu->size);
        if (seq == end_seq) {
          // 找到一个 nalu, 插入到结果数组
          nalu_queue.push(nalu);
          nalu = nullptr;
        }
        uncache(frame_pkt);
        continue;
      }

      //
      // 如果不是上面 3 种类型, 可能发生了错误, 直接 uncache 掉
      //
      uncache(frame_pkt);
    }

    // 复位 nalu
    if (nalu) {
      delete nalu;
      nalue = nullptr;
    }

    //
    // 每个完整帧后面也可能会发一些 padding 空包, 需要先去掉
    //
    uint16_t padding_seq = end_seq + 1;
    RtpPacket* padding_pkt = gop_cache[padding_seq % gop_cache_capacity];
    while (padding_pkt) {
      if (padding_pkt->is_empty_payload()) {
        frame_window_start = padding_seq + 1;
        uncache(padding_pkt);

        padding_seq += 1;
        padding_pkt = gop_cache[padding_seq % gop_cache_capacity];
      } else {
        break;
      }
    }
  } // end of get_complete_frame(start_seq, end_seq)

  return nalu_queue;
}

如上，整体思路就是缓存最近的一个 GOP cache，从第一个 IDR 开始不断向后扫描，不断得到一个完整帧。
如果向后扫描的时候有 rtp 空缺，需要等待收到乱序的 rtp 包后才能继续组帧。
需要注意 webrtc 客户端可能会发送一些空的 padding 包，组帧的时候需要去掉。