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 <list>
12
13#include "testing/gmock/include/gmock/gmock.h"
14#include "testing/gtest/include/gtest/gtest.h"
15#include "webrtc/modules/pacing/paced_sender.h"
16#include "webrtc/system_wrappers/include/clock.h"
17
18using testing::_;
19using testing::Return;
20
21namespace webrtc {
22namespace test {
23
24static const int kTargetBitrate = 800;
25static const float kPaceMultiplier = 1.5f;
26
27class MockPacedSenderCallback : public PacedSender::Callback {
28 public:
29  MOCK_METHOD4(TimeToSendPacket,
30               bool(uint32_t ssrc,
31                    uint16_t sequence_number,
32                    int64_t capture_time_ms,
33                    bool retransmission));
34  MOCK_METHOD1(TimeToSendPadding,
35      size_t(size_t bytes));
36};
37
38class PacedSenderPadding : public PacedSender::Callback {
39 public:
40  PacedSenderPadding() : padding_sent_(0) {}
41
42  bool TimeToSendPacket(uint32_t ssrc,
43                        uint16_t sequence_number,
44                        int64_t capture_time_ms,
45                        bool retransmission) {
46    return true;
47  }
48
49  size_t TimeToSendPadding(size_t bytes) {
50    const size_t kPaddingPacketSize = 224;
51    size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
52    padding_sent_ += kPaddingPacketSize * num_packets;
53    return kPaddingPacketSize * num_packets;
54  }
55
56  size_t padding_sent() { return padding_sent_; }
57
58 private:
59  size_t padding_sent_;
60};
61
62class PacedSenderProbing : public PacedSender::Callback {
63 public:
64  PacedSenderProbing(const std::list<int>& expected_deltas, Clock* clock)
65      : prev_packet_time_ms_(-1),
66        expected_deltas_(expected_deltas),
67        packets_sent_(0),
68        clock_(clock) {}
69
70  bool TimeToSendPacket(uint32_t ssrc,
71                        uint16_t sequence_number,
72                        int64_t capture_time_ms,
73                        bool retransmission) {
74    ExpectAndCountPacket();
75    return true;
76  }
77
78  size_t TimeToSendPadding(size_t bytes) {
79    ExpectAndCountPacket();
80    return bytes;
81  }
82
83  void ExpectAndCountPacket() {
84    ++packets_sent_;
85    EXPECT_FALSE(expected_deltas_.empty());
86    if (expected_deltas_.empty())
87      return;
88    int64_t now_ms = clock_->TimeInMilliseconds();
89    if (prev_packet_time_ms_ >= 0) {
90      EXPECT_EQ(expected_deltas_.front(), now_ms - prev_packet_time_ms_);
91      expected_deltas_.pop_front();
92    }
93    prev_packet_time_ms_ = now_ms;
94  }
95
96  int packets_sent() const { return packets_sent_; }
97
98 private:
99  int64_t prev_packet_time_ms_;
100  std::list<int> expected_deltas_;
101  int packets_sent_;
102  Clock* clock_;
103};
104
105class PacedSenderTest : public ::testing::Test {
106 protected:
107  PacedSenderTest() : clock_(123456) {
108    srand(0);
109    // Need to initialize PacedSender after we initialize clock.
110    send_bucket_.reset(new PacedSender(&clock_,
111                                       &callback_,
112                                       kTargetBitrate,
113                                       kPaceMultiplier * kTargetBitrate,
114                                       0));
115    // Default to bitrate probing disabled for testing purposes. Probing tests
116    // have to enable probing, either by creating a new PacedSender instance or
117    // by calling SetProbingEnabled(true).
118    send_bucket_->SetProbingEnabled(false);
119  }
120
121  void SendAndExpectPacket(PacedSender::Priority priority,
122                           uint32_t ssrc,
123                           uint16_t sequence_number,
124                           int64_t capture_time_ms,
125                           size_t size,
126                           bool retransmission) {
127    send_bucket_->InsertPacket(priority, ssrc, sequence_number, capture_time_ms,
128                               size, retransmission);
129    EXPECT_CALL(callback_,
130                TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
131        .Times(1)
132        .WillRepeatedly(Return(true));
133  }
134
135  SimulatedClock clock_;
136  MockPacedSenderCallback callback_;
137  rtc::scoped_ptr<PacedSender> send_bucket_;
138};
139
140TEST_F(PacedSenderTest, QueuePacket) {
141  uint32_t ssrc = 12345;
142  uint16_t sequence_number = 1234;
143  // Due to the multiplicative factor we can send 3 packets not 2 packets.
144  SendAndExpectPacket(PacedSender::kNormalPriority,
145                      ssrc,
146                      sequence_number++,
147                      clock_.TimeInMilliseconds(),
148                      250,
149                      false);
150  SendAndExpectPacket(PacedSender::kNormalPriority,
151                      ssrc,
152                      sequence_number++,
153                      clock_.TimeInMilliseconds(),
154                      250,
155                      false);
156  SendAndExpectPacket(PacedSender::kNormalPriority,
157                      ssrc,
158                      sequence_number++,
159                      clock_.TimeInMilliseconds(),
160                      250,
161                      false);
162  int64_t queued_packet_timestamp = clock_.TimeInMilliseconds();
163  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
164                             sequence_number, queued_packet_timestamp, 250,
165                             false);
166  send_bucket_->Process();
167  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
168  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
169  clock_.AdvanceTimeMilliseconds(4);
170  EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
171  clock_.AdvanceTimeMilliseconds(1);
172  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
173  EXPECT_CALL(
174      callback_,
175      TimeToSendPacket(ssrc, sequence_number++, queued_packet_timestamp, false))
176      .Times(1)
177      .WillRepeatedly(Return(true));
178  send_bucket_->Process();
179  sequence_number++;
180  SendAndExpectPacket(PacedSender::kNormalPriority,
181                      ssrc,
182                      sequence_number++,
183                      clock_.TimeInMilliseconds(),
184                      250,
185                      false);
186  SendAndExpectPacket(PacedSender::kNormalPriority,
187                      ssrc,
188                      sequence_number++,
189                      clock_.TimeInMilliseconds(),
190                      250,
191                      false);
192  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
193                             sequence_number++, clock_.TimeInMilliseconds(),
194                             250, false);
195  send_bucket_->Process();
196}
197
198TEST_F(PacedSenderTest, PaceQueuedPackets) {
199  uint32_t ssrc = 12345;
200  uint16_t sequence_number = 1234;
201
202  // Due to the multiplicative factor we can send 3 packets not 2 packets.
203  for (int i = 0; i < 3; ++i) {
204    SendAndExpectPacket(PacedSender::kNormalPriority,
205                        ssrc,
206                        sequence_number++,
207                        clock_.TimeInMilliseconds(),
208                        250,
209                        false);
210  }
211  for (int j = 0; j < 30; ++j) {
212    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
213                               sequence_number++, clock_.TimeInMilliseconds(),
214                               250, false);
215  }
216  send_bucket_->Process();
217  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
218  for (int k = 0; k < 10; ++k) {
219    EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
220    clock_.AdvanceTimeMilliseconds(5);
221    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false))
222        .Times(3)
223        .WillRepeatedly(Return(true));
224    EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
225    EXPECT_EQ(0, send_bucket_->Process());
226  }
227  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
228  clock_.AdvanceTimeMilliseconds(5);
229  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
230  EXPECT_EQ(0, send_bucket_->Process());
231  SendAndExpectPacket(PacedSender::kNormalPriority,
232                      ssrc,
233                      sequence_number++,
234                      clock_.TimeInMilliseconds(),
235                      250,
236                      false);
237  SendAndExpectPacket(PacedSender::kNormalPriority,
238                      ssrc,
239                      sequence_number++,
240                      clock_.TimeInMilliseconds(),
241                      250,
242                      false);
243  SendAndExpectPacket(PacedSender::kNormalPriority,
244                      ssrc,
245                      sequence_number++,
246                      clock_.TimeInMilliseconds(),
247                      250,
248                      false);
249  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
250                             sequence_number, clock_.TimeInMilliseconds(), 250,
251                             false);
252  send_bucket_->Process();
253}
254
255TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
256  uint32_t ssrc = 12345;
257  uint16_t sequence_number = 1234;
258  uint16_t queued_sequence_number;
259
260  // Due to the multiplicative factor we can send 3 packets not 2 packets.
261  for (int i = 0; i < 3; ++i) {
262    SendAndExpectPacket(PacedSender::kNormalPriority,
263                        ssrc,
264                        sequence_number++,
265                        clock_.TimeInMilliseconds(),
266                        250,
267                        false);
268  }
269  queued_sequence_number = sequence_number;
270
271  for (int j = 0; j < 30; ++j) {
272    // Send in duplicate packets.
273    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
274                               sequence_number, clock_.TimeInMilliseconds(),
275                               250, false);
276    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
277                               sequence_number++, clock_.TimeInMilliseconds(),
278                               250, false);
279  }
280  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
281  send_bucket_->Process();
282  for (int k = 0; k < 10; ++k) {
283    EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
284    clock_.AdvanceTimeMilliseconds(5);
285
286    for (int i = 0; i < 3; ++i) {
287      EXPECT_CALL(callback_,
288                  TimeToSendPacket(ssrc, queued_sequence_number++, _, false))
289          .Times(1)
290          .WillRepeatedly(Return(true));
291   }
292    EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
293    EXPECT_EQ(0, send_bucket_->Process());
294  }
295  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
296  clock_.AdvanceTimeMilliseconds(5);
297  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
298  EXPECT_EQ(0, send_bucket_->Process());
299  SendAndExpectPacket(PacedSender::kNormalPriority,
300                      ssrc,
301                      sequence_number++,
302                      clock_.TimeInMilliseconds(),
303                      250,
304                      false);
305  SendAndExpectPacket(PacedSender::kNormalPriority,
306                      ssrc,
307                      sequence_number++,
308                      clock_.TimeInMilliseconds(),
309                      250,
310                      false);
311  SendAndExpectPacket(PacedSender::kNormalPriority,
312                      ssrc,
313                      sequence_number++,
314                      clock_.TimeInMilliseconds(),
315                      250,
316                      false);
317  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
318                             sequence_number++, clock_.TimeInMilliseconds(),
319                             250, false);
320  send_bucket_->Process();
321}
322
323TEST_F(PacedSenderTest, CanQueuePacketsWithSameSequenceNumberOnDifferentSsrcs) {
324  uint32_t ssrc = 12345;
325  uint16_t sequence_number = 1234;
326
327  SendAndExpectPacket(PacedSender::kNormalPriority,
328                      ssrc,
329                      sequence_number,
330                      clock_.TimeInMilliseconds(),
331                      250,
332                      false);
333
334  // Expect packet on second ssrc to be queued and sent as well.
335  SendAndExpectPacket(PacedSender::kNormalPriority,
336                      ssrc + 1,
337                      sequence_number,
338                      clock_.TimeInMilliseconds(),
339                      250,
340                      false);
341
342  clock_.AdvanceTimeMilliseconds(1000);
343  send_bucket_->Process();
344}
345
346TEST_F(PacedSenderTest, Padding) {
347  uint32_t ssrc = 12345;
348  uint16_t sequence_number = 1234;
349
350  send_bucket_->UpdateBitrate(
351      kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
352  // Due to the multiplicative factor we can send 3 packets not 2 packets.
353  SendAndExpectPacket(PacedSender::kNormalPriority,
354                      ssrc,
355                      sequence_number++,
356                      clock_.TimeInMilliseconds(),
357                      250,
358                      false);
359  SendAndExpectPacket(PacedSender::kNormalPriority,
360                      ssrc,
361                      sequence_number++,
362                      clock_.TimeInMilliseconds(),
363                      250,
364                      false);
365  SendAndExpectPacket(PacedSender::kNormalPriority,
366                      ssrc,
367                      sequence_number++,
368                      clock_.TimeInMilliseconds(),
369                      250,
370                      false);
371  // No padding is expected since we have sent too much already.
372  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
373  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
374  clock_.AdvanceTimeMilliseconds(5);
375  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
376  EXPECT_EQ(0, send_bucket_->Process());
377
378  // 5 milliseconds later we have enough budget to send some padding.
379  EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
380      WillOnce(Return(250));
381  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
382  clock_.AdvanceTimeMilliseconds(5);
383  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
384  EXPECT_EQ(0, send_bucket_->Process());
385}
386
387TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
388  uint32_t ssrc = 12345;
389  uint16_t sequence_number = 1234;
390  int64_t capture_time_ms = 56789;
391  const int kTimeStep = 5;
392  const int64_t kBitrateWindow = 100;
393  send_bucket_->UpdateBitrate(
394      kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
395  int64_t start_time = clock_.TimeInMilliseconds();
396  while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
397    SendAndExpectPacket(PacedSender::kNormalPriority,
398                        ssrc,
399                        sequence_number++,
400                        capture_time_ms,
401                        250,
402                        false);
403    clock_.AdvanceTimeMilliseconds(kTimeStep);
404    EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
405        WillOnce(Return(250));
406    send_bucket_->Process();
407  }
408}
409
410TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
411  uint32_t ssrc = 12345;
412  uint16_t sequence_number = 1234;
413  int64_t capture_time_ms = 56789;
414  const int kTimeStep = 5;
415  const int64_t kBitrateWindow = 10000;
416  PacedSenderPadding callback;
417  send_bucket_.reset(new PacedSender(
418      &clock_, &callback, kTargetBitrate, kPaceMultiplier * kTargetBitrate, 0));
419  send_bucket_->SetProbingEnabled(false);
420  send_bucket_->UpdateBitrate(
421      kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
422  int64_t start_time = clock_.TimeInMilliseconds();
423  size_t media_bytes = 0;
424  while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
425    size_t media_payload = rand() % 100 + 200;  // [200, 300] bytes.
426    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
427                               sequence_number++, capture_time_ms,
428                               media_payload, false);
429    media_bytes += media_payload;
430    clock_.AdvanceTimeMilliseconds(kTimeStep);
431    send_bucket_->Process();
432  }
433  EXPECT_NEAR(kTargetBitrate,
434              static_cast<int>(8 * (media_bytes + callback.padding_sent()) /
435                  kBitrateWindow), 1);
436}
437
438TEST_F(PacedSenderTest, Priority) {
439  uint32_t ssrc_low_priority = 12345;
440  uint32_t ssrc = 12346;
441  uint16_t sequence_number = 1234;
442  int64_t capture_time_ms = 56789;
443  int64_t capture_time_ms_low_priority = 1234567;
444
445  // Due to the multiplicative factor we can send 3 packets not 2 packets.
446  SendAndExpectPacket(PacedSender::kLowPriority,
447                      ssrc,
448                      sequence_number++,
449                      capture_time_ms,
450                      250,
451                      false);
452  SendAndExpectPacket(PacedSender::kNormalPriority,
453                      ssrc,
454                      sequence_number++,
455                      capture_time_ms,
456                      250,
457                      false);
458  SendAndExpectPacket(PacedSender::kNormalPriority,
459                      ssrc,
460                      sequence_number++,
461                      capture_time_ms,
462                      250,
463                      false);
464  send_bucket_->Process();
465
466  // Expect normal and low priority to be queued and high to pass through.
467  send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
468                             sequence_number++, capture_time_ms_low_priority,
469                             250, false);
470  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
471                             sequence_number++, capture_time_ms, 250, false);
472  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
473                             sequence_number++, capture_time_ms, 250, false);
474  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
475                             sequence_number++, capture_time_ms, 250, false);
476  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
477                             sequence_number++, capture_time_ms, 250, false);
478
479  // Expect all high and normal priority to be sent out first.
480  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
481  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false))
482      .Times(4)
483      .WillRepeatedly(Return(true));
484
485  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
486  clock_.AdvanceTimeMilliseconds(5);
487  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
488  EXPECT_EQ(0, send_bucket_->Process());
489
490  EXPECT_CALL(callback_,
491              TimeToSendPacket(
492                  ssrc_low_priority, _, capture_time_ms_low_priority, false))
493      .Times(1)
494      .WillRepeatedly(Return(true));
495
496  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
497  clock_.AdvanceTimeMilliseconds(5);
498  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
499  EXPECT_EQ(0, send_bucket_->Process());
500}
501
502TEST_F(PacedSenderTest, HighPrioDoesntAffectBudget) {
503  uint32_t ssrc = 12346;
504  uint16_t sequence_number = 1234;
505  int64_t capture_time_ms = 56789;
506
507  // As high prio packets doesn't affect the budget, we should be able to send
508  // a high number of them at once.
509  for (int i = 0; i < 25; ++i) {
510    SendAndExpectPacket(PacedSender::kHighPriority, ssrc, sequence_number++,
511                        capture_time_ms, 250, false);
512  }
513  send_bucket_->Process();
514  // Low prio packets does affect the budget, so we should only be able to send
515  // 3 at once, the 4th should be queued.
516  for (int i = 0; i < 3; ++i) {
517    SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++,
518                        capture_time_ms, 250, false);
519  }
520  send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc, sequence_number,
521                             capture_time_ms, 250, false);
522  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
523  clock_.AdvanceTimeMilliseconds(5);
524  send_bucket_->Process();
525  EXPECT_CALL(callback_,
526              TimeToSendPacket(ssrc, sequence_number++, capture_time_ms, false))
527      .Times(1);
528  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
529  clock_.AdvanceTimeMilliseconds(5);
530  send_bucket_->Process();
531}
532
533TEST_F(PacedSenderTest, Pause) {
534  uint32_t ssrc_low_priority = 12345;
535  uint32_t ssrc = 12346;
536  uint16_t sequence_number = 1234;
537  int64_t capture_time_ms = clock_.TimeInMilliseconds();
538
539  EXPECT_EQ(0, send_bucket_->QueueInMs());
540
541  // Due to the multiplicative factor we can send 3 packets not 2 packets.
542  SendAndExpectPacket(PacedSender::kLowPriority,
543                      ssrc,
544                      sequence_number++,
545                      capture_time_ms,
546                      250,
547                      false);
548  SendAndExpectPacket(PacedSender::kNormalPriority,
549                      ssrc,
550                      sequence_number++,
551                      capture_time_ms,
552                      250,
553                      false);
554  SendAndExpectPacket(PacedSender::kNormalPriority,
555                      ssrc,
556                      sequence_number++,
557                      capture_time_ms,
558                      250,
559                      false);
560  send_bucket_->Process();
561
562  send_bucket_->Pause();
563
564  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
565                             sequence_number++, capture_time_ms, 250, false);
566  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
567                             sequence_number++, capture_time_ms, 250, false);
568  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
569                             sequence_number++, capture_time_ms, 250, false);
570
571  clock_.AdvanceTimeMilliseconds(10000);
572  int64_t second_capture_time_ms = clock_.TimeInMilliseconds();
573
574  // Expect everything to be queued.
575  send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
576                             sequence_number++, second_capture_time_ms, 250,
577                             false);
578
579  EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
580            send_bucket_->QueueInMs());
581
582  // Expect no packet to come out while paused.
583  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
584  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _)).Times(0);
585
586  for (int i = 0; i < 10; ++i) {
587    clock_.AdvanceTimeMilliseconds(5);
588    EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
589    EXPECT_EQ(0, send_bucket_->Process());
590  }
591  // Expect high prio packets to come out first followed by all packets in the
592  // way they were added.
593  EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false))
594      .Times(3)
595      .WillRepeatedly(Return(true));
596  EXPECT_CALL(callback_, TimeToSendPacket(_, _, second_capture_time_ms, false))
597      .Times(1)
598      .WillRepeatedly(Return(true));
599  send_bucket_->Resume();
600
601  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
602  clock_.AdvanceTimeMilliseconds(5);
603  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
604  EXPECT_EQ(0, send_bucket_->Process());
605
606  EXPECT_EQ(0, send_bucket_->QueueInMs());
607}
608
609TEST_F(PacedSenderTest, ResendPacket) {
610  uint32_t ssrc = 12346;
611  uint16_t sequence_number = 1234;
612  int64_t capture_time_ms = clock_.TimeInMilliseconds();
613  EXPECT_EQ(0, send_bucket_->QueueInMs());
614
615  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
616                             sequence_number, capture_time_ms, 250, false);
617  clock_.AdvanceTimeMilliseconds(1);
618  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
619                             sequence_number + 1, capture_time_ms + 1, 250,
620                             false);
621  clock_.AdvanceTimeMilliseconds(9999);
622  EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
623            send_bucket_->QueueInMs());
624  // Fails to send first packet so only one call.
625  EXPECT_CALL(callback_,
626              TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
627      .Times(1)
628      .WillOnce(Return(false));
629  clock_.AdvanceTimeMilliseconds(10000);
630  send_bucket_->Process();
631
632  // Queue remains unchanged.
633  EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
634            send_bucket_->QueueInMs());
635
636  // Fails to send second packet.
637  EXPECT_CALL(callback_,
638              TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
639      .Times(1)
640      .WillOnce(Return(true));
641  EXPECT_CALL(
642      callback_,
643      TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
644      .Times(1)
645      .WillOnce(Return(false));
646  clock_.AdvanceTimeMilliseconds(10000);
647  send_bucket_->Process();
648
649  // Queue is reduced by 1 packet.
650  EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms - 1,
651            send_bucket_->QueueInMs());
652
653  // Send second packet and queue becomes empty.
654  EXPECT_CALL(
655      callback_,
656      TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
657      .Times(1)
658      .WillOnce(Return(true));
659  clock_.AdvanceTimeMilliseconds(10000);
660  send_bucket_->Process();
661  EXPECT_EQ(0, send_bucket_->QueueInMs());
662}
663
664TEST_F(PacedSenderTest, ExpectedQueueTimeMs) {
665  uint32_t ssrc = 12346;
666  uint16_t sequence_number = 1234;
667  const size_t kNumPackets = 60;
668  const size_t kPacketSize = 1200;
669  const int32_t kMaxBitrate = kPaceMultiplier * 30;
670  EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs());
671
672  send_bucket_->UpdateBitrate(30, kMaxBitrate, 0);
673  for (size_t i = 0; i < kNumPackets; ++i) {
674    SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
675                        clock_.TimeInMilliseconds(), kPacketSize, false);
676  }
677
678  // Queue in ms = 1000 * (bytes in queue) / (kbit per second * 1000 / 8)
679  int64_t queue_in_ms =
680      static_cast<int64_t>(kNumPackets * kPacketSize * 8 / kMaxBitrate);
681  EXPECT_EQ(queue_in_ms, send_bucket_->ExpectedQueueTimeMs());
682
683  int64_t time_start = clock_.TimeInMilliseconds();
684  while (send_bucket_->QueueSizePackets() > 0) {
685    int time_until_process = send_bucket_->TimeUntilNextProcess();
686    if (time_until_process <= 0) {
687      send_bucket_->Process();
688    } else {
689      clock_.AdvanceTimeMilliseconds(time_until_process);
690    }
691  }
692  int64_t duration = clock_.TimeInMilliseconds() - time_start;
693
694  EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs());
695
696  // Allow for aliasing, duration should be within one pack of max time limit.
697  EXPECT_NEAR(duration, PacedSender::kMaxQueueLengthMs,
698              static_cast<int64_t>(kPacketSize * 8 / kMaxBitrate));
699}
700
701TEST_F(PacedSenderTest, QueueTimeGrowsOverTime) {
702  uint32_t ssrc = 12346;
703  uint16_t sequence_number = 1234;
704  EXPECT_EQ(0, send_bucket_->QueueInMs());
705
706  send_bucket_->UpdateBitrate(30, kPaceMultiplier * 30, 0);
707  SendAndExpectPacket(PacedSender::kNormalPriority,
708                      ssrc,
709                      sequence_number,
710                      clock_.TimeInMilliseconds(),
711                      1200,
712                      false);
713
714  clock_.AdvanceTimeMilliseconds(500);
715  EXPECT_EQ(500, send_bucket_->QueueInMs());
716  send_bucket_->Process();
717  EXPECT_EQ(0, send_bucket_->QueueInMs());
718}
719
720TEST_F(PacedSenderTest, ProbingWithInitialFrame) {
721  const int kNumPackets = 11;
722  const int kNumDeltas = kNumPackets - 1;
723  const size_t kPacketSize = 1200;
724  const int kInitialBitrateKbps = 300;
725  uint32_t ssrc = 12346;
726  uint16_t sequence_number = 1234;
727  const int expected_deltas[kNumDeltas] = {
728      10, 10, 10, 10, 10, 5, 5, 5, 5, 5};
729  std::list<int> expected_deltas_list(expected_deltas,
730                                      expected_deltas + kNumPackets - 1);
731  PacedSenderProbing callback(expected_deltas_list, &clock_);
732  send_bucket_.reset(
733      new PacedSender(&clock_,
734                      &callback,
735                      kInitialBitrateKbps,
736                      kPaceMultiplier * kInitialBitrateKbps,
737                      0));
738
739  for (int i = 0; i < kNumPackets; ++i) {
740    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
741                               sequence_number++, clock_.TimeInMilliseconds(),
742                               kPacketSize, false);
743  }
744  while (callback.packets_sent() < kNumPackets) {
745    int time_until_process = send_bucket_->TimeUntilNextProcess();
746    if (time_until_process <= 0) {
747      send_bucket_->Process();
748    } else {
749      clock_.AdvanceTimeMilliseconds(time_until_process);
750    }
751  }
752}
753
754TEST_F(PacedSenderTest, ProbingWithTooSmallInitialFrame) {
755  const int kNumPackets = 11;
756  const int kNumDeltas = kNumPackets - 1;
757  const size_t kPacketSize = 1200;
758  const int kInitialBitrateKbps = 300;
759  uint32_t ssrc = 12346;
760  uint16_t sequence_number = 1234;
761  const int expected_deltas[kNumDeltas] = {10, 10, 10, 10, 10, 5, 5, 5, 5, 5};
762  std::list<int> expected_deltas_list(expected_deltas,
763                                      expected_deltas + kNumPackets - 1);
764  PacedSenderProbing callback(expected_deltas_list, &clock_);
765  send_bucket_.reset(new PacedSender(&clock_, &callback, kInitialBitrateKbps,
766                                     kPaceMultiplier * kInitialBitrateKbps, 0));
767
768  for (int i = 0; i < kNumPackets - 5; ++i) {
769    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
770                               sequence_number++, clock_.TimeInMilliseconds(),
771                               kPacketSize, false);
772  }
773  while (callback.packets_sent() < kNumPackets) {
774    int time_until_process = send_bucket_->TimeUntilNextProcess();
775    if (time_until_process <= 0) {
776      send_bucket_->Process();
777    } else {
778      clock_.AdvanceTimeMilliseconds(time_until_process);
779    }
780  }
781
782  // Process one more time and make sure we don't send any more probes.
783  int time_until_process = send_bucket_->TimeUntilNextProcess();
784  clock_.AdvanceTimeMilliseconds(time_until_process);
785  send_bucket_->Process();
786  EXPECT_EQ(kNumPackets, callback.packets_sent());
787}
788
789TEST_F(PacedSenderTest, PriorityInversion) {
790  uint32_t ssrc = 12346;
791  uint16_t sequence_number = 1234;
792  const size_t kPacketSize = 1200;
793
794  send_bucket_->InsertPacket(
795      PacedSender::kHighPriority, ssrc, sequence_number + 3,
796      clock_.TimeInMilliseconds() + 33, kPacketSize, true);
797
798  send_bucket_->InsertPacket(
799      PacedSender::kHighPriority, ssrc, sequence_number + 2,
800      clock_.TimeInMilliseconds() + 33, kPacketSize, true);
801
802  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number,
803                             clock_.TimeInMilliseconds(), kPacketSize, true);
804
805  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
806                             sequence_number + 1, clock_.TimeInMilliseconds(),
807                             kPacketSize, true);
808
809  // Packets from earlier frames should be sent first.
810  {
811    ::testing::InSequence sequence;
812    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
813                                            clock_.TimeInMilliseconds(), true))
814        .WillOnce(Return(true));
815    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
816                                            clock_.TimeInMilliseconds(), true))
817        .WillOnce(Return(true));
818    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 3,
819                                            clock_.TimeInMilliseconds() + 33,
820                                            true)).WillOnce(Return(true));
821    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 2,
822                                            clock_.TimeInMilliseconds() + 33,
823                                            true)).WillOnce(Return(true));
824
825    while (send_bucket_->QueueSizePackets() > 0) {
826      int time_until_process = send_bucket_->TimeUntilNextProcess();
827      if (time_until_process <= 0) {
828        send_bucket_->Process();
829      } else {
830        clock_.AdvanceTimeMilliseconds(time_until_process);
831      }
832    }
833  }
834}
835
836TEST_F(PacedSenderTest, PaddingOveruse) {
837  uint32_t ssrc = 12346;
838  uint16_t sequence_number = 1234;
839  const size_t kPacketSize = 1200;
840
841  // Min bitrate 0 => no padding, padding budget will stay at 0.
842  send_bucket_->UpdateBitrate(60, 90, 0);
843  SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
844                      clock_.TimeInMilliseconds(), kPacketSize, false);
845  send_bucket_->Process();
846
847  // Add 30kbit padding. When increasing budget, media budget will increase from
848  // negative (overuse) while padding budget will increase form 0.
849  clock_.AdvanceTimeMilliseconds(5);
850  send_bucket_->UpdateBitrate(60, 90, 30);
851
852  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
853                             sequence_number++, clock_.TimeInMilliseconds(),
854                             kPacketSize, false);
855
856  // Don't send padding if queue is non-empty, even if padding budget > 0.
857  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
858  send_bucket_->Process();
859}
860
861TEST_F(PacedSenderTest, AverageQueueTime) {
862  uint32_t ssrc = 12346;
863  uint16_t sequence_number = 1234;
864  const size_t kPacketSize = 1200;
865  const int kBitrateBps = 10 * kPacketSize * 8;  // 10 packets per second.
866  const int kBitrateKbps = (kBitrateBps + 500) / 1000;
867
868  send_bucket_->UpdateBitrate(kBitrateKbps, kBitrateKbps, kBitrateKbps);
869
870  EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs());
871
872  int64_t first_capture_time = clock_.TimeInMilliseconds();
873  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
874                             sequence_number, first_capture_time, kPacketSize,
875                             false);
876  clock_.AdvanceTimeMilliseconds(10);
877  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
878                             sequence_number + 1, clock_.TimeInMilliseconds(),
879                             kPacketSize, false);
880  clock_.AdvanceTimeMilliseconds(10);
881
882  EXPECT_EQ((20 + 10) / 2, send_bucket_->AverageQueueTimeMs());
883
884  // Only first packet (queued for 20ms) should be removed, leave the second
885  // packet (queued for 10ms) alone in the queue.
886  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
887                                          first_capture_time, false))
888      .Times(1)
889      .WillRepeatedly(Return(true));
890  send_bucket_->Process();
891
892  EXPECT_EQ(10, send_bucket_->AverageQueueTimeMs());
893
894  clock_.AdvanceTimeMilliseconds(10);
895  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
896                                          first_capture_time + 10, false))
897      .Times(1)
898      .WillRepeatedly(Return(true));
899  for (int i = 0; i < 3; ++i) {
900    clock_.AdvanceTimeMilliseconds(30);  // Max delta.
901    send_bucket_->Process();
902  }
903
904  EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs());
905}
906
907}  // namespace test
908}  // namespace webrtc
909