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 <iostream>
12
13 #include "webrtc/engine_configurations.h"
14 #include "webrtc/test/testsupport/fileutils.h"
15 #include "webrtc/video_engine/include/vie_rtp_rtcp.h"
16 #include "webrtc/video_engine/test/auto_test/interface/vie_autotest.h"
17 #include "webrtc/video_engine/test/auto_test/interface/vie_autotest_defines.h"
18 #include "webrtc/video_engine/test/libvietest/include/tb_capture_device.h"
19 #include "webrtc/video_engine/test/libvietest/include/tb_external_transport.h"
20 #include "webrtc/video_engine/test/libvietest/include/tb_interfaces.h"
21 #include "webrtc/video_engine/test/libvietest/include/tb_video_channel.h"
22
23 class ViERtpObserver: public webrtc::ViERTPObserver
24 {
25 public:
ViERtpObserver()26 ViERtpObserver()
27 {
28 }
~ViERtpObserver()29 virtual ~ViERtpObserver()
30 {
31 }
32
IncomingSSRCChanged(const int videoChannel,const unsigned int SSRC)33 virtual void IncomingSSRCChanged(const int videoChannel,
34 const unsigned int SSRC)
35 {
36 }
IncomingCSRCChanged(const int videoChannel,const unsigned int CSRC,const bool added)37 virtual void IncomingCSRCChanged(const int videoChannel,
38 const unsigned int CSRC, const bool added)
39 {
40 }
41 };
42
43 class ViERtcpObserver: public webrtc::ViERTCPObserver
44 {
45 public:
46 int _channel;
47 unsigned char _subType;
48 unsigned int _name;
49 char* _data;
50 unsigned short _dataLength;
51
ViERtcpObserver()52 ViERtcpObserver() :
53 _channel(-1),
54 _subType(0),
55 _name(0),
56 _data(NULL),
57 _dataLength(0)
58 {
59 }
~ViERtcpObserver()60 ~ViERtcpObserver()
61 {
62 if (_data)
63 {
64 delete[] _data;
65 }
66 }
OnApplicationDataReceived(const int videoChannel,const unsigned char subType,const unsigned int name,const char * data,const unsigned short dataLengthInBytes)67 virtual void OnApplicationDataReceived(
68 const int videoChannel, const unsigned char subType,
69 const unsigned int name, const char* data,
70 const unsigned short dataLengthInBytes)
71 {
72 _channel = videoChannel;
73 _subType = subType;
74 _name = name;
75 if (dataLengthInBytes > _dataLength)
76 {
77 delete[] _data;
78 _data = NULL;
79 }
80 if (_data == NULL)
81 {
82 _data = new char[dataLengthInBytes];
83 }
84 memcpy(_data, data, dataLengthInBytes);
85 _dataLength = dataLengthInBytes;
86 }
87 };
88
ViERtpRtcpStandardTest()89 void ViEAutoTest::ViERtpRtcpStandardTest()
90 {
91 // ***************************************************************
92 // Begin create/initialize WebRTC Video Engine for testing
93 // ***************************************************************
94
95 // Create VIE
96 TbInterfaces ViE("ViERtpRtcpStandardTest");
97 // Create a video channel
98 TbVideoChannel tbChannel(ViE, webrtc::kVideoCodecVP8);
99
100 // Create a capture device
101 TbCaptureDevice tbCapture(ViE);
102 tbCapture.ConnectTo(tbChannel.videoChannel);
103
104 ViETest::Log("\n");
105 TbExternalTransport myTransport(*(ViE.network), tbChannel.videoChannel,
106 NULL);
107
108 ViE.network->DeregisterSendTransport(tbChannel.videoChannel);
109 EXPECT_EQ(0, ViE.network->RegisterSendTransport(
110 tbChannel.videoChannel, myTransport));
111
112 // ***************************************************************
113 // Engine ready. Begin testing class
114 // ***************************************************************
115 unsigned short startSequenceNumber = 12345;
116 ViETest::Log("Set start sequence number: %u", startSequenceNumber);
117 EXPECT_EQ(0, ViE.rtp_rtcp->SetStartSequenceNumber(
118 tbChannel.videoChannel, startSequenceNumber));
119 const unsigned int kVideoSsrc = 123456;
120 // Set an SSRC to avoid issues with collisions.
121 EXPECT_EQ(0, ViE.rtp_rtcp->SetLocalSSRC(tbChannel.videoChannel, kVideoSsrc,
122 webrtc::kViEStreamTypeNormal, 0));
123
124 myTransport.EnableSequenceNumberCheck();
125
126 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
127 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
128
129 AutoTestSleep(2000);
130
131 unsigned short receivedSequenceNumber =
132 myTransport.GetFirstSequenceNumber();
133 ViETest::Log("First received sequence number: %u\n",
134 receivedSequenceNumber);
135 EXPECT_EQ(startSequenceNumber, receivedSequenceNumber);
136
137 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
138
139 //
140 // RTCP CName
141 //
142 ViETest::Log("Testing CName\n");
143 const char* sendCName = "ViEAutoTestCName\0";
144 EXPECT_EQ(0, ViE.rtp_rtcp->SetRTCPCName(tbChannel.videoChannel, sendCName));
145
146 char returnCName[webrtc::ViERTP_RTCP::KMaxRTCPCNameLength];
147 memset(returnCName, 0, webrtc::ViERTP_RTCP::KMaxRTCPCNameLength);
148 EXPECT_EQ(0, ViE.rtp_rtcp->GetRTCPCName(
149 tbChannel.videoChannel, returnCName));
150 EXPECT_STRCASEEQ(sendCName, returnCName);
151
152 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
153
154 AutoTestSleep(1000);
155
156 if (FLAGS_include_timing_dependent_tests) {
157 char remoteCName[webrtc::ViERTP_RTCP::KMaxRTCPCNameLength];
158 memset(remoteCName, 0, webrtc::ViERTP_RTCP::KMaxRTCPCNameLength);
159 EXPECT_EQ(0, ViE.rtp_rtcp->GetRemoteRTCPCName(
160 tbChannel.videoChannel, remoteCName));
161 EXPECT_STRCASEEQ(sendCName, remoteCName);
162 }
163
164
165 //
166 // Pacing
167 //
168 webrtc::RtcpStatistics received;
169 int recRttMs = 0;
170 unsigned int sentTotalBitrate = 0;
171 unsigned int sentVideoBitrate = 0;
172 unsigned int sentFecBitrate = 0;
173 unsigned int sentNackBitrate = 0;
174
175 ViETest::Log("Testing Pacing\n");
176 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
177 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
178
179 myTransport.ClearStats();
180
181 EXPECT_EQ(0, ViE.rtp_rtcp->SetNACKStatus(tbChannel.videoChannel, true));
182 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
183 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
184
185 NetworkParameters network;
186 network.packet_loss_rate = 0;
187 network.loss_model = kUniformLoss;
188 myTransport.SetNetworkParameters(network);
189
190 AutoTestSleep(kAutoTestSleepTimeMs);
191
192 EXPECT_EQ(0, ViE.rtp_rtcp->GetReceiveChannelRtcpStatistics(
193 tbChannel.videoChannel, received, recRttMs));
194 EXPECT_EQ(0, ViE.rtp_rtcp->GetBandwidthUsage(
195 tbChannel.videoChannel, sentTotalBitrate, sentVideoBitrate,
196 sentFecBitrate, sentNackBitrate));
197
198 int num_rtp_packets = 0;
199 int num_dropped_packets = 0;
200 int num_rtcp_packets = 0;
201 std::map<uint8_t, int> packet_counters;
202 myTransport.GetStats(num_rtp_packets, num_dropped_packets, num_rtcp_packets,
203 &packet_counters);
204 EXPECT_GT(num_rtp_packets, 0);
205 EXPECT_EQ(num_dropped_packets, 0);
206 EXPECT_GT(num_rtcp_packets, 0);
207 EXPECT_GT(sentTotalBitrate, 0u);
208 EXPECT_EQ(sentNackBitrate, 0u);
209 EXPECT_EQ(received.cumulative_lost, 0u);
210
211 //
212 // RTX
213 //
214 ViETest::Log("Testing NACK over RTX\n");
215 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
216 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
217
218 myTransport.ClearStats();
219
220 const uint8_t kRtxPayloadType = 96;
221 // Temporarily disable pacing.
222 EXPECT_EQ(0, ViE.rtp_rtcp->SetTransmissionSmoothingStatus(
223 tbChannel.videoChannel, false));
224 EXPECT_EQ(0, ViE.rtp_rtcp->SetNACKStatus(tbChannel.videoChannel, true));
225 EXPECT_EQ(0, ViE.rtp_rtcp->SetRtxSendPayloadType(tbChannel.videoChannel,
226 kRtxPayloadType));
227 EXPECT_EQ(0, ViE.rtp_rtcp->SetRtxReceivePayloadType(tbChannel.videoChannel,
228 kRtxPayloadType));
229 EXPECT_EQ(0, ViE.rtp_rtcp->SetLocalSSRC(tbChannel.videoChannel, 1234,
230 webrtc::kViEStreamTypeRtx, 0));
231 EXPECT_EQ(0, ViE.rtp_rtcp->SetRemoteSSRCType(tbChannel.videoChannel,
232 webrtc::kViEStreamTypeRtx,
233 1234));
234 EXPECT_EQ(0, ViE.rtp_rtcp->SetStartSequenceNumber(
235 tbChannel.videoChannel, startSequenceNumber));
236 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
237 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
238
239 // Make sure the first key frame gets through.
240 AutoTestSleep(100);
241 const int kPacketLossRate = 20;
242 network.packet_loss_rate = kPacketLossRate;
243 network.loss_model = kUniformLoss;
244 myTransport.SetNetworkParameters(network);
245 AutoTestSleep(kAutoTestSleepTimeMs);
246
247 EXPECT_EQ(0, ViE.rtp_rtcp->GetReceiveChannelRtcpStatistics(
248 tbChannel.videoChannel, received, recRttMs));
249 EXPECT_EQ(0, ViE.rtp_rtcp->GetBandwidthUsage(
250 tbChannel.videoChannel, sentTotalBitrate, sentVideoBitrate,
251 sentFecBitrate, sentNackBitrate));
252
253 packet_counters.clear();
254 myTransport.GetStats(num_rtp_packets, num_dropped_packets, num_rtcp_packets,
255 &packet_counters);
256 EXPECT_GT(num_rtp_packets, 0);
257 EXPECT_GT(num_dropped_packets, 0);
258 EXPECT_GT(num_rtcp_packets, 0);
259 EXPECT_GT(packet_counters[kRtxPayloadType], 0);
260
261 // Make sure we have lost packets and that they were retransmitted.
262 // TODO(holmer): Disabled due to being flaky. Could be a bug in our stats.
263 // EXPECT_GT(recCumulativeLost, 0u);
264 EXPECT_GT(sentTotalBitrate, 0u);
265 EXPECT_GT(sentNackBitrate, 0u);
266
267 //
268 // Statistics
269 //
270 // Stop and restart to clear stats
271 ViETest::Log("Testing statistics\n");
272 EXPECT_EQ(0, ViE.rtp_rtcp->SetNACKStatus(tbChannel.videoChannel, false));
273 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
274 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
275
276 myTransport.ClearStats();
277 network.packet_loss_rate = kPacketLossRate;
278 network.loss_model = kUniformLoss;
279 myTransport.SetNetworkParameters(network);
280
281 // Start send to verify sending stats
282
283 EXPECT_EQ(0, ViE.rtp_rtcp->SetStartSequenceNumber(
284 tbChannel.videoChannel, startSequenceNumber));
285 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
286 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
287
288 webrtc::RtcpStatistics sent;
289 int sentRttMs = 0;
290
291 // Fraction lost is a transient value that can get reset after a new rtcp
292 // report block. Make regular polls to make sure it is propagated.
293 // TODO(sprang): Replace with callbacks, when those are fully implemented.
294 int time_to_sleep = kAutoTestSleepTimeMs;
295 bool got_send_channel_frac_lost = false;
296 bool got_receive_channel_frac_lost = false;
297 while (time_to_sleep > 0) {
298 AutoTestSleep(500);
299 time_to_sleep -= 500;
300 EXPECT_EQ(0,
301 ViE.rtp_rtcp->GetSendChannelRtcpStatistics(
302 tbChannel.videoChannel, sent, sentRttMs));
303 got_send_channel_frac_lost |= sent.fraction_lost > 0;
304 EXPECT_EQ(0,
305 ViE.rtp_rtcp->GetReceiveChannelRtcpStatistics(
306 tbChannel.videoChannel, received, recRttMs));
307 got_receive_channel_frac_lost |= received.fraction_lost > 0;
308 }
309 EXPECT_TRUE(got_send_channel_frac_lost);
310 EXPECT_TRUE(got_receive_channel_frac_lost);
311
312 EXPECT_EQ(0, ViE.rtp_rtcp->GetBandwidthUsage(
313 tbChannel.videoChannel, sentTotalBitrate, sentVideoBitrate,
314 sentFecBitrate, sentNackBitrate));
315
316 EXPECT_GT(sentTotalBitrate, 0u);
317 EXPECT_EQ(sentFecBitrate, 0u);
318 EXPECT_EQ(sentNackBitrate, 0u);
319
320 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
321
322 AutoTestSleep(2000);
323
324 EXPECT_EQ(0, ViE.rtp_rtcp->GetSendChannelRtcpStatistics(
325 tbChannel.videoChannel, sent, sentRttMs));
326 EXPECT_GT(sent.cumulative_lost, 0u);
327 EXPECT_GT(sent.extended_max_sequence_number, startSequenceNumber);
328 EXPECT_GT(sent.jitter, 0u);
329 EXPECT_GT(sentRttMs, 0);
330
331 EXPECT_EQ(0, ViE.rtp_rtcp->GetReceiveChannelRtcpStatistics(
332 tbChannel.videoChannel, received, recRttMs));
333
334 EXPECT_GT(received.cumulative_lost, 0u);
335 EXPECT_GT(received.extended_max_sequence_number, startSequenceNumber);
336 EXPECT_GT(received.jitter, 0u);
337 EXPECT_GT(recRttMs, 0);
338
339 unsigned int estimated_bandwidth = 0;
340 EXPECT_EQ(0, ViE.rtp_rtcp->GetEstimatedSendBandwidth(
341 tbChannel.videoChannel,
342 &estimated_bandwidth));
343 EXPECT_GT(estimated_bandwidth, 0u);
344
345 if (FLAGS_include_timing_dependent_tests) {
346 EXPECT_EQ(0, ViE.rtp_rtcp->GetEstimatedReceiveBandwidth(
347 tbChannel.videoChannel,
348 &estimated_bandwidth));
349 EXPECT_GT(estimated_bandwidth, 0u);
350
351 int passive_channel = -1;
352 EXPECT_EQ(ViE.base->CreateReceiveChannel(passive_channel,
353 tbChannel.videoChannel), 0);
354 EXPECT_EQ(ViE.base->StartReceive(passive_channel), 0);
355 EXPECT_EQ(
356 ViE.rtp_rtcp->GetEstimatedReceiveBandwidth(passive_channel,
357 &estimated_bandwidth),
358 0);
359 EXPECT_EQ(estimated_bandwidth, 0u);
360 }
361
362 // Check that rec stats extended max is greater than what we've sent.
363 EXPECT_GE(received.extended_max_sequence_number,
364 sent.extended_max_sequence_number);
365 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
366 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
367
368 //
369 // Test bandwidth statistics with reserved bitrate
370 //
371
372 myTransport.ClearStats();
373 network.packet_loss_rate = 0;
374 network.loss_model = kUniformLoss;
375 myTransport.SetNetworkParameters(network);
376
377 ViE.rtp_rtcp->SetReservedTransmitBitrate(tbChannel.videoChannel, 2000000);
378
379 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
380 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
381
382 AutoTestSleep(kAutoTestSleepTimeMs);
383
384 estimated_bandwidth = 0;
385 EXPECT_EQ(0, ViE.rtp_rtcp->GetEstimatedSendBandwidth(tbChannel.videoChannel,
386 &estimated_bandwidth));
387 if (FLAGS_include_timing_dependent_tests) {
388 EXPECT_EQ(0u, estimated_bandwidth);
389 }
390
391 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
392 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
393
394 //
395 // Test bandwidth statistics with NACK and FEC separately
396 //
397
398 myTransport.ClearStats();
399 network.packet_loss_rate = kPacketLossRate;
400 myTransport.SetNetworkParameters(network);
401
402 EXPECT_EQ(0, ViE.rtp_rtcp->SetFECStatus(
403 tbChannel.videoChannel, true, 96, 97));
404 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
405 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
406
407 AutoTestSleep(kAutoTestSleepTimeMs);
408
409 EXPECT_EQ(0, ViE.rtp_rtcp->GetBandwidthUsage(
410 tbChannel.videoChannel, sentTotalBitrate, sentVideoBitrate,
411 sentFecBitrate, sentNackBitrate));
412
413 if (FLAGS_include_timing_dependent_tests) {
414 EXPECT_GT(sentTotalBitrate, 0u);
415 EXPECT_GT(sentFecBitrate, 0u);
416 EXPECT_EQ(sentNackBitrate, 0u);
417 }
418
419 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
420 EXPECT_EQ(0, ViE.rtp_rtcp->SetFECStatus(
421 tbChannel.videoChannel, false, 96, 97));
422 EXPECT_EQ(0, ViE.rtp_rtcp->SetNACKStatus(tbChannel.videoChannel, true));
423 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
424
425 AutoTestSleep(4 * kAutoTestSleepTimeMs);
426
427 EXPECT_EQ(0, ViE.rtp_rtcp->GetBandwidthUsage(
428 tbChannel.videoChannel, sentTotalBitrate, sentVideoBitrate,
429 sentFecBitrate, sentNackBitrate));
430
431 if (FLAGS_include_timing_dependent_tests) {
432 EXPECT_GT(sentTotalBitrate, 0u);
433 EXPECT_EQ(sentFecBitrate, 0u);
434
435 // TODO(holmer): Test disabled due to being too flaky on buildbots. Tests
436 // for new API provide partial coverage.
437 // EXPECT_GT(sentNackBitrate, 0u);
438 }
439
440 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
441 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
442 EXPECT_EQ(0, ViE.rtp_rtcp->SetNACKStatus(tbChannel.videoChannel, false));
443
444
445 // Test to set SSRC
446 network.packet_loss_rate = 0;
447 myTransport.SetNetworkParameters(network);
448 myTransport.ClearStats();
449
450 unsigned int setSSRC = 0x01234567;
451 ViETest::Log("Set SSRC %u", setSSRC);
452 EXPECT_EQ(0, ViE.rtp_rtcp->SetLocalSSRC(tbChannel.videoChannel, setSSRC));
453 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
454 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
455
456 myTransport.EnableSSRCCheck();
457
458 AutoTestSleep(2000);
459 unsigned int receivedSSRC = myTransport.ReceivedSSRC();
460 ViETest::Log("Received SSRC %u\n", receivedSSRC);
461
462 if (FLAGS_include_timing_dependent_tests) {
463 EXPECT_EQ(setSSRC, receivedSSRC);
464
465 unsigned int localSSRC = 0;
466 EXPECT_EQ(0, ViE.rtp_rtcp->GetLocalSSRC(
467 tbChannel.videoChannel, localSSRC));
468 EXPECT_EQ(setSSRC, localSSRC);
469
470 unsigned int remoteSSRC = 0;
471 EXPECT_EQ(0, ViE.rtp_rtcp->GetRemoteSSRC(
472 tbChannel.videoChannel, remoteSSRC));
473 EXPECT_EQ(setSSRC, remoteSSRC);
474 }
475
476 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
477
478 ViETest::Log("Testing RTP dump...\n");
479
480 std::string inDumpName =
481 ViETest::GetResultOutputPath() + "IncomingRTPDump.rtp";
482 std::string outDumpName =
483 ViETest::GetResultOutputPath() + "OutgoingRTPDump.rtp";
484 EXPECT_EQ(0, ViE.rtp_rtcp->StartRTPDump(
485 tbChannel.videoChannel, inDumpName.c_str(), webrtc::kRtpIncoming));
486 EXPECT_EQ(0, ViE.rtp_rtcp->StartRTPDump(
487 tbChannel.videoChannel, outDumpName.c_str(), webrtc::kRtpOutgoing));
488
489 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
490
491 AutoTestSleep(kAutoTestSleepTimeMs);
492
493 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
494
495 AutoTestSleep(1000);
496
497 EXPECT_EQ(0, ViE.rtp_rtcp->StopRTPDump(
498 tbChannel.videoChannel, webrtc::kRtpIncoming));
499 EXPECT_EQ(0, ViE.rtp_rtcp->StopRTPDump(
500 tbChannel.videoChannel, webrtc::kRtpOutgoing));
501
502 // Make sure data was actually saved to the file and we stored the same
503 // amount of data in both files
504 FILE* inDump = fopen(inDumpName.c_str(), "r");
505 fseek(inDump, 0L, SEEK_END);
506 long inEndPos = ftell(inDump);
507 fclose(inDump);
508 FILE* outDump = fopen(outDumpName.c_str(), "r");
509 fseek(outDump, 0L, SEEK_END);
510 // long outEndPos = ftell(outDump);
511 fclose(outDump);
512
513 EXPECT_GT(inEndPos, 0);
514
515 // TODO(phoglund): This is flaky for some reason. Are the sleeps too
516 // short above?
517 // EXPECT_LT(inEndPos, outEndPos + 100);
518
519 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
520
521
522 ViETest::Log("Testing Network Down...\n");
523
524 EXPECT_EQ(0, ViE.rtp_rtcp->SetNACKStatus(tbChannel.videoChannel, true));
525 // Reenable pacing.
526 EXPECT_EQ(0, ViE.rtp_rtcp->SetTransmissionSmoothingStatus(
527 tbChannel.videoChannel, true));
528
529 webrtc::StreamDataCounters sent_before;
530 webrtc::StreamDataCounters received_before;
531 webrtc::StreamDataCounters sent_after;
532 webrtc::StreamDataCounters received_after;
533
534 EXPECT_EQ(0, ViE.rtp_rtcp->GetRtpStatistics(tbChannel.videoChannel,
535 sent_before,
536 received_before));
537 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
538 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
539
540 // Real-time mode.
541 AutoTestSleep(kAutoTestSleepTimeMs);
542 EXPECT_EQ(0, ViE.rtp_rtcp->GetRtpStatistics(tbChannel.videoChannel,
543 sent_after, received_after));
544 if (FLAGS_include_timing_dependent_tests) {
545 EXPECT_GT(received_after.bytes, received_before.bytes);
546 }
547 // Simulate lost reception and verify that nothing is sent during that time.
548 ViE.network->SetNetworkTransmissionState(tbChannel.videoChannel, false);
549 // Allow the encoder to finish the current frame before we expect that no
550 // additional packets will be sent.
551 AutoTestSleep(kAutoTestSleepTimeMs);
552 received_before.bytes = received_after.bytes;
553 ViETest::Log("Network Down...\n");
554 AutoTestSleep(kAutoTestSleepTimeMs);
555 EXPECT_EQ(0, ViE.rtp_rtcp->GetRtpStatistics(tbChannel.videoChannel,
556 sent_before,
557 received_before));
558 if (FLAGS_include_timing_dependent_tests) {
559 EXPECT_EQ(received_before.bytes, received_after.bytes);
560 }
561
562 // Network reception back. Video should now be sent.
563 ViE.network->SetNetworkTransmissionState(tbChannel.videoChannel, true);
564 ViETest::Log("Network Up...\n");
565 AutoTestSleep(kAutoTestSleepTimeMs);
566 EXPECT_EQ(0, ViE.rtp_rtcp->GetRtpStatistics(tbChannel.videoChannel,
567 sent_before,
568 received_before));
569 if (FLAGS_include_timing_dependent_tests) {
570 EXPECT_GT(received_before.bytes, received_after.bytes);
571 }
572 received_after.bytes = received_before.bytes;
573 // Buffering mode.
574 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
575 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
576 ViE.rtp_rtcp->SetSenderBufferingMode(tbChannel.videoChannel,
577 kAutoTestSleepTimeMs / 2);
578 // Add extra delay to the receiver to make sure it doesn't flush due to
579 // too old packets being received (as the down-time introduced is longer
580 // than what we buffer at the sender).
581 ViE.rtp_rtcp->SetReceiverBufferingMode(tbChannel.videoChannel,
582 3 * kAutoTestSleepTimeMs / 2);
583 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
584 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
585 AutoTestSleep(kAutoTestSleepTimeMs);
586 // Simulate lost reception and verify that nothing is sent during that time.
587 ViETest::Log("Network Down...\n");
588 ViE.network->SetNetworkTransmissionState(tbChannel.videoChannel, false);
589 // Allow the encoder to finish the current frame before we expect that no
590 // additional packets will be sent.
591 AutoTestSleep(kAutoTestSleepTimeMs);
592 EXPECT_EQ(0, ViE.rtp_rtcp->GetRtpStatistics(tbChannel.videoChannel,
593 sent_before,
594 received_before));
595 if (FLAGS_include_timing_dependent_tests) {
596 EXPECT_GT(received_before.bytes, received_after.bytes);
597 }
598 received_after.bytes = received_before.bytes;
599 AutoTestSleep(kAutoTestSleepTimeMs);
600 EXPECT_EQ(0, ViE.rtp_rtcp->GetRtpStatistics(tbChannel.videoChannel,
601 sent_before,
602 received_before));
603 if (FLAGS_include_timing_dependent_tests) {
604 EXPECT_EQ(received_after.bytes, received_before.bytes);
605 }
606 // Network reception back. Video should now be sent.
607 ViETest::Log("Network Up...\n");
608 ViE.network->SetNetworkTransmissionState(tbChannel.videoChannel, true);
609 AutoTestSleep(kAutoTestSleepTimeMs);
610 EXPECT_EQ(0, ViE.rtp_rtcp->GetRtpStatistics(tbChannel.videoChannel,
611 sent_before,
612 received_before));
613 if (FLAGS_include_timing_dependent_tests) {
614 EXPECT_GT(received_before.bytes, received_after.bytes);
615 }
616 // TODO(holmer): Verify that the decoded framerate doesn't decrease on an
617 // outage when in buffering mode. This isn't currently possible because we
618 // don't have an API to get decoded framerate.
619
620 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
621 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
622
623
624 // Deregister external transport
625 EXPECT_EQ(0, ViE.network->DeregisterSendTransport(tbChannel.videoChannel));
626
627
628 //***************************************************************
629 // Testing finished. Tear down Video Engine
630 //***************************************************************
631 }
632
ViERtpRtcpExtendedTest()633 void ViEAutoTest::ViERtpRtcpExtendedTest()
634 {
635 //***************************************************************
636 // Begin create/initialize WebRTC Video Engine for testing
637 //***************************************************************
638 // Create VIE
639 TbInterfaces ViE("ViERtpRtcpExtendedTest");
640 // Create a video channel
641 TbVideoChannel tbChannel(ViE, webrtc::kVideoCodecVP8);
642 // Create a capture device
643 TbCaptureDevice tbCapture(ViE);
644 tbCapture.ConnectTo(tbChannel.videoChannel);
645
646 //tbChannel.StartReceive(rtpPort);
647 //tbChannel.StartSend(rtpPort);
648 TbExternalTransport myTransport(*(ViE.network), tbChannel.videoChannel,
649 NULL);
650
651 EXPECT_EQ(0, ViE.network->DeregisterSendTransport(tbChannel.videoChannel));
652 EXPECT_EQ(0, ViE.network->RegisterSendTransport(
653 tbChannel.videoChannel, myTransport));
654 EXPECT_EQ(0, ViE.base->StartReceive(tbChannel.videoChannel));
655 EXPECT_EQ(0, ViE.base->StartSend(tbChannel.videoChannel));
656
657 //***************************************************************
658 // Engine ready. Begin testing class
659 //***************************************************************
660
661 //
662 // Application specific RTCP
663 //
664 //
665
666 ViERtcpObserver rtcpObserver;
667 EXPECT_EQ(0, ViE.rtp_rtcp->RegisterRTCPObserver(
668 tbChannel.videoChannel, rtcpObserver));
669
670 unsigned char subType = 3;
671 unsigned int name = static_cast<unsigned int> (0x41424344); // 'ABCD';
672 const char* data = "ViEAutoTest Data of length 32 -\0";
673 const unsigned short numBytes = 32;
674
675 EXPECT_EQ(0, ViE.rtp_rtcp->SendApplicationDefinedRTCPPacket(
676 tbChannel.videoChannel, subType, name, data, numBytes));
677
678 ViETest::Log("Sending RTCP application data...\n");
679 AutoTestSleep(kAutoTestSleepTimeMs);
680
681 EXPECT_EQ(subType, rtcpObserver._subType);
682 EXPECT_STRCASEEQ(data, rtcpObserver._data);
683 EXPECT_EQ(name, rtcpObserver._name);
684 EXPECT_EQ(numBytes, rtcpObserver._dataLength);
685
686 ViETest::Log("\t RTCP application data received\n");
687
688 //***************************************************************
689 // Testing finished. Tear down Video Engine
690 //***************************************************************
691 EXPECT_EQ(0, ViE.base->StopReceive(tbChannel.videoChannel));
692 EXPECT_EQ(0, ViE.base->StopSend(tbChannel.videoChannel));
693
694 EXPECT_EQ(0, ViE.network->DeregisterSendTransport(tbChannel.videoChannel));
695 }
696
ViERtpRtcpAPITest()697 void ViEAutoTest::ViERtpRtcpAPITest()
698 {
699 //***************************************************************
700 // Begin create/initialize WebRTC Video Engine for testing
701 //***************************************************************
702 // Create VIE
703 TbInterfaces ViE("ViERtpRtcpAPITest");
704
705 // Create a video channel
706 TbVideoChannel tbChannel(ViE, webrtc::kVideoCodecVP8);
707
708 // Create a capture device
709 TbCaptureDevice tbCapture(ViE);
710 tbCapture.ConnectTo(tbChannel.videoChannel);
711
712 //***************************************************************
713 // Engine ready. Begin testing class
714 //***************************************************************
715
716 //
717 // Check different RTCP modes
718 //
719 webrtc::ViERTCPMode rtcpMode = webrtc::kRtcpNone;
720 EXPECT_EQ(0, ViE.rtp_rtcp->GetRTCPStatus(
721 tbChannel.videoChannel, rtcpMode));
722 EXPECT_EQ(webrtc::kRtcpCompound_RFC4585, rtcpMode);
723 EXPECT_EQ(0, ViE.rtp_rtcp->SetRTCPStatus(
724 tbChannel.videoChannel, webrtc::kRtcpCompound_RFC4585));
725 EXPECT_EQ(0, ViE.rtp_rtcp->GetRTCPStatus(
726 tbChannel.videoChannel, rtcpMode));
727 EXPECT_EQ(webrtc::kRtcpCompound_RFC4585, rtcpMode);
728 EXPECT_EQ(0, ViE.rtp_rtcp->SetRTCPStatus(
729 tbChannel.videoChannel, webrtc::kRtcpNonCompound_RFC5506));
730 EXPECT_EQ(0, ViE.rtp_rtcp->GetRTCPStatus(
731 tbChannel.videoChannel, rtcpMode));
732 EXPECT_EQ(webrtc::kRtcpNonCompound_RFC5506, rtcpMode);
733 EXPECT_EQ(0, ViE.rtp_rtcp->SetRTCPStatus(
734 tbChannel.videoChannel, webrtc::kRtcpNone));
735 EXPECT_EQ(0, ViE.rtp_rtcp->GetRTCPStatus(
736 tbChannel.videoChannel, rtcpMode));
737 EXPECT_EQ(webrtc::kRtcpNone, rtcpMode);
738 EXPECT_EQ(0, ViE.rtp_rtcp->SetRTCPStatus(
739 tbChannel.videoChannel, webrtc::kRtcpCompound_RFC4585));
740
741 //
742 // CName is testedn in SimpleTest
743 // Start sequence number is tested in SimplTEst
744 //
745 const char* testCName = "ViEAutotestCName";
746 EXPECT_EQ(0, ViE.rtp_rtcp->SetRTCPCName(
747 tbChannel.videoChannel, testCName));
748
749 char returnCName[256];
750 memset(returnCName, 0, 256);
751 EXPECT_EQ(0, ViE.rtp_rtcp->GetRTCPCName(
752 tbChannel.videoChannel, returnCName));
753 EXPECT_STRCASEEQ(testCName, returnCName);
754
755 //
756 // SSRC
757 //
758 EXPECT_EQ(0, ViE.rtp_rtcp->SetLocalSSRC(
759 tbChannel.videoChannel, 0x01234567));
760 EXPECT_EQ(0, ViE.rtp_rtcp->SetLocalSSRC(
761 tbChannel.videoChannel, 0x76543210));
762
763 unsigned int ssrc = 0;
764 EXPECT_EQ(0, ViE.rtp_rtcp->GetLocalSSRC(tbChannel.videoChannel, ssrc));
765 EXPECT_EQ(0, ViE.rtp_rtcp->SetStartSequenceNumber(
766 tbChannel.videoChannel, 1000));
767 tbChannel.StartSend();
768 EXPECT_NE(0, ViE.rtp_rtcp->SetStartSequenceNumber(
769 tbChannel.videoChannel, 12345));
770 tbChannel.StopSend();
771
772 //
773 // Start sequence number
774 //
775 EXPECT_EQ(0, ViE.rtp_rtcp->SetStartSequenceNumber(
776 tbChannel.videoChannel, 12345));
777 EXPECT_EQ(0, ViE.rtp_rtcp->SetStartSequenceNumber(
778 tbChannel.videoChannel, 1000));
779 tbChannel.StartSend();
780 EXPECT_NE(0, ViE.rtp_rtcp->SetStartSequenceNumber(
781 tbChannel.videoChannel, 12345));
782 tbChannel.StopSend();
783
784 //
785 // Application specific RTCP
786 //
787 {
788 unsigned char subType = 3;
789 unsigned int name = static_cast<unsigned int> (0x41424344); // 'ABCD';
790 const char* data = "ViEAutoTest Data of length 32 --";
791 const unsigned short numBytes = 32;
792
793 tbChannel.StartSend();
794 EXPECT_EQ(0, ViE.rtp_rtcp->SendApplicationDefinedRTCPPacket(
795 tbChannel.videoChannel, subType, name, data, numBytes));
796 EXPECT_NE(0, ViE.rtp_rtcp->SendApplicationDefinedRTCPPacket(
797 tbChannel.videoChannel, subType, name, NULL, numBytes)) <<
798 "Should fail on NULL input.";
799 EXPECT_NE(0, ViE.rtp_rtcp->SendApplicationDefinedRTCPPacket(
800 tbChannel.videoChannel, subType, name, data, numBytes - 1)) <<
801 "Should fail on incorrect length.";
802
803 EXPECT_EQ(0, ViE.rtp_rtcp->GetRTCPStatus(
804 tbChannel.videoChannel, rtcpMode));
805 EXPECT_EQ(0, ViE.rtp_rtcp->SendApplicationDefinedRTCPPacket(
806 tbChannel.videoChannel, subType, name, data, numBytes));
807 EXPECT_EQ(0, ViE.rtp_rtcp->SetRTCPStatus(
808 tbChannel.videoChannel, webrtc::kRtcpCompound_RFC4585));
809 tbChannel.StopSend();
810 EXPECT_NE(0, ViE.rtp_rtcp->SendApplicationDefinedRTCPPacket(
811 tbChannel.videoChannel, subType, name, data, numBytes));
812 }
813
814 //
815 // Statistics
816 //
817 // Tested in SimpleTest(), we'll get errors if we haven't received a RTCP
818 // packet.
819
820 //
821 // RTP Dump
822 //
823 {
824 std::string output_file = webrtc::test::OutputPath() +
825 "DumpFileName.rtp";
826 const char* dumpName = output_file.c_str();
827
828 EXPECT_EQ(0, ViE.rtp_rtcp->StartRTPDump(
829 tbChannel.videoChannel, dumpName, webrtc::kRtpIncoming));
830 EXPECT_EQ(0, ViE.rtp_rtcp->StopRTPDump(
831 tbChannel.videoChannel, webrtc::kRtpIncoming));
832 EXPECT_NE(0, ViE.rtp_rtcp->StopRTPDump(
833 tbChannel.videoChannel, webrtc::kRtpIncoming));
834 EXPECT_EQ(0, ViE.rtp_rtcp->StartRTPDump(
835 tbChannel.videoChannel, dumpName, webrtc::kRtpOutgoing));
836 EXPECT_EQ(0, ViE.rtp_rtcp->StopRTPDump(
837 tbChannel.videoChannel, webrtc::kRtpOutgoing));
838 EXPECT_NE(0, ViE.rtp_rtcp->StopRTPDump(
839 tbChannel.videoChannel, webrtc::kRtpOutgoing));
840 EXPECT_NE(0, ViE.rtp_rtcp->StartRTPDump(
841 tbChannel.videoChannel, dumpName, (webrtc::RTPDirections) 3));
842 }
843 //
844 // RTP/RTCP Observers
845 //
846 {
847 ViERtpObserver rtpObserver;
848 EXPECT_EQ(0, ViE.rtp_rtcp->RegisterRTPObserver(
849 tbChannel.videoChannel, rtpObserver));
850 EXPECT_NE(0, ViE.rtp_rtcp->RegisterRTPObserver(
851 tbChannel.videoChannel, rtpObserver));
852 EXPECT_EQ(0, ViE.rtp_rtcp->DeregisterRTPObserver(
853 tbChannel.videoChannel));
854 EXPECT_NE(0, ViE.rtp_rtcp->DeregisterRTPObserver(
855 tbChannel.videoChannel));
856
857 ViERtcpObserver rtcpObserver;
858 EXPECT_EQ(0, ViE.rtp_rtcp->RegisterRTCPObserver(
859 tbChannel.videoChannel, rtcpObserver));
860 EXPECT_NE(0, ViE.rtp_rtcp->RegisterRTCPObserver(
861 tbChannel.videoChannel, rtcpObserver));
862 EXPECT_EQ(0, ViE.rtp_rtcp->DeregisterRTCPObserver(
863 tbChannel.videoChannel));
864 EXPECT_NE(0, ViE.rtp_rtcp->DeregisterRTCPObserver(
865 tbChannel.videoChannel));
866 }
867 //
868 // PLI
869 //
870 {
871 EXPECT_EQ(0, ViE.rtp_rtcp->SetKeyFrameRequestMethod(
872 tbChannel.videoChannel, webrtc::kViEKeyFrameRequestPliRtcp));
873 EXPECT_EQ(0, ViE.rtp_rtcp->SetKeyFrameRequestMethod(
874 tbChannel.videoChannel, webrtc::kViEKeyFrameRequestPliRtcp));
875 EXPECT_EQ(0, ViE.rtp_rtcp->SetKeyFrameRequestMethod(
876 tbChannel.videoChannel, webrtc::kViEKeyFrameRequestNone));
877 EXPECT_EQ(0, ViE.rtp_rtcp->SetKeyFrameRequestMethod(
878 tbChannel.videoChannel, webrtc::kViEKeyFrameRequestNone));
879 }
880 //
881 // NACK
882 //
883 {
884 EXPECT_EQ(0, ViE.rtp_rtcp->SetNACKStatus(tbChannel.videoChannel, true));
885 }
886
887 // Timestamp offset extension.
888 // Valid range is 1 to 14 inclusive.
889 EXPECT_EQ(-1, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
890 tbChannel.videoChannel, true, 0));
891 EXPECT_EQ(-1, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
892 tbChannel.videoChannel, true, 15));
893 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
894 tbChannel.videoChannel, true, 3));
895 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
896 tbChannel.videoChannel, true, 3));
897 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
898 tbChannel.videoChannel, false, 3));
899 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
900 tbChannel.videoChannel, true, 3));
901 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
902 tbChannel.videoChannel, false, 3));
903 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendTimestampOffsetStatus(
904 tbChannel.videoChannel, false, 3));
905
906 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
907 tbChannel.videoChannel, true, 0));
908 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
909 tbChannel.videoChannel, true, 15));
910 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
911 tbChannel.videoChannel, true, 3));
912 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
913 tbChannel.videoChannel, true, 3));
914 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
915 tbChannel.videoChannel, false, 3));
916 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
917 tbChannel.videoChannel, true, 3));
918 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
919 tbChannel.videoChannel, false, 3));
920 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveTimestampOffsetStatus(
921 tbChannel.videoChannel, false, 3));
922
923 // Absolute send time extension.
924 // Valid range is 1 to 14 inclusive.
925 EXPECT_EQ(-1, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
926 tbChannel.videoChannel, true, 0));
927 EXPECT_EQ(-1, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
928 tbChannel.videoChannel, true, 15));
929 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
930 tbChannel.videoChannel, true, 3));
931 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
932 tbChannel.videoChannel, true, 3));
933 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
934 tbChannel.videoChannel, false, 3));
935 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
936 tbChannel.videoChannel, true, 3));
937 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
938 tbChannel.videoChannel, false, 3));
939 EXPECT_EQ(0, ViE.rtp_rtcp->SetSendAbsoluteSendTimeStatus(
940 tbChannel.videoChannel, false, 3));
941
942 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
943 tbChannel.videoChannel, true, 0));
944 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
945 tbChannel.videoChannel, true, 15));
946 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
947 tbChannel.videoChannel, true, 3));
948 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
949 tbChannel.videoChannel, true, 3));
950 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
951 tbChannel.videoChannel, false, 3));
952 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
953 tbChannel.videoChannel, true, 3));
954 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
955 tbChannel.videoChannel, false, 3));
956 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiveAbsoluteSendTimeStatus(
957 tbChannel.videoChannel, false, 3));
958
959 // Transmission smoothening.
960 const int invalid_channel_id = 17;
961 EXPECT_EQ(-1, ViE.rtp_rtcp->SetTransmissionSmoothingStatus(
962 invalid_channel_id, true));
963 EXPECT_EQ(0, ViE.rtp_rtcp->SetTransmissionSmoothingStatus(
964 tbChannel.videoChannel, true));
965 EXPECT_EQ(0, ViE.rtp_rtcp->SetTransmissionSmoothingStatus(
966 tbChannel.videoChannel, true));
967 EXPECT_EQ(0, ViE.rtp_rtcp->SetTransmissionSmoothingStatus(
968 tbChannel.videoChannel, false));
969 EXPECT_EQ(0, ViE.rtp_rtcp->SetTransmissionSmoothingStatus(
970 tbChannel.videoChannel, false));
971
972 // Buffering mode - sender side.
973 EXPECT_EQ(-1, ViE.rtp_rtcp->SetSenderBufferingMode(
974 invalid_channel_id, 0));
975 int invalid_delay = -1;
976 EXPECT_EQ(-1, ViE.rtp_rtcp->SetSenderBufferingMode(
977 tbChannel.videoChannel, invalid_delay));
978 invalid_delay = 15000;
979 EXPECT_EQ(-1, ViE.rtp_rtcp->SetSenderBufferingMode(
980 tbChannel.videoChannel, invalid_delay));
981 EXPECT_EQ(0, ViE.rtp_rtcp->SetSenderBufferingMode(
982 tbChannel.videoChannel, 5000));
983
984 // Buffering mode - receiver side.
985 // Run without VoE to verify it that does not crash, but return an error.
986 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiverBufferingMode(
987 tbChannel.videoChannel, 0));
988 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiverBufferingMode(
989 tbChannel.videoChannel, 2000));
990
991 // Set VoE (required to set up stream-sync).
992 webrtc::VoiceEngine* voice_engine = webrtc::VoiceEngine::Create();
993 EXPECT_TRUE(NULL != voice_engine);
994 webrtc::VoEBase* voe_base = webrtc::VoEBase::GetInterface(voice_engine);
995 EXPECT_TRUE(NULL != voe_base);
996 EXPECT_EQ(0, voe_base->Init());
997 int audio_channel = voe_base->CreateChannel();
998 EXPECT_NE(-1, audio_channel);
999 EXPECT_EQ(0, ViE.base->SetVoiceEngine(voice_engine));
1000 EXPECT_EQ(0, ViE.base->ConnectAudioChannel(tbChannel.videoChannel,
1001 audio_channel));
1002
1003 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiverBufferingMode(
1004 invalid_channel_id, 0));
1005 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiverBufferingMode(
1006 tbChannel.videoChannel, invalid_delay));
1007 invalid_delay = 15000;
1008 EXPECT_EQ(-1, ViE.rtp_rtcp->SetReceiverBufferingMode(
1009 tbChannel.videoChannel, invalid_delay));
1010 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiverBufferingMode(
1011 tbChannel.videoChannel, 5000));
1012
1013 // Real-time mode - sender side.
1014 EXPECT_EQ(0, ViE.rtp_rtcp->SetSenderBufferingMode(
1015 tbChannel.videoChannel, 0));
1016 // Real-time mode - receiver side.
1017 EXPECT_EQ(0, ViE.rtp_rtcp->SetReceiverBufferingMode(
1018 tbChannel.videoChannel, 0));
1019
1020 EXPECT_EQ(0, ViE.base->DisconnectAudioChannel(tbChannel.videoChannel));
1021 EXPECT_EQ(0, ViE.base->SetVoiceEngine(NULL));
1022 EXPECT_EQ(0, voe_base->DeleteChannel(audio_channel));
1023 voe_base->Release();
1024 EXPECT_TRUE(webrtc::VoiceEngine::Delete(voice_engine));
1025
1026 //***************************************************************
1027 // Testing finished. Tear down Video Engine
1028 //***************************************************************
1029 }
1030