WebRTC源码阅读——视频组帧

//利用packet的序列号计算出该packet存放于buffer_的位置
uint16_t seq_num = packet->seq_num;
size_t index = seq_num % buffer_.size();

//若buffer_[index]的值不为空，则按照序列号判断是否为同一packet,若是则返回，不是则不断扩充buffer_的容量，直到buffer_容量达到上限或packet待存放的位置未存储内容，若扩充达到上限依旧无法存放packet，则清除buffer_的内容后，直接返回。

 if (buffer_[index] != nullptr) {
    // Duplicate packet, just delete the payload.
    if (buffer_[index]->seq_num == packet->seq_num) {
      return result;
    }

    // The packet buffer is full, try to expand the buffer.
    while (ExpandBufferSize() && buffer_[seq_num % buffer_.size()] != nullptr) {
    }
    index = seq_num % buffer_.size();

    // Packet buffer is still full since we were unable to expand the buffer.
    if (buffer_[index] != nullptr) {
      // Clear the buffer, delete payload, and return false to signal that a
      // new keyframe is needed.
      RTC_LOG(LS_WARNING) << "Clear PacketBuffer and request key frame.";
      ClearInternal();
      result.buffer_cleared = true;
      return result;
    }
  }
  
//若buffer_[index]的值为空,则将packet存入buffer_，并且更新missing_packets_丢包记录，遍历buffer_找出当前packet所在的视频帧及其之后帧的所有packets。
  
packet->continuous = false;
buffer_[index] = std::move(packet);

UpdateMissingPackets(seq_num);

result.packets = FindFrames(seq_num);

//newest_inserted_seq_num_用于记录当前missing_packets_所插入的最新的序号，若seq_num比newest_inserted_seq_num_还要新，则说明seq_num与newest_inserted_seq_num_之间存在丢包。所以删除missing_packets_中从0开始到seq_num往前的1000个数据，并且不断更新newest_inserted_seq_num_值，并插入丢包的序列号到missing_packets_，直到newest_inserted_seq_num_为seq_num。

 const int kMaxPaddingAge = 1000;
 if (AheadOf(seq_num, *newest_inserted_seq_num_)) {
	uint16_t old_seq_num = seq_num - kMaxPaddingAge;
	auto erase_to = missing_packets_.lower_bound(old_seq_num);
	missing_packets_.erase(missing_packets_.begin(), erase_to);
	...
	while (AheadOf(seq_num, *newest_inserted_seq_num_)) {
	  missing_packets_.insert(*newest_inserted_seq_num_);
	  ++*newest_inserted_seq_num_;
	}
}

// Test if all previous packets has arrived for the given sequence number.按照官方注释译为判断是否给定seq_num之前的包都已经接收到。其具体实现其实是判断seq_num在buffer_存储index的packet与prev_index（index > 0 ? index - 1 : buffer_.size() - 1）对应packet的连续性 。当buffer[index]为一帧中的第一个packet或buffer[prev_index]->continuous = true时，该函数返回true，其他情况下比如两者序列号不符合连续条件，两者时间戳不相等都返回false。

bool PacketBuffer::PotentialNewFrame(uint16_t seq_num) const {
  size_t index = seq_num % buffer_.size();
  int prev_index = index > 0 ? index - 1 : buffer_.size() - 1;
  const auto& entry = buffer_[index];
  const auto& prev_entry = buffer_[prev_index];

  if (entry == nullptr)
    return false;
  if (entry->seq_num != seq_num)
    return false;
  if (entry->is_first_packet_in_frame())
    return true;
  if (prev_entry == nullptr)
    return false;
  if (prev_entry->seq_num != static_cast<uint16_t>(entry->seq_num - 1))
    return false;
  if (prev_entry->timestamp != entry->timestamp)
    return false;
  if (prev_entry->continuous)
    return true;

  return false;
}

