1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <stdint.h>
6
7#include "base/big_endian.h"
8#include "base/test/simple_test_tick_clock.h"
9#include "media/cast/logging/logging_impl.h"
10#include "media/cast/logging/simple_event_subscriber.h"
11#include "media/cast/net/pacing/paced_sender.h"
12#include "media/cast/test/fake_single_thread_task_runner.h"
13#include "testing/gmock/include/gmock/gmock.h"
14
15using testing::_;
16
17namespace media {
18namespace cast {
19namespace {
20
21static const uint8 kValue = 123;
22static const size_t kSize1 = 101;
23static const size_t kSize2 = 102;
24static const size_t kSize3 = 103;
25static const size_t kSize4 = 104;
26static const size_t kNackSize = 105;
27static const int64 kStartMillisecond = INT64_C(12345678900000);
28static const uint32 kVideoSsrc = 0x1234;
29static const uint32 kAudioSsrc = 0x5678;
30
31class TestPacketSender : public PacketSender {
32 public:
33  TestPacketSender() : bytes_sent_(0) {}
34
35  virtual bool SendPacket(PacketRef packet, const base::Closure& cb) OVERRIDE {
36    EXPECT_FALSE(expected_packet_size_.empty());
37    size_t expected_packet_size = expected_packet_size_.front();
38    expected_packet_size_.pop_front();
39    EXPECT_EQ(expected_packet_size, packet->data.size());
40    bytes_sent_ += packet->data.size();
41    return true;
42  }
43
44  virtual int64 GetBytesSent() OVERRIDE {
45    return bytes_sent_;
46  }
47
48  void AddExpectedSize(int expected_packet_size, int repeat_count) {
49    for (int i = 0; i < repeat_count; ++i) {
50      expected_packet_size_.push_back(expected_packet_size);
51    }
52  }
53
54 public:
55  std::list<int> expected_packet_size_;
56  int64 bytes_sent_;
57
58  DISALLOW_COPY_AND_ASSIGN(TestPacketSender);
59};
60
61class PacedSenderTest : public ::testing::Test {
62 protected:
63  PacedSenderTest() {
64    logging_.AddRawEventSubscriber(&subscriber_);
65    testing_clock_.Advance(
66        base::TimeDelta::FromMilliseconds(kStartMillisecond));
67    task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
68    paced_sender_.reset(new PacedSender(kTargetBurstSize,
69                                        kMaxBurstSize,
70                                        &testing_clock_,
71                                        &logging_,
72                                        &mock_transport_,
73                                        task_runner_));
74    paced_sender_->RegisterAudioSsrc(kAudioSsrc);
75    paced_sender_->RegisterVideoSsrc(kVideoSsrc);
76  }
77
78  virtual ~PacedSenderTest() {
79    logging_.RemoveRawEventSubscriber(&subscriber_);
80  }
81
82  static void UpdateCastTransportStatus(CastTransportStatus status) {
83    NOTREACHED();
84  }
85
86  SendPacketVector CreateSendPacketVector(size_t packet_size,
87                                          int num_of_packets_in_frame,
88                                          bool audio) {
89    DCHECK_GE(packet_size, 12u);
90    SendPacketVector packets;
91    base::TimeTicks frame_tick = testing_clock_.NowTicks();
92    // Advance the clock so that we don't get the same frame_tick
93    // next time this function is called.
94    testing_clock_.Advance(base::TimeDelta::FromMilliseconds(1));
95    for (int i = 0; i < num_of_packets_in_frame; ++i) {
96      PacketKey key = PacedPacketSender::MakePacketKey(
97          frame_tick,
98          audio ? kAudioSsrc : kVideoSsrc, // ssrc
99          i);
100
101      PacketRef packet(new base::RefCountedData<Packet>);
102      packet->data.resize(packet_size, kValue);
103      // Write ssrc to packet so that it can be recognized as a
104      // "video frame" for logging purposes.
105      base::BigEndianWriter writer(
106          reinterpret_cast<char*>(&packet->data[8]), 4);
107      bool success = writer.WriteU32(audio ? kAudioSsrc : kVideoSsrc);
108      DCHECK(success);
109      packets.push_back(std::make_pair(key, packet));
110    }
111    return packets;
112  }
113
114  // Use this function to drain the packet list in PacedSender without having
115  // to test the pacing implementation details.
116  bool RunUntilEmpty(int max_tries) {
117    for (int i = 0; i < max_tries; i++) {
118      testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10));
119      task_runner_->RunTasks();
120      if (mock_transport_.expected_packet_size_.empty())
121        return true;
122      i++;
123    }
124
125    return mock_transport_.expected_packet_size_.empty();
126  }
127
128  LoggingImpl logging_;
129  SimpleEventSubscriber subscriber_;
130  base::SimpleTestTickClock testing_clock_;
131  TestPacketSender mock_transport_;
132  scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
133  scoped_ptr<PacedSender> paced_sender_;
134
135  DISALLOW_COPY_AND_ASSIGN(PacedSenderTest);
136};
137
138}  // namespace
139
140TEST_F(PacedSenderTest, PassThroughRtcp) {
141  mock_transport_.AddExpectedSize(kSize1, 2);
142  SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true);
143
144  EXPECT_TRUE(paced_sender_->SendPackets(packets));
145  EXPECT_TRUE(paced_sender_->ResendPackets(packets, DedupInfo()));
146
147  mock_transport_.AddExpectedSize(kSize2, 1);
148  Packet tmp(kSize2, kValue);
149  EXPECT_TRUE(paced_sender_->SendRtcpPacket(
150      1,
151      new base::RefCountedData<Packet>(tmp)));
152}
153
154TEST_F(PacedSenderTest, BasicPace) {
155  int num_of_packets = 27;
156  SendPacketVector packets = CreateSendPacketVector(kSize1,
157                                                    num_of_packets,
158                                                    false);
159
160  mock_transport_.AddExpectedSize(kSize1, 10);
161  EXPECT_TRUE(paced_sender_->SendPackets(packets));
162
163  // Check that we get the next burst.
164  mock_transport_.AddExpectedSize(kSize1, 10);
165
166  base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10);
167  testing_clock_.Advance(timeout);
168  task_runner_->RunTasks();
169
170  // If we call process too early make sure we don't send any packets.
171  timeout = base::TimeDelta::FromMilliseconds(5);
172  testing_clock_.Advance(timeout);
173  task_runner_->RunTasks();
174
175  // Check that we get the next burst.
176  mock_transport_.AddExpectedSize(kSize1, 7);
177  testing_clock_.Advance(timeout);
178  task_runner_->RunTasks();
179
180  // Check that we don't get any more packets.
181  EXPECT_TRUE(RunUntilEmpty(3));
182
183  std::vector<PacketEvent> packet_events;
184  subscriber_.GetPacketEventsAndReset(&packet_events);
185  EXPECT_EQ(num_of_packets, static_cast<int>(packet_events.size()));
186  int sent_to_network_event_count = 0;
187  for (std::vector<PacketEvent>::iterator it = packet_events.begin();
188       it != packet_events.end();
189       ++it) {
190    if (it->type == PACKET_SENT_TO_NETWORK)
191      sent_to_network_event_count++;
192    else
193      FAIL() << "Got unexpected event type " << CastLoggingToString(it->type);
194  }
195  EXPECT_EQ(num_of_packets, sent_to_network_event_count);
196}
197
198TEST_F(PacedSenderTest, PaceWithNack) {
199  // Testing what happen when we get multiple NACK requests for a fully lost
200  // frames just as we sent the first packets in a frame.
201  int num_of_packets_in_frame = 12;
202  int num_of_packets_in_nack = 12;
203
204  SendPacketVector nack_packets =
205      CreateSendPacketVector(kNackSize, num_of_packets_in_nack, false);
206
207  SendPacketVector first_frame_packets =
208      CreateSendPacketVector(kSize1, num_of_packets_in_frame, false);
209
210  SendPacketVector second_frame_packets =
211      CreateSendPacketVector(kSize2, num_of_packets_in_frame, true);
212
213  // Check that the first burst of the frame go out on the wire.
214  mock_transport_.AddExpectedSize(kSize1, 10);
215  EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets));
216
217  // Add first NACK request.
218  EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets, DedupInfo()));
219
220  // Check that we get the first NACK burst.
221  mock_transport_.AddExpectedSize(kNackSize, 10);
222  base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10);
223  testing_clock_.Advance(timeout);
224  task_runner_->RunTasks();
225
226  // Add second NACK request.
227  EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets, DedupInfo()));
228
229  // Check that we get the next NACK burst.
230  mock_transport_.AddExpectedSize(kNackSize, 10);
231  testing_clock_.Advance(timeout);
232  task_runner_->RunTasks();
233
234  // End of NACK plus two packets from the oldest frame.
235  // Note that two of the NACKs have been de-duped.
236  mock_transport_.AddExpectedSize(kNackSize, 2);
237  mock_transport_.AddExpectedSize(kSize1, 2);
238  testing_clock_.Advance(timeout);
239  task_runner_->RunTasks();
240
241  // Add second frame.
242  // Make sure we don't delay the second frame due to the previous packets.
243  mock_transport_.AddExpectedSize(kSize2, 10);
244  EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets));
245
246  // Last packets of frame 2.
247  mock_transport_.AddExpectedSize(kSize2, 2);
248  testing_clock_.Advance(timeout);
249  task_runner_->RunTasks();
250
251  // No more packets.
252  EXPECT_TRUE(RunUntilEmpty(5));
253
254  std::vector<PacketEvent> packet_events;
255  subscriber_.GetPacketEventsAndReset(&packet_events);
256  int expected_video_network_event_count = num_of_packets_in_frame;
257  int expected_video_retransmitted_event_count = 2 * num_of_packets_in_nack;
258  expected_video_retransmitted_event_count -= 2; // 2 packets deduped
259  int expected_audio_network_event_count = num_of_packets_in_frame;
260  EXPECT_EQ(expected_video_network_event_count +
261            expected_video_retransmitted_event_count +
262            expected_audio_network_event_count,
263            static_cast<int>(packet_events.size()));
264  int audio_network_event_count = 0;
265  int video_network_event_count = 0;
266  int video_retransmitted_event_count = 0;
267  for (std::vector<PacketEvent>::iterator it = packet_events.begin();
268       it != packet_events.end();
269       ++it) {
270    if (it->type == PACKET_SENT_TO_NETWORK) {
271      if (it->media_type == VIDEO_EVENT)
272        video_network_event_count++;
273      else
274        audio_network_event_count++;
275    } else if (it->type == PACKET_RETRANSMITTED) {
276      if (it->media_type == VIDEO_EVENT)
277        video_retransmitted_event_count++;
278    } else {
279      FAIL() << "Got unexpected event type " << CastLoggingToString(it->type);
280    }
281  }
282  EXPECT_EQ(expected_audio_network_event_count, audio_network_event_count);
283  EXPECT_EQ(expected_video_network_event_count, video_network_event_count);
284  EXPECT_EQ(expected_video_retransmitted_event_count,
285            video_retransmitted_event_count);
286}
287
288TEST_F(PacedSenderTest, PaceWith60fps) {
289  // Testing what happen when we get multiple NACK requests for a fully lost
290  // frames just as we sent the first packets in a frame.
291  int num_of_packets_in_frame = 17;
292
293  SendPacketVector first_frame_packets =
294      CreateSendPacketVector(kSize1, num_of_packets_in_frame, false);
295
296  SendPacketVector second_frame_packets =
297      CreateSendPacketVector(kSize2, num_of_packets_in_frame, false);
298
299  SendPacketVector third_frame_packets =
300      CreateSendPacketVector(kSize3, num_of_packets_in_frame, false);
301
302  SendPacketVector fourth_frame_packets =
303      CreateSendPacketVector(kSize4, num_of_packets_in_frame, false);
304
305  base::TimeDelta timeout_10ms = base::TimeDelta::FromMilliseconds(10);
306
307  // Check that the first burst of the frame go out on the wire.
308  mock_transport_.AddExpectedSize(kSize1, 10);
309  EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets));
310
311  mock_transport_.AddExpectedSize(kSize1, 7);
312  testing_clock_.Advance(timeout_10ms);
313  task_runner_->RunTasks();
314
315  testing_clock_.Advance(base::TimeDelta::FromMilliseconds(6));
316
317  // Add second frame, after 16 ms.
318  mock_transport_.AddExpectedSize(kSize2, 3);
319  EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets));
320  testing_clock_.Advance(base::TimeDelta::FromMilliseconds(4));
321
322  mock_transport_.AddExpectedSize(kSize2, 10);
323  testing_clock_.Advance(timeout_10ms);
324  task_runner_->RunTasks();
325
326  mock_transport_.AddExpectedSize(kSize2, 4);
327  testing_clock_.Advance(timeout_10ms);
328  task_runner_->RunTasks();
329
330  testing_clock_.Advance(base::TimeDelta::FromMilliseconds(3));
331
332  // Add third frame, after 33 ms.
333  mock_transport_.AddExpectedSize(kSize3, 6);
334  EXPECT_TRUE(paced_sender_->SendPackets(third_frame_packets));
335
336  mock_transport_.AddExpectedSize(kSize3, 10);
337  testing_clock_.Advance(base::TimeDelta::FromMilliseconds(7));
338  task_runner_->RunTasks();
339
340  // Add fourth frame, after 50 ms.
341  EXPECT_TRUE(paced_sender_->SendPackets(fourth_frame_packets));
342
343  mock_transport_.AddExpectedSize(kSize3, 1);
344  mock_transport_.AddExpectedSize(kSize4, 9);
345  testing_clock_.Advance(timeout_10ms);
346  task_runner_->RunTasks();
347
348  mock_transport_.AddExpectedSize(kSize4, 8);
349  testing_clock_.Advance(timeout_10ms);
350  task_runner_->RunTasks();
351
352  testing_clock_.Advance(timeout_10ms);
353  task_runner_->RunTasks();
354
355  testing_clock_.Advance(timeout_10ms);
356  task_runner_->RunTasks();
357
358  // No more packets.
359  EXPECT_TRUE(RunUntilEmpty(5));
360}
361
362TEST_F(PacedSenderTest, SendPriority) {
363  // Actual order to the network is:
364  // 1. Video packets x 10.
365  // 2. RTCP packet x 1.
366  // 3. Audio packet x 1.
367  // 4. Video retransmission packet x 10.
368  // 5. Video packet x 10.
369  mock_transport_.AddExpectedSize(kSize2, 10);  // Normal video packets.
370  mock_transport_.AddExpectedSize(kSize3, 1);  // RTCP packet.
371  mock_transport_.AddExpectedSize(kSize1, 1);  // Audio packet.
372  mock_transport_.AddExpectedSize(kSize4, 10);  // Resend video packets.
373  mock_transport_.AddExpectedSize(kSize2, 10);  // Normal video packets.
374
375  paced_sender_->RegisterPrioritySsrc(kAudioSsrc);
376
377  // Retransmission packets with the earlier timestamp.
378  SendPacketVector resend_packets =
379      CreateSendPacketVector(kSize4, 10, false);
380  testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10));
381
382  // Send 20 normal video packets. Only 10 will be sent in this
383  // call, the rest will be sitting in the queue waiting for pacing.
384  EXPECT_TRUE(paced_sender_->SendPackets(
385      CreateSendPacketVector(kSize2, 20, false)));
386
387  testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10));
388
389  // Send normal audio packet. This is queued and will be sent
390  // earlier than video packets.
391  EXPECT_TRUE(paced_sender_->SendPackets(
392      CreateSendPacketVector(kSize1, 1, true)));
393
394  // Send RTCP packet. This is queued and will be sent first.
395  EXPECT_TRUE(paced_sender_->SendRtcpPacket(
396      kVideoSsrc,
397      new base::RefCountedData<Packet>(Packet(kSize3, kValue))));
398
399  // Resend video packets. This is queued and will be sent
400  // earlier than normal video packets.
401  EXPECT_TRUE(paced_sender_->ResendPackets(resend_packets, DedupInfo()));
402
403  // Roll the clock. Queued packets will be sent in this order:
404  // 1. RTCP packet x 1.
405  // 2. Audio packet x 1.
406  // 3. Video retransmission packet x 10.
407  // 4. Video packet x 10.
408  task_runner_->RunTasks();
409  EXPECT_TRUE(RunUntilEmpty(4));
410}
411
412TEST_F(PacedSenderTest, GetLastByteSent) {
413  mock_transport_.AddExpectedSize(kSize1, 4);
414
415  SendPacketVector packets1 = CreateSendPacketVector(kSize1, 1, true);
416  SendPacketVector packets2 = CreateSendPacketVector(kSize1, 1, false);
417
418  EXPECT_TRUE(paced_sender_->SendPackets(packets1));
419  EXPECT_EQ(static_cast<int64>(kSize1),
420            paced_sender_->GetLastByteSentForPacket(packets1[0].first));
421  EXPECT_EQ(static_cast<int64>(kSize1),
422            paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
423  EXPECT_EQ(0, paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
424
425  EXPECT_TRUE(paced_sender_->SendPackets(packets2));
426  EXPECT_EQ(static_cast<int64>(2 * kSize1),
427            paced_sender_->GetLastByteSentForPacket(packets2[0].first));
428  EXPECT_EQ(static_cast<int64>(kSize1),
429            paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
430  EXPECT_EQ(static_cast<int64>(2 * kSize1),
431            paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
432
433  EXPECT_TRUE(paced_sender_->ResendPackets(packets1, DedupInfo()));
434  EXPECT_EQ(static_cast<int64>(3 * kSize1),
435            paced_sender_->GetLastByteSentForPacket(packets1[0].first));
436  EXPECT_EQ(static_cast<int64>(3 * kSize1),
437            paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
438  EXPECT_EQ(static_cast<int64>(2 * kSize1),
439            paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
440
441  EXPECT_TRUE(paced_sender_->ResendPackets(packets2, DedupInfo()));
442  EXPECT_EQ(static_cast<int64>(4 * kSize1),
443            paced_sender_->GetLastByteSentForPacket(packets2[0].first));
444  EXPECT_EQ(static_cast<int64>(3 * kSize1),
445            paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
446  EXPECT_EQ(static_cast<int64>(4 * kSize1),
447            paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
448}
449
450TEST_F(PacedSenderTest, DedupWithResendInterval) {
451  mock_transport_.AddExpectedSize(kSize1, 2);
452
453  SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true);
454  EXPECT_TRUE(paced_sender_->SendPackets(packets));
455  testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10));
456
457  DedupInfo dedup_info;
458  dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(20);
459
460  // This packet will not be sent.
461  EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
462  EXPECT_EQ(static_cast<int64>(kSize1), mock_transport_.GetBytesSent());
463
464  dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(5);
465  EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
466  EXPECT_EQ(static_cast<int64>(2 * kSize1), mock_transport_.GetBytesSent());
467}
468
469}  // namespace cast
470}  // namespace media
471