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/source/rtcp_utility.h"
  22 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
  23 #include "webrtc/system_wrappers/interface/event_wrapper.h"
  24 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  25 #include "webrtc/system_wrappers/interface/sleep.h"
  26 #include "webrtc/test/direct_transport.h"
  27 #include "webrtc/test/fake_audio_device.h"
  28 #include "webrtc/test/fake_decoder.h"
  29 #include "webrtc/test/fake_encoder.h"
  30 #include "webrtc/test/frame_generator.h"
  31 #include "webrtc/test/frame_generator_capturer.h"
  32 #include "webrtc/test/null_transport.h"
  33 #include "webrtc/test/rtp_rtcp_observer.h"
  34 #include "webrtc/test/testsupport/fileutils.h"
  35 #include "webrtc/test/testsupport/perf_test.h"
  36 #include "webrtc/video/transport_adapter.h"
  37
  38 namespace webrtc {
  39
  40 static unsigned int kDefaultTimeoutMs = 30 * 1000;
  41 static unsigned int kLongTimeoutMs = 120 * 1000;
  42 static const uint32_t kSendSsrc = 0x654321;
  43 static const uint32_t kSendRtxSsrc = 0x424242;
  44 static const uint32_t kReceiverLocalSsrc = 0x123456;
  45 static const uint8_t kSendPayloadType = 125;
  46 static const uint8_t kSendRtxPayloadType = 126;
  47
  48 class CallTest : public ::testing::Test {
  49  public:
  50   CallTest()
  51       : send_stream_(NULL),
  52         receive_stream_(NULL),
  53         fake_encoder_(Clock::GetRealTimeClock()) {}
  54
  55   virtual ~CallTest() {
  56     EXPECT_EQ(NULL, send_stream_);
  57     EXPECT_EQ(NULL, receive_stream_);
  58   }
  59
  60  protected:
  61   void CreateCalls(const Call::Config& sender_config,
  62                    const Call::Config& receiver_config) {
  63     sender_call_.reset(Call::Create(sender_config));
  64     receiver_call_.reset(Call::Create(receiver_config));
  65   }
  66
  67   void CreateTestConfigs() {
  68     send_config_ = sender_call_->GetDefaultSendConfig();
  69     receive_config_ = receiver_call_->GetDefaultReceiveConfig();
  70
  71     send_config_.rtp.ssrcs.push_back(kSendSsrc);
  72     send_config_.encoder = &fake_encoder_;
  73     send_config_.internal_source = false;
  74     test::FakeEncoder::SetCodecSettings(&send_config_.codec, 1);
  75     send_config_.codec.plType = kSendPayloadType;
  76
  77     receive_config_.codecs.clear();
  78     receive_config_.codecs.push_back(send_config_.codec);
  79     ExternalVideoDecoder decoder;
  80     decoder.decoder = &fake_decoder_;
  81     decoder.payload_type = send_config_.codec.plType;
  82     receive_config_.external_decoders.push_back(decoder);
  83     receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
  84     receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
  85   }
  86
  87   void CreateStreams() {
  88     assert(send_stream_ == NULL);
  89     assert(receive_stream_ == NULL);
  90
  91     send_stream_ = sender_call_->CreateVideoSendStream(send_config_);
  92     receive_stream_ = receiver_call_->CreateVideoReceiveStream(receive_config_);
  93   }
  94
  95   void CreateFrameGenerator() {
  96     frame_generator_capturer_.reset(
  97         test::FrameGeneratorCapturer::Create(send_stream_->Input(),
  98                                              send_config_.codec.width,
  99                                              send_config_.codec.height,
 100                                              30,
 101                                              Clock::GetRealTimeClock()));
 102   }
 103
 104   void StartSending() {
 105     receive_stream_->StartReceiving();
 106     send_stream_->StartSending();
 107     if (frame_generator_capturer_.get() != NULL)
 108       frame_generator_capturer_->Start();
 109   }
 110
 111   void StopSending() {
 112     if (frame_generator_capturer_.get() != NULL)
 113       frame_generator_capturer_->Stop();
 114     if (send_stream_ != NULL)
 115       send_stream_->StopSending();
 116     if (receive_stream_ != NULL)
 117       receive_stream_->StopReceiving();
 118   }
 119
 120   void DestroyStreams() {
 121     if (send_stream_ != NULL)
 122       sender_call_->DestroyVideoSendStream(send_stream_);
 123     if (receive_stream_ != NULL)
 124       receiver_call_->DestroyVideoReceiveStream(receive_stream_);
 125     send_stream_ = NULL;
 126     receive_stream_ = NULL;
 127   }
 128
 129   void DecodesRetransmittedFrame(bool retransmit_over_rtx);
 130   void ReceivesPliAndRecovers(int rtp_history_ms);
 131   void RespectsRtcpMode(newapi::RtcpMode rtcp_mode);
 132   void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
 133
 134   scoped_ptr<Call> sender_call_;
 135   scoped_ptr<Call> receiver_call_;
 136
 137   VideoSendStream::Config send_config_;
 138   VideoReceiveStream::Config receive_config_;
 139
 140   VideoSendStream* send_stream_;
 141   VideoReceiveStream* receive_stream_;
 142
 143   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
 144
 145   test::FakeEncoder fake_encoder_;
 146   test::FakeDecoder fake_decoder_;
 147 };
 148
 149 class NackObserver : public test::RtpRtcpObserver {
 150   static const int kNumberOfNacksToObserve = 2;
 151   static const int kLossBurstSize = 2;
 152   static const int kPacketsBetweenLossBursts = 9;
 153
 154  public:
 155   NackObserver()
 156       : test::RtpRtcpObserver(kLongTimeoutMs),
 157         rtp_parser_(RtpHeaderParser::Create()),
 158         sent_rtp_packets_(0),
 159         packets_left_to_drop_(0),
 160         nacks_left_(kNumberOfNacksToObserve) {}
 161
 162  private:
 163   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 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) OVERRIDE {
 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 // This test drops second RTP packet with a marker bit set, makes sure it's
 489 // retransmitted and renders. Retransmission SSRCs are also checked.
 490 void CallTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) {
 491   static const int kDroppedFrameNumber = 2;
 492   class RetransmissionObserver : public test::RtpRtcpObserver,
 493                                  public I420FrameCallback {
 494    public:
 495     RetransmissionObserver(bool expect_rtx)
 496         : RtpRtcpObserver(kDefaultTimeoutMs),
 497           retransmission_ssrc_(expect_rtx ? kSendRtxSsrc : kSendSsrc),
 498           retransmission_payload_type_(expect_rtx ? kSendRtxPayloadType
 499                                                   : kSendPayloadType),
 500           marker_bits_observed_(0),
 501           retransmitted_timestamp_(0),
 502           frame_retransmitted_(false) {}
 503
 504    private:
 505     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 506       RTPHeader header;
 507       EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
 508
 509       if (header.timestamp == retransmitted_timestamp_) {
 510         EXPECT_EQ(retransmission_ssrc_, header.ssrc);
 511         EXPECT_EQ(retransmission_payload_type_, header.payloadType);
 512         frame_retransmitted_ = true;
 513         return SEND_PACKET;
 514       }
 515
 516       EXPECT_EQ(kSendSsrc, header.ssrc);
 517       EXPECT_EQ(kSendPayloadType, header.payloadType);
 518
 519       // Found the second frame's final packet, drop this and expect a
 520       // retransmission.
 521       if (header.markerBit && ++marker_bits_observed_ == kDroppedFrameNumber) {
 522         retransmitted_timestamp_ = header.timestamp;
 523         return DROP_PACKET;
 524       }
 525
 526       return SEND_PACKET;
 527     }
 528
 529     virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE {
 530       CriticalSectionScoped crit_(lock_.get());
 531       if (frame->timestamp() == retransmitted_timestamp_) {
 532         EXPECT_TRUE(frame_retransmitted_);
 533         observation_complete_->Set();
 534       }
 535     }
 536
 537     const uint32_t retransmission_ssrc_;
 538     const int retransmission_payload_type_;
 539     int marker_bits_observed_;
 540     uint32_t retransmitted_timestamp_;
 541     bool frame_retransmitted_;
 542   } observer(retransmit_over_rtx);
 543
 544   CreateCalls(Call::Config(observer.SendTransport()),
 545               Call::Config(observer.ReceiveTransport()));
 546
 547   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 548
 549   CreateTestConfigs();
 550   send_config_.rtp.nack.rtp_history_ms =
 551       receive_config_.rtp.nack.rtp_history_ms = 1000;
 552   if (retransmit_over_rtx) {
 553     send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrc);
 554     send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
 555     int payload_type = send_config_.codec.plType;
 556     receive_config_.rtp.rtx[payload_type].ssrc = kSendRtxSsrc;
 557     receive_config_.rtp.rtx[payload_type].payload_type = kSendRtxPayloadType;
 558   }
 559   receive_config_.pre_render_callback = &observer;
 560
 561   CreateStreams();
 562   CreateFrameGenerator();
 563   StartSending();
 564
 565   EXPECT_EQ(kEventSignaled, observer.Wait())
 566       << "Timed out while waiting for retransmission to render.";
 567
 568   StopSending();
 569   observer.StopSending();
 570   DestroyStreams();
 571 }
 572
 573 TEST_F(CallTest, DecodesRetransmittedFrame) {
 574   DecodesRetransmittedFrame(false);
 575 }
 576
 577 TEST_F(CallTest, DecodesRetransmittedFrameOverRtx) {
 578   DecodesRetransmittedFrame(true);
 579 }
 580
 581 TEST_F(CallTest, UsesFrameCallbacks) {
 582   static const int kWidth = 320;
 583   static const int kHeight = 240;
 584
 585   class Renderer : public VideoRenderer {
 586    public:
 587     Renderer() : event_(EventWrapper::Create()) {}
 588
 589     virtual void RenderFrame(const I420VideoFrame& video_frame,
 590                              int /*time_to_render_ms*/) OVERRIDE {
 591       EXPECT_EQ(0, *video_frame.buffer(kYPlane))
 592           << "Rendered frame should have zero luma which is applied by the "
 593              "pre-render callback.";
 594       event_->Set();
 595     }
 596
 597     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 598     scoped_ptr<EventWrapper> event_;
 599   } renderer;
 600
 601   class TestFrameCallback : public I420FrameCallback {
 602    public:
 603     TestFrameCallback(int expected_luma_byte, int next_luma_byte)
 604         : event_(EventWrapper::Create()),
 605           expected_luma_byte_(expected_luma_byte),
 606           next_luma_byte_(next_luma_byte) {}
 607
 608     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 609
 610    private:
 611     virtual void FrameCallback(I420VideoFrame* frame) {
 612       EXPECT_EQ(kWidth, frame->width())
 613           << "Width not as expected, callback done before resize?";
 614       EXPECT_EQ(kHeight, frame->height())
 615           << "Height not as expected, callback done before resize?";
 616
 617       // Previous luma specified, observed luma should be fairly close.
 618       if (expected_luma_byte_ != -1) {
 619         EXPECT_NEAR(expected_luma_byte_, *frame->buffer(kYPlane), 10);
 620       }
 621
 622       memset(frame->buffer(kYPlane),
 623              next_luma_byte_,
 624              frame->allocated_size(kYPlane));
 625
 626       event_->Set();
 627     }
 628
 629     scoped_ptr<EventWrapper> event_;
 630     int expected_luma_byte_;
 631     int next_luma_byte_;
 632   };
 633
 634   TestFrameCallback pre_encode_callback(-1, 255);  // Changes luma to 255.
 635   TestFrameCallback pre_render_callback(255, 0);  // Changes luma from 255 to 0.
 636
 637   test::DirectTransport sender_transport, receiver_transport;
 638
 639   CreateCalls(Call::Config(&sender_transport),
 640               Call::Config(&receiver_transport));
 641
 642   sender_transport.SetReceiver(receiver_call_->Receiver());
 643   receiver_transport.SetReceiver(sender_call_->Receiver());
 644
 645   CreateTestConfigs();
 646   send_config_.encoder = NULL;
 647   send_config_.codec = sender_call_->GetVideoCodecs()[0];
 648   send_config_.codec.width = kWidth;
 649   send_config_.codec.height = kHeight;
 650   send_config_.pre_encode_callback = &pre_encode_callback;
 651   receive_config_.pre_render_callback = &pre_render_callback;
 652   receive_config_.renderer = &renderer;
 653
 654   CreateStreams();
 655   StartSending();
 656
 657   // Create frames that are smaller than the send width/height, this is done to
 658   // check that the callbacks are done after processing video.
 659   scoped_ptr<test::FrameGenerator> frame_generator(
 660       test::FrameGenerator::Create(kWidth / 2, kHeight / 2));
 661   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 662
 663   EXPECT_EQ(kEventSignaled, pre_encode_callback.Wait())
 664       << "Timed out while waiting for pre-encode callback.";
 665   EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
 666       << "Timed out while waiting for pre-render callback.";
 667   EXPECT_EQ(kEventSignaled, renderer.Wait())
 668       << "Timed out while waiting for the frame to render.";
 669
 670   StopSending();
 671
 672   sender_transport.StopSending();
 673   receiver_transport.StopSending();
 674
 675   DestroyStreams();
 676 }
 677
 678 class PliObserver : public test::RtpRtcpObserver, public VideoRenderer {
 679   static const int kInverseDropProbability = 16;
 680
 681  public:
 682   explicit PliObserver(bool nack_enabled)
 683       : test::RtpRtcpObserver(kLongTimeoutMs),
 684         nack_enabled_(nack_enabled),
 685         highest_dropped_timestamp_(0),
 686         frames_to_drop_(0),
 687         received_pli_(false) {}
 688
 689   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 690     RTPHeader header;
 691     EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
 692
 693     // Drop all retransmitted packets to force a PLI.
 694     if (header.timestamp <= highest_dropped_timestamp_)
 695       return DROP_PACKET;
 696
 697     if (frames_to_drop_ > 0) {
 698       highest_dropped_timestamp_ = header.timestamp;
 699       --frames_to_drop_;
 700       return DROP_PACKET;
 701     }
 702
 703     return SEND_PACKET;
 704   }
 705
 706   virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 707     RTCPUtility::RTCPParserV2 parser(packet, length, true);
 708     EXPECT_TRUE(parser.IsValid());
 709
 710     for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 711          packet_type != RTCPUtility::kRtcpNotValidCode;
 712          packet_type = parser.Iterate()) {
 713       if (!nack_enabled_)
 714         EXPECT_NE(packet_type, RTCPUtility::kRtcpRtpfbNackCode);
 715
 716       if (packet_type == RTCPUtility::kRtcpPsfbPliCode) {
 717         received_pli_ = true;
 718         break;
 719       }
 720     }
 721     return SEND_PACKET;
 722   }
 723
 724   virtual void RenderFrame(const I420VideoFrame& video_frame,
 725                            int time_to_render_ms) OVERRIDE {
 726     CriticalSectionScoped crit_(lock_.get());
 727     if (received_pli_ && video_frame.timestamp() > highest_dropped_timestamp_) {
 728       observation_complete_->Set();
 729     }
 730     if (!received_pli_)
 731       frames_to_drop_ = kPacketsToDrop;
 732   }
 733
 734  private:
 735   static const int kPacketsToDrop = 1;
 736
 737   bool nack_enabled_;
 738   uint32_t highest_dropped_timestamp_;
 739   int frames_to_drop_;
 740   bool received_pli_;
 741 };
 742
 743 void CallTest::ReceivesPliAndRecovers(int rtp_history_ms) {
 744   PliObserver observer(rtp_history_ms > 0);
 745
 746   CreateCalls(Call::Config(observer.SendTransport()),
 747               Call::Config(observer.ReceiveTransport()));
 748
 749   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 750
 751   CreateTestConfigs();
 752   send_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 753   receive_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 754   receive_config_.renderer = &observer;
 755
 756   CreateStreams();
 757   CreateFrameGenerator();
 758   StartSending();
 759
 760   // Wait() waits for an event triggered when Pli has been received and frames
 761   // have been rendered afterwards.
 762   EXPECT_EQ(kEventSignaled, observer.Wait());
 763
 764   StopSending();
 765
 766   observer.StopSending();
 767
 768   DestroyStreams();
 769 }
 770
 771 TEST_F(CallTest, ReceivesPliAndRecoversWithNack) {
 772   ReceivesPliAndRecovers(1000);
 773 }
 774
 775 // TODO(pbos): Enable this when 2250 is resolved.
 776 TEST_F(CallTest, DISABLED_ReceivesPliAndRecoversWithoutNack) {
 777   ReceivesPliAndRecovers(0);
 778 }
 779
 780 TEST_F(CallTest, SurvivesIncomingRtpPacketsToDestroyedReceiveStream) {
 781   class PacketInputObserver : public PacketReceiver {
 782    public:
 783     explicit PacketInputObserver(PacketReceiver* receiver)
 784         : receiver_(receiver), delivered_packet_(EventWrapper::Create()) {}
 785
 786     EventTypeWrapper Wait() {
 787       return delivered_packet_->Wait(kDefaultTimeoutMs);
 788     }
 789
 790    private:
 791     virtual bool DeliverPacket(const uint8_t* packet, size_t length) {
 792       if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length))) {
 793         return receiver_->DeliverPacket(packet, length);
 794       } else {
 795         EXPECT_FALSE(receiver_->DeliverPacket(packet, length));
 796         delivered_packet_->Set();
 797         return false;
 798       }
 799     }
 800
 801     PacketReceiver* receiver_;
 802     scoped_ptr<EventWrapper> delivered_packet_;
 803   };
 804
 805   test::DirectTransport send_transport, receive_transport;
 806
 807   CreateCalls(Call::Config(&send_transport), Call::Config(&receive_transport));
 808   PacketInputObserver input_observer(receiver_call_->Receiver());
 809
 810   send_transport.SetReceiver(&input_observer);
 811   receive_transport.SetReceiver(sender_call_->Receiver());
 812
 813   CreateTestConfigs();
 814
 815   CreateStreams();
 816   CreateFrameGenerator();
 817   StartSending();
 818
 819   receiver_call_->DestroyVideoReceiveStream(receive_stream_);
 820   receive_stream_ = NULL;
 821
 822   // Wait() waits for a received packet.
 823   EXPECT_EQ(kEventSignaled, input_observer.Wait());
 824
 825   StopSending();
 826
 827   DestroyStreams();
 828
 829   send_transport.StopSending();
 830   receive_transport.StopSending();
 831 }
 832
 833 void CallTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
 834   static const int kRtpHistoryMs = 1000;
 835   static const int kNumCompoundRtcpPacketsToObserve = 10;
 836   class RtcpModeObserver : public test::RtpRtcpObserver {
 837    public:
 838     explicit RtcpModeObserver(newapi::RtcpMode rtcp_mode)
 839         : test::RtpRtcpObserver(kDefaultTimeoutMs),
 840           rtcp_mode_(rtcp_mode),
 841           sent_rtp_(0),
 842           sent_rtcp_(0) {}
 843
 844    private:
 845     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 846       if (++sent_rtp_ % 3 == 0)
 847         return DROP_PACKET;
 848
 849       return SEND_PACKET;
 850     }
 851
 852     virtual Action OnReceiveRtcp(const uint8_t* packet,
 853                                  size_t length) OVERRIDE {
 854       ++sent_rtcp_;
 855       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 856       EXPECT_TRUE(parser.IsValid());
 857
 858       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 859       bool has_report_block = false;
 860       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 861         EXPECT_NE(RTCPUtility::kRtcpSrCode, packet_type);
 862         if (packet_type == RTCPUtility::kRtcpRrCode) {
 863           has_report_block = true;
 864           break;
 865         }
 866         packet_type = parser.Iterate();
 867       }
 868
 869       switch (rtcp_mode_) {
 870         case newapi::kRtcpCompound:
 871           if (!has_report_block) {
 872             ADD_FAILURE() << "Received RTCP packet without receiver report for "
 873                              "kRtcpCompound.";
 874             observation_complete_->Set();
 875           }
 876
 877           if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
 878             observation_complete_->Set();
 879
 880           break;
 881         case newapi::kRtcpReducedSize:
 882           if (!has_report_block)
 883             observation_complete_->Set();
 884           break;
 885       }
 886
 887       return SEND_PACKET;
 888     }
 889
 890     newapi::RtcpMode rtcp_mode_;
 891     int sent_rtp_;
 892     int sent_rtcp_;
 893   } observer(rtcp_mode);
 894
 895   CreateCalls(Call::Config(observer.SendTransport()),
 896               Call::Config(observer.ReceiveTransport()));
 897
 898   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 899
 900   CreateTestConfigs();
 901   send_config_.rtp.nack.rtp_history_ms = kRtpHistoryMs;
 902   receive_config_.rtp.nack.rtp_history_ms = kRtpHistoryMs;
 903   receive_config_.rtp.rtcp_mode = rtcp_mode;
 904
 905   CreateStreams();
 906   CreateFrameGenerator();
 907   StartSending();
 908
 909   EXPECT_EQ(kEventSignaled, observer.Wait())
 910       << (rtcp_mode == newapi::kRtcpCompound
 911               ? "Timed out before observing enough compound packets."
 912               : "Timed out before receiving a non-compound RTCP packet.");
 913
 914   StopSending();
 915   observer.StopSending();
 916   DestroyStreams();
 917 }
 918
 919 TEST_F(CallTest, UsesRtcpCompoundMode) {
 920   RespectsRtcpMode(newapi::kRtcpCompound);
 921 }
 922
 923 TEST_F(CallTest, UsesRtcpReducedSizeMode) {
 924   RespectsRtcpMode(newapi::kRtcpReducedSize);
 925 }
 926
 927 // Test sets up a Call multiple senders with different resolutions and SSRCs.
 928 // Another is set up to receive all three of these with different renderers.
 929 // Each renderer verifies that it receives the expected resolution, and as soon
 930 // as every renderer has received a frame, the test finishes.
 931 TEST_F(CallTest, SendsAndReceivesMultipleStreams) {
 932   static const size_t kNumStreams = 3;
 933
 934   class VideoOutputObserver : public VideoRenderer {
 935    public:
 936     VideoOutputObserver(test::FrameGeneratorCapturer** capturer,
 937                         int width,
 938                         int height)
 939         : capturer_(capturer),
 940           width_(width),
 941           height_(height),
 942           done_(EventWrapper::Create()) {}
 943
 944     virtual void RenderFrame(const I420VideoFrame& video_frame,
 945                              int time_to_render_ms) OVERRIDE {
 946       EXPECT_EQ(width_, video_frame.width());
 947       EXPECT_EQ(height_, video_frame.height());
 948       (*capturer_)->Stop();
 949       done_->Set();
 950     }
 951
 952     void Wait() { done_->Wait(kDefaultTimeoutMs); }
 953
 954    private:
 955     test::FrameGeneratorCapturer** capturer_;
 956     int width_;
 957     int height_;
 958     scoped_ptr<EventWrapper> done_;
 959   };
 960
 961   struct {
 962     uint32_t ssrc;
 963     int width;
 964     int height;
 965   } codec_settings[kNumStreams] = {{1, 640, 480}, {2, 320, 240}, {3, 240, 160}};
 966
 967   test::DirectTransport sender_transport, receiver_transport;
 968   scoped_ptr<Call> sender_call(Call::Create(Call::Config(&sender_transport)));
 969   scoped_ptr<Call> receiver_call(
 970       Call::Create(Call::Config(&receiver_transport)));
 971   sender_transport.SetReceiver(receiver_call->Receiver());
 972   receiver_transport.SetReceiver(sender_call->Receiver());
 973
 974   VideoSendStream* send_streams[kNumStreams];
 975   VideoReceiveStream* receive_streams[kNumStreams];
 976
 977   VideoOutputObserver* observers[kNumStreams];
 978   test::FrameGeneratorCapturer* frame_generators[kNumStreams];
 979
 980   for (size_t i = 0; i < kNumStreams; ++i) {
 981     uint32_t ssrc = codec_settings[i].ssrc;
 982     int width = codec_settings[i].width;
 983     int height = codec_settings[i].height;
 984     observers[i] = new VideoOutputObserver(&frame_generators[i], width, height);
 985
 986     VideoReceiveStream::Config receive_config =
 987         receiver_call->GetDefaultReceiveConfig();
 988     receive_config.renderer = observers[i];
 989     receive_config.rtp.remote_ssrc = ssrc;
 990     receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
 991     receive_streams[i] =
 992         receiver_call->CreateVideoReceiveStream(receive_config);
 993     receive_streams[i]->StartReceiving();
 994
 995     VideoSendStream::Config send_config = sender_call->GetDefaultSendConfig();
 996     send_config.rtp.ssrcs.push_back(ssrc);
 997     send_config.codec.width = width;
 998     send_config.codec.height = height;
 999     send_streams[i] = sender_call->CreateVideoSendStream(send_config);
1000     send_streams[i]->StartSending();
1001
1002     frame_generators[i] = test::FrameGeneratorCapturer::Create(
1003         send_streams[i]->Input(), width, height, 30, Clock::GetRealTimeClock());
1004     frame_generators[i]->Start();
1005   }
1006
1007   for (size_t i = 0; i < kNumStreams; ++i) {
1008     observers[i]->Wait();
1009   }
1010
1011   for (size_t i = 0; i < kNumStreams; ++i) {
1012     frame_generators[i]->Stop();
1013     sender_call->DestroyVideoSendStream(send_streams[i]);
1014     receiver_call->DestroyVideoReceiveStream(receive_streams[i]);
1015     delete frame_generators[i];
1016     delete observers[i];
1017   }
1018
1019   sender_transport.StopSending();
1020   receiver_transport.StopSending();
1021 };
1022
1023 TEST_F(CallTest, ObserversEncodedFrames) {
1024   class EncodedFrameTestObserver : public EncodedFrameObserver {
1025    public:
1026     EncodedFrameTestObserver()
1027         : length_(0),
1028           frame_type_(kFrameEmpty),
1029           called_(EventWrapper::Create()) {}
1030     virtual ~EncodedFrameTestObserver() {}
1031
1032     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
1033       frame_type_ = encoded_frame.frame_type_;
1034       length_ = encoded_frame.length_;
1035       buffer_.reset(new uint8_t[length_]);
1036       memcpy(buffer_.get(), encoded_frame.data_, length_);
1037       called_->Set();
1038     }
1039
1040     EventTypeWrapper Wait() { return called_->Wait(kDefaultTimeoutMs); }
1041
1042     void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
1043       ASSERT_EQ(length_, observer.length_)
1044           << "Observed frames are of different lengths.";
1045       EXPECT_EQ(frame_type_, observer.frame_type_)
1046           << "Observed frames have different frame types.";
1047       EXPECT_EQ(0, memcmp(buffer_.get(), observer.buffer_.get(), length_))
1048           << "Observed encoded frames have different content.";
1049     }
1050
1051    private:
1052     scoped_ptr<uint8_t[]> buffer_;
1053     size_t length_;
1054     FrameType frame_type_;
1055     scoped_ptr<EventWrapper> called_;
1056   };
1057
1058   EncodedFrameTestObserver post_encode_observer;
1059   EncodedFrameTestObserver pre_decode_observer;
1060
1061   test::DirectTransport sender_transport, receiver_transport;
1062
1063   CreateCalls(Call::Config(&sender_transport),
1064               Call::Config(&receiver_transport));
1065
1066   sender_transport.SetReceiver(receiver_call_->Receiver());
1067   receiver_transport.SetReceiver(sender_call_->Receiver());
1068
1069   CreateTestConfigs();
1070   send_config_.post_encode_callback = &post_encode_observer;
1071   receive_config_.pre_decode_callback = &pre_decode_observer;
1072
1073   CreateStreams();
1074   StartSending();
1075
1076   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
1077       send_config_.codec.width, send_config_.codec.height));
1078   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
1079
1080   EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
1081       << "Timed out while waiting for send-side encoded-frame callback.";
1082
1083   EXPECT_EQ(kEventSignaled, pre_decode_observer.Wait())
1084       << "Timed out while waiting for pre-decode encoded-frame callback.";
1085
1086   post_encode_observer.ExpectEqualFrames(pre_decode_observer);
1087
1088   StopSending();
1089
1090   sender_transport.StopSending();
1091   receiver_transport.StopSending();
1092
1093   DestroyStreams();
1094 }
1095
1096 TEST_F(CallTest, ReceiveStreamSendsRemb) {
1097   class RembObserver : public test::RtpRtcpObserver {
1098    public:
1099     RembObserver() : test::RtpRtcpObserver(kDefaultTimeoutMs) {}
1100
1101     virtual Action OnReceiveRtcp(const uint8_t* packet,
1102                                  size_t length) OVERRIDE {
1103       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1104       EXPECT_TRUE(parser.IsValid());
1105
1106       bool received_psfb = false;
1107       bool received_remb = false;
1108       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1109       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1110         if (packet_type == RTCPUtility::kRtcpPsfbRembCode) {
1111           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1112           EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalSsrc);
1113           received_psfb = true;
1114         } else if (packet_type == RTCPUtility::kRtcpPsfbRembItemCode) {
1115           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1116           EXPECT_GT(packet.REMBItem.BitRate, 0u);
1117           EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
1118           EXPECT_EQ(packet.REMBItem.SSRCs[0], kSendSsrc);
1119           received_remb = true;
1120         }
1121         packet_type = parser.Iterate();
1122       }
1123       if (received_psfb && received_remb)
1124         observation_complete_->Set();
1125       return SEND_PACKET;
1126     }
1127   } observer;
1128
1129   CreateCalls(Call::Config(observer.SendTransport()),
1130               Call::Config(observer.ReceiveTransport()));
1131   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
1132   CreateTestConfigs();
1133   CreateStreams();
1134   CreateFrameGenerator();
1135   StartSending();
1136
1137   EXPECT_EQ(kEventSignaled, observer.Wait())
1138       << "Timed out while waiting for a receiver RTCP REMB packet to be sent.";
1139
1140   StopSending();
1141   observer.StopSending();
1142   DestroyStreams();
1143 }
1144
1145 void CallTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
1146   static const int kNumRtcpReportPacketsToObserve = 5;
1147   class RtcpXrObserver : public test::RtpRtcpObserver {
1148    public:
1149     explicit RtcpXrObserver(bool enable_rrtr)
1150         : test::RtpRtcpObserver(kDefaultTimeoutMs),
1151           enable_rrtr_(enable_rrtr),
1152           sent_rtcp_sr_(0),
1153           sent_rtcp_rr_(0),
1154           sent_rtcp_rrtr_(0),
1155           sent_rtcp_dlrr_(0) {}
1156
1157    private:
1158     // Receive stream should send RR packets (and RRTR packets if enabled).
1159     virtual Action OnReceiveRtcp(const uint8_t* packet,
1160                                  size_t length) OVERRIDE {
1161       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1162       EXPECT_TRUE(parser.IsValid());
1163
1164       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1165       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1166         if (packet_type == RTCPUtility::kRtcpRrCode) {
1167           ++sent_rtcp_rr_;
1168         } else if (packet_type ==
1169                    RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
1170           ++sent_rtcp_rrtr_;
1171         }
1172         EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode);
1173         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrDlrrReportBlockItemCode);
1174         packet_type = parser.Iterate();
1175       }
1176       return SEND_PACKET;
1177     }
1178     // Send stream should send SR packets (and DLRR packets if enabled).
1179     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) {
1180       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1181       EXPECT_TRUE(parser.IsValid());
1182
1183       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1184       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1185         if (packet_type == RTCPUtility::kRtcpSrCode) {
1186           ++sent_rtcp_sr_;
1187         } else if (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
1188           ++sent_rtcp_dlrr_;
1189         }
1190         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrReceiverReferenceTimeCode);
1191         packet_type = parser.Iterate();
1192       }
1193       if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
1194           sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) {
1195         if (enable_rrtr_) {
1196           EXPECT_GT(sent_rtcp_rrtr_, 0);
1197           EXPECT_GT(sent_rtcp_dlrr_, 0);
1198         } else {
1199           EXPECT_EQ(0, sent_rtcp_rrtr_);
1200           EXPECT_EQ(0, sent_rtcp_dlrr_);
1201         }
1202         observation_complete_->Set();
1203       }
1204       return SEND_PACKET;
1205     }
1206     bool enable_rrtr_;
1207     int sent_rtcp_sr_;
1208     int sent_rtcp_rr_;
1209     int sent_rtcp_rrtr_;
1210     int sent_rtcp_dlrr_;
1211   } observer(enable_rrtr);
1212
1213   CreateCalls(Call::Config(observer.SendTransport()),
1214               Call::Config(observer.ReceiveTransport()));
1215   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
1216
1217   CreateTestConfigs();
1218   receive_config_.rtp.rtcp_mode = newapi::kRtcpReducedSize;
1219   receive_config_.rtp.rtcp_xr.receiver_reference_time_report = enable_rrtr;
1220
1221   CreateStreams();
1222   CreateFrameGenerator();
1223   StartSending();
1224
1225   EXPECT_EQ(kEventSignaled, observer.Wait())
1226       << "Timed out while waiting for RTCP SR/RR packets to be sent.";
1227
1228   StopSending();
1229   observer.StopSending();
1230   DestroyStreams();
1231 }
1232
1233 class StatsObserver : public test::RtpRtcpObserver, public I420FrameCallback {
1234  public:
1235   StatsObserver()
1236       : test::RtpRtcpObserver(kLongTimeoutMs),
1237         receive_stream_(NULL),
1238         send_stream_(NULL),
1239         expected_receive_ssrc_(),
1240         expected_send_ssrcs_(),
1241         check_stats_event_(EventWrapper::Create()) {}
1242
1243   void SetExpectedReceiveSsrc(uint32_t ssrc) { expected_receive_ssrc_ = ssrc; }
1244
1245   void SetExpectedSendSsrcs(const std::vector<uint32_t>& ssrcs) {
1246     for (std::vector<uint32_t>::const_iterator it = ssrcs.begin();
1247          it != ssrcs.end();
1248          ++it) {
1249       expected_send_ssrcs_.insert(*it);
1250     }
1251   }
1252
1253   void SetExpectedCName(std::string cname) { expected_cname_ = cname; }
1254
1255   void SetReceiveStream(VideoReceiveStream* stream) {
1256     receive_stream_ = stream;
1257   }
1258
1259   void SetSendStream(VideoSendStream* stream) { send_stream_ = stream; }
1260
1261   void WaitForFilledStats() {
1262     Clock* clock = Clock::GetRealTimeClock();
1263     int64_t now = clock->TimeInMilliseconds();
1264     int64_t stop_time = now + kLongTimeoutMs;
1265     bool receive_ok = false;
1266     bool send_ok = false;
1267
1268     while (now < stop_time) {
1269       if (!receive_ok)
1270         receive_ok = CheckReceiveStats();
1271       if (!send_ok)
1272         send_ok = CheckSendStats();
1273
1274       if (receive_ok && send_ok)
1275         return;
1276
1277       int64_t time_until_timout_ = stop_time - now;
1278       if (time_until_timout_ > 0)
1279         check_stats_event_->Wait(time_until_timout_);
1280       now = clock->TimeInMilliseconds();
1281     }
1282
1283     ADD_FAILURE() << "Timed out waiting for filled stats.";
1284     for (std::map<std::string, bool>::const_iterator it =
1285              receive_stats_filled_.begin();
1286          it != receive_stats_filled_.end();
1287          ++it) {
1288       if (!it->second) {
1289         ADD_FAILURE() << "Missing receive stats: " << it->first;
1290       }
1291     }
1292
1293     for (std::map<std::string, bool>::const_iterator it =
1294              send_stats_filled_.begin();
1295          it != send_stats_filled_.end();
1296          ++it) {
1297       if (!it->second) {
1298         ADD_FAILURE() << "Missing send stats: " << it->first;
1299       }
1300     }
1301   }
1302
1303  private:
1304   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1305     check_stats_event_->Set();
1306     return SEND_PACKET;
1307   }
1308
1309   virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
1310     check_stats_event_->Set();
1311     return SEND_PACKET;
1312   }
1313
1314   virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) OVERRIDE {
1315     check_stats_event_->Set();
1316     return SEND_PACKET;
1317   }
1318
1319   virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
1320     check_stats_event_->Set();
1321     return SEND_PACKET;
1322   }
1323
1324   virtual void FrameCallback(I420VideoFrame* video_frame) OVERRIDE {
1325     // Ensure that we have at least 5ms send side delay.
1326     int64_t render_time = video_frame->render_time_ms();
1327     if (render_time > 0)
1328       video_frame->set_render_time_ms(render_time - 5);
1329   }
1330
1331   bool CheckReceiveStats() {
1332     assert(receive_stream_ != NULL);
1333     VideoReceiveStream::Stats stats = receive_stream_->GetStats();
1334     EXPECT_EQ(expected_receive_ssrc_, stats.ssrc);
1335
1336     // Make sure all fields have been populated.
1337
1338     receive_stats_filled_["IncomingRate"] |=
1339         stats.network_frame_rate != 0 || stats.bitrate_bps != 0;
1340
1341     receive_stats_filled_["FrameCallback"] |= stats.decode_frame_rate != 0;
1342
1343     receive_stats_filled_["FrameRendered"] |= stats.render_frame_rate != 0;
1344
1345     receive_stats_filled_["StatisticsUpdated"] |=
1346         stats.rtcp_stats.cumulative_lost != 0 ||
1347         stats.rtcp_stats.extended_max_sequence_number != 0 ||
1348         stats.rtcp_stats.fraction_lost != 0 || stats.rtcp_stats.jitter != 0;
1349
1350     receive_stats_filled_["DataCountersUpdated"] |=
1351         stats.rtp_stats.bytes != 0 || stats.rtp_stats.fec_packets != 0 ||
1352         stats.rtp_stats.header_bytes != 0 || stats.rtp_stats.packets != 0 ||
1353         stats.rtp_stats.padding_bytes != 0 ||
1354         stats.rtp_stats.retransmitted_packets != 0;
1355
1356     receive_stats_filled_["CodecStats"] |=
1357         stats.avg_delay_ms != 0 || stats.discarded_packets != 0 ||
1358         stats.key_frames != 0 || stats.delta_frames != 0;
1359
1360     receive_stats_filled_["CName"] |= stats.c_name == expected_cname_;
1361
1362     return AllStatsFilled(receive_stats_filled_);
1363   }
1364
1365   bool CheckSendStats() {
1366     assert(send_stream_ != NULL);
1367     VideoSendStream::Stats stats = send_stream_->GetStats();
1368
1369     send_stats_filled_["NumStreams"] |=
1370         stats.substreams.size() == expected_send_ssrcs_.size();
1371
1372     send_stats_filled_["Delay"] |=
1373         stats.avg_delay_ms != 0 || stats.max_delay_ms != 0;
1374
1375     receive_stats_filled_["CName"] |= stats.c_name == expected_cname_;
1376
1377     for (std::map<uint32_t, StreamStats>::const_iterator it =
1378              stats.substreams.begin();
1379          it != stats.substreams.end();
1380          ++it) {
1381       EXPECT_TRUE(expected_send_ssrcs_.find(it->first) !=
1382                   expected_send_ssrcs_.end());
1383
1384       send_stats_filled_[CompoundKey("IncomingRate", it->first)] |=
1385           stats.input_frame_rate != 0;
1386
1387       const StreamStats& stream_stats = it->second;
1388
1389       send_stats_filled_[CompoundKey("StatisticsUpdated", it->first)] |=
1390           stream_stats.rtcp_stats.cumulative_lost != 0 ||
1391           stream_stats.rtcp_stats.extended_max_sequence_number != 0 ||
1392           stream_stats.rtcp_stats.fraction_lost != 0;
1393
1394       send_stats_filled_[CompoundKey("DataCountersUpdated", it->first)] |=
1395           stream_stats.rtp_stats.fec_packets != 0 ||
1396           stream_stats.rtp_stats.padding_bytes != 0 ||
1397           stream_stats.rtp_stats.retransmitted_packets != 0 ||
1398           stream_stats.rtp_stats.packets != 0;
1399
1400       send_stats_filled_[CompoundKey("BitrateStatisticsObserver", it->first)] |=
1401           stream_stats.bitrate_bps != 0;
1402
1403       send_stats_filled_[CompoundKey("FrameCountObserver", it->first)] |=
1404           stream_stats.delta_frames != 0 || stream_stats.key_frames != 0;
1405
1406       send_stats_filled_[CompoundKey("OutgoingRate", it->first)] |=
1407           stats.encode_frame_rate != 0;
1408     }
1409
1410     return AllStatsFilled(send_stats_filled_);
1411   }
1412
1413   std::string CompoundKey(const char* name, uint32_t ssrc) {
1414     std::ostringstream oss;
1415     oss << name << "_" << ssrc;
1416     return oss.str();
1417   }
1418
1419   bool AllStatsFilled(const std::map<std::string, bool>& stats_map) {
1420     for (std::map<std::string, bool>::const_iterator it = stats_map.begin();
1421          it != stats_map.end();
1422          ++it) {
1423       if (!it->second)
1424         return false;
1425     }
1426     return true;
1427   }
1428
1429   VideoReceiveStream* receive_stream_;
1430   std::map<std::string, bool> receive_stats_filled_;
1431
1432   VideoSendStream* send_stream_;
1433   std::map<std::string, bool> send_stats_filled_;
1434
1435   uint32_t expected_receive_ssrc_;
1436   std::set<uint32_t> expected_send_ssrcs_;
1437   std::string expected_cname_;
1438
1439   scoped_ptr<EventWrapper> check_stats_event_;
1440 };
1441
1442 TEST_F(CallTest, GetStats) {
1443   StatsObserver observer;
1444
1445   CreateCalls(Call::Config(observer.SendTransport()),
1446               Call::Config(observer.ReceiveTransport()));
1447
1448   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
1449
1450   CreateTestConfigs();
1451   send_config_.pre_encode_callback = &observer;  // Used to inject delay.
1452   send_config_.rtp.c_name = "SomeCName";
1453
1454   observer.SetExpectedReceiveSsrc(receive_config_.rtp.local_ssrc);
1455   observer.SetExpectedSendSsrcs(send_config_.rtp.ssrcs);
1456   observer.SetExpectedCName(send_config_.rtp.c_name);
1457
1458   CreateStreams();
1459   observer.SetReceiveStream(receive_stream_);
1460   observer.SetSendStream(send_stream_);
1461   CreateFrameGenerator();
1462   StartSending();
1463
1464   observer.WaitForFilledStats();
1465
1466   StopSending();
1467   observer.StopSending();
1468   DestroyStreams();
1469 }
1470
1471 TEST_F(CallTest, ReceiverReferenceTimeReportEnabled) {
1472   TestXrReceiverReferenceTimeReport(true);
1473 }
1474
1475 TEST_F(CallTest, ReceiverReferenceTimeReportDisabled) {
1476   TestXrReceiverReferenceTimeReport(false);
1477 }
1478 }  // namespace webrtc