1/*
2 *  Copyright (c) 2013 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 "testing/gmock/include/gmock/gmock.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14#include "webrtc/common_types.h"
15#include "webrtc/modules/pacing/include/mock/mock_paced_sender.h"
16#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
17#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
18#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
19#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
20#include "webrtc/system_wrappers/interface/scoped_vector.h"
21
22using ::testing::_;
23using ::testing::NiceMock;
24using ::testing::Return;
25using ::testing::SaveArg;
26
27namespace webrtc {
28namespace {
29const uint32_t kSenderSsrc = 0x12345;
30const uint32_t kReceiverSsrc = 0x23456;
31const uint32_t kSenderRtxSsrc = 0x32345;
32const uint32_t kOneWayNetworkDelayMs = 100;
33const uint8_t kBaseLayerTid = 0;
34const uint8_t kHigherLayerTid = 1;
35const uint16_t kSequenceNumber = 100;
36
37class RtcpRttStatsTestImpl : public RtcpRttStats {
38 public:
39  RtcpRttStatsTestImpl() : rtt_ms_(0) {}
40  virtual ~RtcpRttStatsTestImpl() {}
41
42  virtual void OnRttUpdate(uint32_t rtt_ms) {
43    rtt_ms_ = rtt_ms;
44  }
45  virtual uint32_t LastProcessedRtt() const {
46    return rtt_ms_;
47  }
48  uint32_t rtt_ms_;
49};
50
51class SendTransport : public Transport,
52                      public NullRtpData {
53 public:
54  SendTransport()
55      : receiver_(NULL),
56        clock_(NULL),
57        delay_ms_(0),
58        rtp_packets_sent_(0) {
59  }
60
61  void SetRtpRtcpModule(ModuleRtpRtcpImpl* receiver) {
62    receiver_ = receiver;
63  }
64  void SimulateNetworkDelay(uint32_t delay_ms, SimulatedClock* clock) {
65    clock_ = clock;
66    delay_ms_ = delay_ms;
67  }
68  virtual int SendPacket(int /*ch*/, const void* data, int len) {
69    RTPHeader header;
70    scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
71    EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data),
72                              static_cast<size_t>(len),
73                              &header));
74    ++rtp_packets_sent_;
75    last_rtp_header_ = header;
76    return len;
77  }
78  virtual int SendRTCPPacket(int /*ch*/, const void *data, int len) {
79    if (clock_) {
80      clock_->AdvanceTimeMilliseconds(delay_ms_);
81    }
82    EXPECT_TRUE(receiver_ != NULL);
83    EXPECT_EQ(0, receiver_->IncomingRtcpPacket(
84        static_cast<const uint8_t*>(data), len));
85    return len;
86  }
87  ModuleRtpRtcpImpl* receiver_;
88  SimulatedClock* clock_;
89  uint32_t delay_ms_;
90  int rtp_packets_sent_;
91  RTPHeader last_rtp_header_;
92};
93
94class RtpRtcpModule {
95 public:
96  RtpRtcpModule(SimulatedClock* clock)
97      : receive_statistics_(ReceiveStatistics::Create(clock)) {
98    RtpRtcp::Configuration config;
99    config.audio = false;
100    config.clock = clock;
101    config.outgoing_transport = &transport_;
102    config.receive_statistics = receive_statistics_.get();
103    config.rtt_stats = &rtt_stats_;
104
105    impl_.reset(new ModuleRtpRtcpImpl(config));
106    EXPECT_EQ(0, impl_->SetRTCPStatus(kRtcpCompound));
107
108    transport_.SimulateNetworkDelay(kOneWayNetworkDelayMs, clock);
109  }
110
111  RtcpPacketTypeCounter packets_sent_;
112  RtcpPacketTypeCounter packets_received_;
113  scoped_ptr<ReceiveStatistics> receive_statistics_;
114  SendTransport transport_;
115  RtcpRttStatsTestImpl rtt_stats_;
116  scoped_ptr<ModuleRtpRtcpImpl> impl_;
117
118  RtcpPacketTypeCounter RtcpSent() {
119    impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_);
120    return packets_sent_;
121  }
122  RtcpPacketTypeCounter RtcpReceived() {
123    impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_);
124    return packets_received_;
125  }
126  int RtpSent() {
127    return transport_.rtp_packets_sent_;
128  }
129  uint16_t LastRtpSequenceNumber() {
130    return transport_.last_rtp_header_.sequenceNumber;
131  }
132};
133}  // namespace
134
135class RtpRtcpImplTest : public ::testing::Test {
136 protected:
137  RtpRtcpImplTest()
138      : clock_(1335900000),
139        sender_(&clock_),
140        receiver_(&clock_) {
141    // Send module.
142    EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
143    EXPECT_EQ(0, sender_.impl_->SetSendingMediaStatus(true));
144    sender_.impl_->SetSSRC(kSenderSsrc);
145    sender_.impl_->SetRemoteSSRC(kReceiverSsrc);
146    sender_.impl_->SetSequenceNumber(kSequenceNumber);
147    sender_.impl_->SetStorePacketsStatus(true, 100);
148
149    memset(&codec_, 0, sizeof(VideoCodec));
150    codec_.plType = 100;
151    strncpy(codec_.plName, "VP8", 3);
152    codec_.width = 320;
153    codec_.height = 180;
154    EXPECT_EQ(0, sender_.impl_->RegisterSendPayload(codec_));
155
156    // Receive module.
157    EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
158    EXPECT_EQ(0, receiver_.impl_->SetSendingMediaStatus(false));
159    receiver_.impl_->SetSSRC(kReceiverSsrc);
160    receiver_.impl_->SetRemoteSSRC(kSenderSsrc);
161    // Transport settings.
162    sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get());
163    receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
164  }
165  SimulatedClock clock_;
166  RtpRtcpModule sender_;
167  RtpRtcpModule receiver_;
168  VideoCodec codec_;
169
170  void SendFrame(const RtpRtcpModule* module, uint8_t tid) {
171    RTPVideoHeaderVP8 vp8_header = {};
172    vp8_header.temporalIdx = tid;
173    RTPVideoHeader rtp_video_header = {
174        codec_.width, codec_.height, true, 0, kRtpVideoVp8, {vp8_header}};
175
176    const uint8_t payload[100] = {0};
177    EXPECT_EQ(0, module->impl_->SendOutgoingData(kVideoFrameKey,
178                                                 codec_.plType,
179                                                 0,
180                                                 0,
181                                                 payload,
182                                                 sizeof(payload),
183                                                 NULL,
184                                                 &rtp_video_header));
185  }
186
187  void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) {
188    rtcp::Nack nack;
189    uint16_t list[1];
190    list[0] = sequence_number;
191    const uint16_t kListLength = sizeof(list) / sizeof(list[0]);
192    nack.From(kReceiverSsrc);
193    nack.To(kSenderSsrc);
194    nack.WithList(list, kListLength);
195    rtcp::RawPacket packet = nack.Build();
196    EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet.buffer(),
197                                                   packet.buffer_length()));
198  }
199};
200
201TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_BaseLayer) {
202  sender_.impl_->SetSelectiveRetransmissions(kRetransmitBaseLayer);
203  EXPECT_EQ(kRetransmitBaseLayer, sender_.impl_->SelectiveRetransmissions());
204
205  // Send frames.
206  EXPECT_EQ(0, sender_.RtpSent());
207  SendFrame(&sender_, kBaseLayerTid);    // kSequenceNumber
208  SendFrame(&sender_, kHigherLayerTid);  // kSequenceNumber + 1
209  SendFrame(&sender_, kNoTemporalIdx);   // kSequenceNumber + 2
210  EXPECT_EQ(3, sender_.RtpSent());
211  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
212
213  // Frame with kBaseLayerTid re-sent.
214  IncomingRtcpNack(&sender_, kSequenceNumber);
215  EXPECT_EQ(4, sender_.RtpSent());
216  EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
217  // Frame with kHigherLayerTid not re-sent.
218  IncomingRtcpNack(&sender_, kSequenceNumber + 1);
219  EXPECT_EQ(4, sender_.RtpSent());
220  // Frame with kNoTemporalIdx re-sent.
221  IncomingRtcpNack(&sender_, kSequenceNumber + 2);
222  EXPECT_EQ(5, sender_.RtpSent());
223  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
224}
225
226TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_HigherLayers) {
227  const uint8_t kSetting = kRetransmitBaseLayer + kRetransmitHigherLayers;
228  sender_.impl_->SetSelectiveRetransmissions(kSetting);
229  EXPECT_EQ(kSetting, sender_.impl_->SelectiveRetransmissions());
230
231  // Send frames.
232  EXPECT_EQ(0, sender_.RtpSent());
233  SendFrame(&sender_, kBaseLayerTid);    // kSequenceNumber
234  SendFrame(&sender_, kHigherLayerTid);  // kSequenceNumber + 1
235  SendFrame(&sender_, kNoTemporalIdx);   // kSequenceNumber + 2
236  EXPECT_EQ(3, sender_.RtpSent());
237  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
238
239  // Frame with kBaseLayerTid re-sent.
240  IncomingRtcpNack(&sender_, kSequenceNumber);
241  EXPECT_EQ(4, sender_.RtpSent());
242  EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
243  // Frame with kHigherLayerTid re-sent.
244  IncomingRtcpNack(&sender_, kSequenceNumber + 1);
245  EXPECT_EQ(5, sender_.RtpSent());
246  EXPECT_EQ(kSequenceNumber + 1, sender_.LastRtpSequenceNumber());
247  // Frame with kNoTemporalIdx re-sent.
248  IncomingRtcpNack(&sender_, kSequenceNumber + 2);
249  EXPECT_EQ(6, sender_.RtpSent());
250  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
251}
252
253TEST_F(RtpRtcpImplTest, Rtt) {
254  RTPHeader header;
255  header.timestamp = 1;
256  header.sequenceNumber = 123;
257  header.ssrc = kSenderSsrc;
258  header.headerLength = 12;
259  receiver_.receive_statistics_->IncomingPacket(header, 100, false);
260
261  // Sender module should send a SR.
262  EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
263
264  // Receiver module should send a RR with a response to the last received SR.
265  clock_.AdvanceTimeMilliseconds(1000);
266  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
267
268  // Verify RTT.
269  uint16_t rtt;
270  uint16_t avg_rtt;
271  uint16_t min_rtt;
272  uint16_t max_rtt;
273  EXPECT_EQ(0,
274      sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt));
275  EXPECT_EQ(2 * kOneWayNetworkDelayMs, rtt);
276  EXPECT_EQ(2 * kOneWayNetworkDelayMs, avg_rtt);
277  EXPECT_EQ(2 * kOneWayNetworkDelayMs, min_rtt);
278  EXPECT_EQ(2 * kOneWayNetworkDelayMs, max_rtt);
279
280  // No RTT from other ssrc.
281  EXPECT_EQ(-1,
282      sender_.impl_->RTT(kReceiverSsrc+1, &rtt, &avg_rtt, &min_rtt, &max_rtt));
283
284  // Verify RTT from rtt_stats config.
285  EXPECT_EQ(0U, sender_.rtt_stats_.LastProcessedRtt());
286  EXPECT_EQ(0U, sender_.impl_->rtt_ms());
287  sender_.impl_->Process();
288  EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.rtt_stats_.LastProcessedRtt());
289  EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.impl_->rtt_ms());
290}
291
292TEST_F(RtpRtcpImplTest, SetRtcpXrRrtrStatus) {
293  EXPECT_FALSE(receiver_.impl_->RtcpXrRrtrStatus());
294  receiver_.impl_->SetRtcpXrRrtrStatus(true);
295  EXPECT_TRUE(receiver_.impl_->RtcpXrRrtrStatus());
296}
297
298TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
299  receiver_.impl_->SetRtcpXrRrtrStatus(true);
300
301  // Receiver module should send a Receiver time reference report (RTRR).
302  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
303
304  // Sender module should send a response to the last received RTRR (DLRR).
305  clock_.AdvanceTimeMilliseconds(1000);
306  EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
307
308  // Verify RTT.
309  EXPECT_EQ(0U, receiver_.rtt_stats_.LastProcessedRtt());
310  EXPECT_EQ(0U, receiver_.impl_->rtt_ms());
311  receiver_.impl_->Process();
312  EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.rtt_stats_.LastProcessedRtt());
313  EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms());
314}
315
316TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_Nack) {
317  EXPECT_EQ(0U, sender_.RtcpReceived().nack_packets);
318  EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
319  // Receive module sends a NACK.
320  const uint16_t kNackLength = 1;
321  uint16_t nack_list[kNackLength] = {123};
322  EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
323  EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
324
325  // Send module receives the NACK.
326  EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
327}
328
329TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_FirAndPli) {
330  EXPECT_EQ(0U, sender_.RtcpReceived().fir_packets);
331  EXPECT_EQ(0U, receiver_.RtcpSent().fir_packets);
332  // Receive module sends a FIR.
333  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir));
334  EXPECT_EQ(1U, receiver_.RtcpSent().fir_packets);
335  // Send module receives the FIR.
336  EXPECT_EQ(1U, sender_.RtcpReceived().fir_packets);
337
338  // Receive module sends a FIR and PLI.
339  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir | kRtcpPli));
340  EXPECT_EQ(2U, receiver_.RtcpSent().fir_packets);
341  EXPECT_EQ(1U, receiver_.RtcpSent().pli_packets);
342  // Send module receives the FIR and PLI.
343  EXPECT_EQ(2U, sender_.RtcpReceived().fir_packets);
344  EXPECT_EQ(1U, sender_.RtcpReceived().pli_packets);
345}
346
347class RtpSendingTestTransport : public Transport {
348 public:
349  void ResetCounters() { bytes_received_.clear(); }
350
351  virtual int SendPacket(int channel, const void* data, int length) {
352    RTPHeader header;
353    scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
354    EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data),
355                              static_cast<size_t>(length),
356                              &header));
357    bytes_received_[header.ssrc] += length;
358    ++packets_received_[header.ssrc];
359    return length;
360  }
361
362  virtual int SendRTCPPacket(int channel, const void* data, int length) {
363    return length;
364  }
365
366  int GetPacketsReceived(uint32_t ssrc) const {
367    std::map<uint32_t, int>::const_iterator it = packets_received_.find(ssrc);
368    if (it == packets_received_.end())
369      return 0;
370    return it->second;
371  }
372
373  int GetBytesReceived(uint32_t ssrc) const {
374    std::map<uint32_t, int>::const_iterator it = bytes_received_.find(ssrc);
375    if (it == bytes_received_.end())
376      return 0;
377    return it->second;
378  }
379
380  int GetTotalBytesReceived() const {
381    int sum = 0;
382    for (std::map<uint32_t, int>::const_iterator it = bytes_received_.begin();
383         it != bytes_received_.end();
384         ++it) {
385      sum += it->second;
386    }
387    return sum;
388  }
389
390 private:
391  std::map<uint32_t, int> bytes_received_;
392  std::map<uint32_t, int> packets_received_;
393};
394
395class RtpSendingTest : public ::testing::Test {
396 protected:
397  // Map from SSRC to number of received packets and bytes.
398  typedef std::map<uint32_t, std::pair<int, int> > PaddingMap;
399
400  RtpSendingTest() {
401    // Send module.
402    RtpRtcp::Configuration config;
403    config.audio = false;
404    config.clock = Clock::GetRealTimeClock();
405    config.outgoing_transport = &transport_;
406    config.receive_statistics = receive_statistics_.get();
407    config.rtt_stats = &rtt_stats_;
408    config.paced_sender = &pacer_;
409    memset(&codec_, 0, sizeof(VideoCodec));
410    codec_.plType = 100;
411    strncpy(codec_.plName, "VP8", 3);
412    codec_.numberOfSimulcastStreams = 3;
413    codec_.simulcastStream[0].width = 320;
414    codec_.simulcastStream[0].height = 180;
415    codec_.simulcastStream[0].maxBitrate = 300;
416    codec_.simulcastStream[1].width = 640;
417    codec_.simulcastStream[1].height = 360;
418    codec_.simulcastStream[1].maxBitrate = 600;
419    codec_.simulcastStream[2].width = 1280;
420    codec_.simulcastStream[2].height = 720;
421    codec_.simulcastStream[2].maxBitrate = 1200;
422    // We need numberOfSimulcastStreams + 1 RTP modules since we need one
423    // default module.
424    for (int i = 0; i < codec_.numberOfSimulcastStreams + 1; ++i) {
425      RtpRtcp* sender = RtpRtcp::CreateRtpRtcp(config);
426      EXPECT_EQ(0, sender->RegisterSendPayload(codec_));
427      EXPECT_EQ(0, sender->SetSendingStatus(true));
428      EXPECT_EQ(0, sender->SetSendingMediaStatus(true));
429      sender->SetSSRC(kSenderSsrc + i);
430      sender->SetRemoteSSRC(kReceiverSsrc + i);
431      senders_.push_back(sender);
432      config.default_module = senders_[0];
433    }
434    std::vector<uint32_t> bitrates;
435    bitrates.push_back(codec_.simulcastStream[0].maxBitrate);
436    bitrates.push_back(codec_.simulcastStream[1].maxBitrate);
437    bitrates.push_back(codec_.simulcastStream[2].maxBitrate);
438    senders_[0]->SetTargetSendBitrate(bitrates);
439  }
440
441  ~RtpSendingTest() {
442    for (int i = senders_.size() - 1; i >= 0; --i) {
443      delete senders_[i];
444    }
445  }
446
447  void SendFrameOnSender(int sender_index,
448                         const uint8_t* payload,
449                         size_t length) {
450    RTPVideoHeader rtp_video_header = {
451        codec_.simulcastStream[sender_index].width,
452        codec_.simulcastStream[sender_index].height,
453        true,
454        0,
455        kRtpVideoVp8,
456        {}};
457    uint32_t seq_num = 0;
458    uint32_t ssrc = 0;
459    int64_t capture_time_ms = 0;
460    bool retransmission = false;
461    EXPECT_CALL(pacer_, SendPacket(_, _, _, _, _, _))
462        .WillRepeatedly(DoAll(SaveArg<1>(&ssrc),
463                              SaveArg<2>(&seq_num),
464                              SaveArg<3>(&capture_time_ms),
465                              SaveArg<5>(&retransmission),
466                              Return(true)));
467    EXPECT_EQ(0,
468              senders_[sender_index]->SendOutgoingData(kVideoFrameKey,
469                                                       codec_.plType,
470                                                       0,
471                                                       0,
472                                                       payload,
473                                                       length,
474                                                       NULL,
475                                                       &rtp_video_header));
476    EXPECT_TRUE(senders_[sender_index]->TimeToSendPacket(
477        ssrc, seq_num, capture_time_ms, retransmission));
478  }
479
480  void ExpectPadding(const PaddingMap& expected_padding) {
481    int expected_total_bytes = 0;
482    for (PaddingMap::const_iterator it = expected_padding.begin();
483         it != expected_padding.end();
484         ++it) {
485      int packets_received = transport_.GetBytesReceived(it->first);
486      if (it->second.first > 0) {
487        EXPECT_GE(packets_received, it->second.first)
488            << "On SSRC: " << it->first;
489      }
490      int bytes_received = transport_.GetBytesReceived(it->first);
491      expected_total_bytes += bytes_received;
492      if (it->second.second > 0) {
493        EXPECT_GE(bytes_received, it->second.second)
494            << "On SSRC: " << it->first;
495      } else {
496        EXPECT_EQ(0, bytes_received) << "On SSRC: " << it->first;
497      }
498    }
499    EXPECT_EQ(expected_total_bytes, transport_.GetTotalBytesReceived());
500  }
501
502  scoped_ptr<ReceiveStatistics> receive_statistics_;
503  RtcpRttStatsTestImpl rtt_stats_;
504  std::vector<RtpRtcp*> senders_;
505  RtpSendingTestTransport transport_;
506  NiceMock<MockPacedSender> pacer_;
507  VideoCodec codec_;
508};
509
510TEST_F(RtpSendingTest, DISABLED_RoundRobinPadding) {
511  // We have to send on an SSRC to be allowed to pad, since a marker bit must
512  // be sent prior to padding packets.
513  const uint8_t payload[200] = {0};
514  for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
515    SendFrameOnSender(i + 1, payload, sizeof(payload));
516  }
517  transport_.ResetCounters();
518  senders_[0]->TimeToSendPadding(500);
519  PaddingMap expected_padding;
520  expected_padding[kSenderSsrc + 1] = std::make_pair(2, 500);
521  expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0);
522  expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0);
523  ExpectPadding(expected_padding);
524  senders_[0]->TimeToSendPadding(1000);
525  expected_padding[kSenderSsrc + 2] = std::make_pair(4, 1000);
526  ExpectPadding(expected_padding);
527  senders_[0]->TimeToSendPadding(1500);
528  expected_padding[kSenderSsrc + 3] = std::make_pair(6, 1500);
529  ExpectPadding(expected_padding);
530}
531
532TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtx) {
533  // Enable RTX to allow padding to be sent prior to media.
534  for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
535    // Abs-send-time is needed to be allowed to send padding prior to media,
536    // as otherwise the timestmap used for BWE will be broken.
537    senders_[i]->RegisterSendRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
538                                                1);
539    senders_[i]->SetRtxSendPayloadType(96);
540    senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
541    senders_[i]->SetRTXSendStatus(kRtxRetransmitted);
542  }
543  transport_.ResetCounters();
544  senders_[0]->TimeToSendPadding(500);
545  PaddingMap expected_padding;
546  expected_padding[kSenderSsrc + 1] = std::make_pair(0, 0);
547  expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0);
548  expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0);
549  expected_padding[kSenderRtxSsrc + 1] = std::make_pair(2, 500);
550  expected_padding[kSenderRtxSsrc + 2] = std::make_pair(0, 0);
551  expected_padding[kSenderRtxSsrc + 3] = std::make_pair(0, 0);
552  ExpectPadding(expected_padding);
553  senders_[0]->TimeToSendPadding(1000);
554  expected_padding[kSenderRtxSsrc + 2] = std::make_pair(4, 500);
555  ExpectPadding(expected_padding);
556  senders_[0]->TimeToSendPadding(1500);
557
558  expected_padding[kSenderRtxSsrc + 3] = std::make_pair(6, 500);
559  ExpectPadding(expected_padding);
560}
561
562TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtxRedundantPayloads) {
563  for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
564    senders_[i]->SetRtxSendPayloadType(96);
565    senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
566    senders_[i]->SetRTXSendStatus(kRtxRetransmitted | kRtxRedundantPayloads);
567    senders_[i]->SetStorePacketsStatus(true, 100);
568  }
569  // First send payloads so that we have something to retransmit.
570  const size_t kPayloadSize = 500;
571  const uint8_t payload[kPayloadSize] = {0};
572  for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
573    SendFrameOnSender(i + 1, payload, sizeof(payload));
574  }
575  transport_.ResetCounters();
576  senders_[0]->TimeToSendPadding(500);
577  PaddingMap expected_padding;
578  expected_padding[kSenderSsrc + 1] = std::make_pair<int, int>(0, 0);
579  expected_padding[kSenderSsrc + 2] = std::make_pair<int, int>(0, 0);
580  expected_padding[kSenderSsrc + 3] = std::make_pair<int, int>(0, 0);
581  expected_padding[kSenderRtxSsrc + 1] = std::make_pair<int, int>(1, 500);
582  expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(0, 0);
583  expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(0, 0);
584  ExpectPadding(expected_padding);
585  senders_[0]->TimeToSendPadding(1000);
586  expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(2, 1000);
587  ExpectPadding(expected_padding);
588  senders_[0]->TimeToSendPadding(1500);
589  expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(3, 1500);
590  ExpectPadding(expected_padding);
591}
592}  // namespace webrtc
593