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/modules/video_coding/codecs/vp8/include/vp8.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/encoder_settings.h"
  29 #include "webrtc/test/fake_audio_device.h"
  30 #include "webrtc/test/fake_decoder.h"
  31 #include "webrtc/test/fake_encoder.h"
  32 #include "webrtc/test/frame_generator.h"
  33 #include "webrtc/test/frame_generator_capturer.h"
  34 #include "webrtc/test/null_transport.h"
  35 #include "webrtc/test/rtp_rtcp_observer.h"
  36 #include "webrtc/test/testsupport/fileutils.h"
  37 #include "webrtc/test/testsupport/perf_test.h"
  38 #include "webrtc/video/transport_adapter.h"
  39
  40 namespace webrtc {
  41
  42 static unsigned int kDefaultTimeoutMs = 30 * 1000;
  43 static unsigned int kLongTimeoutMs = 120 * 1000;
  44 static const uint32_t kSendSsrc = 0x654321;
  45 static const uint32_t kSendRtxSsrc = 0x424242;
  46 static const uint32_t kReceiverLocalSsrc = 0x123456;
  47 static const uint8_t kSendPayloadType = 125;
  48 static const uint8_t kSendRtxPayloadType = 126;
  49 static const int kRedPayloadType = 118;
  50 static const int kUlpfecPayloadType = 119;
  51
  52 class CallTest : public ::testing::Test {
  53  public:
  54   CallTest()
  55       : send_stream_(NULL),
  56         receive_stream_(NULL),
  57         fake_encoder_(Clock::GetRealTimeClock()) {}
  58
  59   virtual ~CallTest() {
  60     EXPECT_EQ(NULL, send_stream_);
  61     EXPECT_EQ(NULL, receive_stream_);
  62   }
  63
  64  protected:
  65   void CreateCalls(const Call::Config& sender_config,
  66                    const Call::Config& receiver_config) {
  67     sender_call_.reset(Call::Create(sender_config));
  68     receiver_call_.reset(Call::Create(receiver_config));
  69   }
  70
  71   void CreateTestConfigs() {
  72     send_config_ = sender_call_->GetDefaultSendConfig();
  73     receive_config_ = receiver_call_->GetDefaultReceiveConfig();
  74
  75     send_config_.rtp.ssrcs.push_back(kSendSsrc);
  76     send_config_.encoder_settings = test::CreateEncoderSettings(
  77         &fake_encoder_, "FAKE", kSendPayloadType, 1);
  78
  79     assert(receive_config_.codecs.empty());
  80     VideoCodec codec =
  81         test::CreateDecoderVideoCodec(send_config_.encoder_settings);
  82     receive_config_.codecs.push_back(codec);
  83     ExternalVideoDecoder decoder;
  84     decoder.decoder = &fake_decoder_;
  85     decoder.payload_type = send_config_.encoder_settings.payload_type;
  86     receive_config_.external_decoders.push_back(decoder);
  87     receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
  88     receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
  89   }
  90
  91   void CreateStreams() {
  92     assert(send_stream_ == NULL);
  93     assert(receive_stream_ == NULL);
  94
  95     send_stream_ = sender_call_->CreateVideoSendStream(send_config_);
  96     receive_stream_ = receiver_call_->CreateVideoReceiveStream(receive_config_);
  97   }
  98
  99   void CreateFrameGenerator() {
 100     frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
 101         send_stream_->Input(),
 102         send_config_.encoder_settings.streams[0].width,
 103         send_config_.encoder_settings.streams[0].height,
 104         30,
 105         Clock::GetRealTimeClock()));
 106   }
 107
 108   void StartSending() {
 109     receive_stream_->Start();
 110     send_stream_->Start();
 111     if (frame_generator_capturer_.get() != NULL)
 112       frame_generator_capturer_->Start();
 113   }
 114
 115   void StopSending() {
 116     if (frame_generator_capturer_.get() != NULL)
 117       frame_generator_capturer_->Stop();
 118     if (send_stream_ != NULL)
 119       send_stream_->Stop();
 120     if (receive_stream_ != NULL)
 121       receive_stream_->Stop();
 122   }
 123
 124   void DestroyStreams() {
 125     if (send_stream_ != NULL)
 126       sender_call_->DestroyVideoSendStream(send_stream_);
 127     if (receive_stream_ != NULL)
 128       receiver_call_->DestroyVideoReceiveStream(receive_stream_);
 129     send_stream_ = NULL;
 130     receive_stream_ = NULL;
 131   }
 132
 133   void DecodesRetransmittedFrame(bool retransmit_over_rtx);
 134   void ReceivesPliAndRecovers(int rtp_history_ms);
 135   void RespectsRtcpMode(newapi::RtcpMode rtcp_mode);
 136   void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
 137
 138   scoped_ptr<Call> sender_call_;
 139   scoped_ptr<Call> receiver_call_;
 140
 141   VideoSendStream::Config send_config_;
 142   VideoReceiveStream::Config receive_config_;
 143
 144   VideoSendStream* send_stream_;
 145   VideoReceiveStream* receive_stream_;
 146
 147   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
 148
 149   test::FakeEncoder fake_encoder_;
 150   test::FakeDecoder fake_decoder_;
 151 };
 152
 153 class NackObserver : public test::RtpRtcpObserver {
 154   static const int kNumberOfNacksToObserve = 2;
 155   static const int kLossBurstSize = 2;
 156   static const int kPacketsBetweenLossBursts = 9;
 157
 158  public:
 159   NackObserver()
 160       : test::RtpRtcpObserver(kLongTimeoutMs),
 161         rtp_parser_(RtpHeaderParser::Create()),
 162         sent_rtp_packets_(0),
 163         packets_left_to_drop_(0),
 164         nacks_left_(kNumberOfNacksToObserve) {}
 165
 166  private:
 167   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 168     RTPHeader header;
 169     EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
 170
 171     // Never drop retransmitted packets.
 172     if (dropped_packets_.find(header.sequenceNumber) !=
 173         dropped_packets_.end()) {
 174       retransmitted_packets_.insert(header.sequenceNumber);
 175       if (nacks_left_ == 0 &&
 176           retransmitted_packets_.size() == dropped_packets_.size()) {
 177         observation_complete_->Set();
 178       }
 179       return SEND_PACKET;
 180     }
 181
 182     ++sent_rtp_packets_;
 183
 184     // Enough NACKs received, stop dropping packets.
 185     if (nacks_left_ == 0)
 186       return SEND_PACKET;
 187
 188     // Check if it's time for a new loss burst.
 189     if (sent_rtp_packets_ % kPacketsBetweenLossBursts == 0)
 190       packets_left_to_drop_ = kLossBurstSize;
 191
 192     if (packets_left_to_drop_ > 0) {
 193       --packets_left_to_drop_;
 194       dropped_packets_.insert(header.sequenceNumber);
 195       return DROP_PACKET;
 196     }
 197
 198     return SEND_PACKET;
 199   }
 200
 201   virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 202     RTCPUtility::RTCPParserV2 parser(packet, length, true);
 203     EXPECT_TRUE(parser.IsValid());
 204
 205     RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 206     while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 207       if (packet_type == RTCPUtility::kRtcpRtpfbNackCode) {
 208         --nacks_left_;
 209         break;
 210       }
 211       packet_type = parser.Iterate();
 212     }
 213     return SEND_PACKET;
 214   }
 215
 216  private:
 217   scoped_ptr<RtpHeaderParser> rtp_parser_;
 218   std::set<uint16_t> dropped_packets_;
 219   std::set<uint16_t> retransmitted_packets_;
 220   uint64_t sent_rtp_packets_;
 221   int packets_left_to_drop_;
 222   int nacks_left_;
 223 };
 224
 225 TEST_F(CallTest, ReceiverCanBeStartedTwice) {
 226   test::NullTransport transport;
 227   CreateCalls(Call::Config(&transport), Call::Config(&transport));
 228
 229   CreateTestConfigs();
 230   CreateStreams();
 231
 232   receive_stream_->Start();
 233   receive_stream_->Start();
 234
 235   DestroyStreams();
 236 }
 237
 238 TEST_F(CallTest, ReceiverCanBeStoppedTwice) {
 239   test::NullTransport transport;
 240   CreateCalls(Call::Config(&transport), Call::Config(&transport));
 241
 242   CreateTestConfigs();
 243   CreateStreams();
 244
 245   receive_stream_->Stop();
 246   receive_stream_->Stop();
 247
 248   DestroyStreams();
 249 }
 250
 251 TEST_F(CallTest, RendersSingleDelayedFrame) {
 252   static const int kWidth = 320;
 253   static const int kHeight = 240;
 254   // This constant is chosen to be higher than the timeout in the video_render
 255   // module. This makes sure that frames aren't dropped if there are no other
 256   // frames in the queue.
 257   static const int kDelayRenderCallbackMs = 1000;
 258
 259   class Renderer : public VideoRenderer {
 260    public:
 261     Renderer() : event_(EventWrapper::Create()) {}
 262
 263     virtual void RenderFrame(const I420VideoFrame& video_frame,
 264                              int /*time_to_render_ms*/) OVERRIDE {
 265       event_->Set();
 266     }
 267
 268     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 269
 270     scoped_ptr<EventWrapper> event_;
 271   } renderer;
 272
 273   class TestFrameCallback : public I420FrameCallback {
 274    public:
 275     TestFrameCallback() : event_(EventWrapper::Create()) {}
 276
 277     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 278
 279    private:
 280     virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE {
 281       SleepMs(kDelayRenderCallbackMs);
 282       event_->Set();
 283     }
 284
 285     scoped_ptr<EventWrapper> event_;
 286   };
 287
 288   test::DirectTransport sender_transport, receiver_transport;
 289
 290   CreateCalls(Call::Config(&sender_transport),
 291               Call::Config(&receiver_transport));
 292
 293   sender_transport.SetReceiver(receiver_call_->Receiver());
 294   receiver_transport.SetReceiver(sender_call_->Receiver());
 295
 296   CreateTestConfigs();
 297
 298   TestFrameCallback pre_render_callback;
 299   receive_config_.pre_render_callback = &pre_render_callback;
 300   receive_config_.renderer = &renderer;
 301
 302   CreateStreams();
 303   StartSending();
 304
 305   // Create frames that are smaller than the send width/height, this is done to
 306   // check that the callbacks are done after processing video.
 307   scoped_ptr<test::FrameGenerator> frame_generator(
 308       test::FrameGenerator::Create(kWidth, kHeight));
 309   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 310   EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
 311       << "Timed out while waiting for pre-render callback.";
 312   EXPECT_EQ(kEventSignaled, renderer.Wait())
 313       << "Timed out while waiting for the frame to render.";
 314
 315   StopSending();
 316
 317   sender_transport.StopSending();
 318   receiver_transport.StopSending();
 319
 320   DestroyStreams();
 321 }
 322
 323 TEST_F(CallTest, TransmitsFirstFrame) {
 324   class Renderer : public VideoRenderer {
 325    public:
 326     Renderer() : event_(EventWrapper::Create()) {}
 327
 328     virtual void RenderFrame(const I420VideoFrame& video_frame,
 329                              int /*time_to_render_ms*/) OVERRIDE {
 330       event_->Set();
 331     }
 332
 333     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 334
 335     scoped_ptr<EventWrapper> event_;
 336   } renderer;
 337
 338   test::DirectTransport sender_transport, receiver_transport;
 339
 340   CreateCalls(Call::Config(&sender_transport),
 341               Call::Config(&receiver_transport));
 342
 343   sender_transport.SetReceiver(receiver_call_->Receiver());
 344   receiver_transport.SetReceiver(sender_call_->Receiver());
 345
 346   CreateTestConfigs();
 347   receive_config_.renderer = &renderer;
 348
 349   CreateStreams();
 350   StartSending();
 351
 352   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
 353       send_config_.encoder_settings.streams[0].width,
 354       send_config_.encoder_settings.streams[0].height));
 355   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 356
 357   EXPECT_EQ(kEventSignaled, renderer.Wait())
 358       << "Timed out while waiting for the frame to render.";
 359
 360   StopSending();
 361
 362   sender_transport.StopSending();
 363   receiver_transport.StopSending();
 364
 365   DestroyStreams();
 366 }
 367
 368 TEST_F(CallTest, ReceiverUsesLocalSsrc) {
 369   class SyncRtcpObserver : public test::RtpRtcpObserver {
 370    public:
 371     SyncRtcpObserver() : test::RtpRtcpObserver(kDefaultTimeoutMs) {}
 372
 373     virtual Action OnReceiveRtcp(const uint8_t* packet,
 374                                  size_t length) OVERRIDE {
 375       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 376       EXPECT_TRUE(parser.IsValid());
 377       uint32_t ssrc = 0;
 378       ssrc |= static_cast<uint32_t>(packet[4]) << 24;
 379       ssrc |= static_cast<uint32_t>(packet[5]) << 16;
 380       ssrc |= static_cast<uint32_t>(packet[6]) << 8;
 381       ssrc |= static_cast<uint32_t>(packet[7]) << 0;
 382       EXPECT_EQ(kReceiverLocalSsrc, ssrc);
 383       observation_complete_->Set();
 384
 385       return SEND_PACKET;
 386     }
 387   } observer;
 388
 389   CreateCalls(Call::Config(observer.SendTransport()),
 390               Call::Config(observer.ReceiveTransport()));
 391
 392   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 393
 394   CreateTestConfigs();
 395
 396   CreateStreams();
 397   CreateFrameGenerator();
 398   StartSending();
 399
 400   EXPECT_EQ(kEventSignaled, observer.Wait())
 401       << "Timed out while waiting for a receiver RTCP packet to be sent.";
 402
 403   StopSending();
 404
 405   observer.StopSending();
 406
 407   DestroyStreams();
 408 }
 409
 410 TEST_F(CallTest, ReceivesAndRetransmitsNack) {
 411   NackObserver observer;
 412
 413   CreateCalls(Call::Config(observer.SendTransport()),
 414               Call::Config(observer.ReceiveTransport()));
 415
 416   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 417
 418   CreateTestConfigs();
 419   int rtp_history_ms = 1000;
 420   send_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 421   receive_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 422
 423   CreateStreams();
 424   CreateFrameGenerator();
 425   StartSending();
 426
 427   // Wait() waits for an event triggered when NACKs have been received, NACKed
 428   // packets retransmitted and frames rendered again.
 429   EXPECT_EQ(kEventSignaled, observer.Wait());
 430
 431   StopSending();
 432
 433   observer.StopSending();
 434
 435   DestroyStreams();
 436 }
 437
 438 // TODO(pbos): Flaky, webrtc:3269
 439 TEST_F(CallTest, DISABLED_CanReceiveFec) {
 440   class FecRenderObserver : public test::RtpRtcpObserver, public VideoRenderer {
 441    public:
 442     FecRenderObserver()
 443         : RtpRtcpObserver(kDefaultTimeoutMs),
 444           state_(kFirstPacket),
 445           protected_sequence_number_(0),
 446           protected_frame_timestamp_(0) {}
 447
 448    private:
 449     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE
 450         EXCLUSIVE_LOCKS_REQUIRED(crit_) {
 451       RTPHeader header;
 452       EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
 453
 454       EXPECT_EQ(kRedPayloadType, header.payloadType);
 455       int encapsulated_payload_type =
 456           static_cast<int>(packet[header.headerLength]);
 457       if (encapsulated_payload_type != kSendPayloadType)
 458         EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type);
 459
 460       switch(state_) {
 461         case kFirstPacket:
 462           state_ = kDropEveryOtherPacketUntilFec;
 463           break;
 464         case kDropEveryOtherPacketUntilFec:
 465           if (encapsulated_payload_type == kUlpfecPayloadType) {
 466             state_ = kDropNextMediaPacket;
 467             return SEND_PACKET;
 468           }
 469           if (header.sequenceNumber % 2 == 0)
 470             return DROP_PACKET;
 471           break;
 472         case kDropNextMediaPacket:
 473           if (encapsulated_payload_type == kSendPayloadType) {
 474             protected_sequence_number_ = header.sequenceNumber;
 475             protected_frame_timestamp_ = header.timestamp;
 476             state_ = kProtectedPacketDropped;
 477             return DROP_PACKET;
 478           }
 479           break;
 480         case kProtectedPacketDropped:
 481           EXPECT_NE(header.sequenceNumber, protected_sequence_number_)
 482               << "Protected packet retransmitted. Should not happen with FEC.";
 483           break;
 484       }
 485
 486       return SEND_PACKET;
 487     }
 488
 489     virtual void RenderFrame(const I420VideoFrame& video_frame,
 490                              int time_to_render_ms) OVERRIDE {
 491       CriticalSectionScoped lock(crit_.get());
 492       // Rendering frame with timestamp associated with dropped packet -> FEC
 493       // protection worked.
 494       if (state_ == kProtectedPacketDropped &&
 495           video_frame.timestamp() == protected_frame_timestamp_) {
 496         observation_complete_->Set();
 497       }
 498     }
 499
 500     enum {
 501       kFirstPacket,
 502       kDropEveryOtherPacketUntilFec,
 503       kDropNextMediaPacket,
 504       kProtectedPacketDropped,
 505     } state_;
 506
 507     uint32_t protected_sequence_number_ GUARDED_BY(crit_);
 508     uint32_t protected_frame_timestamp_ GUARDED_BY(crit_);
 509   } observer;
 510
 511   CreateCalls(Call::Config(observer.SendTransport()),
 512               Call::Config(observer.ReceiveTransport()));
 513
 514   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 515
 516   CreateTestConfigs();
 517   // TODO(pbos): Run this test with combined NACK/FEC enabled as well.
 518   // int rtp_history_ms = 1000;
 519   // receive_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 520   // send_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 521   send_config_.rtp.fec.red_payload_type = kRedPayloadType;
 522   send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 523
 524   receive_config_.rtp.fec.red_payload_type = kRedPayloadType;
 525   receive_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 526   receive_config_.renderer = &observer;
 527
 528   CreateStreams();
 529   CreateFrameGenerator();
 530   StartSending();
 531
 532   // Wait() waits for an event triggered when NACKs have been received, NACKed
 533   // packets retransmitted and frames rendered again.
 534   EXPECT_EQ(kEventSignaled, observer.Wait());
 535
 536   StopSending();
 537
 538   observer.StopSending();
 539
 540   DestroyStreams();
 541 }
 542
 543 // This test drops second RTP packet with a marker bit set, makes sure it's
 544 // retransmitted and renders. Retransmission SSRCs are also checked.
 545 void CallTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) {
 546   static const int kDroppedFrameNumber = 2;
 547   class RetransmissionObserver : public test::RtpRtcpObserver,
 548                                  public I420FrameCallback {
 549    public:
 550     RetransmissionObserver(bool expect_rtx)
 551         : RtpRtcpObserver(kDefaultTimeoutMs),
 552           retransmission_ssrc_(expect_rtx ? kSendRtxSsrc : kSendSsrc),
 553           retransmission_payload_type_(expect_rtx ? kSendRtxPayloadType
 554                                                   : kSendPayloadType),
 555           marker_bits_observed_(0),
 556           retransmitted_timestamp_(0),
 557           frame_retransmitted_(false) {}
 558
 559    private:
 560     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 561       RTPHeader header;
 562       EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
 563
 564       if (header.timestamp == retransmitted_timestamp_) {
 565         EXPECT_EQ(retransmission_ssrc_, header.ssrc);
 566         EXPECT_EQ(retransmission_payload_type_, header.payloadType);
 567         frame_retransmitted_ = true;
 568         return SEND_PACKET;
 569       }
 570
 571       EXPECT_EQ(kSendSsrc, header.ssrc);
 572       EXPECT_EQ(kSendPayloadType, header.payloadType);
 573
 574       // Found the second frame's final packet, drop this and expect a
 575       // retransmission.
 576       if (header.markerBit && ++marker_bits_observed_ == kDroppedFrameNumber) {
 577         retransmitted_timestamp_ = header.timestamp;
 578         return DROP_PACKET;
 579       }
 580
 581       return SEND_PACKET;
 582     }
 583
 584     virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE {
 585       CriticalSectionScoped lock(crit_.get());
 586       if (frame->timestamp() == retransmitted_timestamp_) {
 587         EXPECT_TRUE(frame_retransmitted_);
 588         observation_complete_->Set();
 589       }
 590     }
 591
 592     const uint32_t retransmission_ssrc_;
 593     const int retransmission_payload_type_;
 594     int marker_bits_observed_;
 595     uint32_t retransmitted_timestamp_;
 596     bool frame_retransmitted_;
 597   } observer(retransmit_over_rtx);
 598
 599   CreateCalls(Call::Config(observer.SendTransport()),
 600               Call::Config(observer.ReceiveTransport()));
 601
 602   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 603
 604   CreateTestConfigs();
 605   send_config_.rtp.nack.rtp_history_ms =
 606       receive_config_.rtp.nack.rtp_history_ms = 1000;
 607   if (retransmit_over_rtx) {
 608     send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrc);
 609     send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
 610     int payload_type = send_config_.encoder_settings.payload_type;
 611     receive_config_.rtp.rtx[payload_type].ssrc = kSendRtxSsrc;
 612     receive_config_.rtp.rtx[payload_type].payload_type = kSendRtxPayloadType;
 613   }
 614   receive_config_.pre_render_callback = &observer;
 615
 616   CreateStreams();
 617   CreateFrameGenerator();
 618   StartSending();
 619
 620   EXPECT_EQ(kEventSignaled, observer.Wait())
 621       << "Timed out while waiting for retransmission to render.";
 622
 623   StopSending();
 624   observer.StopSending();
 625   DestroyStreams();
 626 }
 627
 628 TEST_F(CallTest, DecodesRetransmittedFrame) {
 629   DecodesRetransmittedFrame(false);
 630 }
 631
 632 TEST_F(CallTest, DecodesRetransmittedFrameOverRtx) {
 633   DecodesRetransmittedFrame(true);
 634 }
 635
 636 TEST_F(CallTest, UsesFrameCallbacks) {
 637   static const int kWidth = 320;
 638   static const int kHeight = 240;
 639
 640   class Renderer : public VideoRenderer {
 641    public:
 642     Renderer() : event_(EventWrapper::Create()) {}
 643
 644     virtual void RenderFrame(const I420VideoFrame& video_frame,
 645                              int /*time_to_render_ms*/) OVERRIDE {
 646       EXPECT_EQ(0, *video_frame.buffer(kYPlane))
 647           << "Rendered frame should have zero luma which is applied by the "
 648              "pre-render callback.";
 649       event_->Set();
 650     }
 651
 652     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 653     scoped_ptr<EventWrapper> event_;
 654   } renderer;
 655
 656   class TestFrameCallback : public I420FrameCallback {
 657    public:
 658     TestFrameCallback(int expected_luma_byte, int next_luma_byte)
 659         : event_(EventWrapper::Create()),
 660           expected_luma_byte_(expected_luma_byte),
 661           next_luma_byte_(next_luma_byte) {}
 662
 663     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 664
 665    private:
 666     virtual void FrameCallback(I420VideoFrame* frame) {
 667       EXPECT_EQ(kWidth, frame->width())
 668           << "Width not as expected, callback done before resize?";
 669       EXPECT_EQ(kHeight, frame->height())
 670           << "Height not as expected, callback done before resize?";
 671
 672       // Previous luma specified, observed luma should be fairly close.
 673       if (expected_luma_byte_ != -1) {
 674         EXPECT_NEAR(expected_luma_byte_, *frame->buffer(kYPlane), 10);
 675       }
 676
 677       memset(frame->buffer(kYPlane),
 678              next_luma_byte_,
 679              frame->allocated_size(kYPlane));
 680
 681       event_->Set();
 682     }
 683
 684     scoped_ptr<EventWrapper> event_;
 685     int expected_luma_byte_;
 686     int next_luma_byte_;
 687   };
 688
 689   TestFrameCallback pre_encode_callback(-1, 255);  // Changes luma to 255.
 690   TestFrameCallback pre_render_callback(255, 0);  // Changes luma from 255 to 0.
 691
 692   test::DirectTransport sender_transport, receiver_transport;
 693
 694   CreateCalls(Call::Config(&sender_transport),
 695               Call::Config(&receiver_transport));
 696
 697   sender_transport.SetReceiver(receiver_call_->Receiver());
 698   receiver_transport.SetReceiver(sender_call_->Receiver());
 699
 700   CreateTestConfigs();
 701   scoped_ptr<VP8Encoder> encoder(VP8Encoder::Create());
 702   send_config_.encoder_settings.encoder = encoder.get();
 703   send_config_.encoder_settings.payload_name = "VP8";
 704   ASSERT_EQ(1u, send_config_.encoder_settings.streams.size())
 705       << "Test setup error.";
 706   send_config_.encoder_settings.streams[0].width = kWidth;
 707   send_config_.encoder_settings.streams[0].height = kHeight;
 708   send_config_.pre_encode_callback = &pre_encode_callback;
 709   receive_config_.codecs.clear();
 710   VideoCodec codec =
 711       test::CreateDecoderVideoCodec(send_config_.encoder_settings);
 712   receive_config_.external_decoders.clear();
 713   receive_config_.codecs.push_back(codec);
 714   receive_config_.pre_render_callback = &pre_render_callback;
 715   receive_config_.renderer = &renderer;
 716
 717   CreateStreams();
 718   StartSending();
 719
 720   // Create frames that are smaller than the send width/height, this is done to
 721   // check that the callbacks are done after processing video.
 722   scoped_ptr<test::FrameGenerator> frame_generator(
 723       test::FrameGenerator::Create(kWidth / 2, kHeight / 2));
 724   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 725
 726   EXPECT_EQ(kEventSignaled, pre_encode_callback.Wait())
 727       << "Timed out while waiting for pre-encode callback.";
 728   EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
 729       << "Timed out while waiting for pre-render callback.";
 730   EXPECT_EQ(kEventSignaled, renderer.Wait())
 731       << "Timed out while waiting for the frame to render.";
 732
 733   StopSending();
 734
 735   sender_transport.StopSending();
 736   receiver_transport.StopSending();
 737
 738   DestroyStreams();
 739 }
 740
 741 class PliObserver : public test::RtpRtcpObserver, public VideoRenderer {
 742   static const int kInverseDropProbability = 16;
 743
 744  public:
 745   explicit PliObserver(bool nack_enabled)
 746       : test::RtpRtcpObserver(kLongTimeoutMs),
 747         nack_enabled_(nack_enabled),
 748         highest_dropped_timestamp_(0),
 749         frames_to_drop_(0),
 750         received_pli_(false) {}
 751
 752   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 753     RTPHeader header;
 754     EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
 755
 756     // Drop all retransmitted packets to force a PLI.
 757     if (header.timestamp <= highest_dropped_timestamp_)
 758       return DROP_PACKET;
 759
 760     if (frames_to_drop_ > 0) {
 761       highest_dropped_timestamp_ = header.timestamp;
 762       --frames_to_drop_;
 763       return DROP_PACKET;
 764     }
 765
 766     return SEND_PACKET;
 767   }
 768
 769   virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 770     RTCPUtility::RTCPParserV2 parser(packet, length, true);
 771     EXPECT_TRUE(parser.IsValid());
 772
 773     for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 774          packet_type != RTCPUtility::kRtcpNotValidCode;
 775          packet_type = parser.Iterate()) {
 776       if (!nack_enabled_)
 777         EXPECT_NE(packet_type, RTCPUtility::kRtcpRtpfbNackCode);
 778
 779       if (packet_type == RTCPUtility::kRtcpPsfbPliCode) {
 780         received_pli_ = true;
 781         break;
 782       }
 783     }
 784     return SEND_PACKET;
 785   }
 786
 787   virtual void RenderFrame(const I420VideoFrame& video_frame,
 788                            int time_to_render_ms) OVERRIDE {
 789     CriticalSectionScoped lock(crit_.get());
 790     if (received_pli_ && video_frame.timestamp() > highest_dropped_timestamp_) {
 791       observation_complete_->Set();
 792     }
 793     if (!received_pli_)
 794       frames_to_drop_ = kPacketsToDrop;
 795   }
 796
 797  private:
 798   static const int kPacketsToDrop = 1;
 799
 800   bool nack_enabled_;
 801   uint32_t highest_dropped_timestamp_;
 802   int frames_to_drop_;
 803   bool received_pli_;
 804 };
 805
 806 void CallTest::ReceivesPliAndRecovers(int rtp_history_ms) {
 807   PliObserver observer(rtp_history_ms > 0);
 808
 809   CreateCalls(Call::Config(observer.SendTransport()),
 810               Call::Config(observer.ReceiveTransport()));
 811
 812   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 813
 814   CreateTestConfigs();
 815   send_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 816   receive_config_.rtp.nack.rtp_history_ms = rtp_history_ms;
 817   receive_config_.renderer = &observer;
 818
 819   CreateStreams();
 820   CreateFrameGenerator();
 821   StartSending();
 822
 823   // Wait() waits for an event triggered when Pli has been received and frames
 824   // have been rendered afterwards.
 825   EXPECT_EQ(kEventSignaled, observer.Wait());
 826
 827   StopSending();
 828
 829   observer.StopSending();
 830
 831   DestroyStreams();
 832 }
 833
 834 TEST_F(CallTest, ReceivesPliAndRecoversWithNack) {
 835   ReceivesPliAndRecovers(1000);
 836 }
 837
 838 // TODO(pbos): Enable this when 2250 is resolved.
 839 TEST_F(CallTest, DISABLED_ReceivesPliAndRecoversWithoutNack) {
 840   ReceivesPliAndRecovers(0);
 841 }
 842
 843 TEST_F(CallTest, SurvivesIncomingRtpPacketsToDestroyedReceiveStream) {
 844   class PacketInputObserver : public PacketReceiver {
 845    public:
 846     explicit PacketInputObserver(PacketReceiver* receiver)
 847         : receiver_(receiver), delivered_packet_(EventWrapper::Create()) {}
 848
 849     EventTypeWrapper Wait() {
 850       return delivered_packet_->Wait(kDefaultTimeoutMs);
 851     }
 852
 853    private:
 854     virtual bool DeliverPacket(const uint8_t* packet, size_t length) {
 855       if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length))) {
 856         return receiver_->DeliverPacket(packet, length);
 857       } else {
 858         EXPECT_FALSE(receiver_->DeliverPacket(packet, length));
 859         delivered_packet_->Set();
 860         return false;
 861       }
 862     }
 863
 864     PacketReceiver* receiver_;
 865     scoped_ptr<EventWrapper> delivered_packet_;
 866   };
 867
 868   test::DirectTransport send_transport, receive_transport;
 869
 870   CreateCalls(Call::Config(&send_transport), Call::Config(&receive_transport));
 871   PacketInputObserver input_observer(receiver_call_->Receiver());
 872
 873   send_transport.SetReceiver(&input_observer);
 874   receive_transport.SetReceiver(sender_call_->Receiver());
 875
 876   CreateTestConfigs();
 877
 878   CreateStreams();
 879   CreateFrameGenerator();
 880   StartSending();
 881
 882   receiver_call_->DestroyVideoReceiveStream(receive_stream_);
 883   receive_stream_ = NULL;
 884
 885   // Wait() waits for a received packet.
 886   EXPECT_EQ(kEventSignaled, input_observer.Wait());
 887
 888   StopSending();
 889
 890   DestroyStreams();
 891
 892   send_transport.StopSending();
 893   receive_transport.StopSending();
 894 }
 895
 896 void CallTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
 897   static const int kRtpHistoryMs = 1000;
 898   static const int kNumCompoundRtcpPacketsToObserve = 10;
 899   class RtcpModeObserver : public test::RtpRtcpObserver {
 900    public:
 901     explicit RtcpModeObserver(newapi::RtcpMode rtcp_mode)
 902         : test::RtpRtcpObserver(kDefaultTimeoutMs),
 903           rtcp_mode_(rtcp_mode),
 904           sent_rtp_(0),
 905           sent_rtcp_(0) {}
 906
 907    private:
 908     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 909       if (++sent_rtp_ % 3 == 0)
 910         return DROP_PACKET;
 911
 912       return SEND_PACKET;
 913     }
 914
 915     virtual Action OnReceiveRtcp(const uint8_t* packet,
 916                                  size_t length) OVERRIDE {
 917       ++sent_rtcp_;
 918       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 919       EXPECT_TRUE(parser.IsValid());
 920
 921       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 922       bool has_report_block = false;
 923       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 924         EXPECT_NE(RTCPUtility::kRtcpSrCode, packet_type);
 925         if (packet_type == RTCPUtility::kRtcpRrCode) {
 926           has_report_block = true;
 927           break;
 928         }
 929         packet_type = parser.Iterate();
 930       }
 931
 932       switch (rtcp_mode_) {
 933         case newapi::kRtcpCompound:
 934           if (!has_report_block) {
 935             ADD_FAILURE() << "Received RTCP packet without receiver report for "
 936                              "kRtcpCompound.";
 937             observation_complete_->Set();
 938           }
 939
 940           if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
 941             observation_complete_->Set();
 942
 943           break;
 944         case newapi::kRtcpReducedSize:
 945           if (!has_report_block)
 946             observation_complete_->Set();
 947           break;
 948       }
 949
 950       return SEND_PACKET;
 951     }
 952
 953     newapi::RtcpMode rtcp_mode_;
 954     int sent_rtp_;
 955     int sent_rtcp_;
 956   } observer(rtcp_mode);
 957
 958   CreateCalls(Call::Config(observer.SendTransport()),
 959               Call::Config(observer.ReceiveTransport()));
 960
 961   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 962
 963   CreateTestConfigs();
 964   send_config_.rtp.nack.rtp_history_ms = kRtpHistoryMs;
 965   receive_config_.rtp.nack.rtp_history_ms = kRtpHistoryMs;
 966   receive_config_.rtp.rtcp_mode = rtcp_mode;
 967
 968   CreateStreams();
 969   CreateFrameGenerator();
 970   StartSending();
 971
 972   EXPECT_EQ(kEventSignaled, observer.Wait())
 973       << (rtcp_mode == newapi::kRtcpCompound
 974               ? "Timed out before observing enough compound packets."
 975               : "Timed out before receiving a non-compound RTCP packet.");
 976
 977   StopSending();
 978   observer.StopSending();
 979   DestroyStreams();
 980 }
 981
 982 TEST_F(CallTest, UsesRtcpCompoundMode) {
 983   RespectsRtcpMode(newapi::kRtcpCompound);
 984 }
 985
 986 TEST_F(CallTest, UsesRtcpReducedSizeMode) {
 987   RespectsRtcpMode(newapi::kRtcpReducedSize);
 988 }
 989
 990 // Test sets up a Call multiple senders with different resolutions and SSRCs.
 991 // Another is set up to receive all three of these with different renderers.
 992 // Each renderer verifies that it receives the expected resolution, and as soon
 993 // as every renderer has received a frame, the test finishes.
 994 TEST_F(CallTest, SendsAndReceivesMultipleStreams) {
 995   static const size_t kNumStreams = 3;
 996
 997   class VideoOutputObserver : public VideoRenderer {
 998    public:
 999     VideoOutputObserver(test::FrameGeneratorCapturer** capturer,
1000                         int width,
1001                         int height)
1002         : capturer_(capturer),
1003           width_(width),
1004           height_(height),
1005           done_(EventWrapper::Create()) {}
1006
1007     virtual void RenderFrame(const I420VideoFrame& video_frame,
1008                              int time_to_render_ms) OVERRIDE {
1009       EXPECT_EQ(width_, video_frame.width());
1010       EXPECT_EQ(height_, video_frame.height());
1011       (*capturer_)->Stop();
1012       done_->Set();
1013     }
1014
1015     EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); }
1016
1017    private:
1018     test::FrameGeneratorCapturer** capturer_;
1019     int width_;
1020     int height_;
1021     scoped_ptr<EventWrapper> done_;
1022   };
1023
1024   struct {
1025     uint32_t ssrc;
1026     int width;
1027     int height;
1028   } codec_settings[kNumStreams] = {{1, 640, 480}, {2, 320, 240}, {3, 240, 160}};
1029
1030   test::DirectTransport sender_transport, receiver_transport;
1031   scoped_ptr<Call> sender_call(Call::Create(Call::Config(&sender_transport)));
1032   scoped_ptr<Call> receiver_call(
1033       Call::Create(Call::Config(&receiver_transport)));
1034   sender_transport.SetReceiver(receiver_call->Receiver());
1035   receiver_transport.SetReceiver(sender_call->Receiver());
1036
1037   VideoSendStream* send_streams[kNumStreams];
1038   VideoReceiveStream* receive_streams[kNumStreams];
1039
1040   VideoOutputObserver* observers[kNumStreams];
1041   test::FrameGeneratorCapturer* frame_generators[kNumStreams];
1042
1043   scoped_ptr<VP8Encoder> encoders[kNumStreams];
1044   for (size_t i = 0; i < kNumStreams; ++i)
1045     encoders[i].reset(VP8Encoder::Create());
1046
1047   for (size_t i = 0; i < kNumStreams; ++i) {
1048     uint32_t ssrc = codec_settings[i].ssrc;
1049     int width = codec_settings[i].width;
1050     int height = codec_settings[i].height;
1051     observers[i] = new VideoOutputObserver(&frame_generators[i], width, height);
1052
1053     VideoSendStream::Config send_config = sender_call->GetDefaultSendConfig();
1054     send_config.rtp.ssrcs.push_back(ssrc);
1055     send_config.encoder_settings =
1056         test::CreateEncoderSettings(encoders[i].get(), "VP8", 124, 1);
1057     VideoStream* stream = &send_config.encoder_settings.streams[0];
1058     stream->width = width;
1059     stream->height = height;
1060     stream->max_framerate = 5;
1061     stream->min_bitrate_bps = stream->target_bitrate_bps =
1062         stream->max_bitrate_bps = 100000;
1063     send_streams[i] = sender_call->CreateVideoSendStream(send_config);
1064     send_streams[i]->Start();
1065
1066     VideoReceiveStream::Config receive_config =
1067         receiver_call->GetDefaultReceiveConfig();
1068     receive_config.renderer = observers[i];
1069     receive_config.rtp.remote_ssrc = ssrc;
1070     receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
1071     VideoCodec codec =
1072         test::CreateDecoderVideoCodec(send_config.encoder_settings);
1073     receive_config.codecs.push_back(codec);
1074     receive_streams[i] =
1075         receiver_call->CreateVideoReceiveStream(receive_config);
1076     receive_streams[i]->Start();
1077
1078     frame_generators[i] = test::FrameGeneratorCapturer::Create(
1079         send_streams[i]->Input(), width, height, 30, Clock::GetRealTimeClock());
1080     frame_generators[i]->Start();
1081   }
1082
1083   for (size_t i = 0; i < kNumStreams; ++i) {
1084     EXPECT_EQ(kEventSignaled, observers[i]->Wait())
1085         << "Timed out while waiting for observer " << i << " to render.";
1086   }
1087
1088   for (size_t i = 0; i < kNumStreams; ++i) {
1089     frame_generators[i]->Stop();
1090     sender_call->DestroyVideoSendStream(send_streams[i]);
1091     receiver_call->DestroyVideoReceiveStream(receive_streams[i]);
1092     delete frame_generators[i];
1093     delete observers[i];
1094   }
1095
1096   sender_transport.StopSending();
1097   receiver_transport.StopSending();
1098 };
1099
1100 TEST_F(CallTest, ObserversEncodedFrames) {
1101   class EncodedFrameTestObserver : public EncodedFrameObserver {
1102    public:
1103     EncodedFrameTestObserver()
1104         : length_(0),
1105           frame_type_(kFrameEmpty),
1106           called_(EventWrapper::Create()) {}
1107     virtual ~EncodedFrameTestObserver() {}
1108
1109     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
1110       frame_type_ = encoded_frame.frame_type_;
1111       length_ = encoded_frame.length_;
1112       buffer_.reset(new uint8_t[length_]);
1113       memcpy(buffer_.get(), encoded_frame.data_, length_);
1114       called_->Set();
1115     }
1116
1117     EventTypeWrapper Wait() { return called_->Wait(kDefaultTimeoutMs); }
1118
1119     void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
1120       ASSERT_EQ(length_, observer.length_)
1121           << "Observed frames are of different lengths.";
1122       EXPECT_EQ(frame_type_, observer.frame_type_)
1123           << "Observed frames have different frame types.";
1124       EXPECT_EQ(0, memcmp(buffer_.get(), observer.buffer_.get(), length_))
1125           << "Observed encoded frames have different content.";
1126     }
1127
1128    private:
1129     scoped_ptr<uint8_t[]> buffer_;
1130     size_t length_;
1131     FrameType frame_type_;
1132     scoped_ptr<EventWrapper> called_;
1133   };
1134
1135   EncodedFrameTestObserver post_encode_observer;
1136   EncodedFrameTestObserver pre_decode_observer;
1137
1138   test::DirectTransport sender_transport, receiver_transport;
1139
1140   CreateCalls(Call::Config(&sender_transport),
1141               Call::Config(&receiver_transport));
1142
1143   sender_transport.SetReceiver(receiver_call_->Receiver());
1144   receiver_transport.SetReceiver(sender_call_->Receiver());
1145
1146   CreateTestConfigs();
1147   send_config_.post_encode_callback = &post_encode_observer;
1148   receive_config_.pre_decode_callback = &pre_decode_observer;
1149
1150   CreateStreams();
1151   StartSending();
1152
1153   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
1154       send_config_.encoder_settings.streams[0].width,
1155       send_config_.encoder_settings.streams[0].height));
1156   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
1157
1158   EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
1159       << "Timed out while waiting for send-side encoded-frame callback.";
1160
1161   EXPECT_EQ(kEventSignaled, pre_decode_observer.Wait())
1162       << "Timed out while waiting for pre-decode encoded-frame callback.";
1163
1164   post_encode_observer.ExpectEqualFrames(pre_decode_observer);
1165
1166   StopSending();
1167
1168   sender_transport.StopSending();
1169   receiver_transport.StopSending();
1170
1171   DestroyStreams();
1172 }
1173
1174 TEST_F(CallTest, ReceiveStreamSendsRemb) {
1175   class RembObserver : public test::RtpRtcpObserver {
1176    public:
1177     RembObserver() : test::RtpRtcpObserver(kDefaultTimeoutMs) {}
1178
1179     virtual Action OnReceiveRtcp(const uint8_t* packet,
1180                                  size_t length) OVERRIDE {
1181       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1182       EXPECT_TRUE(parser.IsValid());
1183
1184       bool received_psfb = false;
1185       bool received_remb = false;
1186       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1187       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1188         if (packet_type == RTCPUtility::kRtcpPsfbRembCode) {
1189           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1190           EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalSsrc);
1191           received_psfb = true;
1192         } else if (packet_type == RTCPUtility::kRtcpPsfbRembItemCode) {
1193           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1194           EXPECT_GT(packet.REMBItem.BitRate, 0u);
1195           EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
1196           EXPECT_EQ(packet.REMBItem.SSRCs[0], kSendSsrc);
1197           received_remb = true;
1198         }
1199         packet_type = parser.Iterate();
1200       }
1201       if (received_psfb && received_remb)
1202         observation_complete_->Set();
1203       return SEND_PACKET;
1204     }
1205   } observer;
1206
1207   CreateCalls(Call::Config(observer.SendTransport()),
1208               Call::Config(observer.ReceiveTransport()));
1209   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
1210   CreateTestConfigs();
1211   CreateStreams();
1212   CreateFrameGenerator();
1213   StartSending();
1214
1215   EXPECT_EQ(kEventSignaled, observer.Wait())
1216       << "Timed out while waiting for a receiver RTCP REMB packet to be sent.";
1217
1218   StopSending();
1219   observer.StopSending();
1220   DestroyStreams();
1221 }
1222
1223 void CallTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
1224   static const int kNumRtcpReportPacketsToObserve = 5;
1225   class RtcpXrObserver : public test::RtpRtcpObserver {
1226    public:
1227     explicit RtcpXrObserver(bool enable_rrtr)
1228         : test::RtpRtcpObserver(kDefaultTimeoutMs),
1229           enable_rrtr_(enable_rrtr),
1230           sent_rtcp_sr_(0),
1231           sent_rtcp_rr_(0),
1232           sent_rtcp_rrtr_(0),
1233           sent_rtcp_dlrr_(0) {}
1234
1235    private:
1236     // Receive stream should send RR packets (and RRTR packets if enabled).
1237     virtual Action OnReceiveRtcp(const uint8_t* packet,
1238                                  size_t length) OVERRIDE {
1239       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1240       EXPECT_TRUE(parser.IsValid());
1241
1242       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1243       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1244         if (packet_type == RTCPUtility::kRtcpRrCode) {
1245           ++sent_rtcp_rr_;
1246         } else if (packet_type ==
1247                    RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
1248           ++sent_rtcp_rrtr_;
1249         }
1250         EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode);
1251         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrDlrrReportBlockItemCode);
1252         packet_type = parser.Iterate();
1253       }
1254       return SEND_PACKET;
1255     }
1256     // Send stream should send SR packets (and DLRR packets if enabled).
1257     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) {
1258       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1259       EXPECT_TRUE(parser.IsValid());
1260
1261       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1262       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1263         if (packet_type == RTCPUtility::kRtcpSrCode) {
1264           ++sent_rtcp_sr_;
1265         } else if (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
1266           ++sent_rtcp_dlrr_;
1267         }
1268         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrReceiverReferenceTimeCode);
1269         packet_type = parser.Iterate();
1270       }
1271       if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
1272           sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) {
1273         if (enable_rrtr_) {
1274           EXPECT_GT(sent_rtcp_rrtr_, 0);
1275           EXPECT_GT(sent_rtcp_dlrr_, 0);
1276         } else {
1277           EXPECT_EQ(0, sent_rtcp_rrtr_);
1278           EXPECT_EQ(0, sent_rtcp_dlrr_);
1279         }
1280         observation_complete_->Set();
1281       }
1282       return SEND_PACKET;
1283     }
1284     bool enable_rrtr_;
1285     int sent_rtcp_sr_;
1286     int sent_rtcp_rr_;
1287     int sent_rtcp_rrtr_;
1288     int sent_rtcp_dlrr_;
1289   } observer(enable_rrtr);
1290
1291   CreateCalls(Call::Config(observer.SendTransport()),
1292               Call::Config(observer.ReceiveTransport()));
1293   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
1294
1295   CreateTestConfigs();
1296   receive_config_.rtp.rtcp_mode = newapi::kRtcpReducedSize;
1297   receive_config_.rtp.rtcp_xr.receiver_reference_time_report = enable_rrtr;
1298
1299   CreateStreams();
1300   CreateFrameGenerator();
1301   StartSending();
1302
1303   EXPECT_EQ(kEventSignaled, observer.Wait())
1304       << "Timed out while waiting for RTCP SR/RR packets to be sent.";
1305
1306   StopSending();
1307   observer.StopSending();
1308   DestroyStreams();
1309 }
1310
1311 class StatsObserver : public test::RtpRtcpObserver, public I420FrameCallback {
1312  public:
1313   StatsObserver()
1314       : test::RtpRtcpObserver(kLongTimeoutMs),
1315         receive_stream_(NULL),
1316         send_stream_(NULL),
1317         expected_receive_ssrc_(),
1318         expected_send_ssrcs_(),
1319         check_stats_event_(EventWrapper::Create()) {}
1320
1321   void SetExpectedReceiveSsrc(uint32_t ssrc) { expected_receive_ssrc_ = ssrc; }
1322
1323   void SetExpectedSendSsrcs(const std::vector<uint32_t>& ssrcs) {
1324     for (std::vector<uint32_t>::const_iterator it = ssrcs.begin();
1325          it != ssrcs.end();
1326          ++it) {
1327       expected_send_ssrcs_.insert(*it);
1328     }
1329   }
1330
1331   void SetExpectedCName(std::string cname) { expected_cname_ = cname; }
1332
1333   void SetReceiveStream(VideoReceiveStream* stream) {
1334     receive_stream_ = stream;
1335   }
1336
1337   void SetSendStream(VideoSendStream* stream) { send_stream_ = stream; }
1338
1339   void WaitForFilledStats() {
1340     Clock* clock = Clock::GetRealTimeClock();
1341     int64_t now = clock->TimeInMilliseconds();
1342     int64_t stop_time = now + kLongTimeoutMs;
1343     bool receive_ok = false;
1344     bool send_ok = false;
1345
1346     while (now < stop_time) {
1347       if (!receive_ok)
1348         receive_ok = CheckReceiveStats();
1349       if (!send_ok)
1350         send_ok = CheckSendStats();
1351
1352       if (receive_ok && send_ok)
1353         return;
1354
1355       int64_t time_until_timout_ = stop_time - now;
1356       if (time_until_timout_ > 0)
1357         check_stats_event_->Wait(time_until_timout_);
1358       now = clock->TimeInMilliseconds();
1359     }
1360
1361     ADD_FAILURE() << "Timed out waiting for filled stats.";
1362     for (std::map<std::string, bool>::const_iterator it =
1363              receive_stats_filled_.begin();
1364          it != receive_stats_filled_.end();
1365          ++it) {
1366       if (!it->second) {
1367         ADD_FAILURE() << "Missing receive stats: " << it->first;
1368       }
1369     }
1370
1371     for (std::map<std::string, bool>::const_iterator it =
1372              send_stats_filled_.begin();
1373          it != send_stats_filled_.end();
1374          ++it) {
1375       if (!it->second) {
1376         ADD_FAILURE() << "Missing send stats: " << it->first;
1377       }
1378     }
1379   }
1380
1381  private:
1382   virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1383     check_stats_event_->Set();
1384     return SEND_PACKET;
1385   }
1386
1387   virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
1388     check_stats_event_->Set();
1389     return SEND_PACKET;
1390   }
1391
1392   virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) OVERRIDE {
1393     check_stats_event_->Set();
1394     return SEND_PACKET;
1395   }
1396
1397   virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) OVERRIDE {
1398     check_stats_event_->Set();
1399     return SEND_PACKET;
1400   }
1401
1402   virtual void FrameCallback(I420VideoFrame* video_frame) OVERRIDE {
1403     // Ensure that we have at least 5ms send side delay.
1404     int64_t render_time = video_frame->render_time_ms();
1405     if (render_time > 0)
1406       video_frame->set_render_time_ms(render_time - 5);
1407   }
1408
1409   bool CheckReceiveStats() {
1410     assert(receive_stream_ != NULL);
1411     VideoReceiveStream::Stats stats = receive_stream_->GetStats();
1412     EXPECT_EQ(expected_receive_ssrc_, stats.ssrc);
1413
1414     // Make sure all fields have been populated.
1415
1416     receive_stats_filled_["IncomingRate"] |=
1417         stats.network_frame_rate != 0 || stats.bitrate_bps != 0;
1418
1419     receive_stats_filled_["FrameCallback"] |= stats.decode_frame_rate != 0;
1420
1421     receive_stats_filled_["FrameRendered"] |= stats.render_frame_rate != 0;
1422
1423     receive_stats_filled_["StatisticsUpdated"] |=
1424         stats.rtcp_stats.cumulative_lost != 0 ||
1425         stats.rtcp_stats.extended_max_sequence_number != 0 ||
1426         stats.rtcp_stats.fraction_lost != 0 || stats.rtcp_stats.jitter != 0;
1427
1428     receive_stats_filled_["DataCountersUpdated"] |=
1429         stats.rtp_stats.bytes != 0 || stats.rtp_stats.fec_packets != 0 ||
1430         stats.rtp_stats.header_bytes != 0 || stats.rtp_stats.packets != 0 ||
1431         stats.rtp_stats.padding_bytes != 0 ||
1432         stats.rtp_stats.retransmitted_packets != 0;
1433
1434     receive_stats_filled_["CodecStats"] |=
1435         stats.avg_delay_ms != 0 || stats.discarded_packets != 0 ||
1436         stats.key_frames != 0 || stats.delta_frames != 0;
1437
1438     receive_stats_filled_["CName"] |= stats.c_name == expected_cname_;
1439
1440     return AllStatsFilled(receive_stats_filled_);
1441   }
1442
1443   bool CheckSendStats() {
1444     assert(send_stream_ != NULL);
1445     VideoSendStream::Stats stats = send_stream_->GetStats();
1446
1447     send_stats_filled_["NumStreams"] |=
1448         stats.substreams.size() == expected_send_ssrcs_.size();
1449
1450     send_stats_filled_["Delay"] |=
1451         stats.avg_delay_ms != 0 || stats.max_delay_ms != 0;
1452
1453     receive_stats_filled_["CName"] |= stats.c_name == expected_cname_;
1454
1455     for (std::map<uint32_t, StreamStats>::const_iterator it =
1456              stats.substreams.begin();
1457          it != stats.substreams.end();
1458          ++it) {
1459       EXPECT_TRUE(expected_send_ssrcs_.find(it->first) !=
1460                   expected_send_ssrcs_.end());
1461
1462       send_stats_filled_[CompoundKey("IncomingRate", it->first)] |=
1463           stats.input_frame_rate != 0;
1464
1465       const StreamStats& stream_stats = it->second;
1466
1467       send_stats_filled_[CompoundKey("StatisticsUpdated", it->first)] |=
1468           stream_stats.rtcp_stats.cumulative_lost != 0 ||
1469           stream_stats.rtcp_stats.extended_max_sequence_number != 0 ||
1470           stream_stats.rtcp_stats.fraction_lost != 0;
1471
1472       send_stats_filled_[CompoundKey("DataCountersUpdated", it->first)] |=
1473           stream_stats.rtp_stats.fec_packets != 0 ||
1474           stream_stats.rtp_stats.padding_bytes != 0 ||
1475           stream_stats.rtp_stats.retransmitted_packets != 0 ||
1476           stream_stats.rtp_stats.packets != 0;
1477
1478       send_stats_filled_[CompoundKey("BitrateStatisticsObserver", it->first)] |=
1479           stream_stats.bitrate_bps != 0;
1480
1481       send_stats_filled_[CompoundKey("FrameCountObserver", it->first)] |=
1482           stream_stats.delta_frames != 0 || stream_stats.key_frames != 0;
1483
1484       send_stats_filled_[CompoundKey("OutgoingRate", it->first)] |=
1485           stats.encode_frame_rate != 0;
1486     }
1487
1488     return AllStatsFilled(send_stats_filled_);
1489   }
1490
1491   std::string CompoundKey(const char* name, uint32_t ssrc) {
1492     std::ostringstream oss;
1493     oss << name << "_" << ssrc;
1494     return oss.str();
1495   }
1496
1497   bool AllStatsFilled(const std::map<std::string, bool>& stats_map) {
1498     for (std::map<std::string, bool>::const_iterator it = stats_map.begin();
1499          it != stats_map.end();
1500          ++it) {
1501       if (!it->second)
1502         return false;
1503     }
1504     return true;
1505   }
1506
1507   VideoReceiveStream* receive_stream_;
1508   std::map<std::string, bool> receive_stats_filled_;
1509
1510   VideoSendStream* send_stream_;
1511   std::map<std::string, bool> send_stats_filled_;
1512
1513   uint32_t expected_receive_ssrc_;
1514   std::set<uint32_t> expected_send_ssrcs_;
1515   std::string expected_cname_;
1516
1517   scoped_ptr<EventWrapper> check_stats_event_;
1518 };
1519
1520 TEST_F(CallTest, GetStats) {
1521   StatsObserver observer;
1522
1523   CreateCalls(Call::Config(observer.SendTransport()),
1524               Call::Config(observer.ReceiveTransport()));
1525
1526   observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
1527
1528   CreateTestConfigs();
1529   send_config_.pre_encode_callback = &observer;  // Used to inject delay.
1530   send_config_.rtp.c_name = "SomeCName";
1531
1532   observer.SetExpectedReceiveSsrc(receive_config_.rtp.local_ssrc);
1533   observer.SetExpectedSendSsrcs(send_config_.rtp.ssrcs);
1534   observer.SetExpectedCName(send_config_.rtp.c_name);
1535
1536   CreateStreams();
1537   observer.SetReceiveStream(receive_stream_);
1538   observer.SetSendStream(send_stream_);
1539   CreateFrameGenerator();
1540   StartSending();
1541
1542   observer.WaitForFilledStats();
1543
1544   StopSending();
1545   observer.StopSending();
1546   DestroyStreams();
1547 }
1548
1549 TEST_F(CallTest, ReceiverReferenceTimeReportEnabled) {
1550   TestXrReceiverReferenceTimeReport(true);
1551 }
1552
1553 TEST_F(CallTest, ReceiverReferenceTimeReportDisabled) {
1554   TestXrReceiverReferenceTimeReport(false);
1555 }
1556
1557 }  // namespace webrtc