src/third_party/webrtc/video/call_tests.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10 #include <assert.h>
  11
  12 #include <algorithm>
  13 #include <map>
  14 #include <sstream>
  15 #include <string>
  16
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 #include "webrtc/call.h"
  20 #include "webrtc/frame_callback.h"
  21 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
  22 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
  23 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
  24 #include "webrtc/system_wrappers/interface/event_wrapper.h"
  25 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  26 #include "webrtc/system_wrappers/interface/sleep.h"
  27 #include "webrtc/test/direct_transport.h"
  28 #include "webrtc/test/fake_audio_device.h"
  29 #include "webrtc/test/fake_decoder.h"
  30 #include "webrtc/test/fake_encoder.h"
  31 #include "webrtc/test/frame_generator.h"
  32 #include "webrtc/test/frame_generator_capturer.h"
  33 #include "webrtc/test/null_transport.h"
  34 #include "webrtc/test/rtp_rtcp_observer.h"
  35 #include "webrtc/test/testsupport/fileutils.h"
  36 #include "webrtc/test/testsupport/perf_test.h"
  37 #include "webrtc/video/transport_adapter.h"
  38
  39 namespace webrtc {
  40
  41 static unsigned int kDefaultTimeoutMs = 30 * 1000;
  42 static unsigned int kLongTimeoutMs = 120 * 1000;
  43 static const uint32_t kSendSsrc = 0x654321;
  44 static const uint32_t kReceiverLocalSsrc = 0x123456;
  45 static const uint8_t kSendPayloadType = 125;
  46
  47 class CallTest : public ::testing::Test {
  48  public:
  49   CallTest()
  50       : send_stream_(NULL),
  51         receive_stream_(NULL),
  52         fake_encoder_(Clock::GetRealTimeClock()) {}
  53
  54   virtual ~CallTest() {
  55     EXPECT_EQ(NULL, send_stream_);
  56     EXPECT_EQ(NULL, receive_stream_);
  57   }
  58
  59  protected:
  60   void CreateCalls(const Call::Config& sender_config,
  61                    const Call::Config& receiver_config) {
  62     sender_call_.reset(Call::Create(sender_config));
  63     receiver_call_.reset(Call::Create(receiver_config));
  64   }
  65
  66   void CreateTestConfigs() {
  67     send_config_ = sender_call_->GetDefaultSendConfig();
  68     receive_config_ = receiver_call_->GetDefaultReceiveConfig();
  69
  70     send_config_.rtp.ssrcs.push_back(kSendSsrc);
  71     send_config_.encoder = &fake_encoder_;
  72     send_config_.internal_source = false;
  73     test::FakeEncoder::SetCodecSettings(&send_config_.codec, 1);
  74     send_config_.codec.plType = kSendPayloadType;
  75
  76     receive_config_.codecs.clear();
  77     receive_config_.codecs.push_back(send_config_.codec);
  78     ExternalVideoDecoder decoder;
  79     decoder.decoder = &fake_decoder_;
  80     decoder.payload_type = send_config_.codec.plType;
  81     receive_config_.external_decoders.push_back(decoder);
  82     receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
  83     receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
  84   }
  85
  86   void CreateStreams() {
  87     assert(send_stream_ == NULL);
  88     assert(receive_stream_ == NULL);
  89
  90     send_stream_ = sender_call_->CreateVideoSendStream(send_config_);
  91     receive_stream_ = receiver_call_->CreateVideoReceiveStream(receive_config_);
  92   }
  93
  94   void CreateFrameGenerator() {
  95     frame_generator_capturer_.reset(
  96         test::FrameGeneratorCapturer::Create(send_stream_->Input(),
  97                                              send_config_.codec.width,
  98                                              send_config_.codec.height,
  99                                              30,
 100                                              Clock::GetRealTimeClock()));
 101   }
 102
 103   void StartSending() {
 104     receive_stream_->StartReceiving();
 105     send_stream_->StartSending();
 106     if (frame_generator_capturer_.get() != NULL)
 107       frame_generator_capturer_->Start();
 108   }
 109
 110   void StopSending() {
 111     if (frame_generator_capturer_.get() != NULL)
 112       frame_generator_capturer_->Stop();
 113     if (send_stream_ != NULL)
 114       send_stream_->StopSending();
 115     if (receive_stream_ != NULL)
 116       receive_stream_->StopReceiving();
 117   }
 118
 119   void DestroyStreams() {
 120     if (send_stream_ != NULL)
 121       sender_call_->DestroyVideoSendStream(send_stream_);
 122     if (receive_stream_ != NULL)
 123       receiver_call_->DestroyVideoReceiveStream(receive_stream_);
 124     send_stream_ = NULL;
 125     receive_stream_ = NULL;
 126   }
 127
 128   void ReceivesPliAndRecovers(int rtp_history_ms);
 129   void RespectsRtcpMode(newapi::RtcpMode rtcp_mode);
 130   void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
 131
 132   scoped_ptr<Call> sender_call_;
 133   scoped_ptr<Call> receiver_call_;
 134
 135   VideoSendStream::Config send_config_;
 136   VideoReceiveStream::Config receive_config_;
 137
 138   VideoSendStream* send_stream_;
 139   VideoReceiveStream* receive_stream_;
 140
 141   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
 142
 143   test::FakeEncoder fake_encoder_;
 144   test::FakeDecoder fake_decoder_;
 145 };
 146
 147 class NackObserver : public test::RtpRtcpObserver {
 148   static const int kNumberOfNacksToObserve = 2;
 149   static const int kLossBurstSize = 2;
 150   static const int kPacketsBetweenLossBursts = 9;
 151
 152  public:
 153   NackObserver()
 154       : test::RtpRtcpObserver(kLongTimeoutMs),
 155         rtp_parser_(RtpHeaderParser::Create()),
 156         sent_rtp_packets_(0),
 157         packets_left_to_drop_(0),
 158         nacks_left_(kNumberOfNacksToObserve) {}
 159
 160  private:
 161   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 162     EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)));
 163
 164     RTPHeader header;
 165     EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
 166
 167     // Never drop retransmitted packets.
 168     if (dropped_packets_.find(header.sequenceNumber) !=
 169         dropped_packets_.end()) {
 170       retransmitted_packets_.insert(header.sequenceNumber);
 171       if (nacks_left_ == 0 &&
 172           retransmitted_packets_.size() == dropped_packets_.size()) {
 173         observation_complete_->Set();
 174       }
 175       return SEND_PACKET;
 176     }
 177
 178     ++sent_rtp_packets_;
 179
 180     // Enough NACKs received, stop dropping packets.
 181     if (nacks_left_ == 0)
 182       return SEND_PACKET;
 183
 184     // Check if it's time for a new loss burst.
 185     if (sent_rtp_packets_ % kPacketsBetweenLossBursts == 0)
 186       packets_left_to_drop_ = kLossBurstSize;
 187
 188     if (packets_left_to_drop_ > 0) {
 189       --packets_left_to_drop_;
 190       dropped_packets_.insert(header.sequenceNumber);
 191       return DROP_PACKET;
 192     }
 193
 194     return SEND_PACKET;
 195   }
 196
 197   virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 198     RTCPUtility::RTCPParserV2 parser(packet, length, true);
 199     EXPECT_TRUE(parser.IsValid());
 200
 201     RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 202     while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 203       if (packet_type == RTCPUtility::kRtcpRtpfbNackCode) {
 204         --nacks_left_;
 205         break;
 206       }
 207       packet_type = parser.Iterate();
 208     }
 209     return SEND_PACKET;
 210   }
 211
 212  private:
 213   scoped_ptr<RtpHeaderParser> rtp_parser_;
 214   std::set<uint16_t> dropped_packets_;
 215   std::set<uint16_t> retransmitted_packets_;
 216   uint64_t sent_rtp_packets_;
 217   int packets_left_to_drop_;
 218   int nacks_left_;
 219 };
 220
 221 TEST_F(CallTest, UsesTraceCallback) {
 222   const unsigned int kSenderTraceFilter = kTraceDebug;
 223   const unsigned int kReceiverTraceFilter = kTraceDefault & (~kTraceDebug);
 224   class TraceObserver : public TraceCallback {
 225    public:
 226     explicit TraceObserver(unsigned int filter)
 227         : filter_(filter), messages_left_(50), done_(EventWrapper::Create()) {}
 228
 229     virtual void Print(TraceLevel level,
 230                        const char* message,
 231                        int length) OVERRIDE {
 232       EXPECT_EQ(0u, level & (~filter_));
 233       if (--messages_left_ == 0)
 234         done_->Set();
 235     }
 236
 237     EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); }
 238
 239    private:
 240     unsigned int filter_;
 241     unsigned int messages_left_;
 242     scoped_ptr<EventWrapper> done_;
 243   } sender_trace(kSenderTraceFilter), receiver_trace(kReceiverTraceFilter);
 244
 245   test::DirectTransport send_transport, receive_transport;
 246   Call::Config sender_call_config(&send_transport);
 247   sender_call_config.trace_callback = &sender_trace;
 248   sender_call_config.trace_filter = kSenderTraceFilter;
 249   Call::Config receiver_call_config(&receive_transport);
 250   receiver_call_config.trace_callback = &receiver_trace;
 251   receiver_call_config.trace_filter = kReceiverTraceFilter;
 252   CreateCalls(sender_call_config, receiver_call_config);
 253   send_transport.SetReceiver(receiver_call_->Receiver());
 254   receive_transport.SetReceiver(sender_call_->Receiver());
 255
 256   CreateTestConfigs();
 257
 258   CreateStreams();
 259   CreateFrameGenerator();
 260   StartSending();
 261
 262   // Wait() waits for a couple of trace callbacks to occur.
 263   EXPECT_EQ(kEventSignaled, sender_trace.Wait());
 264   EXPECT_EQ(kEventSignaled, receiver_trace.Wait());
 265
 266   StopSending();
 267   send_transport.StopSending();
 268   receive_transport.StopSending();
 269   DestroyStreams();
 270
 271   // The TraceCallback instance MUST outlive Calls, destroy Calls explicitly.
 272   sender_call_.reset();
 273   receiver_call_.reset();
 274 }
 275
 276 TEST_F(CallTest, ReceiverCanBeStartedTwice) {
 277   test::NullTransport transport;
 278   CreateCalls(Call::Config(&transport), Call::Config(&transport));
 279
 280   CreateTestConfigs();
 281   CreateStreams();
 282
 283   receive_stream_->StartReceiving();
 284   receive_stream_->StartReceiving();
 285
 286   DestroyStreams();
 287 }
 288
 289 TEST_F(CallTest, ReceiverCanBeStoppedTwice) {
 290   test::NullTransport transport;
 291   CreateCalls(Call::Config(&transport), Call::Config(&transport));
 292
 293   CreateTestConfigs();
 294   CreateStreams();
 295
 296   receive_stream_->StopReceiving();
 297   receive_stream_->StopReceiving();
 298
 299   DestroyStreams();
 300 }
 301
 302 TEST_F(CallTest, RendersSingleDelayedFrame) {
 303   static const int kWidth = 320;
 304   static const int kHeight = 240;
 305   // This constant is chosen to be higher than the timeout in the video_render
 306   // module. This makes sure that frames aren't dropped if there are no other
 307   // frames in the queue.
 308   static const int kDelayRenderCallbackMs = 1000;
 309
 310   class Renderer : public VideoRenderer {
 311    public:
 312     Renderer() : event_(EventWrapper::Create()) {}
 313
 314     virtual void RenderFrame(const I420VideoFrame& video_frame,
 315                              int /*time_to_render_ms*/) OVERRIDE {
 316       event_->Set();
 317     }
 318
 319     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 320
 321     scoped_ptr<EventWrapper> event_;
 322   } renderer;
 323
 324   class TestFrameCallback : public I420FrameCallback {
 325    public:
 326     TestFrameCallback() : event_(EventWrapper::Create()) {}
 327
 328     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 329
 330    private:
 331     virtual void FrameCallback(I420VideoFrame* frame) {
 332       SleepMs(kDelayRenderCallbackMs);
 333       event_->Set();
 334     }
 335
 336     scoped_ptr<EventWrapper> event_;
 337   };
 338
 339   test::DirectTransport sender_transport, receiver_transport;
 340
 341   CreateCalls(Call::Config(&sender_transport),
 342               Call::Config(&receiver_transport));
 343
 344   sender_transport.SetReceiver(receiver_call_->Receiver());
 345   receiver_transport.SetReceiver(sender_call_->Receiver());
 346
 347   CreateTestConfigs();
 348
 349   TestFrameCallback pre_render_callback;
 350   receive_config_.pre_render_callback = &pre_render_callback;
 351   receive_config_.renderer = &renderer;
 352
 353   CreateStreams();
 354   StartSending();
 355
 356   // Create frames that are smaller than the send width/height, this is done to
 357   // check that the callbacks are done after processing video.
 358   scoped_ptr<test::FrameGenerator> frame_generator(
 359       test::FrameGenerator::Create(kWidth, kHeight));
 360   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 361   EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
 362       << "Timed out while waiting for pre-render callback.";
 363   EXPECT_EQ(kEventSignaled, renderer.Wait())
 364       << "Timed out while waiting for the frame to render.";
 365
 366   StopSending();
 367
 368   sender_transport.StopSending();
 369   receiver_transport.StopSending();
 370
 371   DestroyStreams();
 372 }
 373
 374 TEST_F(CallTest, TransmitsFirstFrame) {
 375   class Renderer : public VideoRenderer {
 376    public:
 377     Renderer() : event_(EventWrapper::Create()) {}
 378
 379     virtual void RenderFrame(const I420VideoFrame& video_frame,
 380                              int /*time_to_render_ms*/) OVERRIDE {
 381       event_->Set();
 382     }
 383
 384     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 385
 386     scoped_ptr<EventWrapper> event_;
 387   } renderer;
 388
 389   test::DirectTransport sender_transport, receiver_transport;
 390
 391   CreateCalls(Call::Config(&sender_transport),
 392               Call::Config(&receiver_transport));
 393
 394   sender_transport.SetReceiver(receiver_call_->Receiver());
 395   receiver_transport.SetReceiver(sender_call_->Receiver());
 396
 397   CreateTestConfigs();
 398   receive_config_.renderer = &renderer;
 399
 400   CreateStreams();
 401   StartSending();
 402
 403   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
 404       send_config_.codec.width, send_config_.codec.height));
 405   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 406
 407   EXPECT_EQ(kEventSignaled, renderer.Wait())
 408       << "Timed out while waiting for the frame to render.";
 409
 410   StopSending();
 411
 412   sender_transport.StopSending();
 413   receiver_transport.StopSending();
 414
 415   DestroyStreams();
 416 }
 417
 418 TEST_F(CallTest, ReceiverUsesLocalSsrc) {
 419   class SyncRtcpObserver : public test::RtpRtcpObserver {
 420    public:
 421     SyncRtcpObserver() : test::RtpRtcpObserver(kDefaultTimeoutMs) {}
 422
 423     virtual Action OnReceiveRtcp(const uint8_t* packet,
 424                                  size_t length) OVERRIDE {
 425       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 426       EXPECT_TRUE(parser.IsValid());
 427       uint32_t ssrc = 0;
 428       ssrc |= static_cast<uint32_t>(packet[4]) << 24;
 429       ssrc |= static_cast<uint32_t>(packet[5]) << 16;
 430       ssrc |= static_cast<uint32_t>(packet[6]) << 8;
 431       ssrc |= static_cast<uint32_t>(packet[7]) << 0;
 432       EXPECT_EQ(kReceiverLocalSsrc, ssrc);
 433       observation_complete_->Set();
 434
 435       return SEND_PACKET;
 436     }
 437   } observer;
 438
 439   CreateCalls(Call::Config(observer.SendTransport()),
 440               Call::Config(observer.ReceiveTransport()));
 441
 442   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 443
 444   CreateTestConfigs();
 445
 446   CreateStreams();
 447   CreateFrameGenerator();
 448   StartSending();
 449
 450   EXPECT_EQ(kEventSignaled, observer.Wait())
 451       << "Timed out while waiting for a receiver RTCP packet to be sent.";
 452
 453   StopSending();
 454
 455   observer.StopSending();
 456
 457   DestroyStreams();
 458 }
 459
 460 TEST_F(CallTest, ReceivesAndRetransmitsNack) {
 461   NackObserver observer;
 462
 463   CreateCalls(Call::Config(observer.SendTransport()),
 464               Call::Config(observer.ReceiveTransport()));
 465
 466   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 467
 468   CreateTestConfigs();
 469   int rtp_history_ms = 1000;
 470   send_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 471   receive_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 472
 473   CreateStreams();
 474   CreateFrameGenerator();
 475   StartSending();
 476
 477   // Wait() waits for an event triggered when NACKs have been received, NACKed
 478   // packets retransmitted and frames rendered again.
 479   EXPECT_EQ(kEventSignaled, observer.Wait());
 480
 481   StopSending();
 482
 483   observer.StopSending();
 484
 485   DestroyStreams();
 486 }
 487
 488 TEST_F(CallTest, UsesFrameCallbacks) {
 489   static const int kWidth = 320;
 490   static const int kHeight = 240;
 491
 492   class Renderer : public VideoRenderer {
 493    public:
 494     Renderer() : event_(EventWrapper::Create()) {}
 495
 496     virtual void RenderFrame(const I420VideoFrame& video_frame,
 497                              int /*time_to_render_ms*/) OVERRIDE {
 498       EXPECT_EQ(0, *video_frame.buffer(kYPlane))
 499           << "Rendered frame should have zero luma which is applied by the "
 500              "pre-render callback.";
 501       event_->Set();
 502     }
 503
 504     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 505     scoped_ptr<EventWrapper> event_;
 506   } renderer;
 507
 508   class TestFrameCallback : public I420FrameCallback {
 509    public:
 510     TestFrameCallback(int expected_luma_byte, int next_luma_byte)
 511         : event_(EventWrapper::Create()),
 512           expected_luma_byte_(expected_luma_byte),
 513           next_luma_byte_(next_luma_byte) {}
 514
 515     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 516
 517    private:
 518     virtual void FrameCallback(I420VideoFrame* frame) {
 519       EXPECT_EQ(kWidth, frame->width())
 520           << "Width not as expected, callback done before resize?";
 521       EXPECT_EQ(kHeight, frame->height())
 522           << "Height not as expected, callback done before resize?";
 523
 524       // Previous luma specified, observed luma should be fairly close.
 525       if (expected_luma_byte_ != -1) {
 526         EXPECT_NEAR(expected_luma_byte_, *frame->buffer(kYPlane), 10);
 527       }
 528
 529       memset(frame->buffer(kYPlane),
 530              next_luma_byte_,
 531              frame->allocated_size(kYPlane));
 532
 533       event_->Set();
 534     }
 535
 536     scoped_ptr<EventWrapper> event_;
 537     int expected_luma_byte_;
 538     int next_luma_byte_;
 539   };
 540
 541   TestFrameCallback pre_encode_callback(-1, 255);  // Changes luma to 255.
 542   TestFrameCallback pre_render_callback(255, 0);  // Changes luma from 255 to 0.
 543
 544   test::DirectTransport sender_transport, receiver_transport;
 545
 546   CreateCalls(Call::Config(&sender_transport),
 547               Call::Config(&receiver_transport));
 548
 549   sender_transport.SetReceiver(receiver_call_->Receiver());
 550   receiver_transport.SetReceiver(sender_call_->Receiver());
 551
 552   CreateTestConfigs();
 553   send_config_.encoder = NULL;
 554   send_config_.codec = sender_call_->GetVideoCodecs()[0];
 555   send_config_.codec.width = kWidth;
 556   send_config_.codec.height = kHeight;
 557   send_config_.pre_encode_callback = &pre_encode_callback;
 558   receive_config_.pre_render_callback = &pre_render_callback;
 559   receive_config_.renderer = &renderer;
 560
 561   CreateStreams();
 562   StartSending();
 563
 564   // Create frames that are smaller than the send width/height, this is done to
 565   // check that the callbacks are done after processing video.
 566   scoped_ptr<test::FrameGenerator> frame_generator(
 567       test::FrameGenerator::Create(kWidth / 2, kHeight / 2));
 568   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 569
 570   EXPECT_EQ(kEventSignaled, pre_encode_callback.Wait())
 571       << "Timed out while waiting for pre-encode callback.";
 572   EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
 573       << "Timed out while waiting for pre-render callback.";
 574   EXPECT_EQ(kEventSignaled, renderer.Wait())
 575       << "Timed out while waiting for the frame to render.";
 576
 577   StopSending();
 578
 579   sender_transport.StopSending();
 580   receiver_transport.StopSending();
 581
 582   DestroyStreams();
 583 }
 584
 585 class PliObserver : public test::RtpRtcpObserver, public VideoRenderer {
 586   static const int kInverseDropProbability = 16;
 587
 588  public:
 589   explicit PliObserver(bool nack_enabled)
 590       : test::RtpRtcpObserver(kLongTimeoutMs),
 591         rtp_header_parser_(RtpHeaderParser::Create()),
 592         nack_enabled_(nack_enabled),
 593         highest_dropped_timestamp_(0),
 594         frames_to_drop_(0),
 595         received_pli_(false) {}
 596
 597   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 598     RTPHeader header;
 599     EXPECT_TRUE(
 600         rtp_header_parser_->Parse(packet, static_cast<int>(length), &header));
 601
 602     // Drop all retransmitted packets to force a PLI.
 603     if (header.timestamp <= highest_dropped_timestamp_)
 604       return DROP_PACKET;
 605
 606     if (frames_to_drop_ > 0) {
 607       highest_dropped_timestamp_ = header.timestamp;
 608       --frames_to_drop_;
 609       return DROP_PACKET;
 610     }
 611
 612     return SEND_PACKET;
 613   }
 614
 615   virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 616     RTCPUtility::RTCPParserV2 parser(packet, length, true);
 617     EXPECT_TRUE(parser.IsValid());
 618
 619     for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 620          packet_type != RTCPUtility::kRtcpNotValidCode;
 621          packet_type = parser.Iterate()) {
 622       if (!nack_enabled_)
 623         EXPECT_NE(packet_type, RTCPUtility::kRtcpRtpfbNackCode);
 624
 625       if (packet_type == RTCPUtility::kRtcpPsfbPliCode) {
 626         received_pli_ = true;
 627         break;
 628       }
 629     }
 630     return SEND_PACKET;
 631   }
 632
 633   virtual void RenderFrame(const I420VideoFrame& video_frame,
 634                            int time_to_render_ms) OVERRIDE {
 635     CriticalSectionScoped crit_(lock_.get());
 636     if (received_pli_ && video_frame.timestamp() > highest_dropped_timestamp_) {
 637       observation_complete_->Set();
 638     }
 639     if (!received_pli_)
 640       frames_to_drop_ = kPacketsToDrop;
 641   }
 642
 643  private:
 644   static const int kPacketsToDrop = 1;
 645
 646   scoped_ptr<RtpHeaderParser> rtp_header_parser_;
 647   bool nack_enabled_;
 648   uint32_t highest_dropped_timestamp_;
 649   int frames_to_drop_;
 650   bool received_pli_;
 651 };
 652
 653 void CallTest::ReceivesPliAndRecovers(int rtp_history_ms) {
 654   PliObserver observer(rtp_history_ms > 0);
 655
 656   CreateCalls(Call::Config(observer.SendTransport()),
 657               Call::Config(observer.ReceiveTransport()));
 658
 659   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 660
 661   CreateTestConfigs();
 662   send_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 663   receive_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 664   receive_config_.renderer = &observer;
 665
 666   CreateStreams();
 667   CreateFrameGenerator();
 668   StartSending();
 669
 670   // Wait() waits for an event triggered when Pli has been received and frames
 671   // have been rendered afterwards.
 672   EXPECT_EQ(kEventSignaled, observer.Wait());
 673
 674   StopSending();
 675
 676   observer.StopSending();
 677
 678   DestroyStreams();
 679 }
 680
 681 TEST_F(CallTest, ReceivesPliAndRecoversWithNack) {
 682   ReceivesPliAndRecovers(1000);
 683 }
 684
 685 // TODO(pbos): Enable this when 2250 is resolved.
 686 TEST_F(CallTest, DISABLED_ReceivesPliAndRecoversWithoutNack) {
 687   ReceivesPliAndRecovers(0);
 688 }
 689
 690 TEST_F(CallTest, SurvivesIncomingRtpPacketsToDestroyedReceiveStream) {
 691   class PacketInputObserver : public PacketReceiver {
 692    public:
 693     explicit PacketInputObserver(PacketReceiver* receiver)
 694         : receiver_(receiver), delivered_packet_(EventWrapper::Create()) {}
 695
 696     EventTypeWrapper Wait() {
 697       return delivered_packet_->Wait(kDefaultTimeoutMs);
 698     }
 699
 700    private:
 701     virtual bool DeliverPacket(const uint8_t* packet, size_t length) {
 702       if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length))) {
 703         return receiver_->DeliverPacket(packet, length);
 704       } else {
 705         EXPECT_FALSE(receiver_->DeliverPacket(packet, length));
 706         delivered_packet_->Set();
 707         return false;
 708       }
 709     }
 710
 711     PacketReceiver* receiver_;
 712     scoped_ptr<EventWrapper> delivered_packet_;
 713   };
 714
 715   test::DirectTransport send_transport, receive_transport;
 716
 717   CreateCalls(Call::Config(&send_transport), Call::Config(&receive_transport));
 718   PacketInputObserver input_observer(receiver_call_->Receiver());
 719
 720   send_transport.SetReceiver(&input_observer);
 721   receive_transport.SetReceiver(sender_call_->Receiver());
 722
 723   CreateTestConfigs();
 724
 725   CreateStreams();
 726   CreateFrameGenerator();
 727   StartSending();
 728
 729   receiver_call_->DestroyVideoReceiveStream(receive_stream_);
 730   receive_stream_ = NULL;
 731
 732   // Wait() waits for a received packet.
 733   EXPECT_EQ(kEventSignaled, input_observer.Wait());
 734
 735   StopSending();
 736
 737   DestroyStreams();
 738
 739   send_transport.StopSending();
 740   receive_transport.StopSending();
 741 }
 742
 743 void CallTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
 744   static const int kRtpHistoryMs = 1000;
 745   static const int kNumCompoundRtcpPacketsToObserve = 10;
 746   class RtcpModeObserver : public test::RtpRtcpObserver {
 747    public:
 748     explicit RtcpModeObserver(newapi::RtcpMode rtcp_mode)
 749         : test::RtpRtcpObserver(kDefaultTimeoutMs),
 750           rtcp_mode_(rtcp_mode),
 751           sent_rtp_(0),
 752           sent_rtcp_(0) {}
 753
 754    private:
 755     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 756       if (++sent_rtp_ % 3 == 0)
 757         return DROP_PACKET;
 758
 759       return SEND_PACKET;
 760     }
 761
 762     virtual Action OnReceiveRtcp(const uint8_t* packet,
 763                                  size_t length) OVERRIDE {
 764       ++sent_rtcp_;
 765       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 766       EXPECT_TRUE(parser.IsValid());
 767
 768       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 769       bool has_report_block = false;
 770       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 771         EXPECT_NE(RTCPUtility::kRtcpSrCode, packet_type);
 772         if (packet_type == RTCPUtility::kRtcpRrCode) {
 773           has_report_block = true;
 774           break;
 775         }
 776         packet_type = parser.Iterate();
 777       }
 778
 779       switch (rtcp_mode_) {
 780         case newapi::kRtcpCompound:
 781           if (!has_report_block) {
 782             ADD_FAILURE() << "Received RTCP packet without receiver report for "
 783                              "kRtcpCompound.";
 784             observation_complete_->Set();
 785           }
 786
 787           if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
 788             observation_complete_->Set();
 789
 790           break;
 791         case newapi::kRtcpReducedSize:
 792           if (!has_report_block)
 793             observation_complete_->Set();
 794           break;
 795       }
 796
 797       return SEND_PACKET;
 798     }
 799
 800     newapi::RtcpMode rtcp_mode_;
 801     int sent_rtp_;
 802     int sent_rtcp_;
 803   } observer(rtcp_mode);
 804
 805   CreateCalls(Call::Config(observer.SendTransport()),
 806               Call::Config(observer.ReceiveTransport()));
 807
 808   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 809
 810   CreateTestConfigs();
 811   send_config_.rtp.nack.rtp_history_ms = kRtpHistoryMs;
 812   receive_config_.rtp.nack.rtp_history_ms = kRtpHistoryMs;
 813   receive_config_.rtp.rtcp_mode = rtcp_mode;
 814
 815   CreateStreams();
 816   CreateFrameGenerator();
 817   StartSending();
 818
 819   EXPECT_EQ(kEventSignaled, observer.Wait())
 820       << (rtcp_mode == newapi::kRtcpCompound
 821               ? "Timed out before observing enough compound packets."
 822               : "Timed out before receiving a non-compound RTCP packet.");
 823
 824   StopSending();
 825   observer.StopSending();
 826   DestroyStreams();
 827 }
 828
 829 TEST_F(CallTest, UsesRtcpCompoundMode) {
 830   RespectsRtcpMode(newapi::kRtcpCompound);
 831 }
 832
 833 TEST_F(CallTest, UsesRtcpReducedSizeMode) {
 834   RespectsRtcpMode(newapi::kRtcpReducedSize);
 835 }
 836
 837 // Test sets up a Call multiple senders with different resolutions and SSRCs.
 838 // Another is set up to receive all three of these with different renderers.
 839 // Each renderer verifies that it receives the expected resolution, and as soon
 840 // as every renderer has received a frame, the test finishes.
 841 TEST_F(CallTest, SendsAndReceivesMultipleStreams) {
 842   static const size_t kNumStreams = 3;
 843
 844   class VideoOutputObserver : public VideoRenderer {
 845    public:
 846     VideoOutputObserver(test::FrameGeneratorCapturer** capturer,
 847                         int width,
 848                         int height)
 849         : capturer_(capturer),
 850           width_(width),
 851           height_(height),
 852           done_(EventWrapper::Create()) {}
 853
 854     virtual void RenderFrame(const I420VideoFrame& video_frame,
 855                              int time_to_render_ms) OVERRIDE {
 856       EXPECT_EQ(width_, video_frame.width());
 857       EXPECT_EQ(height_, video_frame.height());
 858       (*capturer_)->Stop();
 859       done_->Set();
 860     }
 861
 862     void Wait() { done_->Wait(kDefaultTimeoutMs); }
 863
 864    private:
 865     test::FrameGeneratorCapturer** capturer_;
 866     int width_;
 867     int height_;
 868     scoped_ptr<EventWrapper> done_;
 869   };
 870
 871   struct {
 872     uint32_t ssrc;
 873     int width;
 874     int height;
 875   } codec_settings[kNumStreams] = {{1, 640, 480}, {2, 320, 240}, {3, 240, 160}};
 876
 877   test::DirectTransport sender_transport, receiver_transport;
 878   scoped_ptr<Call> sender_call(Call::Create(Call::Config(&sender_transport)));
 879   scoped_ptr<Call> receiver_call(
 880       Call::Create(Call::Config(&receiver_transport)));
 881   sender_transport.SetReceiver(receiver_call->Receiver());
 882   receiver_transport.SetReceiver(sender_call->Receiver());
 883
 884   VideoSendStream* send_streams[kNumStreams];
 885   VideoReceiveStream* receive_streams[kNumStreams];
 886
 887   VideoOutputObserver* observers[kNumStreams];
 888   test::FrameGeneratorCapturer* frame_generators[kNumStreams];
 889
 890   for (size_t i = 0; i < kNumStreams; ++i) {
 891     uint32_t ssrc = codec_settings[i].ssrc;
 892     int width = codec_settings[i].width;
 893     int height = codec_settings[i].height;
 894     observers[i] = new VideoOutputObserver(&frame_generators[i], width, height);
 895
 896     VideoReceiveStream::Config receive_config =
 897         receiver_call->GetDefaultReceiveConfig();
 898     receive_config.renderer = observers[i];
 899     receive_config.rtp.remote_ssrc = ssrc;
 900     receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
 901     receive_streams[i] =
 902         receiver_call->CreateVideoReceiveStream(receive_config);
 903     receive_streams[i]->StartReceiving();
 904
 905     VideoSendStream::Config send_config = sender_call->GetDefaultSendConfig();
 906     send_config.rtp.ssrcs.push_back(ssrc);
 907     send_config.codec.width = width;
 908     send_config.codec.height = height;
 909     send_streams[i] = sender_call->CreateVideoSendStream(send_config);
 910     send_streams[i]->StartSending();
 911
 912     frame_generators[i] = test::FrameGeneratorCapturer::Create(
 913         send_streams[i]->Input(), width, height, 30, Clock::GetRealTimeClock());
 914     frame_generators[i]->Start();
 915   }
 916
 917   for (size_t i = 0; i < kNumStreams; ++i) {
 918     observers[i]->Wait();
 919   }
 920
 921   for (size_t i = 0; i < kNumStreams; ++i) {
 922     frame_generators[i]->Stop();
 923     sender_call->DestroyVideoSendStream(send_streams[i]);
 924     receiver_call->DestroyVideoReceiveStream(receive_streams[i]);
 925     delete frame_generators[i];
 926     delete observers[i];
 927   }
 928
 929   sender_transport.StopSending();
 930   receiver_transport.StopSending();
 931 };
 932
 933 TEST_F(CallTest, ObserversEncodedFrames) {
 934   class EncodedFrameTestObserver : public EncodedFrameObserver {
 935    public:
 936     EncodedFrameTestObserver() : length_(0),
 937                                  frame_type_(kFrameEmpty),
 938                                  called_(EventWrapper::Create()) {}
 939     virtual ~EncodedFrameTestObserver() {}
 940
 941     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
 942       frame_type_ = encoded_frame.frame_type_;
 943       length_ = encoded_frame.length_;
 944       buffer_.reset(new uint8_t[length_]);
 945       memcpy(buffer_.get(), encoded_frame.data_, length_);
 946       called_->Set();
 947     }
 948
 949     EventTypeWrapper Wait() {
 950       return called_->Wait(kDefaultTimeoutMs);
 951     }
 952
 953     void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
 954       ASSERT_EQ(length_, observer.length_)
 955           << "Observed frames are of different lengths.";
 956       EXPECT_EQ(frame_type_, observer.frame_type_)
 957           << "Observed frames have different frame types.";
 958       EXPECT_EQ(0, memcmp(buffer_.get(), observer.buffer_.get(), length_))
 959           << "Observed encoded frames have different content.";
 960     }
 961
 962    private:
 963     scoped_ptr<uint8_t[]> buffer_;
 964     size_t length_;
 965     FrameType frame_type_;
 966     scoped_ptr<EventWrapper> called_;
 967   };
 968
 969   EncodedFrameTestObserver post_encode_observer;
 970   EncodedFrameTestObserver pre_decode_observer;
 971
 972   test::DirectTransport sender_transport, receiver_transport;
 973
 974   CreateCalls(Call::Config(&sender_transport),
 975               Call::Config(&receiver_transport));
 976
 977   sender_transport.SetReceiver(receiver_call_->Receiver());
 978   receiver_transport.SetReceiver(sender_call_->Receiver());
 979
 980   CreateTestConfigs();
 981   send_config_.post_encode_callback = &post_encode_observer;
 982   receive_config_.pre_decode_callback = &pre_decode_observer;
 983
 984   CreateStreams();
 985   StartSending();
 986
 987   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
 988       send_config_.codec.width, send_config_.codec.height));
 989   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 990
 991   EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
 992       << "Timed out while waiting for send-side encoded-frame callback.";
 993
 994   EXPECT_EQ(kEventSignaled, pre_decode_observer.Wait())
 995       << "Timed out while waiting for pre-decode encoded-frame callback.";
 996
 997   post_encode_observer.ExpectEqualFrames(pre_decode_observer);
 998
 999   StopSending();
