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