Reland of Rename RTPVideoHeader.isFirstPacket to .is_first_packet_in_frame.

webrtc/modules/video_coding/h264_sps_pps_tracker.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 52 matching lines @@
         pps_data_[nalu.pps_id].size = nalu.size;
         pps_data_[nalu.pps_id].data.reset(new uint8_t[nalu.size]);
         memcpy(pps_data_[nalu.pps_id].data.get(), data + nalu.offset,
                nalu.size);
         break;
       }
       case H264::NaluType::kIdr: {
         // If this is the first packet of an IDR, make sure we have the required
         // SPS/PPS and also calculate how much extra space we need in the buffer
         // to prepend the SPS/PPS to the bitstream with start codes.
-        if (video_header.isFirstPacket) {
+        if (video_header.is_first_packet_in_frame) {
           if (nalu.pps_id == -1) {
             LOG(LS_WARNING) << "No PPS id in IDR nalu.";
             return kRequestKeyframe;
           }
 
           auto pps = pps_data_.find(nalu.pps_id);
           if (pps == pps_data_.end()) {
             LOG(LS_WARNING) << "No PPS with id << " << nalu.pps_id
                             << " received";
             return kRequestKeyframe;
@@ skipping 20 matching lines @@
     }
   }
 
   if (!insert_packet)
     return kDrop;
 
   // Calculate how much space we need for the rest of the bitstream.
   if (codec_header.packetization_type == kH264StapA) {
     const uint8_t* nalu_ptr = data + 1;
     while (nalu_ptr < data + data_size) {
-      RTC_DCHECK(video_header.isFirstPacket);
+      RTC_DCHECK(video_header.is_first_packet_in_frame);
       required_size += sizeof(start_code_h264);
 
       // The first two bytes describe the length of a segment.
       uint16_t segment_length = nalu_ptr[0] << 8 | nalu_ptr[1];
       nalu_ptr += 2;
 
       required_size += segment_length;
       nalu_ptr += segment_length;
     }
   } else {
-    if (video_header.isFirstPacket)
+    if (video_header.is_first_packet_in_frame)
       required_size += sizeof(start_code_h264);
     required_size += data_size;
   }
 
   // Then we copy to the new buffer.
   uint8_t* buffer = new uint8_t[required_size];
   uint8_t* insert_at = buffer;
 
   // If pps_id != -1 then we have the SPS/PPS and they should be prepended
   // to the bitstream with start codes inserted.
@@ skipping 27 matching lines @@
       if (copy_end > data_size) {
         delete[] buffer;
         return kDrop;
       }
 
       memcpy(insert_at, nalu_ptr, segment_length);
       insert_at += segment_length;
       nalu_ptr += segment_length;
     }
   } else {
-    if (video_header.isFirstPacket) {
+    if (video_header.is_first_packet_in_frame) {
       memcpy(insert_at, start_code_h264, sizeof(start_code_h264));
       insert_at += sizeof(start_code_h264);
     }
     memcpy(insert_at, data, data_size);
   }
 
   packet->dataPtr = buffer;
   packet->sizeBytes = required_size;
   return kInsert;
 }
@@ skipping 21 matching lines @@
   pps_info.size = pps.size();
   pps_info.sps_id = parsed_pps->sps_id;
   uint8_t* pps_data = new uint8_t[pps_info.size];
   memcpy(pps_data, pps.data(), pps_info.size);
   pps_info.data.reset(pps_data);
   pps_data_[parsed_pps->id] = std::move(pps_info);
 }
 
 }  // namespace video_coding
 }  // namespace webrtc