Home | History | Annotate | Download | only in source 
      1 /*
      2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
     12 
     13 #include <assert.h>
     14 #include <string.h>
     15 
     16 #include "webrtc/common_types.h"
     17 #include "webrtc/system_wrappers/interface/logging.h"
     18 #include "webrtc/system_wrappers/interface/trace.h"
     19 
     20 #ifdef _WIN32
     21 // Disable warning C4355: 'this' : used in base member initializer list.
     22 #pragma warning(disable : 4355)
     23 #endif
     24 
     25 namespace webrtc {
     26 
     27 RtpRtcp::Configuration::Configuration()
     28     : id(-1),
     29       audio(false),
     30       clock(NULL),
     31       default_module(NULL),
     32       receive_statistics(NullObjectReceiveStatistics()),
     33       outgoing_transport(NULL),
     34       rtcp_feedback(NULL),
     35       intra_frame_callback(NULL),
     36       bandwidth_callback(NULL),
     37       rtt_stats(NULL),
     38       audio_messages(NullObjectRtpAudioFeedback()),
     39       remote_bitrate_estimator(NULL),
     40       paced_sender(NULL) {
     41 }
     42 
     43 RtpRtcp* RtpRtcp::CreateRtpRtcp(const RtpRtcp::Configuration& configuration) {
     44   if (configuration.clock) {
     45     return new ModuleRtpRtcpImpl(configuration);
     46   } else {
     47     RtpRtcp::Configuration configuration_copy;
     48     memcpy(&configuration_copy, &configuration,
     49            sizeof(RtpRtcp::Configuration));
     50     configuration_copy.clock = Clock::GetRealTimeClock();
     51     ModuleRtpRtcpImpl* rtp_rtcp_instance =
     52         new ModuleRtpRtcpImpl(configuration_copy);
     53     return rtp_rtcp_instance;
     54   }
     55 }
     56 
     57 ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
     58     : rtp_sender_(configuration.id,
     59                   configuration.audio,
     60                   configuration.clock,
     61                   configuration.outgoing_transport,
     62                   configuration.audio_messages,
     63                   configuration.paced_sender),
     64       rtcp_sender_(configuration.id,
     65                    configuration.audio,
     66                    configuration.clock,
     67                    configuration.receive_statistics),
     68       rtcp_receiver_(configuration.id, configuration.clock, this),
     69       clock_(configuration.clock),
     70       id_(configuration.id),
     71       audio_(configuration.audio),
     72       collision_detected_(false),
     73       last_process_time_(configuration.clock->TimeInMilliseconds()),
     74       last_bitrate_process_time_(configuration.clock->TimeInMilliseconds()),
     75       last_rtt_process_time_(configuration.clock->TimeInMilliseconds()),
     76       packet_overhead_(28),  // IPV4 UDP.
     77       critical_section_module_ptrs_(
     78           CriticalSectionWrapper::CreateCriticalSection()),
     79       critical_section_module_ptrs_feedback_(
     80           CriticalSectionWrapper::CreateCriticalSection()),
     81       default_module_(
     82           static_cast<ModuleRtpRtcpImpl*>(configuration.default_module)),
     83       padding_index_(-1),  // Start padding at the first child module.
     84       nack_method_(kNackOff),
     85       nack_last_time_sent_full_(0),
     86       nack_last_seq_number_sent_(0),
     87       simulcast_(false),
     88       key_frame_req_method_(kKeyFrameReqFirRtp),
     89       remote_bitrate_(configuration.remote_bitrate_estimator),
     90       rtt_stats_(configuration.rtt_stats),
     91       critical_section_rtt_(CriticalSectionWrapper::CreateCriticalSection()),
     92       rtt_ms_(0) {
     93   send_video_codec_.codecType = kVideoCodecUnknown;
     94 
     95   if (default_module_) {
     96     default_module_->RegisterChildModule(this);
     97   }
     98   // TODO(pwestin) move to constructors of each rtp/rtcp sender/receiver object.
     99   rtcp_receiver_.RegisterRtcpObservers(configuration.intra_frame_callback,
    100                                        configuration.bandwidth_callback,
    101                                        configuration.rtcp_feedback);
    102   rtcp_sender_.RegisterSendTransport(configuration.outgoing_transport);
    103 
    104   // Make sure that RTCP objects are aware of our SSRC.
    105   uint32_t SSRC = rtp_sender_.SSRC();
    106   rtcp_sender_.SetSSRC(SSRC);
    107   SetRtcpReceiverSsrcs(SSRC);
    108 }
    109 
    110 ModuleRtpRtcpImpl::~ModuleRtpRtcpImpl() {
    111   // All child modules MUST be deleted before deleting the default.
    112   assert(child_modules_.empty());
    113 
    114   // Deregister for the child modules.
    115   // Will go in to the default and remove it self.
    116   if (default_module_) {
    117     default_module_->DeRegisterChildModule(this);
    118   }
    119 }
    120 
    121 void ModuleRtpRtcpImpl::RegisterChildModule(RtpRtcp* module) {
    122   CriticalSectionScoped lock(
    123       critical_section_module_ptrs_.get());
    124   CriticalSectionScoped double_lock(
    125       critical_section_module_ptrs_feedback_.get());
    126 
    127   // We use two locks for protecting child_modules_, one
    128   // (critical_section_module_ptrs_feedback_) for incoming
    129   // messages (BitrateSent) and critical_section_module_ptrs_
    130   // for all outgoing messages sending packets etc.
    131   child_modules_.push_back(static_cast<ModuleRtpRtcpImpl*>(module));
    132 }
    133 
    134 void ModuleRtpRtcpImpl::DeRegisterChildModule(RtpRtcp* remove_module) {
    135   CriticalSectionScoped lock(
    136       critical_section_module_ptrs_.get());
    137   CriticalSectionScoped double_lock(
    138       critical_section_module_ptrs_feedback_.get());
    139 
    140   std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
    141   while (it != child_modules_.end()) {
    142     RtpRtcp* module = *it;
    143     if (module == remove_module) {
    144       child_modules_.erase(it);
    145       return;
    146     }
    147     it++;
    148   }
    149 }
    150 
    151 // Returns the number of milliseconds until the module want a worker thread
    152 // to call Process.
    153 int32_t ModuleRtpRtcpImpl::TimeUntilNextProcess() {
    154     const int64_t now = clock_->TimeInMilliseconds();
    155   return kRtpRtcpMaxIdleTimeProcess - (now - last_process_time_);
    156 }
    157 
    158 // Process any pending tasks such as timeouts (non time critical events).
    159 int32_t ModuleRtpRtcpImpl::Process() {
    160   const int64_t now = clock_->TimeInMilliseconds();
    161   last_process_time_ = now;
    162 
    163   if (now >= last_bitrate_process_time_ + kRtpRtcpBitrateProcessTimeMs) {
    164     rtp_sender_.ProcessBitrate();
    165     last_bitrate_process_time_ = now;
    166   }
    167 
    168   if (!IsDefaultModule()) {
    169     bool process_rtt = now >= last_rtt_process_time_ + kRtpRtcpRttProcessTimeMs;
    170     if (rtcp_sender_.Sending()) {
    171       // Process RTT if we have received a receiver report and we haven't
    172       // processed RTT for at least |kRtpRtcpRttProcessTimeMs| milliseconds.
    173       if (rtcp_receiver_.LastReceivedReceiverReport() >
    174           last_rtt_process_time_ && process_rtt) {
    175         std::vector<RTCPReportBlock> receive_blocks;
    176         rtcp_receiver_.StatisticsReceived(&receive_blocks);
    177         uint16_t max_rtt = 0;
    178         for (std::vector<RTCPReportBlock>::iterator it = receive_blocks.begin();
    179              it != receive_blocks.end(); ++it) {
    180           uint16_t rtt = 0;
    181           rtcp_receiver_.RTT(it->remoteSSRC, &rtt, NULL, NULL, NULL);
    182           max_rtt = (rtt > max_rtt) ? rtt : max_rtt;
    183         }
    184         // Report the rtt.
    185         if (rtt_stats_ && max_rtt != 0)
    186           rtt_stats_->OnRttUpdate(max_rtt);
    187       }
    188 
    189       // Verify receiver reports are delivered and the reported sequence number
    190       // is increasing.
    191       int64_t rtcp_interval = RtcpReportInterval();
    192       if (rtcp_receiver_.RtcpRrTimeout(rtcp_interval)) {
    193         LOG_F(LS_WARNING) << "Timeout: No RTCP RR received.";
    194       } else if (rtcp_receiver_.RtcpRrSequenceNumberTimeout(rtcp_interval)) {
    195         LOG_F(LS_WARNING) <<
    196             "Timeout: No increase in RTCP RR extended highest sequence number.";
    197       }
    198 
    199       if (remote_bitrate_ && rtcp_sender_.TMMBR()) {
    200         unsigned int target_bitrate = 0;
    201         std::vector<unsigned int> ssrcs;
    202         if (remote_bitrate_->LatestEstimate(&ssrcs, &target_bitrate)) {
    203           if (!ssrcs.empty()) {
    204             target_bitrate = target_bitrate / ssrcs.size();
    205           }
    206           rtcp_sender_.SetTargetBitrate(target_bitrate);
    207         }
    208       }
    209     } else {
    210       // Report rtt from receiver.
    211       if (process_rtt) {
    212          uint16_t rtt_ms;
    213          if (rtt_stats_ && rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)) {
    214            rtt_stats_->OnRttUpdate(rtt_ms);
    215          }
    216       }
    217     }
    218 
    219     // Get processed rtt.
    220     if (process_rtt) {
    221       last_rtt_process_time_ = now;
    222       if (rtt_stats_) {
    223         set_rtt_ms(rtt_stats_->LastProcessedRtt());
    224       }
    225     }
    226 
    227     if (rtcp_sender_.TimeToSendRTCPReport()) {
    228       RTCPSender::FeedbackState feedback_state(this);
    229       rtcp_sender_.SendRTCP(feedback_state, kRtcpReport);
    230     }
    231   }
    232 
    233   if (UpdateRTCPReceiveInformationTimers()) {
    234     // A receiver has timed out
    235     rtcp_receiver_.UpdateTMMBR();
    236   }
    237   return 0;
    238 }
    239 
    240 void ModuleRtpRtcpImpl::SetRTXSendStatus(int mode) {
    241   rtp_sender_.SetRTXStatus(mode);
    242 }
    243 
    244 void ModuleRtpRtcpImpl::RTXSendStatus(int* mode,
    245                                       uint32_t* ssrc,
    246                                       int* payload_type) const {
    247   rtp_sender_.RTXStatus(mode, ssrc, payload_type);
    248 }
    249 
    250 void ModuleRtpRtcpImpl::SetRtxSsrc(uint32_t ssrc) {
    251   rtp_sender_.SetRtxSsrc(ssrc);
    252 }
    253 
    254 void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type) {
    255   rtp_sender_.SetRtxPayloadType(payload_type);
    256 }
    257 
    258 int32_t ModuleRtpRtcpImpl::IncomingRtcpPacket(
    259     const uint8_t* rtcp_packet,
    260     const uint16_t length) {
    261   // Allow receive of non-compound RTCP packets.
    262   RTCPUtility::RTCPParserV2 rtcp_parser(rtcp_packet, length, true);
    263 
    264   const bool valid_rtcpheader = rtcp_parser.IsValid();
    265   if (!valid_rtcpheader) {
    266     LOG(LS_WARNING) << "Incoming invalid RTCP packet";
    267     return -1;
    268   }
    269   RTCPHelp::RTCPPacketInformation rtcp_packet_information;
    270   int32_t ret_val = rtcp_receiver_.IncomingRTCPPacket(
    271       rtcp_packet_information, &rtcp_parser);
    272   if (ret_val == 0) {
    273     rtcp_receiver_.TriggerCallbacksFromRTCPPacket(rtcp_packet_information);
    274   }
    275   return ret_val;
    276 }
    277 
    278 int32_t ModuleRtpRtcpImpl::RegisterSendPayload(
    279     const CodecInst& voice_codec) {
    280   return rtp_sender_.RegisterPayload(
    281            voice_codec.plname,
    282            voice_codec.pltype,
    283            voice_codec.plfreq,
    284            voice_codec.channels,
    285            (voice_codec.rate < 0) ? 0 : voice_codec.rate);
    286 }
    287 
    288 int32_t ModuleRtpRtcpImpl::RegisterSendPayload(
    289     const VideoCodec& video_codec) {
    290   send_video_codec_ = video_codec;
    291   {
    292     // simulcast_ is accessed when accessing child_modules_, so this write needs
    293     // to be protected by the same lock.
    294     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    295     simulcast_ = video_codec.numberOfSimulcastStreams > 1;
    296   }
    297   return rtp_sender_.RegisterPayload(video_codec.plName,
    298                                      video_codec.plType,
    299                                      90000,
    300                                      0,
    301                                      video_codec.maxBitrate);
    302 }
    303 
    304 int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(
    305     const int8_t payload_type) {
    306   return rtp_sender_.DeRegisterSendPayload(payload_type);
    307 }
    308 
    309 int8_t ModuleRtpRtcpImpl::SendPayloadType() const {
    310   return rtp_sender_.SendPayloadType();
    311 }
    312 
    313 uint32_t ModuleRtpRtcpImpl::StartTimestamp() const {
    314   return rtp_sender_.StartTimestamp();
    315 }
    316 
    317 // Configure start timestamp, default is a random number.
    318 int32_t ModuleRtpRtcpImpl::SetStartTimestamp(
    319     const uint32_t timestamp) {
    320   rtcp_sender_.SetStartTimestamp(timestamp);
    321   rtp_sender_.SetStartTimestamp(timestamp, true);
    322   return 0;  // TODO(pwestin): change to void.
    323 }
    324 
    325 uint16_t ModuleRtpRtcpImpl::SequenceNumber() const {
    326   return rtp_sender_.SequenceNumber();
    327 }
    328 
    329 // Set SequenceNumber, default is a random number.
    330 int32_t ModuleRtpRtcpImpl::SetSequenceNumber(
    331     const uint16_t seq_num) {
    332   rtp_sender_.SetSequenceNumber(seq_num);
    333   return 0;  // TODO(pwestin): change to void.
    334 }
    335 
    336 uint32_t ModuleRtpRtcpImpl::SSRC() const {
    337   return rtp_sender_.SSRC();
    338 }
    339 
    340 // Configure SSRC, default is a random number.
    341 void ModuleRtpRtcpImpl::SetSSRC(const uint32_t ssrc) {
    342   rtp_sender_.SetSSRC(ssrc);
    343   rtcp_sender_.SetSSRC(ssrc);
    344   SetRtcpReceiverSsrcs(ssrc);
    345 }
    346 
    347 int32_t ModuleRtpRtcpImpl::SetCSRCStatus(const bool include) {
    348   rtcp_sender_.SetCSRCStatus(include);
    349   rtp_sender_.SetCSRCStatus(include);
    350   return 0;  // TODO(pwestin): change to void.
    351 }
    352 
    353 int32_t ModuleRtpRtcpImpl::CSRCs(
    354   uint32_t arr_of_csrc[kRtpCsrcSize]) const {
    355   return rtp_sender_.CSRCs(arr_of_csrc);
    356 }
    357 
    358 int32_t ModuleRtpRtcpImpl::SetCSRCs(
    359     const uint32_t arr_of_csrc[kRtpCsrcSize],
    360     const uint8_t arr_length) {
    361   if (IsDefaultModule()) {
    362     // For default we need to update all child modules too.
    363     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    364 
    365     std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
    366     while (it != child_modules_.end()) {
    367       RtpRtcp* module = *it;
    368       if (module) {
    369         module->SetCSRCs(arr_of_csrc, arr_length);
    370       }
    371       it++;
    372     }
    373   } else {
    374     rtcp_sender_.SetCSRCs(arr_of_csrc, arr_length);
    375     rtp_sender_.SetCSRCs(arr_of_csrc, arr_length);
    376   }
    377   return 0;  // TODO(pwestin): change to void.
    378 }
    379 
    380 uint32_t ModuleRtpRtcpImpl::PacketCountSent() const {
    381   return rtp_sender_.Packets();
    382 }
    383 
    384 uint32_t ModuleRtpRtcpImpl::ByteCountSent() const {
    385   return rtp_sender_.Bytes();
    386 }
    387 
    388 int ModuleRtpRtcpImpl::CurrentSendFrequencyHz() const {
    389   return rtp_sender_.SendPayloadFrequency();
    390 }
    391 
    392 int32_t ModuleRtpRtcpImpl::SetSendingStatus(const bool sending) {
    393   if (rtcp_sender_.Sending() != sending) {
    394     // Sends RTCP BYE when going from true to false
    395     RTCPSender::FeedbackState feedback_state(this);
    396     if (rtcp_sender_.SetSendingStatus(feedback_state, sending) != 0) {
    397       LOG(LS_WARNING) << "Failed to send RTCP BYE";
    398     }
    399 
    400     collision_detected_ = false;
    401 
    402     // Generate a new time_stamp if true and not configured via API
    403     // Generate a new SSRC for the next "call" if false
    404     rtp_sender_.SetSendingStatus(sending);
    405     if (sending) {
    406       // Make sure the RTCP sender has the same timestamp offset.
    407       rtcp_sender_.SetStartTimestamp(rtp_sender_.StartTimestamp());
    408     }
    409 
    410     // Make sure that RTCP objects are aware of our SSRC (it could have changed
    411     // Due to collision)
    412     uint32_t SSRC = rtp_sender_.SSRC();
    413     rtcp_sender_.SetSSRC(SSRC);
    414     SetRtcpReceiverSsrcs(SSRC);
    415 
    416     return 0;
    417   }
    418   return 0;
    419 }
    420 
    421 bool ModuleRtpRtcpImpl::Sending() const {
    422   return rtcp_sender_.Sending();
    423 }
    424 
    425 int32_t ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
    426   rtp_sender_.SetSendingMediaStatus(sending);
    427   return 0;
    428 }
    429 
    430 bool ModuleRtpRtcpImpl::SendingMedia() const {
    431   if (!IsDefaultModule()) {
    432     return rtp_sender_.SendingMedia();
    433   }
    434 
    435   CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    436   std::vector<ModuleRtpRtcpImpl*>::const_iterator it = child_modules_.begin();
    437   while (it != child_modules_.end()) {
    438     RTPSender& rtp_sender = (*it)->rtp_sender_;
    439     if (rtp_sender.SendingMedia()) {
    440       return true;
    441     }
    442     it++;
    443   }
    444   return false;
    445 }
    446 
    447 int32_t ModuleRtpRtcpImpl::SendOutgoingData(
    448     FrameType frame_type,
    449     int8_t payload_type,
    450     uint32_t time_stamp,
    451     int64_t capture_time_ms,
    452     const uint8_t* payload_data,
    453     uint32_t payload_size,
    454     const RTPFragmentationHeader* fragmentation,
    455     const RTPVideoHeader* rtp_video_hdr) {
    456   rtcp_sender_.SetLastRtpTime(time_stamp, capture_time_ms);
    457 
    458   if (!IsDefaultModule()) {
    459     // Don't send RTCP from default module.
    460     if (rtcp_sender_.TimeToSendRTCPReport(kVideoFrameKey == frame_type)) {
    461       RTCPSender::FeedbackState feedback_state(this);
    462       rtcp_sender_.SendRTCP(feedback_state, kRtcpReport);
    463     }
    464     return rtp_sender_.SendOutgoingData(frame_type,
    465                                         payload_type,
    466                                         time_stamp,
    467                                         capture_time_ms,
    468                                         payload_data,
    469                                         payload_size,
    470                                         fragmentation,
    471                                         NULL,
    472                                         &(rtp_video_hdr->codecHeader));
    473   }
    474   int32_t ret_val = -1;
    475   CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    476   if (simulcast_) {
    477     if (rtp_video_hdr == NULL) {
    478       return -1;
    479     }
    480     int idx = 0;
    481     std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
    482     for (; idx < rtp_video_hdr->simulcastIdx; ++it) {
    483       if (it == child_modules_.end()) {
    484         return -1;
    485       }
    486       if ((*it)->SendingMedia()) {
    487         ++idx;
    488       }
    489     }
    490     for (; it != child_modules_.end(); ++it) {
    491       if ((*it)->SendingMedia()) {
    492         break;
    493       }
    494       ++idx;
    495     }
    496     if (it == child_modules_.end()) {
    497       return -1;
    498     }
    499     return (*it)->SendOutgoingData(frame_type,
    500                                    payload_type,
    501                                    time_stamp,
    502                                    capture_time_ms,
    503                                    payload_data,
    504                                    payload_size,
    505                                    fragmentation,
    506                                    rtp_video_hdr);
    507   } else {
    508     std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
    509     // Send to all "child" modules
    510     while (it != child_modules_.end()) {
    511       if ((*it)->SendingMedia()) {
    512         ret_val = (*it)->SendOutgoingData(frame_type,
    513                                           payload_type,
    514                                           time_stamp,
    515                                           capture_time_ms,
    516                                           payload_data,
    517                                           payload_size,
    518                                           fragmentation,
    519                                           rtp_video_hdr);
    520       }
    521       it++;
    522     }
    523   }
    524   return ret_val;
    525 }
    526 
    527 bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc,
    528                                          uint16_t sequence_number,
    529                                          int64_t capture_time_ms,
    530                                          bool retransmission) {
    531   if (!IsDefaultModule()) {
    532     // Don't send from default module.
    533     if (SendingMedia() && ssrc == rtp_sender_.SSRC()) {
    534       return rtp_sender_.TimeToSendPacket(sequence_number, capture_time_ms,
    535                                           retransmission);
    536     }
    537   } else {
    538     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    539     std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
    540     while (it != child_modules_.end()) {
    541       if ((*it)->SendingMedia() && ssrc == (*it)->rtp_sender_.SSRC()) {
    542         return (*it)->rtp_sender_.TimeToSendPacket(sequence_number,
    543                                                    capture_time_ms,
    544                                                    retransmission);
    545       }
    546       ++it;
    547     }
    548   }
    549   // No RTP sender is interested in sending this packet.
    550   return true;
    551 }
    552 
    553 int ModuleRtpRtcpImpl::TimeToSendPadding(int bytes) {
    554   if (!IsDefaultModule()) {
    555     // Don't send from default module.
    556     if (SendingMedia()) {
    557       return rtp_sender_.TimeToSendPadding(bytes);
    558     }
    559   } else {
    560     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    561     for (size_t i = 0; i < child_modules_.size(); ++i) {
    562       // Send padding on one of the modules sending media.
    563       if (child_modules_[i]->SendingMedia()) {
    564         return child_modules_[i]->rtp_sender_.TimeToSendPadding(bytes);
    565       }
    566     }
    567   }
    568   return 0;
    569 }
    570 
    571 bool ModuleRtpRtcpImpl::GetSendSideDelay(int* avg_send_delay_ms,
    572                                          int* max_send_delay_ms) const {
    573   assert(avg_send_delay_ms);
    574   assert(max_send_delay_ms);
    575 
    576   if (IsDefaultModule()) {
    577     // This API is only supported for child modules.
    578     return false;
    579   }
    580   return rtp_sender_.GetSendSideDelay(avg_send_delay_ms, max_send_delay_ms);
    581 }
    582 
    583 uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const {
    584   return rtp_sender_.MaxPayloadLength();
    585 }
    586 
    587 uint16_t ModuleRtpRtcpImpl::MaxDataPayloadLength() const {
    588   // Assuming IP/UDP.
    589   uint16_t min_data_payload_length = IP_PACKET_SIZE - 28;
    590 
    591   if (IsDefaultModule()) {
    592     // For default we need to update all child modules too.
    593     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    594     std::vector<ModuleRtpRtcpImpl*>::const_iterator it = child_modules_.begin();
    595     while (it != child_modules_.end()) {
    596       RtpRtcp* module = *it;
    597       if (module) {
    598         uint16_t data_payload_length =
    599           module->MaxDataPayloadLength();
    600         if (data_payload_length < min_data_payload_length) {
    601           min_data_payload_length = data_payload_length;
    602         }
    603       }
    604       it++;
    605     }
    606   }
    607 
    608   uint16_t data_payload_length = rtp_sender_.MaxDataPayloadLength();
    609   if (data_payload_length < min_data_payload_length) {
    610     min_data_payload_length = data_payload_length;
    611   }
    612   return min_data_payload_length;
    613 }
    614 
    615 int32_t ModuleRtpRtcpImpl::SetTransportOverhead(
    616     const bool tcp,
    617     const bool ipv6,
    618     const uint8_t authentication_overhead) {
    619   uint16_t packet_overhead = 0;
    620   if (ipv6) {
    621     packet_overhead = 40;
    622   } else {
    623     packet_overhead = 20;
    624   }
    625   if (tcp) {
    626     // TCP.
    627     packet_overhead += 20;
    628   } else {
    629     // UDP.
    630     packet_overhead += 8;
    631   }
    632   packet_overhead += authentication_overhead;
    633 
    634   if (packet_overhead == packet_overhead_) {
    635     // Ok same as before.
    636     return 0;
    637   }
    638   // Calc diff.
    639   int16_t packet_over_head_diff = packet_overhead - packet_overhead_;
    640 
    641   // Store new.
    642   packet_overhead_ = packet_overhead;
    643 
    644   uint16_t length =
    645       rtp_sender_.MaxPayloadLength() - packet_over_head_diff;
    646   return rtp_sender_.SetMaxPayloadLength(length, packet_overhead_);
    647 }
    648 
    649 int32_t ModuleRtpRtcpImpl::SetMaxTransferUnit(const uint16_t mtu) {
    650   if (mtu > IP_PACKET_SIZE) {
    651     LOG(LS_ERROR) << "Invalid mtu: " << mtu;
    652     return -1;
    653   }
    654   return rtp_sender_.SetMaxPayloadLength(mtu - packet_overhead_,
    655                                          packet_overhead_);
    656 }
    657 
    658 RTCPMethod ModuleRtpRtcpImpl::RTCP() const {
    659   if (rtcp_sender_.Status() != kRtcpOff) {
    660     return rtcp_receiver_.Status();
    661   }
    662   return kRtcpOff;
    663 }
    664 
    665 // Configure RTCP status i.e on/off.
    666 int32_t ModuleRtpRtcpImpl::SetRTCPStatus(const RTCPMethod method) {
    667   if (rtcp_sender_.SetRTCPStatus(method) == 0) {
    668     return rtcp_receiver_.SetRTCPStatus(method);
    669   }
    670   return -1;
    671 }
    672 
    673 // Only for internal test.
    674 uint32_t ModuleRtpRtcpImpl::LastSendReport(
    675     uint32_t& last_rtcptime) {
    676   return rtcp_sender_.LastSendReport(last_rtcptime);
    677 }
    678 
    679 int32_t ModuleRtpRtcpImpl::SetCNAME(const char c_name[RTCP_CNAME_SIZE]) {
    680   return rtcp_sender_.SetCNAME(c_name);
    681 }
    682 
    683 int32_t ModuleRtpRtcpImpl::CNAME(char c_name[RTCP_CNAME_SIZE]) {
    684   return rtcp_sender_.CNAME(c_name);
    685 }
    686 
    687 int32_t ModuleRtpRtcpImpl::AddMixedCNAME(
    688   const uint32_t ssrc,
    689   const char c_name[RTCP_CNAME_SIZE]) {
    690   return rtcp_sender_.AddMixedCNAME(ssrc, c_name);
    691 }
    692 
    693 int32_t ModuleRtpRtcpImpl::RemoveMixedCNAME(const uint32_t ssrc) {
    694   return rtcp_sender_.RemoveMixedCNAME(ssrc);
    695 }
    696 
    697 int32_t ModuleRtpRtcpImpl::RemoteCNAME(
    698     const uint32_t remote_ssrc,
    699     char c_name[RTCP_CNAME_SIZE]) const {
    700   return rtcp_receiver_.CNAME(remote_ssrc, c_name);
    701 }
    702 
    703 int32_t ModuleRtpRtcpImpl::RemoteNTP(
    704     uint32_t* received_ntpsecs,
    705     uint32_t* received_ntpfrac,
    706     uint32_t* rtcp_arrival_time_secs,
    707     uint32_t* rtcp_arrival_time_frac,
    708     uint32_t* rtcp_timestamp) const {
    709   return rtcp_receiver_.NTP(received_ntpsecs,
    710                             received_ntpfrac,
    711                             rtcp_arrival_time_secs,
    712                             rtcp_arrival_time_frac,
    713                             rtcp_timestamp);
    714 }
    715 
    716 // Get RoundTripTime.
    717 int32_t ModuleRtpRtcpImpl::RTT(const uint32_t remote_ssrc,
    718                                uint16_t* rtt,
    719                                uint16_t* avg_rtt,
    720                                uint16_t* min_rtt,
    721                                uint16_t* max_rtt) const {
    722   int32_t ret = rtcp_receiver_.RTT(remote_ssrc, rtt, avg_rtt, min_rtt, max_rtt);
    723   if (rtt && *rtt == 0) {
    724     // Try to get RTT from RtcpRttStats class.
    725     *rtt = static_cast<uint16_t>(rtt_ms());
    726   }
    727   return ret;
    728 }
    729 
    730 // Reset RoundTripTime statistics.
    731 int32_t ModuleRtpRtcpImpl::ResetRTT(const uint32_t remote_ssrc) {
    732   return rtcp_receiver_.ResetRTT(remote_ssrc);
    733 }
    734 
    735 // Reset RTP data counters for the sending side.
    736 int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
    737   rtp_sender_.ResetDataCounters();
    738   return 0;  // TODO(pwestin): change to void.
    739 }
    740 
    741 // Force a send of an RTCP packet.
    742 // Normal SR and RR are triggered via the process function.
    743 int32_t ModuleRtpRtcpImpl::SendRTCP(uint32_t rtcp_packet_type) {
    744   RTCPSender::FeedbackState feedback_state(this);
    745   return rtcp_sender_.SendRTCP(feedback_state, rtcp_packet_type);
    746 }
    747 
    748 int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
    749     const uint8_t sub_type,
    750     const uint32_t name,
    751     const uint8_t* data,
    752     const uint16_t length) {
    753   return  rtcp_sender_.SetApplicationSpecificData(sub_type, name, data, length);
    754 }
    755 
    756 // (XR) VOIP metric.
    757 int32_t ModuleRtpRtcpImpl::SetRTCPVoIPMetrics(
    758   const RTCPVoIPMetric* voip_metric) {
    759   return  rtcp_sender_.SetRTCPVoIPMetrics(voip_metric);
    760 }
    761 
    762 void ModuleRtpRtcpImpl::SetRtcpXrRrtrStatus(bool enable) {
    763   return rtcp_sender_.SendRtcpXrReceiverReferenceTime(enable);
    764 }
    765 
    766 bool ModuleRtpRtcpImpl::RtcpXrRrtrStatus() const {
    767   return rtcp_sender_.RtcpXrReceiverReferenceTime();
    768 }
    769 
    770 int32_t ModuleRtpRtcpImpl::DataCountersRTP(
    771     uint32_t* bytes_sent,
    772     uint32_t* packets_sent) const {
    773   if (bytes_sent) {
    774     *bytes_sent = rtp_sender_.Bytes();
    775   }
    776   if (packets_sent) {
    777     *packets_sent = rtp_sender_.Packets();
    778   }
    779   return 0;
    780 }
    781 
    782 int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(RTCPSenderInfo* sender_info) {
    783   return rtcp_receiver_.SenderInfoReceived(sender_info);
    784 }
    785 
    786 // Received RTCP report.
    787 int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(
    788     std::vector<RTCPReportBlock>* receive_blocks) const {
    789   return rtcp_receiver_.StatisticsReceived(receive_blocks);
    790 }
    791 
    792 int32_t ModuleRtpRtcpImpl::AddRTCPReportBlock(
    793     const uint32_t ssrc,
    794     const RTCPReportBlock* report_block) {
    795   return rtcp_sender_.AddExternalReportBlock(ssrc, report_block);
    796 }
    797 
    798 int32_t ModuleRtpRtcpImpl::RemoveRTCPReportBlock(
    799   const uint32_t ssrc) {
    800   return rtcp_sender_.RemoveExternalReportBlock(ssrc);
    801 }
    802 
    803 void ModuleRtpRtcpImpl::GetRtcpPacketTypeCounters(
    804     RtcpPacketTypeCounter* packets_sent,
    805     RtcpPacketTypeCounter* packets_received) const {
    806   rtcp_sender_.GetPacketTypeCounter(packets_sent);
    807   rtcp_receiver_.GetPacketTypeCounter(packets_received);
    808 }
    809 
    810 // (REMB) Receiver Estimated Max Bitrate.
    811 bool ModuleRtpRtcpImpl::REMB() const {
    812   return rtcp_sender_.REMB();
    813 }
    814 
    815 int32_t ModuleRtpRtcpImpl::SetREMBStatus(const bool enable) {
    816   return rtcp_sender_.SetREMBStatus(enable);
    817 }
    818 
    819 int32_t ModuleRtpRtcpImpl::SetREMBData(const uint32_t bitrate,
    820                                        const uint8_t number_of_ssrc,
    821                                        const uint32_t* ssrc) {
    822   return rtcp_sender_.SetREMBData(bitrate, number_of_ssrc, ssrc);
    823 }
    824 
    825 // (IJ) Extended jitter report.
    826 bool ModuleRtpRtcpImpl::IJ() const {
    827   return rtcp_sender_.IJ();
    828 }
    829 
    830 int32_t ModuleRtpRtcpImpl::SetIJStatus(const bool enable) {
    831   return rtcp_sender_.SetIJStatus(enable);
    832 }
    833 
    834 int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
    835     const RTPExtensionType type,
    836     const uint8_t id) {
    837   return rtp_sender_.RegisterRtpHeaderExtension(type, id);
    838 }
    839 
    840 int32_t ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
    841     const RTPExtensionType type) {
    842   return rtp_sender_.DeregisterRtpHeaderExtension(type);
    843 }
    844 
    845 // (TMMBR) Temporary Max Media Bit Rate.
    846 bool ModuleRtpRtcpImpl::TMMBR() const {
    847   return rtcp_sender_.TMMBR();
    848 }
    849 
    850 int32_t ModuleRtpRtcpImpl::SetTMMBRStatus(const bool enable) {
    851   return rtcp_sender_.SetTMMBRStatus(enable);
    852 }
    853 
    854 int32_t ModuleRtpRtcpImpl::SetTMMBN(const TMMBRSet* bounding_set) {
    855   uint32_t max_bitrate_kbit =
    856       rtp_sender_.MaxConfiguredBitrateVideo() / 1000;
    857   return rtcp_sender_.SetTMMBN(bounding_set, max_bitrate_kbit);
    858 }
    859 
    860 // Returns the currently configured retransmission mode.
    861 int ModuleRtpRtcpImpl::SelectiveRetransmissions() const {
    862   return rtp_sender_.SelectiveRetransmissions();
    863 }
    864 
    865 // Enable or disable a retransmission mode, which decides which packets will
    866 // be retransmitted if NACKed.
    867 int ModuleRtpRtcpImpl::SetSelectiveRetransmissions(uint8_t settings) {
    868   return rtp_sender_.SetSelectiveRetransmissions(settings);
    869 }
    870 
    871 // Send a Negative acknowledgment packet.
    872 int32_t ModuleRtpRtcpImpl::SendNACK(const uint16_t* nack_list,
    873                                     const uint16_t size) {
    874   // Use RTT from RtcpRttStats class if provided.
    875   uint16_t rtt = rtt_ms();
    876   if (rtt == 0) {
    877     rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
    878   }
    879 
    880   int64_t wait_time = 5 + ((rtt * 3) >> 1);  // 5 + RTT * 1.5.
    881   if (wait_time == 5) {
    882     wait_time = 100;  // During startup we don't have an RTT.
    883   }
    884   const int64_t now = clock_->TimeInMilliseconds();
    885   const int64_t time_limit = now - wait_time;
    886   uint16_t nackLength = size;
    887   uint16_t start_id = 0;
    888 
    889   if (nack_last_time_sent_full_ < time_limit) {
    890     // Send list. Set the timer to make sure we only send a full NACK list once
    891     // within every time_limit.
    892     nack_last_time_sent_full_ = now;
    893   } else {
    894     // Only send if extended list.
    895     if (nack_last_seq_number_sent_ == nack_list[size - 1]) {
    896       // Last seq num is the same don't send list.
    897       return 0;
    898     } else {
    899       // Send NACKs only for new sequence numbers to avoid re-sending
    900       // NACKs for sequences we have already sent.
    901       for (int i = 0; i < size; ++i)  {
    902         if (nack_last_seq_number_sent_ == nack_list[i]) {
    903           start_id = i + 1;
    904           break;
    905         }
    906       }
    907       nackLength = size - start_id;
    908     }
    909   }
    910   // Our RTCP NACK implementation is limited to kRtcpMaxNackFields sequence
    911   // numbers per RTCP packet.
    912   if (nackLength > kRtcpMaxNackFields) {
    913     nackLength = kRtcpMaxNackFields;
    914   }
    915   nack_last_seq_number_sent_ = nack_list[start_id + nackLength - 1];
    916 
    917   RTCPSender::FeedbackState feedback_state(this);
    918   return rtcp_sender_.SendRTCP(
    919       feedback_state, kRtcpNack, nackLength, &nack_list[start_id]);
    920 }
    921 
    922 // Store the sent packets, needed to answer to a Negative acknowledgment
    923 // requests.
    924 int32_t ModuleRtpRtcpImpl::SetStorePacketsStatus(
    925     const bool enable,
    926     const uint16_t number_to_store) {
    927   rtp_sender_.SetStorePacketsStatus(enable, number_to_store);
    928   return 0;  // TODO(pwestin): change to void.
    929 }
    930 
    931 bool ModuleRtpRtcpImpl::StorePackets() const {
    932   return rtp_sender_.StorePackets();
    933 }
    934 
    935 void ModuleRtpRtcpImpl::RegisterSendChannelRtcpStatisticsCallback(
    936     RtcpStatisticsCallback* callback) {
    937   rtcp_receiver_.RegisterRtcpStatisticsCallback(callback);
    938 }
    939 
    940 RtcpStatisticsCallback* ModuleRtpRtcpImpl::
    941         GetSendChannelRtcpStatisticsCallback() {
    942   return rtcp_receiver_.GetRtcpStatisticsCallback();
    943 }
    944 
    945 // Send a TelephoneEvent tone using RFC 2833 (4733).
    946 int32_t ModuleRtpRtcpImpl::SendTelephoneEventOutband(
    947     const uint8_t key,
    948     const uint16_t time_ms,
    949     const uint8_t level) {
    950   return rtp_sender_.SendTelephoneEvent(key, time_ms, level);
    951 }
    952 
    953 bool ModuleRtpRtcpImpl::SendTelephoneEventActive(
    954     int8_t& telephone_event) const {
    955   return rtp_sender_.SendTelephoneEventActive(&telephone_event);
    956 }
    957 
    958 // Set audio packet size, used to determine when it's time to send a DTMF
    959 // packet in silence (CNG).
    960 int32_t ModuleRtpRtcpImpl::SetAudioPacketSize(
    961     const uint16_t packet_size_samples) {
    962   return rtp_sender_.SetAudioPacketSize(packet_size_samples);
    963 }
    964 
    965 int32_t ModuleRtpRtcpImpl::SetAudioLevel(
    966     const uint8_t level_d_bov) {
    967   return rtp_sender_.SetAudioLevel(level_d_bov);
    968 }
    969 
    970 // Set payload type for Redundant Audio Data RFC 2198.
    971 int32_t ModuleRtpRtcpImpl::SetSendREDPayloadType(
    972     const int8_t payload_type) {
    973   return rtp_sender_.SetRED(payload_type);
    974 }
    975 
    976 // Get payload type for Redundant Audio Data RFC 2198.
    977 int32_t ModuleRtpRtcpImpl::SendREDPayloadType(
    978     int8_t& payload_type) const {
    979   return rtp_sender_.RED(&payload_type);
    980 }
    981 
    982 RtpVideoCodecTypes ModuleRtpRtcpImpl::SendVideoCodec() const {
    983   return rtp_sender_.VideoCodecType();
    984 }
    985 
    986 void ModuleRtpRtcpImpl::SetTargetSendBitrate(
    987     const std::vector<uint32_t>& stream_bitrates) {
    988   if (IsDefaultModule()) {
    989     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
    990     if (simulcast_) {
    991       std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
    992       for (size_t i = 0;
    993            it != child_modules_.end() && i < stream_bitrates.size(); ++it) {
    994         if ((*it)->SendingMedia()) {
    995           RTPSender& rtp_sender = (*it)->rtp_sender_;
    996           rtp_sender.SetTargetBitrate(stream_bitrates[i]);
    997           ++i;
    998         }
    999       }
   1000     } else {
   1001       if (stream_bitrates.size() > 1)
   1002         return;
   1003       std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
   1004       for (; it != child_modules_.end(); ++it) {
   1005         RTPSender& rtp_sender = (*it)->rtp_sender_;
   1006         rtp_sender.SetTargetBitrate(stream_bitrates[0]);
   1007       }
   1008     }
   1009   } else {
   1010     if (stream_bitrates.size() > 1)
   1011       return;
   1012     rtp_sender_.SetTargetBitrate(stream_bitrates[0]);
   1013   }
   1014 }
   1015 
   1016 int32_t ModuleRtpRtcpImpl::SetKeyFrameRequestMethod(
   1017     const KeyFrameRequestMethod method) {
   1018   key_frame_req_method_ = method;
   1019   return 0;
   1020 }
   1021 
   1022 int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
   1023   switch (key_frame_req_method_) {
   1024     case kKeyFrameReqFirRtp:
   1025       return rtp_sender_.SendRTPIntraRequest();
   1026     case kKeyFrameReqPliRtcp:
   1027       return SendRTCP(kRtcpPli);
   1028     case kKeyFrameReqFirRtcp:
   1029       return SendRTCP(kRtcpFir);
   1030   }
   1031   return -1;
   1032 }
   1033 
   1034 int32_t ModuleRtpRtcpImpl::SendRTCPSliceLossIndication(
   1035     const uint8_t picture_id) {
   1036   RTCPSender::FeedbackState feedback_state(this);
   1037   return rtcp_sender_.SendRTCP(
   1038       feedback_state, kRtcpSli, 0, 0, false, picture_id);
   1039 }
   1040 
   1041 int32_t ModuleRtpRtcpImpl::SetCameraDelay(const int32_t delay_ms) {
   1042   if (IsDefaultModule()) {
   1043     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
   1044     std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
   1045     while (it != child_modules_.end()) {
   1046       RtpRtcp* module = *it;
   1047       if (module) {
   1048         module->SetCameraDelay(delay_ms);
   1049       }
   1050       it++;
   1051     }
   1052     return 0;
   1053   }
   1054   return rtcp_sender_.SetCameraDelay(delay_ms);
   1055 }
   1056 
   1057 int32_t ModuleRtpRtcpImpl::SetGenericFECStatus(
   1058     const bool enable,
   1059     const uint8_t payload_type_red,
   1060     const uint8_t payload_type_fec) {
   1061   return rtp_sender_.SetGenericFECStatus(enable,
   1062                                          payload_type_red,
   1063                                          payload_type_fec);
   1064 }
   1065 
   1066 int32_t ModuleRtpRtcpImpl::GenericFECStatus(
   1067     bool& enable,
   1068     uint8_t& payload_type_red,
   1069     uint8_t& payload_type_fec) {
   1070   bool child_enabled = false;
   1071   if (IsDefaultModule()) {
   1072     // For default we need to check all child modules too.
   1073     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
   1074     std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
   1075     while (it != child_modules_.end()) {
   1076       RtpRtcp* module = *it;
   1077       if (module)  {
   1078         bool enabled = false;
   1079         uint8_t dummy_ptype_red = 0;
   1080         uint8_t dummy_ptype_fec = 0;
   1081         if (module->GenericFECStatus(enabled,
   1082                                      dummy_ptype_red,
   1083                                      dummy_ptype_fec) == 0 && enabled) {
   1084           child_enabled = true;
   1085           break;
   1086         }
   1087       }
   1088       it++;
   1089     }
   1090   }
   1091   int32_t ret_val = rtp_sender_.GenericFECStatus(&enable,
   1092                                                  &payload_type_red,
   1093                                                  &payload_type_fec);
   1094   if (child_enabled) {
   1095     // Returns true if enabled for any child module.
   1096     enable = child_enabled;
   1097   }
   1098   return ret_val;
   1099 }
   1100 
   1101 int32_t ModuleRtpRtcpImpl::SetFecParameters(
   1102     const FecProtectionParams* delta_params,
   1103     const FecProtectionParams* key_params) {
   1104   if (IsDefaultModule())  {
   1105     // For default we need to update all child modules too.
   1106     CriticalSectionScoped lock(critical_section_module_ptrs_.get());
   1107 
   1108     std::vector<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
   1109     while (it != child_modules_.end()) {
   1110       RtpRtcp* module = *it;
   1111       if (module) {
   1112         module->SetFecParameters(delta_params, key_params);
   1113       }
   1114       it++;
   1115     }
   1116     return 0;
   1117   }
   1118   return rtp_sender_.SetFecParameters(delta_params, key_params);
   1119 }
   1120 
   1121 void ModuleRtpRtcpImpl::SetRemoteSSRC(const uint32_t ssrc) {
   1122   // Inform about the incoming SSRC.
   1123   rtcp_sender_.SetRemoteSSRC(ssrc);
   1124   rtcp_receiver_.SetRemoteSSRC(ssrc);
   1125 
   1126   // Check for a SSRC collision.
   1127   if (rtp_sender_.SSRC() == ssrc && !collision_detected_) {
   1128     // If we detect a collision change the SSRC but only once.
   1129     collision_detected_ = true;
   1130     uint32_t new_ssrc = rtp_sender_.GenerateNewSSRC();
   1131     if (new_ssrc == 0) {
   1132       // Configured via API ignore.
   1133       return;
   1134     }
   1135     if (kRtcpOff != rtcp_sender_.Status()) {
   1136       // Send RTCP bye on the current SSRC.
   1137       SendRTCP(kRtcpBye);
   1138     }
   1139     // Change local SSRC and inform all objects about the new SSRC.
   1140     rtcp_sender_.SetSSRC(new_ssrc);
   1141     SetRtcpReceiverSsrcs(new_ssrc);
   1142   }
   1143 }
   1144 
   1145 void ModuleRtpRtcpImpl::BitrateSent(uint32_t* total_rate,
   1146                                     uint32_t* video_rate,
   1147                                     uint32_t* fec_rate,
   1148                                     uint32_t* nack_rate) const {
   1149   if (IsDefaultModule()) {
   1150     // For default we need to update the send bitrate.
   1151     CriticalSectionScoped lock(critical_section_module_ptrs_feedback_.get());
   1152 
   1153     if (total_rate != NULL)
   1154       *total_rate = 0;
   1155     if (video_rate != NULL)
   1156       *video_rate = 0;
   1157     if (fec_rate != NULL)
   1158       *fec_rate = 0;
   1159     if (nack_rate != NULL)
   1160       *nack_rate = 0;
   1161 
   1162     std::vector<ModuleRtpRtcpImpl*>::const_iterator it = child_modules_.begin();
   1163     while (it != child_modules_.end()) {
   1164       RtpRtcp* module = *it;
   1165       if (module) {
   1166         uint32_t child_total_rate = 0;
   1167         uint32_t child_video_rate = 0;
   1168         uint32_t child_fec_rate = 0;
   1169         uint32_t child_nack_rate = 0;
   1170         module->BitrateSent(&child_total_rate,
   1171                             &child_video_rate,
   1172                             &child_fec_rate,
   1173                             &child_nack_rate);
   1174         if (total_rate != NULL && child_total_rate > *total_rate)
   1175           *total_rate = child_total_rate;
   1176         if (video_rate != NULL && child_video_rate > *video_rate)
   1177           *video_rate = child_video_rate;
   1178         if (fec_rate != NULL && child_fec_rate > *fec_rate)
   1179           *fec_rate = child_fec_rate;
   1180         if (nack_rate != NULL && child_nack_rate > *nack_rate)
   1181           *nack_rate = child_nack_rate;
   1182       }
   1183       it++;
   1184     }
   1185     return;
   1186   }
   1187   if (total_rate != NULL)
   1188     *total_rate = rtp_sender_.BitrateSent();
   1189   if (video_rate != NULL)
   1190     *video_rate = rtp_sender_.VideoBitrateSent();
   1191   if (fec_rate != NULL)
   1192     *fec_rate = rtp_sender_.FecOverheadRate();
   1193   if (nack_rate != NULL)
   1194     *nack_rate = rtp_sender_.NackOverheadRate();
   1195 }
   1196 
   1197 void ModuleRtpRtcpImpl::RegisterVideoBitrateObserver(
   1198     BitrateStatisticsObserver* observer) {
   1199   assert(!IsDefaultModule());
   1200   rtp_sender_.RegisterBitrateObserver(observer);
   1201 }
   1202 
   1203 BitrateStatisticsObserver* ModuleRtpRtcpImpl::GetVideoBitrateObserver() const {
   1204   return rtp_sender_.GetBitrateObserver();
   1205 }
   1206 
   1207 void ModuleRtpRtcpImpl::OnRequestIntraFrame() {
   1208   RequestKeyFrame();
   1209 }
   1210 
   1211 void ModuleRtpRtcpImpl::OnRequestSendReport() {
   1212   SendRTCP(kRtcpSr);
   1213 }
   1214 
   1215 int32_t ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
   1216     const uint64_t picture_id) {
   1217   RTCPSender::FeedbackState feedback_state(this);
   1218   return rtcp_sender_.SendRTCP(
   1219       feedback_state, kRtcpRpsi, 0, 0, false, picture_id);
   1220 }
   1221 
   1222 uint32_t ModuleRtpRtcpImpl::SendTimeOfSendReport(
   1223     const uint32_t send_report) {
   1224   return rtcp_sender_.SendTimeOfSendReport(send_report);
   1225 }
   1226 
   1227 bool ModuleRtpRtcpImpl::SendTimeOfXrRrReport(
   1228     uint32_t mid_ntp, int64_t* time_ms) const {
   1229   return rtcp_sender_.SendTimeOfXrRrReport(mid_ntp, time_ms);
   1230 }
   1231 
   1232 void ModuleRtpRtcpImpl::OnReceivedNACK(
   1233     const std::list<uint16_t>& nack_sequence_numbers) {
   1234   if (!rtp_sender_.StorePackets() ||
   1235       nack_sequence_numbers.size() == 0) {
   1236     return;
   1237   }
   1238   // Use RTT from RtcpRttStats class if provided.
   1239   uint16_t rtt = rtt_ms();
   1240   if (rtt == 0) {
   1241     rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
   1242   }
   1243   rtp_sender_.OnReceivedNACK(nack_sequence_numbers, rtt);
   1244 }
   1245 
   1246 int32_t ModuleRtpRtcpImpl::LastReceivedNTP(
   1247     uint32_t& rtcp_arrival_time_secs,  // When we got the last report.
   1248     uint32_t& rtcp_arrival_time_frac,
   1249     uint32_t& remote_sr) {
   1250   // Remote SR: NTP inside the last received (mid 16 bits from sec and frac).
   1251   uint32_t ntp_secs = 0;
   1252   uint32_t ntp_frac = 0;
   1253 
   1254   if (-1 == rtcp_receiver_.NTP(&ntp_secs,
   1255                                &ntp_frac,
   1256                                &rtcp_arrival_time_secs,
   1257                                &rtcp_arrival_time_frac,
   1258                                NULL)) {
   1259     return -1;
   1260   }
   1261   remote_sr = ((ntp_secs & 0x0000ffff) << 16) + ((ntp_frac & 0xffff0000) >> 16);
   1262   return 0;
   1263 }
   1264 
   1265 bool ModuleRtpRtcpImpl::LastReceivedXrReferenceTimeInfo(
   1266     RtcpReceiveTimeInfo* info) const {
   1267   return rtcp_receiver_.LastReceivedXrReferenceTimeInfo(info);
   1268 }
   1269 
   1270 bool ModuleRtpRtcpImpl::UpdateRTCPReceiveInformationTimers() {
   1271   // If this returns true this channel has timed out.
   1272   // Periodically check if this is true and if so call UpdateTMMBR.
   1273   return rtcp_receiver_.UpdateRTCPReceiveInformationTimers();
   1274 }
   1275 
   1276 // Called from RTCPsender.
   1277 int32_t ModuleRtpRtcpImpl::BoundingSet(bool& tmmbr_owner,
   1278                                        TMMBRSet*& bounding_set) {
   1279   return rtcp_receiver_.BoundingSet(tmmbr_owner, bounding_set);
   1280 }
   1281 
   1282 int64_t ModuleRtpRtcpImpl::RtcpReportInterval() {
   1283   if (audio_)
   1284     return RTCP_INTERVAL_AUDIO_MS;
   1285   else
   1286     return RTCP_INTERVAL_VIDEO_MS;
   1287 }
   1288 
   1289 void ModuleRtpRtcpImpl::SetRtcpReceiverSsrcs(uint32_t main_ssrc) {
   1290   std::set<uint32_t> ssrcs;
   1291   ssrcs.insert(main_ssrc);
   1292   int rtx_mode = kRtxOff;
   1293   uint32_t rtx_ssrc = 0;
   1294   int rtx_payload_type = 0;
   1295   rtp_sender_.RTXStatus(&rtx_mode, &rtx_ssrc, &rtx_payload_type);
   1296   if (rtx_mode != kRtxOff)
   1297     ssrcs.insert(rtx_ssrc);
   1298   rtcp_receiver_.SetSsrcs(main_ssrc, ssrcs);
   1299 }
   1300 
   1301 void ModuleRtpRtcpImpl::set_rtt_ms(uint32_t rtt_ms) {
   1302   CriticalSectionScoped cs(critical_section_rtt_.get());
   1303   rtt_ms_ = rtt_ms;
   1304 }
   1305 
   1306 uint32_t ModuleRtpRtcpImpl::rtt_ms() const {
   1307   CriticalSectionScoped cs(critical_section_rtt_.get());
   1308   return rtt_ms_;
   1309 }
   1310 
   1311 void ModuleRtpRtcpImpl::RegisterSendChannelRtpStatisticsCallback(
   1312     StreamDataCountersCallback* callback) {
   1313   rtp_sender_.RegisterRtpStatisticsCallback(callback);
   1314 }
   1315 
   1316 StreamDataCountersCallback*
   1317     ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
   1318   return rtp_sender_.GetRtpStatisticsCallback();
   1319 }
   1320 
   1321 void ModuleRtpRtcpImpl::RegisterSendFrameCountObserver(
   1322     FrameCountObserver* observer) {
   1323   rtp_sender_.RegisterFrameCountObserver(observer);
   1324 }
   1325 
   1326 FrameCountObserver* ModuleRtpRtcpImpl::GetSendFrameCountObserver() const {
   1327   return rtp_sender_.GetFrameCountObserver();
   1328 }
   1329 
   1330 bool ModuleRtpRtcpImpl::IsDefaultModule() const {
   1331   CriticalSectionScoped cs(critical_section_module_ptrs_.get());
   1332   return !child_modules_.empty();
   1333 }
   1334 
   1335 }  // Namespace webrtc
   1336