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
25namespace webrtc {
26
27RtpRtcp::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
46RtpRtcp* 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
59ModuleRtpRtcpImpl::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
115ModuleRtpRtcpImpl::~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
126void 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
139void 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.
158int32_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).
164int32_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
244void ModuleRtpRtcpImpl::SetRTXSendStatus(int mode) {
245  rtp_sender_.SetRTXStatus(mode);
246}
247
248void ModuleRtpRtcpImpl::RTXSendStatus(int* mode,
249                                      uint32_t* ssrc,
250                                      int* payload_type) const {
251  rtp_sender_.RTXStatus(mode, ssrc, payload_type);
252}
253
254void ModuleRtpRtcpImpl::SetRtxSsrc(uint32_t ssrc) {
255  rtp_sender_.SetRtxSsrc(ssrc);
256}
257
258void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type) {
259  rtp_sender_.SetRtxPayloadType(payload_type);
260}
261
262int32_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
282int32_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
292int32_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
308int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(
309    const int8_t payload_type) {
310  return rtp_sender_.DeRegisterSendPayload(payload_type);
311}
312
313int8_t ModuleRtpRtcpImpl::SendPayloadType() const {
314  return rtp_sender_.SendPayloadType();
315}
316
317uint32_t ModuleRtpRtcpImpl::StartTimestamp() const {
318  return rtp_sender_.StartTimestamp();
319}
320
321// Configure start timestamp, default is a random number.
322int32_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
329uint16_t ModuleRtpRtcpImpl::SequenceNumber() const {
330  return rtp_sender_.SequenceNumber();
331}
332
333// Set SequenceNumber, default is a random number.
334int32_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
340void 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
357bool 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
376uint32_t ModuleRtpRtcpImpl::SSRC() const {
377  return rtp_sender_.SSRC();
378}
379
380// Configure SSRC, default is a random number.
381void ModuleRtpRtcpImpl::SetSSRC(const uint32_t ssrc) {
382  rtp_sender_.SetSSRC(ssrc);
383  rtcp_sender_.SetSSRC(ssrc);
384  SetRtcpReceiverSsrcs(ssrc);
385}
386
387int32_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
393int32_t ModuleRtpRtcpImpl::CSRCs(
394  uint32_t arr_of_csrc[kRtpCsrcSize]) const {
395  return rtp_sender_.CSRCs(arr_of_csrc);
396}
397
398int32_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).
422RTCPSender::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
445int ModuleRtpRtcpImpl::CurrentSendFrequencyHz() const {
446  return rtp_sender_.SendPayloadFrequency();
447}
448
449int32_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
477bool ModuleRtpRtcpImpl::Sending() const {
478  return rtcp_sender_.Sending();
479}
480
481int32_t ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
482  rtp_sender_.SetSendingMediaStatus(sending);
483  return 0;
484}
485
486bool 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
503int32_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
582bool 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
608int 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
624bool 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
636uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const {
637  return rtp_sender_.MaxPayloadLength();
638}
639
640uint16_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
668int32_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
702int32_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
711RTCPMethod 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.
719int32_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.
727uint32_t ModuleRtpRtcpImpl::LastSendReport(
728    uint32_t& last_rtcptime) {
729  return rtcp_sender_.LastSendReport(last_rtcptime);
730}
731
732int32_t ModuleRtpRtcpImpl::SetCNAME(const char c_name[RTCP_CNAME_SIZE]) {
733  return rtcp_sender_.SetCNAME(c_name);
734}
735
736int32_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
742int32_t ModuleRtpRtcpImpl::RemoveMixedCNAME(const uint32_t ssrc) {
743  return rtcp_sender_.RemoveMixedCNAME(ssrc);
744}
745
746int32_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
752int32_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.
768int32_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.
782int32_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.
787int32_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.
794int32_t ModuleRtpRtcpImpl::SendRTCP(uint32_t rtcp_packet_type) {
795  return rtcp_sender_.SendRTCP(GetFeedbackState(), rtcp_packet_type);
796}
797
798int32_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.
807int32_t ModuleRtpRtcpImpl::SetRTCPVoIPMetrics(
808  const RTCPVoIPMetric* voip_metric) {
809  return  rtcp_sender_.SetRTCPVoIPMetrics(voip_metric);
810}
811
812void ModuleRtpRtcpImpl::SetRtcpXrRrtrStatus(bool enable) {
813  return rtcp_sender_.SendRtcpXrReceiverReferenceTime(enable);
814}
815
816bool ModuleRtpRtcpImpl::RtcpXrRrtrStatus() const {
817  return rtcp_sender_.RtcpXrReceiverReferenceTime();
818}
819
820int32_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
838int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(RTCPSenderInfo* sender_info) {
839  return rtcp_receiver_.SenderInfoReceived(sender_info);
840}
841
842// Received RTCP report.
843int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(
844    std::vector<RTCPReportBlock>* receive_blocks) const {
845  return rtcp_receiver_.StatisticsReceived(receive_blocks);
846}
847
848int32_t ModuleRtpRtcpImpl::AddRTCPReportBlock(
849    const uint32_t ssrc,
850    const RTCPReportBlock* report_block) {
851  return rtcp_sender_.AddExternalReportBlock(ssrc, report_block);
852}
853
854int32_t ModuleRtpRtcpImpl::RemoveRTCPReportBlock(
855  const uint32_t ssrc) {
856  return rtcp_sender_.RemoveExternalReportBlock(ssrc);
857}
858
859void 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.
867bool ModuleRtpRtcpImpl::REMB() const {
868  return rtcp_sender_.REMB();
869}
870
871int32_t ModuleRtpRtcpImpl::SetREMBStatus(const bool enable) {
872  return rtcp_sender_.SetREMBStatus(enable);
873}
874
875int32_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.
882bool ModuleRtpRtcpImpl::IJ() const {
883  return rtcp_sender_.IJ();
884}
885
886int32_t ModuleRtpRtcpImpl::SetIJStatus(const bool enable) {
887  return rtcp_sender_.SetIJStatus(enable);
888}
889
890int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
891    const RTPExtensionType type,
892    const uint8_t id) {
893  return rtp_sender_.RegisterRtpHeaderExtension(type, id);
894}
895
896int32_t ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
897    const RTPExtensionType type) {
898  return rtp_sender_.DeregisterRtpHeaderExtension(type);
899}
900
901// (TMMBR) Temporary Max Media Bit Rate.
902bool ModuleRtpRtcpImpl::TMMBR() const {
903  return rtcp_sender_.TMMBR();
904}
905
906int32_t ModuleRtpRtcpImpl::SetTMMBRStatus(const bool enable) {
907  return rtcp_sender_.SetTMMBRStatus(enable);
908}
909
910int32_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.
917int 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.
923int ModuleRtpRtcpImpl::SetSelectiveRetransmissions(uint8_t settings) {
924  return rtp_sender_.SetSelectiveRetransmissions(settings);
925}
926
927// Send a Negative acknowledgment packet.
928int32_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.
979int32_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
986bool ModuleRtpRtcpImpl::StorePackets() const {
987  return rtp_sender_.StorePackets();
988}
989
990void ModuleRtpRtcpImpl::RegisterSendChannelRtcpStatisticsCallback(
991    RtcpStatisticsCallback* callback) {
992  rtcp_receiver_.RegisterRtcpStatisticsCallback(callback);
993}
994
995RtcpStatisticsCallback* ModuleRtpRtcpImpl::
996        GetSendChannelRtcpStatisticsCallback() {
997  return rtcp_receiver_.GetRtcpStatisticsCallback();
998}
999
1000// Send a TelephoneEvent tone using RFC 2833 (4733).
1001int32_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
1008bool 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).
1015int32_t ModuleRtpRtcpImpl::SetAudioPacketSize(
1016    const uint16_t packet_size_samples) {
1017  return rtp_sender_.SetAudioPacketSize(packet_size_samples);
1018}
1019
1020int32_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.
1026int32_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.
1032int32_t ModuleRtpRtcpImpl::SendREDPayloadType(
1033    int8_t& payload_type) const {
1034  return rtp_sender_.RED(&payload_type);
1035}
1036
1037void 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
1067int32_t ModuleRtpRtcpImpl::SetKeyFrameRequestMethod(
1068    const KeyFrameRequestMethod method) {
1069  key_frame_req_method_ = method;
1070  return 0;
1071}
1072
1073int32_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
1085int32_t ModuleRtpRtcpImpl::SendRTCPSliceLossIndication(
1086    const uint8_t picture_id) {
1087  return rtcp_sender_.SendRTCP(
1088      GetFeedbackState(), kRtcpSli, 0, 0, false, picture_id);
1089}
1090
1091int32_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
1107int32_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
1116int32_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
1151int32_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
1171void 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
1195void 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
1247void ModuleRtpRtcpImpl::OnRequestIntraFrame() {
1248  RequestKeyFrame();
1249}
1250
1251void ModuleRtpRtcpImpl::OnRequestSendReport() {
1252  SendRTCP(kRtcpSr);
1253}
1254
1255int32_t ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
1256    const uint64_t picture_id) {
1257  return rtcp_sender_.SendRTCP(
1258      GetFeedbackState(), kRtcpRpsi, 0, 0, false, picture_id);
1259}
1260
1261uint32_t ModuleRtpRtcpImpl::SendTimeOfSendReport(
1262    const uint32_t send_report) {
1263  return rtcp_sender_.SendTimeOfSendReport(send_report);
1264}
1265
1266bool ModuleRtpRtcpImpl::SendTimeOfXrRrReport(
1267    uint32_t mid_ntp, int64_t* time_ms) const {
1268  return rtcp_sender_.SendTimeOfXrRrReport(mid_ntp, time_ms);
1269}
1270
1271void 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
1285bool 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
1305bool ModuleRtpRtcpImpl::LastReceivedXrReferenceTimeInfo(
1306    RtcpReceiveTimeInfo* info) const {
1307  return rtcp_receiver_.LastReceivedXrReferenceTimeInfo(info);
1308}
1309
1310bool 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.
1317int32_t ModuleRtpRtcpImpl::BoundingSet(bool& tmmbr_owner,
1318                                       TMMBRSet*& bounding_set) {
1319  return rtcp_receiver_.BoundingSet(tmmbr_owner, bounding_set);
1320}
1321
1322int64_t ModuleRtpRtcpImpl::RtcpReportInterval() {
1323  if (audio_)
1324    return RTCP_INTERVAL_AUDIO_MS;
1325  else
1326    return RTCP_INTERVAL_VIDEO_MS;
1327}
1328
1329void 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
1341void ModuleRtpRtcpImpl::set_rtt_ms(uint32_t rtt_ms) {
1342  CriticalSectionScoped cs(critical_section_rtt_.get());
1343  rtt_ms_ = rtt_ms;
1344}
1345
1346uint32_t ModuleRtpRtcpImpl::rtt_ms() const {
1347  CriticalSectionScoped cs(critical_section_rtt_.get());
1348  return rtt_ms_;
1349}
1350
1351void ModuleRtpRtcpImpl::RegisterSendChannelRtpStatisticsCallback(
1352    StreamDataCountersCallback* callback) {
1353  rtp_sender_.RegisterRtpStatisticsCallback(callback);
1354}
1355
1356StreamDataCountersCallback*
1357    ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
1358  return rtp_sender_.GetRtpStatisticsCallback();
1359}
1360
1361bool ModuleRtpRtcpImpl::IsDefaultModule() const {
1362  CriticalSectionScoped cs(critical_section_module_ptrs_.get());
1363  return !child_modules_.empty();
1364}
1365
1366}  // Namespace webrtc
1367