//遍历buffer_查找完整帧的包
 for (size_t i = 0; i < buffer_.size() && PotentialNewFrame(seq_num); ++i) {
 ...
 	size_t index = seq_num % buffer_.size();
    buffer_[index]->continuous = true;
    //当找到一帧的最后一个包时，利用while(true)向前查找一帧的第一个包的序列号start_seq_num
    if (buffer_[index]->is_last_packet_in_frame()) {
     	 uint16_t start_seq_num = seq_num;
     	 int start_index = index;
     	 size_t tested_packets = 0;
		 ...
      	 int64_t frame_timestamp = buffer_[start_index]->timestamp;
    	 ...
    	 while (true) {
    	 	 ++tested_packets;
    	 	 //非h264编码依据packet->is_first_packet_in_frame()判断是否找到帧的第一个包
	    	 if (!is_h264 && buffer_[start_index]->is_first_packet_in_frame())
	          break;
	    	 ...
	    	 
	    	 if (tested_packets == buffer_.size())
             break;
          
	    	 start_index = start_index > 0 ? start_index - 1 : buffer_.size() - 1;
	    	 //对于h264没有确切的一帧起始标识，所以利用时间戳是否相等，判断是否找到一帧的起始包
	    	 if (is_h264 && (buffer_[start_index] == nullptr ||
	                        buffer_[start_index]->timestamp != frame_timestamp)) {
	          break;
	        }
	    	  --start_seq_num;
    	 }
    	 if (is_h264) {
    	 	...
    	 	//如果不属于h264的关键帧，并且在start_seq_num位置之前存在丢包，则直接返回
    	 	if (!is_h264_keyframe && missing_packets_.upper_bound(start_seq_num) !=
                                     missing_packets_.begin()) {
          	return found_frames;
        	}
    	 }
    	 //将查找到的一帧所有包存储到found_frames中
    	 const uint16_t end_seq_num = seq_num + 1;
    	 for (uint16_t i = start_seq_num; i != end_seq_num; ++i) {
	        std::unique_ptr<Packet>& packet = buffer_[i % buffer_.size()];
	        RTC_DCHECK(packet);
	        RTC_DCHECK_EQ(i, packet->seq_num);
	        // Ensure frame boundary flags are properly set.
	        packet->video_header.is_first_packet_in_frame = (i == start_seq_num);
	        packet->video_header.is_last_packet_in_frame = (i == seq_num);
	        found_frames.push_back(std::move(packet));
      	 }
		 //删除seq_num之前的丢包记录 
        missing_packets_.erase(missing_packets_.begin(),
                             missing_packets_.upper_bound(seq_num));
    	 
    }
  	++seq_num;
 }
 return found_frames;

（bool is_first_packet_in_frame() const {
   return video_header.is_first_packet_in_frame;
 }）

absl::optional<VideoRtpDepacketizer::ParsedRtpPayload> ProcessStapAOrSingleNalu(
    rtc::CopyOnWriteBuffer rtp_payload) {
    ...
     parsed_payload->video_header.is_first_packet_in_frame = true;
    ...
}

absl::optional<VideoRtpDepacketizer::ParsedRtpPayload> ParseFuaNalu(
    rtc::CopyOnWriteBuffer rtp_payload) {
  	...
  	bool first_fragment = (rtp_payload.cdata()[1] & kSBit) > 0;
  	...
   parsed_payload->video_header.is_first_packet_in_frame = first_fragment;
   ...
 }

if (!is_h264_keyframe && missing_packets_.upper_bound(start_seq_num) !=
                                     missing_packets_.begin()) {
	return found_frames;
}

//遍历result.packets
for (auto& packet : result.packets) {
 	if (packet->is_first_packet_in_frame()) {
 		...
 		payloads.clear();
      	packet_infos.clear();
 	}
	...
    payloads.emplace_back(packet->video_payload);
    packet_infos.push_back(packet->packet_info);
	...
	//若此packet为帧的结束packet,则进行转换
	 if (packet->is_last_packet_in_frame()) {
	 	...
	 	//将全部的video_payload拼接合成EncodedImageBuffer
	 	rtc::scoped_refptr<EncodedImageBuffer> bitstream =
          depacketizer_it->second->AssembleFrame(payloads);
      	...
      	//利用上述过程结果，将一帧数据的packets转换为RtpFrameObject类型对象（至此组帧完成），并交由OnAssembledFrame进行下一步处理。
      	 OnAssembledFrame(std::make_unique<video_coding::RtpFrameObject>(
          first_packet->seq_num,                    //
          last_packet.seq_num,                      //
          last_packet.marker_bit,                   //
          max_nack_count,                           //
          min_recv_time,                            //
          max_recv_time,                            //
          first_packet->timestamp,                  //
          first_packet->ntp_time_ms,                //
          last_packet.video_header.video_timing,    //
          first_packet->payload_type,               //
          first_packet->codec(),                    //
          last_packet.video_header.rotation,        //
          last_packet.video_header.content_type,    //
          first_packet->video_header,               //
          last_packet.video_header.color_space,     //
          RtpPacketInfos(std::move(packet_infos)),  //
          std::move(bitstream)));
	 }

}
//当packet_buffer插入packet发现buffer_已经再无法添加元素时，会清空buffer_，设置result.buffer_cleared标识为true，故此时需要重新请求关键帧。
if (result.buffer_cleared) {
	RequestKeyFrame();
}