1000
1001   sender_transport.StopSending();
1002   receiver_transport.StopSending();
1003
1004   DestroyStreams();
1005 }
1006
1007 TEST_F(CallTest, ReceiveStreamSendsRemb) {
1008   class RembObserver : public test::RtpRtcpObserver {
1009    public:
1010     RembObserver() : test::RtpRtcpObserver(kDefaultTimeoutMs) {}
1011
1012     virtual Action OnReceiveRtcp(const uint8_t* packet,
1013                                  size_t length) OVERRIDE {
1014       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1015       EXPECT_TRUE(parser.IsValid());
1016
1017       bool received_psfb = false;
1018       bool received_remb = false;
1019       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1020       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1021         if (packet_type == RTCPUtility::kRtcpPsfbRembCode) {
1022           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1023           EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalSsrc);
1024           received_psfb = true;
1025         } else if (packet_type == RTCPUtility::kRtcpPsfbRembItemCode) {
1026           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1027           EXPECT_GT(packet.REMBItem.BitRate, 0u);
1028           EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
1029           EXPECT_EQ(packet.REMBItem.SSRCs[0], kSendSsrc);
1030           received_remb = true;
1031         }
1032         packet_type = parser.Iterate();
1033       }
1034       if (received_psfb && received_remb)
1035         observation_complete_->Set();
1036       return SEND_PACKET;
1037     }
1038   } observer;
1039
1040   CreateCalls(Call::Config(observer.SendTransport()),
1041               Call::Config(observer.ReceiveTransport()));
1042   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
1043   CreateTestConfigs();
1044   CreateStreams();
1045   CreateFrameGenerator();
1046   StartSending();
1047
1048   EXPECT_EQ(kEventSignaled, observer.Wait())
1049       << "Timed out while waiting for a receiver RTCP REMB packet to be sent.";
1050
1051   StopSending();
1052   observer.StopSending();
1053   DestroyStreams();
1054 }
1055
1056 void CallTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
1057   static const int kNumRtcpReportPacketsToObserve = 5;
1058   class RtcpXrObserver : public test::RtpRtcpObserver {
1059    public:
1060     explicit RtcpXrObserver(bool enable_rrtr)
1061         : test::RtpRtcpObserver(kDefaultTimeoutMs),
1062           enable_rrtr_(enable_rrtr),
1063           sent_rtcp_sr_(0),
1064           sent_rtcp_rr_(0),
1065           sent_rtcp_rrtr_(0),
1066           sent_rtcp_dlrr_(0) {}
1067    private:
1068     // Receive stream should send RR packets (and RRTR packets if enabled).
1069     virtual Action OnReceiveRtcp(const uint8_t* packet,
1070                                  size_t length) OVERRIDE {
1071       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1072       EXPECT_TRUE(parser.IsValid());
1073
1074       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1075       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1076         if (packet_type == RTCPUtility::kRtcpRrCode) {
1077           ++sent_rtcp_rr_;
1078         } else if (
1079             packet_type == RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
1080           ++sent_rtcp_rrtr_;
1081         }
1082         EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode);
1083         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrDlrrReportBlockItemCode);
1084         packet_type = parser.Iterate();
1085       }
1086       return SEND_PACKET;
1087     }
1088     // Send stream should send SR packets (and DLRR packets if enabled).
1089     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) {
1090       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1091       EXPECT_TRUE(parser.IsValid());
1092
1093       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1094       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1095         if (packet_type == RTCPUtility::kRtcpSrCode) {
1096           ++sent_rtcp_sr_;
1097         } else if (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
1098           ++sent_rtcp_dlrr_;
1099         }
1100         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrReceiverReferenceTimeCode);
1101         packet_type = parser.Iterate();
1102       }
1103       if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
1104           sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) {
1105         if (enable_rrtr_) {
1106           EXPECT_GT(sent_rtcp_rrtr_, 0);
1107           EXPECT_GT(sent_rtcp_dlrr_, 0);
1108         } else {
1109           EXPECT_EQ(0, sent_rtcp_rrtr_);
1110           EXPECT_EQ(0, sent_rtcp_dlrr_);
1111         }
1112         observation_complete_->Set();
1113       }
1114       return SEND_PACKET;
1115     }
1116     bool enable_rrtr_;
1117     int sent_rtcp_sr_;
1118     int sent_rtcp_rr_;
1119     int sent_rtcp_rrtr_;
1120     int sent_rtcp_dlrr_;
1121   } observer(enable_rrtr);
1122
1123   CreateCalls(Call::Config(observer.SendTransport()),
1124               Call::Config(observer.ReceiveTransport()));
1125   observer.SetReceivers(receiver_call_->Receiver(),
1126                         sender_call_->Receiver());
1127
1128   CreateTestConfigs();
1129   receive_config_.rtp.rtcp_mode = newapi::kRtcpReducedSize;
1130   receive_config_.rtp.rtcp_xr.receiver_reference_time_report = enable_rrtr;
1131
1132   CreateStreams();
1133   CreateFrameGenerator();
1134   StartSending();
1135
1136   EXPECT_EQ(kEventSignaled, observer.Wait())
1137       << "Timed out while waiting for RTCP SR/RR packets to be sent.";
1138
1139   StopSending();
1140   observer.StopSending();
1141   DestroyStreams();
1142 }
1143
1144 TEST_F(CallTest, ReceiverReferenceTimeReportEnabled) {
1145   TestXrReceiverReferenceTimeReport(true);
1146 }
1147
1148 TEST_F(CallTest, ReceiverReferenceTimeReportDisabled) {
1149   TestXrReceiverReferenceTimeReport(false);
1150 }
1151 }  // namespace webrtc