Fix build issues after rebasing to M88 (#116)

Author: taste1981

modules/rtp_rtcp/source/rtp_format.cc

@@ -51,11 +51,10 @@ std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(
     }
 #ifndef DISABLE_H265
     case kVideoCodecH265: {
-      RTC_CHECK(fragmentation);
       const auto& h265 =
           absl::get<RTPVideoHeaderH265>(rtp_video_header.video_type_header);
       return absl::make_unique<RtpPacketizerH265>(
-          payload, limits, h265.packetization_mode, *fragmentation);
+          payload, limits, h265.packetization_mode);
     }
 #endif
     case kVideoCodecVP8: {

modules/rtp_rtcp/source/rtp_format_h265.cc

@@ -79,19 +79,17 @@ enum HevcFuDefs { kHevcSBit = 0x80, kHevcEBit = 0x40, kHevcFuTypeBit = 0x3F };
 RtpPacketizerH265::RtpPacketizerH265(
     rtc::ArrayView<const uint8_t> payload,
     PayloadSizeLimits limits,
-    H265PacketizationMode packetization_mode,
-    const RTPFragmentationHeader& fragmentation)
+    H265PacketizationMode packetization_mode)
     : limits_(limits),
       num_packets_left_(0) {
   // Guard against uninitialized memory in packetization_mode.
   RTC_CHECK(packetization_mode == H265PacketizationMode::NonInterleaved ||
             packetization_mode == H265PacketizationMode::SingleNalUnit);
 
-  for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) {
-    const uint8_t* fragment =
-        payload.data() + fragmentation.fragmentationOffset[i];
-    const size_t fragment_length = fragmentation.fragmentationLength[i];
-    input_fragments_.push_back(Fragment(fragment, fragment_length));
+  for (const auto& nalu :
+       H264::FindNaluIndices(payload.data(), payload.size())) {
+    input_fragments_.push_back(
+        payload.subview(nalu.payload_start_offset, nalu.payload_size));
   }
 
   if (!GeneratePackets(packetization_mode)) {
@@ -111,18 +109,12 @@ size_t RtpPacketizerH265::NumPackets() const {
   return num_packets_left_;
 }
 
-RtpPacketizerH265::Fragment::Fragment(const uint8_t* buffer, size_t length)
-    : buffer(buffer), length(length) {}
-RtpPacketizerH265::Fragment::Fragment(const Fragment& fragment)
-    : buffer(fragment.buffer), length(fragment.length) {}
-
-
 bool RtpPacketizerH265::GeneratePackets(
     H265PacketizationMode packetization_mode) {
   // For HEVC we follow non-interleaved mode for the packetization,
   // and don't support single-nalu mode at present.
   for (size_t i = 0; i < input_fragments_.size();) {
-    int fragment_len = input_fragments_[i].length;
+    int fragment_len = input_fragments_[i].size();
     int single_packet_capacity = limits_.max_payload_len;
     if (input_fragments_.size() == 1)
       single_packet_capacity -= limits_.single_packet_reduction_len;
@@ -147,7 +139,7 @@ bool RtpPacketizerH265::GeneratePackets(
 bool RtpPacketizerH265::PacketizeFu(size_t fragment_index) {
   // Fragment payload into packets (FU).
   // Strip out the original header and leave room for the FU header.
-  const Fragment& fragment = input_fragments_[fragment_index];
+  rtc::ArrayView<const uint8_t> fragment = input_fragments_[fragment_index];
   PayloadSizeLimits limits = limits_;
   limits.max_payload_len -= kHevcFuHeaderSize + kHevcNalHeaderSize;
 
@@ -170,7 +162,7 @@ bool RtpPacketizerH265::PacketizeFu(size_t fragment_index) {
     limits.last_packet_reduction_len = 0;
 
   // Strip out the original header.
-  size_t payload_left = fragment.length - kHevcNalHeaderSize;
+  size_t payload_left = fragment.size() - kHevcNalHeaderSize;
   int offset = kHevcNalHeaderSize;
 
   std::vector<int> payload_sizes = SplitAboutEqually(payload_left, limits);
@@ -180,8 +172,8 @@ bool RtpPacketizerH265::PacketizeFu(size_t fragment_index) {
   for (size_t i = 0; i < payload_sizes.size(); ++i) {
     int packet_length = payload_sizes[i];
     RTC_CHECK_GT(packet_length, 0);
-    uint16_t header = (fragment.buffer[0] << 8) | fragment.buffer[1];
-    packets_.push(PacketUnit(Fragment(fragment.buffer + offset, packet_length),
+    uint16_t header = (fragment[0] << 8) | fragment[1];
+    packets_.push(PacketUnit(fragment.subview(offset, packet_length),
                              /*first_fragment=*/i == 0,
                              /*last_fragment=*/i == payload_sizes.size() - 1,
                              false, header));
@@ -203,18 +195,18 @@ bool RtpPacketizerH265::PacketizeSingleNalu(size_t fragment_index) {
     payload_size_left -= limits_.first_packet_reduction_len;
   else if (fragment_index + 1 == input_fragments_.size())
     payload_size_left -= limits_.last_packet_reduction_len;
-  const Fragment* fragment = &input_fragments_[fragment_index];
-  if (payload_size_left < fragment->length) {
+  rtc::ArrayView<const uint8_t> fragment = input_fragments_[fragment_index];
+  if (payload_size_left < fragment.size()) {
     RTC_LOG(LS_ERROR) << "Failed to fit a fragment to packet in SingleNalu "
                          "packetization mode. Payload size left "
                       << payload_size_left << ", fragment length "
-                      << fragment->length << ", packet capacity "
+                      << fragment.size() << ", packet capacity "
                       << limits_.max_payload_len;
     return false;
   }
-  RTC_CHECK_GT(fragment->length, 0u);
-  packets_.push(PacketUnit(*fragment, true /* first */, true /* last */,
-                           false /* aggregated */, fragment->buffer[0]));
+  RTC_CHECK_GT(fragment.size(), 0u);
+  packets_.push(PacketUnit(fragment, true /* first */, true /* last */,
+                           false /* aggregated */, fragment[0]));
   ++num_packets_left_;
   return true;
 }
@@ -228,12 +220,12 @@ int RtpPacketizerH265::PacketizeAp(size_t fragment_index) {
     payload_size_left -= limits_.first_packet_reduction_len;
   int aggregated_fragments = 0;
   size_t fragment_headers_length = 0;
-  const Fragment* fragment = &input_fragments_[fragment_index];
-  RTC_CHECK_GE(payload_size_left, fragment->length);
+  rtc::ArrayView<const uint8_t> fragment = input_fragments_[fragment_index];
+  RTC_CHECK_GE(payload_size_left, fragment.size());
   ++num_packets_left_;
 
   auto payload_size_needed = [&] {
-    size_t fragment_size = fragment->length + fragment_headers_length;
+    size_t fragment_size = fragment.size() + fragment_headers_length;
     if (input_fragments_.size() == 1) {
       // Single fragment, single packet, payload_size_left already adjusted
       // with limits_.single_packet_reduction_len.
@@ -247,10 +239,10 @@ int RtpPacketizerH265::PacketizeAp(size_t fragment_index) {
   };
 
   while (payload_size_left >= payload_size_needed()) {
-    RTC_CHECK_GT(fragment->length, 0);
-    packets_.push(PacketUnit(*fragment, aggregated_fragments == 0, false, true,
-                             fragment->buffer[0]));
-    payload_size_left -= fragment->length;
+    RTC_CHECK_GT(fragment.size(), 0);
+    packets_.push(PacketUnit(fragment, aggregated_fragments == 0, false, true,
+                             fragment[0]));
+    payload_size_left -= fragment.size();
     payload_size_left -= fragment_headers_length;
 
     fragment_headers_length = kHevcLengthFieldSize;
@@ -265,7 +257,7 @@ int RtpPacketizerH265::PacketizeAp(size_t fragment_index) {
     ++fragment_index;
     if (fragment_index == input_fragments_.size())
       break;
-    fragment = &input_fragments_[fragment_index];
+    fragment = input_fragments_[fragment_index];
   }
   RTC_CHECK_GT(aggregated_fragments, 0);
   packets_.back().last_fragment = true;
@@ -283,9 +275,9 @@ bool RtpPacketizerH265::NextPacket(RtpPacketToSend* rtp_packet) {
 
   if (packet.first_fragment && packet.last_fragment) {
     // Single NAL unit packet.
-    size_t bytes_to_send = packet.source_fragment.length;
+    size_t bytes_to_send = packet.source_fragment.size();
     uint8_t* buffer = rtp_packet->AllocatePayload(bytes_to_send);
-    memcpy(buffer, packet.source_fragment.buffer, bytes_to_send);
+    memcpy(buffer, packet.source_fragment.data(), bytes_to_send);
     packets_.pop();
     input_fragments_.pop_front();
   } else if (packet.aggregated) {
@@ -320,12 +312,12 @@ void RtpPacketizerH265::NextAggregatePacket(RtpPacketToSend* rtp_packet,
   bool is_last_fragment = packet->last_fragment;
   while (packet->aggregated) {
     // Add NAL unit length field.
-    const Fragment& fragment = packet->source_fragment;
-    ByteWriter<uint16_t>::WriteBigEndian(&buffer[index], fragment.length);
+    rtc::ArrayView<const uint8_t> fragment = packet->source_fragment;
+    ByteWriter<uint16_t>::WriteBigEndian(&buffer[index], fragment.size());
     index += kHevcLengthFieldSize;
     // Add NAL unit.
-    memcpy(&buffer[index], fragment.buffer, fragment.length);
-    index += fragment.length;
+    memcpy(&buffer[index], fragment.data(), fragment.size());
+    index += fragment.size();
     packets_.pop();
     input_fragments_.pop_front();
     if (is_last_fragment)
@@ -355,20 +347,20 @@ void RtpPacketizerH265::NextFragmentPacket(RtpPacketToSend* rtp_packet) {
   // Now update payload_hdr_h with FU type.
   payload_hdr_h =
       (payload_hdr_h & kHevcTypeMaskN) | (kHevcFu << 1) | layer_id_h;
-  const Fragment& fragment = packet->source_fragment;
+  rtc::ArrayView<const uint8_t> fragment = packet->source_fragment;
   uint8_t* buffer = rtp_packet->AllocatePayload(
-      kHevcFuHeaderSize + kHevcNalHeaderSize + fragment.length);
+      kHevcFuHeaderSize + kHevcNalHeaderSize + fragment.size());
   RTC_CHECK(buffer);
   buffer[0] = payload_hdr_h;
   buffer[1] = payload_hdr_l;
   buffer[2] = fu_header;
 
   if (packet->last_fragment) {
-    memcpy(buffer + kHevcFuHeaderSize + kHevcNalHeaderSize, fragment.buffer,
-           fragment.length);
+    memcpy(buffer + kHevcFuHeaderSize + kHevcNalHeaderSize, fragment.data(),
+           fragment.size());
   } else {
-    memcpy(buffer + kHevcFuHeaderSize + kHevcNalHeaderSize, fragment.buffer,
-           fragment.length);
+    memcpy(buffer + kHevcFuHeaderSize + kHevcNalHeaderSize, fragment.data(),
+           fragment.size());
   }
   packets_.pop();
 }

modules/rtp_rtcp/source/rtp_format_h265.h

@@ -31,8 +31,7 @@ class RtpPacketizerH265 : public RtpPacketizer {
   // The payload_data must be exactly one encoded H.265 frame.
   RtpPacketizerH265(rtc::ArrayView<const uint8_t> payload,
                     PayloadSizeLimits limits,
-                    H265PacketizationMode packetization_mode,
-                    const RTPFragmentationHeader& fragmentation);
+                    H265PacketizationMode packetization_mode);
 
    ~RtpPacketizerH265() override;
 
@@ -69,15 +68,8 @@ class RtpPacketizerH265 : public RtpPacketizer {
     bool aggregated;
     uint16_t header;  // Different from H264
   };
-  struct Fragment {
-    Fragment(const uint8_t* buffer, size_t length);
-    explicit Fragment(const Fragment& fragment);
-    const uint8_t* buffer = nullptr;
-    size_t length = 0;
-    std::unique_ptr<rtc::Buffer> tmp_buffer;
-  };
   struct PacketUnit {
-    PacketUnit(const Fragment& source_fragment,
+    PacketUnit(rtc::ArrayView<const uint8_t> source_fragment,
                bool first_fragment,
                bool last_fragment,
                bool aggregated,
@@ -88,14 +80,14 @@ class RtpPacketizerH265 : public RtpPacketizer {
           aggregated(aggregated),
           header(header) {}
 
-    const Fragment source_fragment;
+    rtc::ArrayView<const uint8_t> source_fragment;
     bool first_fragment;
     bool last_fragment;
     bool aggregated;
     uint16_t header;
   };
   typedef std::queue<Packet> PacketQueue;
-  std::deque<Fragment> input_fragments_;
+  std::deque<rtc::ArrayView<const uint8_t>> input_fragments_;
   std::queue<PacketUnit> packets_;
 
   bool GeneratePackets(H265PacketizationMode packetization_mode);
@@ -108,7 +100,6 @@ class RtpPacketizerH265 : public RtpPacketizer {
 
   const PayloadSizeLimits limits_;
   size_t num_packets_left_;
-  RTPFragmentationHeader fragmentation_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtpPacketizerH265);
 };