Minor fixes in FEC and RtpSender{,Video}. (pt. 2)

webrtc/modules/rtp_rtcp/source/forward_error_correction.cc

 /*
  *  Copyright (c) 2012 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 101 matching lines @@
   if (num_media_packets > kMaxMediaPackets) {
     LOG(LS_WARNING) << "Can't protect " << num_media_packets
                     << " media packets per frame. Max is " << kMaxMediaPackets
                     << ".";
     return -1;
   }
 
   bool l_bit = (num_media_packets > 8 * kMaskSizeLBitClear);
   int num_mask_bytes = l_bit ? kMaskSizeLBitSet : kMaskSizeLBitClear;
 
-  // Do some error checking on the media packets.
+  // Error check the media packets.
   for (const auto& media_packet : media_packets) {
     RTC_DCHECK(media_packet);
-
     if (media_packet->length < kRtpHeaderSize) {
       LOG(LS_WARNING) << "Media packet " << media_packet->length << " bytes "
                       << "is smaller than RTP header.";
       return -1;
     }
-
-    // Ensure our FEC packets will fit in a typical MTU.
-    if (media_packet->length + PacketOverhead() + kTransportOverhead >
+    // Ensure the FEC packets will fit in a typical MTU.
+    if (media_packet->length + MaxPacketOverhead() + kTransportOverhead >
         IP_PACKET_SIZE) {
       LOG(LS_WARNING) << "Media packet " << media_packet->length << " bytes "
                       << "with overhead is larger than " << IP_PACKET_SIZE
                       << " bytes.";
     }
   }
 
-  int num_fec_packets = GetNumberOfFecPackets(num_media_packets,
-                                              protection_factor);
+  int num_fec_packets = NumFecPackets(num_media_packets, protection_factor);
   if (num_fec_packets == 0) {
     return 0;
   }
 
   // Prepare generated FEC packets by setting them to 0.
   for (int i = 0; i < num_fec_packets; ++i) {
     memset(generated_fec_packets_[i].data, 0, IP_PACKET_SIZE);
     // Use this as a marker for untouched packets.
     generated_fec_packets_[i].length = 0;
     fec_packets->push_back(&generated_fec_packets_[i]);
@@ skipping 17 matching lines @@
   if (l_bit) {
     num_mask_bytes = kMaskSizeLBitSet;
   }
 
   GenerateFecBitStrings(media_packets, packet_mask_, num_fec_packets, l_bit);
   GenerateFecUlpHeaders(media_packets, packet_mask_, num_fec_packets, l_bit);
 
   return 0;
 }
 
-int ForwardErrorCorrection::GetNumberOfFecPackets(int num_media_packets,
-                                                  int protection_factor) {
+int ForwardErrorCorrection::NumFecPackets(int num_media_packets,
+                                          int protection_factor) {
   // Result in Q0 with an unsigned round.
   int num_fec_packets = (num_media_packets * protection_factor + (1 << 7)) >> 8;
   // Generate at least one FEC packet if we need protection.
   if (protection_factor > 0 && num_fec_packets == 0) {
     num_fec_packets = 1;
   }
   RTC_DCHECK_LE(num_fec_packets, num_media_packets);
   return num_fec_packets;
 }
 
@@ skipping 577 matching lines @@
       // A big gap in sequence numbers. The old recovered packets
       // are now useless, so it's safe to do a reset.
       ResetState(recovered_packets);
     }
   }
   InsertPackets(received_packets, recovered_packets);
   AttemptRecover(recovered_packets);
   return 0;
 }
 
-size_t ForwardErrorCorrection::PacketOverhead() {
+size_t ForwardErrorCorrection::MaxPacketOverhead() const {
   return kFecHeaderSize + kUlpHeaderSizeLBitSet;
 }
 }  // namespace webrtc