Add test which verifies that the RTP header extensions are set correctly for FEC packets.

webrtc/modules/rtp_rtcp/source/rtp_sender_video.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 24 matching lines @@
 };
 
 RTPSenderVideo::RTPSenderVideo(Clock* clock, RTPSenderInterface* rtpSender)
     : _rtpSender(*rtpSender),
       crit_(CriticalSectionWrapper::CreateCriticalSection()),
       _videoType(kRtpVideoGeneric),
       _maxBitrate(0),
       _retransmissionSettings(kRetransmitBaseLayer),
 
       // Generic FEC
-      _fec(),
-      _fecEnabled(false),
-      _payloadTypeRED(-1),
-      _payloadTypeFEC(-1),
+      fec_(),
+      fec_enabled_(false),
+      red_payload_type_(-1),
+      fec_payload_type_(-1),
       delta_fec_params_(),
       key_fec_params_(),
-      producer_fec_(&_fec),
+      producer_fec_(&fec_),
       _fecOverheadRate(clock, NULL),
       _videoBitrate(clock, NULL) {
   memset(&delta_fec_params_, 0, sizeof(delta_fec_params_));
   memset(&key_fec_params_, 0, sizeof(key_fec_params_));
   delta_fec_params_.max_fec_frames = key_fec_params_.max_fec_frames = 1;
   delta_fec_params_.fec_mask_type = key_fec_params_.fec_mask_type =
       kFecMaskRandom;
 }
 
 RTPSenderVideo::~RTPSenderVideo() {
@@ skipping 61 matching lines @@
                                           StorageType media_packet_storage,
                                           bool protect) {
   rtc::scoped_ptr<RedPacket> red_packet;
   std::vector<RedPacket*> fec_packets;
   StorageType fec_storage = kDontRetransmit;
   uint16_t next_fec_sequence_number = 0;
   {
     // Only protect while creating RED and FEC packets, not when sending.
     CriticalSectionScoped cs(crit_.get());
     red_packet.reset(producer_fec_.BuildRedPacket(
-        data_buffer, payload_length, rtp_header_length, _payloadTypeRED));
+        data_buffer, payload_length, rtp_header_length, red_payload_type_));
     if (protect) {
       producer_fec_.AddRtpPacketAndGenerateFec(data_buffer, payload_length,
                                                rtp_header_length);
     }
     uint16_t num_fec_packets = producer_fec_.NumAvailableFecPackets();
     if (num_fec_packets > 0) {
       next_fec_sequence_number =
           _rtpSender.AllocateSequenceNumber(num_fec_packets);
       fec_packets = producer_fec_.GetFecPackets(
-          _payloadTypeRED, _payloadTypeFEC, next_fec_sequence_number,
+          red_payload_type_, fec_payload_type_, next_fec_sequence_number,
           rtp_header_length);
       RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
       if (_retransmissionSettings & kRetransmitFECPackets)
         fec_storage = kAllowRetransmission;
     }
   }
   if (_rtpSender.SendToNetwork(
           red_packet->data(), red_packet->length() - rtp_header_length,
           rtp_header_length, capture_time_ms, media_packet_storage,
           RtpPacketSender::kLowPriority) == 0) {
@@ skipping 19 matching lines @@
     }
     delete fec_packet;
     ++next_fec_sequence_number;
   }
 }
 
 void RTPSenderVideo::SetGenericFECStatus(const bool enable,
                                          const uint8_t payloadTypeRED,
                                          const uint8_t payloadTypeFEC) {
   CriticalSectionScoped cs(crit_.get());
-  _fecEnabled = enable;
-  _payloadTypeRED = payloadTypeRED;
-  _payloadTypeFEC = payloadTypeFEC;
+  fec_enabled_ = enable;
+  red_payload_type_ = payloadTypeRED;
+  fec_payload_type_ = payloadTypeFEC;
   memset(&delta_fec_params_, 0, sizeof(delta_fec_params_));
   memset(&key_fec_params_, 0, sizeof(key_fec_params_));
   delta_fec_params_.max_fec_frames = key_fec_params_.max_fec_frames = 1;
   delta_fec_params_.fec_mask_type = key_fec_params_.fec_mask_type =
       kFecMaskRandom;
 }
 
 void RTPSenderVideo::GenericFECStatus(bool& enable,
                                       uint8_t& payloadTypeRED,
                                       uint8_t& payloadTypeFEC) const {
   CriticalSectionScoped cs(crit_.get());
-  enable = _fecEnabled;
-  payloadTypeRED = _payloadTypeRED;
-  payloadTypeFEC = _payloadTypeFEC;
+  enable = fec_enabled_;
+  payloadTypeRED = red_payload_type_;
+  payloadTypeFEC = fec_payload_type_;
 }
 
 size_t RTPSenderVideo::FECPacketOverhead() const {
   CriticalSectionScoped cs(crit_.get());
-  if (_fecEnabled) {
+  if (fec_enabled_) {
     // Overhead is FEC headers plus RED for FEC header plus anything in RTP
     // header beyond the 12 bytes base header (CSRC list, extensions...)
     // This reason for the header extensions to be included here is that
     // from an FEC viewpoint, they are part of the payload to be protected.
     // (The base RTP header is already protected by the FEC header.)
     return ForwardErrorCorrection::PacketOverhead() + REDForFECHeaderLength +
            (_rtpSender.RTPHeaderLength() - kRtpHeaderSize);
   }
   return 0;
 }
@@ skipping 25 matching lines @@
                             &(rtpHdr->codecHeader), frameType));
 
   StorageType storage;
   bool fec_enabled;
   {
     CriticalSectionScoped cs(crit_.get());
     FecProtectionParams* fec_params =
         frameType == kVideoFrameKey ? &key_fec_params_ : &delta_fec_params_;
     producer_fec_.SetFecParameters(fec_params, 0);
     storage = packetizer->GetStorageType(_retransmissionSettings);
-    fec_enabled = _fecEnabled;
+    fec_enabled = fec_enabled_;
   }
 
   // Register CVO rtp header extension at the first time when we receive a frame
   // with pending rotation.
   RTPSenderInterface::CVOMode cvo_mode = RTPSenderInterface::kCVONone;
   if (rtpHdr && rtpHdr->rotation != kVideoRotation_0) {
     cvo_mode = _rtpSender.ActivateCVORtpHeaderExtension();
   }
 
   uint16_t rtp_header_length = _rtpSender.RTPHeaderLength();
@@ skipping 89 matching lines @@
   CriticalSectionScoped cs(crit_.get());
   return _retransmissionSettings;
 }
 
 void RTPSenderVideo::SetSelectiveRetransmissions(uint8_t settings) {
   CriticalSectionScoped cs(crit_.get());
   _retransmissionSettings = settings;
 }
 
 }  // namespace webrtc