webrtc 源码有个RTPFragmentationHeader 类。在自己注入264 数据的时候，需要解析出一个这样的头，这个我的理解，就是用来把一帧264数据按照nalu 结构切分一下，方便后面的rtp封装

我们来看一个解析一帧数据的HEAD

这里只分析264的

RTPFragmentationHeader VideoEncoderWrapper::ParseFragmentationHeader(
    rtc::ArrayView<const uint8_t> buffer) {
  RTPFragmentationHeader header;
  if (codec_settings_.codecType == kVideoCodecH264) {
    h264_bitstream_parser_.ParseBitstream(buffer.data(), buffer.size());

    // For H.264 search for start codes.
    const std::vector<H264::NaluIndex> nalu_idxs =
        H264::FindNaluIndices(buffer.data(), buffer.size());
    if (nalu_idxs.empty()) {
      RTC_LOG(LS_ERROR) << "Start code is not found!";
      RTC_LOG(LS_ERROR) << "Data:" << buffer[0] << " " << buffer[1] << " "
                        << buffer[2] << " " << buffer[3] << " " << buffer[4]
                        << " " << buffer[5];
    }
    header.VerifyAndAllocateFragmentationHeader(nalu_idxs.size());
    for (size_t i = 0; i < nalu_idxs.size(); i++) {
      header.fragmentationOffset[i] = nalu_idxs[i].payload_start_offset;
      header.fragmentationLength[i] = nalu_idxs[i].payload_size;
    }
  } else {
    // Generate a header describing a single fragment.
    header.VerifyAndAllocateFragmentationHeader(1);
    header.fragmentationOffset[0] = 0;
    header.fragmentationLength[0] = buffer.size();
  }
  return header;
}

• 1. 首先是把帧字节数据拆分成多个nalu 信息

const std::vector<H264::NaluIndex> nalu_idxs =
        H264::FindNaluIndices(buffer.data(), buffer.size());

• 2. VerifyAndAllocateFragmentationHeader 是分配head 里面的空间
• 3. 后面就是把nalu_idxs 信息解析到header里面，这样header 里面就有了nalu的位置信息了，后面可以用于rtp封装
• 4. 对于一个nalu 就是一帧的，其实可简化，相当于header 长度1，fragmentationOffset 为 3或者4，fragmentationLength 就是整个长度减去3或者4

• 详细理解一下FindNaluIndices方法，以后可能用得着
  这个NaluIndex 的结构如下

struct NaluIndex {
  // Start index of NALU, including start sequence.
  size_t start_offset;
  // Start index of NALU payload, typically type header.
  size_t payload_start_offset;
  // Length of NALU payload, in bytes, counting from payload_start_offset.
  size_t payload_size;
};

start_offset: 一个nalu 的开始位置，包括nalu头 这个位置是相对于整个帧数据长度的

payload_start_offset: 一个nalu 的开始位置，不包括nalu头, 这个位置是相对于整个帧数据长度的

payload_size: nalu 的负载长度，不包括nalu头

再来分析一下 FindNaluIndices 的实现：

std::vector<NaluIndex> FindNaluIndices(const uint8_t* buffer,
                                       size_t buffer_size) {
  std::vector<NaluIndex> sequences;
  if (buffer_size < kNaluShortStartSequenceSize)
    return sequences;

  const size_t end = buffer_size - kNaluShortStartSequenceSize;
  for (size_t i = 0; i < end;) {
    if (buffer[i + 2] > 1) {
      i += 3;
    } else if (buffer[i + 2] == 1 && buffer[i + 1] == 0 && buffer[i] == 0) {
      // We found a start sequence, now check if it was a 3 of 4 byte one.
      NaluIndex index = {i, i + 3, 0};
      if (index.start_offset > 0 && buffer[index.start_offset - 1] == 0)
        --index.start_offset;

      // Update length of previous entry.
      auto it = sequences.rbegin();
      if (it != sequences.rend())
        it->payload_size = index.start_offset - it->payload_start_offset;

      sequences.push_back(index);

      i += 3;
    } else {
      ++i;
    }
  }

  // Update length of last entry, if any.
  auto it = sequences.rbegin();
  if (it != sequences.rend())
    it->payload_size = buffer_size - it->payload_start_offset;

  return sequences;
}

这里面要理解的是，找到一个nalu得出它的start_offset,payload_start_offset。 但是他的payload_size是在下一次nalu 的时候，用下一个nalu的start_offset 减去当前的payload_start_offset 刚好就是负载的长度。