src/third_party/webrtc/video/end_to_end_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/modules/video_coding/codecs/vp9/include/vp9.h"
  24 #include "webrtc/modules/video_coding/main/interface/video_coding_defines.h"
  25 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
  26 #include "webrtc/system_wrappers/interface/event_wrapper.h"
  27 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  28 #include "webrtc/system_wrappers/interface/sleep.h"
  29 #include "webrtc/test/call_test.h"
  30 #include "webrtc/test/direct_transport.h"
  31 #include "webrtc/test/encoder_settings.h"
  32 #include "webrtc/test/fake_audio_device.h"
  33 #include "webrtc/test/fake_decoder.h"
  34 #include "webrtc/test/fake_encoder.h"
  35 #include "webrtc/test/frame_generator.h"
  36 #include "webrtc/test/frame_generator_capturer.h"
  37 #include "webrtc/test/null_transport.h"
  38 #include "webrtc/test/rtp_rtcp_observer.h"
  39 #include "webrtc/test/testsupport/fileutils.h"
  40 #include "webrtc/test/testsupport/gtest_disable.h"
  41 #include "webrtc/test/testsupport/perf_test.h"
  42 #include "webrtc/video/transport_adapter.h"
  43 #include "webrtc/video_encoder.h"
  44
  45 namespace webrtc {
  46
  47 static const unsigned long kSilenceTimeoutMs = 2000;
  48
  49 class EndToEndTest : public test::CallTest {
  50  public:
  51   EndToEndTest() {}
  52
  53   virtual ~EndToEndTest() {
  54     EXPECT_EQ(NULL, send_stream_);
  55     EXPECT_TRUE(receive_streams_.empty());
  56   }
  57
  58  protected:
  59   class UnusedTransport : public newapi::Transport {
  60    private:
  61     virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
  62       ADD_FAILURE() << "Unexpected RTP sent.";
  63       return false;
  64     }
  65
  66     virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
  67       ADD_FAILURE() << "Unexpected RTCP sent.";
  68       return false;
  69     }
  70   };
  71
  72   void DecodesRetransmittedFrame(bool retransmit_over_rtx);
  73   void ReceivesPliAndRecovers(int rtp_history_ms);
  74   void RespectsRtcpMode(newapi::RtcpMode rtcp_mode);
  75   void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
  76   void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
  77   void TestRtpStatePreservation(bool use_rtx);
  78 };
  79
  80 TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
  81   test::NullTransport transport;
  82   CreateCalls(Call::Config(&transport), Call::Config(&transport));
  83
  84   CreateSendConfig(1);
  85   CreateMatchingReceiveConfigs();
  86
  87   CreateStreams();
  88
  89   receive_streams_[0]->Start();
  90   receive_streams_[0]->Start();
  91
  92   DestroyStreams();
  93 }
  94
  95 TEST_F(EndToEndTest, ReceiverCanBeStoppedTwice) {
  96   test::NullTransport transport;
  97   CreateCalls(Call::Config(&transport), Call::Config(&transport));
  98
  99   CreateSendConfig(1);
 100   CreateMatchingReceiveConfigs();
 101
 102   CreateStreams();
 103
 104   receive_streams_[0]->Stop();
 105   receive_streams_[0]->Stop();
 106
 107   DestroyStreams();
 108 }
 109
 110 TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
 111   static const int kWidth = 320;
 112   static const int kHeight = 240;
 113   // This constant is chosen to be higher than the timeout in the video_render
 114   // module. This makes sure that frames aren't dropped if there are no other
 115   // frames in the queue.
 116   static const int kDelayRenderCallbackMs = 1000;
 117
 118   class Renderer : public VideoRenderer {
 119    public:
 120     Renderer() : event_(EventWrapper::Create()) {}
 121
 122     virtual void RenderFrame(const I420VideoFrame& video_frame,
 123                              int /*time_to_render_ms*/) OVERRIDE {
 124       event_->Set();
 125     }
 126
 127     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 128
 129     scoped_ptr<EventWrapper> event_;
 130   } renderer;
 131
 132   class TestFrameCallback : public I420FrameCallback {
 133    public:
 134     TestFrameCallback() : event_(EventWrapper::Create()) {}
 135
 136     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 137
 138    private:
 139     virtual void FrameCallback(I420VideoFrame* frame) OVERRIDE {
 140       SleepMs(kDelayRenderCallbackMs);
 141       event_->Set();
 142     }
 143
 144     scoped_ptr<EventWrapper> event_;
 145   };
 146
 147   test::DirectTransport sender_transport, receiver_transport;
 148
 149   CreateCalls(Call::Config(&sender_transport),
 150               Call::Config(&receiver_transport));
 151
 152   sender_transport.SetReceiver(receiver_call_->Receiver());
 153   receiver_transport.SetReceiver(sender_call_->Receiver());
 154
 155   CreateSendConfig(1);
 156   CreateMatchingReceiveConfigs();
 157
 158   TestFrameCallback pre_render_callback;
 159   receive_configs_[0].pre_render_callback = &pre_render_callback;
 160   receive_configs_[0].renderer = &renderer;
 161
 162   CreateStreams();
 163   Start();
 164
 165   // Create frames that are smaller than the send width/height, this is done to
 166   // check that the callbacks are done after processing video.
 167   scoped_ptr<test::FrameGenerator> frame_generator(
 168       test::FrameGenerator::Create(kWidth, kHeight));
 169   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 170   EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
 171       << "Timed out while waiting for pre-render callback.";
 172   EXPECT_EQ(kEventSignaled, renderer.Wait())
 173       << "Timed out while waiting for the frame to render.";
 174
 175   Stop();
 176
 177   sender_transport.StopSending();
 178   receiver_transport.StopSending();
 179
 180   DestroyStreams();
 181 }
 182
 183 TEST_F(EndToEndTest, TransmitsFirstFrame) {
 184   class Renderer : public VideoRenderer {
 185    public:
 186     Renderer() : event_(EventWrapper::Create()) {}
 187
 188     virtual void RenderFrame(const I420VideoFrame& video_frame,
 189                              int /*time_to_render_ms*/) OVERRIDE {
 190       event_->Set();
 191     }
 192
 193     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 194
 195     scoped_ptr<EventWrapper> event_;
 196   } renderer;
 197
 198   test::DirectTransport sender_transport, receiver_transport;
 199
 200   CreateCalls(Call::Config(&sender_transport),
 201               Call::Config(&receiver_transport));
 202
 203   sender_transport.SetReceiver(receiver_call_->Receiver());
 204   receiver_transport.SetReceiver(sender_call_->Receiver());
 205
 206   CreateSendConfig(1);
 207   CreateMatchingReceiveConfigs();
 208   receive_configs_[0].renderer = &renderer;
 209
 210   CreateStreams();
 211   Start();
 212
 213   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
 214       encoder_config_.streams[0].width, encoder_config_.streams[0].height));
 215   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 216
 217   EXPECT_EQ(kEventSignaled, renderer.Wait())
 218       << "Timed out while waiting for the frame to render.";
 219
 220   Stop();
 221
 222   sender_transport.StopSending();
 223   receiver_transport.StopSending();
 224
 225   DestroyStreams();
 226 }
 227
 228 TEST_F(EndToEndTest, SendsAndReceivesVP9) {
 229   class VP9Observer : public test::EndToEndTest, public VideoRenderer {
 230    public:
 231     VP9Observer()
 232         : EndToEndTest(2 * kDefaultTimeoutMs),
 233           encoder_(VideoEncoder::Create(VideoEncoder::kVp9)),
 234           decoder_(VP9Decoder::Create()),
 235           frame_counter_(0) {}
 236
 237     virtual void PerformTest() OVERRIDE {
 238       EXPECT_EQ(kEventSignaled, Wait())
 239           << "Timed out while waiting for enough frames to be decoded.";
 240     }
 241
 242     virtual void ModifyConfigs(
 243         VideoSendStream::Config* send_config,
 244         std::vector<VideoReceiveStream::Config>* receive_configs,
 245         VideoEncoderConfig* encoder_config) OVERRIDE {
 246       send_config->encoder_settings.encoder = encoder_.get();
 247       send_config->encoder_settings.payload_name = "VP9";
 248       send_config->encoder_settings.payload_type = VCM_VP9_PAYLOAD_TYPE;
 249       encoder_config->streams[0].min_bitrate_bps = 50000;
 250       encoder_config->streams[0].target_bitrate_bps =
 251           encoder_config->streams[0].max_bitrate_bps = 2000000;
 252
 253       (*receive_configs)[0].renderer = this;
 254       (*receive_configs)[0].decoders.resize(1);
 255       (*receive_configs)[0].decoders[0].payload_type =
 256           send_config->encoder_settings.payload_type;
 257       (*receive_configs)[0].decoders[0].payload_name =
 258           send_config->encoder_settings.payload_name;
 259       (*receive_configs)[0].decoders[0].decoder = decoder_.get();
 260     }
 261
 262     virtual void RenderFrame(const I420VideoFrame& video_frame,
 263                              int time_to_render_ms) OVERRIDE {
 264       const int kRequiredFrames = 500;
 265       if (++frame_counter_ == kRequiredFrames)
 266         observation_complete_->Set();
 267     }
 268
 269    private:
 270     scoped_ptr<webrtc::VideoEncoder> encoder_;
 271     scoped_ptr<webrtc::VideoDecoder> decoder_;
 272     int frame_counter_;
 273   } test;
 274
 275   RunBaseTest(&test);
 276 }
 277
 278 TEST_F(EndToEndTest, SendsAndReceivesH264) {
 279   class H264Observer : public test::EndToEndTest, public VideoRenderer {
 280    public:
 281     H264Observer()
 282         : EndToEndTest(2 * kDefaultTimeoutMs),
 283           fake_encoder_(Clock::GetRealTimeClock()),
 284           frame_counter_(0) {}
 285
 286     virtual void PerformTest() OVERRIDE {
 287       EXPECT_EQ(kEventSignaled, Wait())
 288           << "Timed out while waiting for enough frames to be decoded.";
 289     }
 290
 291     virtual void ModifyConfigs(
 292         VideoSendStream::Config* send_config,
 293         std::vector<VideoReceiveStream::Config>* receive_configs,
 294         VideoEncoderConfig* encoder_config) OVERRIDE {
 295       send_config->encoder_settings.encoder = &fake_encoder_;
 296       send_config->encoder_settings.payload_name = "H264";
 297       send_config->encoder_settings.payload_type = kFakeSendPayloadType;
 298       encoder_config->streams[0].min_bitrate_bps = 50000;
 299       encoder_config->streams[0].target_bitrate_bps =
 300           encoder_config->streams[0].max_bitrate_bps = 2000000;
 301
 302       (*receive_configs)[0].renderer = this;
 303       (*receive_configs)[0].decoders.resize(1);
 304       (*receive_configs)[0].decoders[0].payload_type =
 305           send_config->encoder_settings.payload_type;
 306       (*receive_configs)[0].decoders[0].payload_name =
 307           send_config->encoder_settings.payload_name;
 308       (*receive_configs)[0].decoders[0].decoder = &fake_decoder_;
 309     }
 310
 311     virtual void RenderFrame(const I420VideoFrame& video_frame,
 312                              int time_to_render_ms) OVERRIDE {
 313       const int kRequiredFrames = 500;
 314       if (++frame_counter_ == kRequiredFrames)
 315         observation_complete_->Set();
 316     }
 317
 318    private:
 319     test::FakeH264Decoder fake_decoder_;
 320     test::FakeH264Encoder fake_encoder_;
 321     int frame_counter_;
 322   } test;
 323
 324   RunBaseTest(&test);
 325 }
 326
 327 TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
 328   class SyncRtcpObserver : public test::EndToEndTest {
 329    public:
 330     SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
 331
 332     virtual Action OnReceiveRtcp(const uint8_t* packet,
 333                                  size_t length) OVERRIDE {
 334       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 335       EXPECT_TRUE(parser.IsValid());
 336       uint32_t ssrc = 0;
 337       ssrc |= static_cast<uint32_t>(packet[4]) << 24;
 338       ssrc |= static_cast<uint32_t>(packet[5]) << 16;
 339       ssrc |= static_cast<uint32_t>(packet[6]) << 8;
 340       ssrc |= static_cast<uint32_t>(packet[7]) << 0;
 341       EXPECT_EQ(kReceiverLocalSsrc, ssrc);
 342       observation_complete_->Set();
 343
 344       return SEND_PACKET;
 345     }
 346
 347     virtual void PerformTest() OVERRIDE {
 348       EXPECT_EQ(kEventSignaled, Wait())
 349           << "Timed out while waiting for a receiver RTCP packet to be sent.";
 350     }
 351   } test;
 352
 353   RunBaseTest(&test);
 354 }
 355
 356 TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
 357   static const int kNumberOfNacksToObserve = 2;
 358   static const int kLossBurstSize = 2;
 359   static const int kPacketsBetweenLossBursts = 9;
 360   class NackObserver : public test::EndToEndTest {
 361    public:
 362     NackObserver()
 363         : EndToEndTest(kLongTimeoutMs),
 364           rtp_parser_(RtpHeaderParser::Create()),
 365           sent_rtp_packets_(0),
 366           packets_left_to_drop_(0),
 367           nacks_left_(kNumberOfNacksToObserve) {}
 368
 369    private:
 370     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 371       RTPHeader header;
 372       EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
 373
 374       // Never drop retransmitted packets.
 375       if (dropped_packets_.find(header.sequenceNumber) !=
 376           dropped_packets_.end()) {
 377         retransmitted_packets_.insert(header.sequenceNumber);
 378         if (nacks_left_ == 0 &&
 379             retransmitted_packets_.size() == dropped_packets_.size()) {
 380           observation_complete_->Set();
 381         }
 382         return SEND_PACKET;
 383       }
 384
 385       ++sent_rtp_packets_;
 386
 387       // Enough NACKs received, stop dropping packets.
 388       if (nacks_left_ == 0)
 389         return SEND_PACKET;
 390
 391       // Check if it's time for a new loss burst.
 392       if (sent_rtp_packets_ % kPacketsBetweenLossBursts == 0)
 393         packets_left_to_drop_ = kLossBurstSize;
 394
 395       if (packets_left_to_drop_ > 0) {
 396         --packets_left_to_drop_;
 397         dropped_packets_.insert(header.sequenceNumber);
 398         return DROP_PACKET;
 399       }
 400
 401       return SEND_PACKET;
 402     }
 403
 404     virtual Action OnReceiveRtcp(const uint8_t* packet,
 405                                  size_t length) OVERRIDE {
 406       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 407       EXPECT_TRUE(parser.IsValid());
 408
 409       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 410       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 411         if (packet_type == RTCPUtility::kRtcpRtpfbNackCode) {
 412           --nacks_left_;
 413           break;
 414         }
 415         packet_type = parser.Iterate();
 416       }
 417       return SEND_PACKET;
 418     }
 419
 420     virtual void ModifyConfigs(
 421         VideoSendStream::Config* send_config,
 422         std::vector<VideoReceiveStream::Config>* receive_configs,
 423         VideoEncoderConfig* encoder_config) OVERRIDE {
 424       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 425       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 426     }
 427
 428     virtual void PerformTest() OVERRIDE {
 429       EXPECT_EQ(kEventSignaled, Wait())
 430           << "Timed out waiting for packets to be NACKed, retransmitted and "
 431              "rendered.";
 432     }
 433
 434     scoped_ptr<RtpHeaderParser> rtp_parser_;
 435     std::set<uint16_t> dropped_packets_;
 436     std::set<uint16_t> retransmitted_packets_;
 437     uint64_t sent_rtp_packets_;
 438     int packets_left_to_drop_;
 439     int nacks_left_;
 440   } test;
 441
 442   RunBaseTest(&test);
 443 }
 444
 445 // TODO(pbos): Flaky, webrtc:3269
 446 TEST_F(EndToEndTest, DISABLED_CanReceiveFec) {
 447   class FecRenderObserver : public test::EndToEndTest, public VideoRenderer {
 448    public:
 449     FecRenderObserver()
 450         : EndToEndTest(kDefaultTimeoutMs),
 451           state_(kFirstPacket),
 452           protected_sequence_number_(0),
 453           protected_frame_timestamp_(0) {}
 454
 455    private:
 456     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE
 457         EXCLUSIVE_LOCKS_REQUIRED(crit_) {
 458       RTPHeader header;
 459       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 460
 461       EXPECT_EQ(kRedPayloadType, header.payloadType);
 462       int encapsulated_payload_type =
 463           static_cast<int>(packet[header.headerLength]);
 464       if (encapsulated_payload_type != kFakeSendPayloadType)
 465         EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type);
 466
 467       switch (state_) {
 468         case kFirstPacket:
 469           state_ = kDropEveryOtherPacketUntilFec;
 470           break;
 471         case kDropEveryOtherPacketUntilFec:
 472           if (encapsulated_payload_type == kUlpfecPayloadType) {
 473             state_ = kDropNextMediaPacket;
 474             return SEND_PACKET;
 475           }
 476           if (header.sequenceNumber % 2 == 0)
 477             return DROP_PACKET;
 478           break;
 479         case kDropNextMediaPacket:
 480           if (encapsulated_payload_type == kFakeSendPayloadType) {
 481             protected_sequence_number_ = header.sequenceNumber;
 482             protected_frame_timestamp_ = header.timestamp;
 483             state_ = kProtectedPacketDropped;
 484             return DROP_PACKET;
 485           }
 486           break;
 487         case kProtectedPacketDropped:
 488           EXPECT_NE(header.sequenceNumber, protected_sequence_number_)
 489               << "Protected packet retransmitted. Should not happen with FEC.";
 490           break;
 491       }
 492
 493       return SEND_PACKET;
 494     }
 495
 496     virtual void RenderFrame(const I420VideoFrame& video_frame,
 497                              int time_to_render_ms) OVERRIDE {
 498       CriticalSectionScoped lock(crit_.get());
 499       // Rendering frame with timestamp associated with dropped packet -> FEC
 500       // protection worked.
 501       if (state_ == kProtectedPacketDropped &&
 502           video_frame.timestamp() == protected_frame_timestamp_) {
 503         observation_complete_->Set();
 504       }
 505     }
 506
 507     enum {
 508       kFirstPacket,
 509       kDropEveryOtherPacketUntilFec,
 510       kDropNextMediaPacket,
 511       kProtectedPacketDropped,
 512     } state_;
 513
 514     virtual void ModifyConfigs(
 515         VideoSendStream::Config* send_config,
 516         std::vector<VideoReceiveStream::Config>* receive_configs,
 517         VideoEncoderConfig* encoder_config) OVERRIDE {
 518       // TODO(pbos): Run this test with combined NACK/FEC enabled as well.
 519       // int rtp_history_ms = 1000;
 520       // (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms;
 521       // send_config->rtp.nack.rtp_history_ms = rtp_history_ms;
 522       send_config->rtp.fec.red_payload_type = kRedPayloadType;
 523       send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 524
 525       (*receive_configs)[0].rtp.fec.red_payload_type = kRedPayloadType;
 526       (*receive_configs)[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 527       (*receive_configs)[0].renderer = this;
 528     }
 529
 530     virtual void PerformTest() OVERRIDE {
 531       EXPECT_EQ(kEventSignaled, Wait())
 532           << "Timed out while waiting for retransmitted NACKed frames to be "
 533              "rendered again.";
 534     }
 535
 536     uint32_t protected_sequence_number_ GUARDED_BY(crit_);
 537     uint32_t protected_frame_timestamp_ GUARDED_BY(crit_);
 538   } test;
 539
 540   RunBaseTest(&test);
 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 EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) {
 546   static const int kDroppedFrameNumber = 2;
 547   class RetransmissionObserver : public test::EndToEndTest,
 548                                  public I420FrameCallback {
 549    public:
 550     explicit RetransmissionObserver(bool expect_rtx)
 551         : EndToEndTest(kDefaultTimeoutMs),
 552           retransmission_ssrc_(expect_rtx ? kSendRtxSsrcs[0] : kSendSsrcs[0]),
 553           retransmission_payload_type_(expect_rtx ? kSendRtxPayloadType
 554                                                   : kFakeSendPayloadType),
 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, 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(kSendSsrcs[0], header.ssrc);
 572       EXPECT_EQ(kFakeSendPayloadType, 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     virtual void ModifyConfigs(
 593         VideoSendStream::Config* send_config,
 594         std::vector<VideoReceiveStream::Config>* receive_configs,
 595         VideoEncoderConfig* encoder_config) OVERRIDE {
 596       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 597       (*receive_configs)[0].pre_render_callback = this;
 598       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 599       if (retransmission_ssrc_ == kSendRtxSsrcs[0]) {
 600         send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
 601         send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
 602         (*receive_configs)[0].rtp.rtx[kSendRtxPayloadType].ssrc =
 603             kSendRtxSsrcs[0];
 604         (*receive_configs)[0].rtp.rtx[kSendRtxPayloadType].payload_type =
 605             kSendRtxPayloadType;
 606       }
 607     }
 608
 609     virtual void PerformTest() OVERRIDE {
 610       EXPECT_EQ(kEventSignaled, Wait())
 611           << "Timed out while waiting for retransmission to render.";
 612     }
 613
 614     const uint32_t retransmission_ssrc_;
 615     const int retransmission_payload_type_;
 616     int marker_bits_observed_;
 617     uint32_t retransmitted_timestamp_;
 618     bool frame_retransmitted_;
 619   } test(retransmit_over_rtx);
 620
 621   RunBaseTest(&test);
 622 }
 623
 624 TEST_F(EndToEndTest, DecodesRetransmittedFrame) {
 625   DecodesRetransmittedFrame(false);
 626 }
 627
 628 TEST_F(EndToEndTest, DecodesRetransmittedFrameOverRtx) {
 629   DecodesRetransmittedFrame(true);
 630 }
 631
 632 TEST_F(EndToEndTest, UsesFrameCallbacks) {
 633   static const int kWidth = 320;
 634   static const int kHeight = 240;
 635
 636   class Renderer : public VideoRenderer {
 637    public:
 638     Renderer() : event_(EventWrapper::Create()) {}
 639
 640     virtual void RenderFrame(const I420VideoFrame& video_frame,
 641                              int /*time_to_render_ms*/) OVERRIDE {
 642       EXPECT_EQ(0, *video_frame.buffer(kYPlane))
 643           << "Rendered frame should have zero luma which is applied by the "
 644              "pre-render callback.";
 645       event_->Set();
 646     }
 647
 648     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 649     scoped_ptr<EventWrapper> event_;
 650   } renderer;
 651
 652   class TestFrameCallback : public I420FrameCallback {
 653    public:
 654     TestFrameCallback(int expected_luma_byte, int next_luma_byte)
 655         : event_(EventWrapper::Create()),
 656           expected_luma_byte_(expected_luma_byte),
 657           next_luma_byte_(next_luma_byte) {}
 658
 659     EventTypeWrapper Wait() { return event_->Wait(kDefaultTimeoutMs); }
 660
 661    private:
 662     virtual void FrameCallback(I420VideoFrame* frame) {
 663       EXPECT_EQ(kWidth, frame->width())
 664           << "Width not as expected, callback done before resize?";
 665       EXPECT_EQ(kHeight, frame->height())
 666           << "Height not as expected, callback done before resize?";
 667
 668       // Previous luma specified, observed luma should be fairly close.
 669       if (expected_luma_byte_ != -1) {
 670         EXPECT_NEAR(expected_luma_byte_, *frame->buffer(kYPlane), 10);
 671       }
 672
 673       memset(frame->buffer(kYPlane),
 674              next_luma_byte_,
 675              frame->allocated_size(kYPlane));
 676
 677       event_->Set();
 678     }
 679
 680     scoped_ptr<EventWrapper> event_;
 681     int expected_luma_byte_;
 682     int next_luma_byte_;
 683   };
 684
 685   TestFrameCallback pre_encode_callback(-1, 255);  // Changes luma to 255.
 686   TestFrameCallback pre_render_callback(255, 0);  // Changes luma from 255 to 0.
 687
 688   test::DirectTransport sender_transport, receiver_transport;
 689
 690   CreateCalls(Call::Config(&sender_transport),
 691               Call::Config(&receiver_transport));
 692
 693   sender_transport.SetReceiver(receiver_call_->Receiver());
 694   receiver_transport.SetReceiver(sender_call_->Receiver());
 695
 696   CreateSendConfig(1);
 697   scoped_ptr<VideoEncoder> encoder(
 698       VideoEncoder::Create(VideoEncoder::kVp8));
 699   send_config_.encoder_settings.encoder = encoder.get();
 700   send_config_.encoder_settings.payload_name = "VP8";
 701   ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error.";
 702   encoder_config_.streams[0].width = kWidth;
 703   encoder_config_.streams[0].height = kHeight;
 704   send_config_.pre_encode_callback = &pre_encode_callback;
 705
 706   CreateMatchingReceiveConfigs();
 707   receive_configs_[0].pre_render_callback = &pre_render_callback;
 708   receive_configs_[0].renderer = &renderer;
 709
 710   CreateStreams();
 711   Start();
 712
 713   // Create frames that are smaller than the send width/height, this is done to
 714   // check that the callbacks are done after processing video.
 715   scoped_ptr<test::FrameGenerator> frame_generator(
 716       test::FrameGenerator::Create(kWidth / 2, kHeight / 2));
 717   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 718
 719   EXPECT_EQ(kEventSignaled, pre_encode_callback.Wait())
 720       << "Timed out while waiting for pre-encode callback.";
 721   EXPECT_EQ(kEventSignaled, pre_render_callback.Wait())
 722       << "Timed out while waiting for pre-render callback.";
 723   EXPECT_EQ(kEventSignaled, renderer.Wait())
 724       << "Timed out while waiting for the frame to render.";
 725
 726   Stop();
 727
 728   sender_transport.StopSending();
 729   receiver_transport.StopSending();
 730
 731   DestroyStreams();
 732 }
 733
 734 void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
 735   static const int kPacketsToDrop = 1;
 736
 737   class PliObserver : public test::EndToEndTest, public VideoRenderer {
 738    public:
 739     explicit PliObserver(int rtp_history_ms)
 740         : EndToEndTest(kLongTimeoutMs),
 741           rtp_history_ms_(rtp_history_ms),
 742           nack_enabled_(rtp_history_ms > 0),
 743           highest_dropped_timestamp_(0),
 744           frames_to_drop_(0),
 745           received_pli_(false) {}
 746
 747    private:
 748     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 749       RTPHeader header;
 750       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 751
 752       // Drop all retransmitted packets to force a PLI.
 753       if (header.timestamp <= highest_dropped_timestamp_)
 754         return DROP_PACKET;
 755
 756       if (frames_to_drop_ > 0) {
 757         highest_dropped_timestamp_ = header.timestamp;
 758         --frames_to_drop_;
 759         return DROP_PACKET;
 760       }
 761
 762       return SEND_PACKET;
 763     }
 764
 765     virtual Action OnReceiveRtcp(const uint8_t* packet,
 766                                  size_t length) OVERRIDE {
 767       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 768       EXPECT_TRUE(parser.IsValid());
 769
 770       for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 771            packet_type != RTCPUtility::kRtcpNotValidCode;
 772            packet_type = parser.Iterate()) {
 773         if (!nack_enabled_)
 774           EXPECT_NE(packet_type, RTCPUtility::kRtcpRtpfbNackCode);
 775
 776         if (packet_type == RTCPUtility::kRtcpPsfbPliCode) {
 777           received_pli_ = true;
 778           break;
 779         }
 780       }
 781       return SEND_PACKET;
 782     }
 783
 784     virtual void RenderFrame(const I420VideoFrame& video_frame,
 785                              int time_to_render_ms) OVERRIDE {
 786       CriticalSectionScoped lock(crit_.get());
 787       if (received_pli_ &&
 788           video_frame.timestamp() > highest_dropped_timestamp_) {
 789         observation_complete_->Set();
 790       }
 791       if (!received_pli_)
 792         frames_to_drop_ = kPacketsToDrop;
 793     }
 794
 795     virtual void ModifyConfigs(
 796         VideoSendStream::Config* send_config,
 797         std::vector<VideoReceiveStream::Config>* receive_configs,
 798         VideoEncoderConfig* encoder_config) OVERRIDE {
 799       send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
 800       (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
 801       (*receive_configs)[0].renderer = this;
 802     }
 803
 804     virtual void PerformTest() OVERRIDE {
 805       EXPECT_EQ(kEventSignaled, Wait()) << "Timed out waiting for PLI to be "
 806                                            "received and a frame to be "
 807                                            "rendered afterwards.";
 808     }
 809
 810     int rtp_history_ms_;
 811     bool nack_enabled_;
 812     uint32_t highest_dropped_timestamp_;
 813     int frames_to_drop_;
 814     bool received_pli_;
 815   } test(rtp_history_ms);
 816
 817   RunBaseTest(&test);
 818 }
 819
 820 TEST_F(EndToEndTest, ReceivesPliAndRecoversWithNack) {
 821   ReceivesPliAndRecovers(1000);
 822 }
 823
 824 // TODO(pbos): Enable this when 2250 is resolved.
 825 TEST_F(EndToEndTest, DISABLED_ReceivesPliAndRecoversWithoutNack) {
 826   ReceivesPliAndRecovers(0);
 827 }
 828
 829 TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
 830   class PacketInputObserver : public PacketReceiver {
 831    public:
 832     explicit PacketInputObserver(PacketReceiver* receiver)
 833         : receiver_(receiver), delivered_packet_(EventWrapper::Create()) {}
 834
 835     EventTypeWrapper Wait() {
 836       return delivered_packet_->Wait(kDefaultTimeoutMs);
 837     }
 838
 839    private:
 840     virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
 841                                          size_t length) OVERRIDE {
 842       if (RtpHeaderParser::IsRtcp(packet, length)) {
 843         return receiver_->DeliverPacket(packet, length);
 844       } else {
 845         DeliveryStatus delivery_status =
 846             receiver_->DeliverPacket(packet, length);
 847         EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
 848         delivered_packet_->Set();
 849         return delivery_status;
 850       }
 851     }
 852
 853     PacketReceiver* receiver_;
 854     scoped_ptr<EventWrapper> delivered_packet_;
 855   };
 856
 857   test::DirectTransport send_transport, receive_transport;
 858
 859   CreateCalls(Call::Config(&send_transport), Call::Config(&receive_transport));
 860   PacketInputObserver input_observer(receiver_call_->Receiver());
 861
 862   send_transport.SetReceiver(&input_observer);
 863   receive_transport.SetReceiver(sender_call_->Receiver());
 864
 865   CreateSendConfig(1);
 866   CreateMatchingReceiveConfigs();
 867
 868   CreateStreams();
 869   CreateFrameGeneratorCapturer();
 870   Start();
 871
 872   receiver_call_->DestroyVideoReceiveStream(receive_streams_[0]);
 873   receive_streams_.clear();
 874
 875   // Wait() waits for a received packet.
 876   EXPECT_EQ(kEventSignaled, input_observer.Wait());
 877
 878   Stop();
 879
 880   DestroyStreams();
 881
 882   send_transport.StopSending();
 883   receive_transport.StopSending();
 884 }
 885
 886 void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
 887   static const int kNumCompoundRtcpPacketsToObserve = 10;
 888   class RtcpModeObserver : public test::EndToEndTest {
 889    public:
 890     explicit RtcpModeObserver(newapi::RtcpMode rtcp_mode)
 891         : EndToEndTest(kDefaultTimeoutMs),
 892           rtcp_mode_(rtcp_mode),
 893           sent_rtp_(0),
 894           sent_rtcp_(0) {}
 895
 896    private:
 897     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 898       if (++sent_rtp_ % 3 == 0)
 899         return DROP_PACKET;
 900
 901       return SEND_PACKET;
 902     }
 903
 904     virtual Action OnReceiveRtcp(const uint8_t* packet,
 905                                  size_t length) OVERRIDE {
 906       ++sent_rtcp_;
 907       RTCPUtility::RTCPParserV2 parser(packet, length, true);
 908       EXPECT_TRUE(parser.IsValid());
 909
 910       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 911       bool has_report_block = false;
 912       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 913         EXPECT_NE(RTCPUtility::kRtcpSrCode, packet_type);
 914         if (packet_type == RTCPUtility::kRtcpRrCode) {
 915           has_report_block = true;
 916           break;
 917         }
 918         packet_type = parser.Iterate();
 919       }
 920
 921       switch (rtcp_mode_) {
 922         case newapi::kRtcpCompound:
 923           if (!has_report_block) {
 924             ADD_FAILURE() << "Received RTCP packet without receiver report for "
 925                              "kRtcpCompound.";
 926             observation_complete_->Set();
 927           }
 928
 929           if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
 930             observation_complete_->Set();
 931
 932           break;
 933         case newapi::kRtcpReducedSize:
 934           if (!has_report_block)
 935             observation_complete_->Set();
 936           break;
 937       }
 938
 939       return SEND_PACKET;
 940     }
 941
 942     virtual void ModifyConfigs(
 943         VideoSendStream::Config* send_config,
 944         std::vector<VideoReceiveStream::Config>* receive_configs,
 945         VideoEncoderConfig* encoder_config) OVERRIDE {
 946       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 947       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 948       (*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
 949     }
 950
 951     virtual void PerformTest() OVERRIDE {
 952       EXPECT_EQ(kEventSignaled, Wait())
 953           << (rtcp_mode_ == newapi::kRtcpCompound
 954                   ? "Timed out before observing enough compound packets."
 955                   : "Timed out before receiving a non-compound RTCP packet.");
 956     }
 957
 958     newapi::RtcpMode rtcp_mode_;
 959     int sent_rtp_;
 960     int sent_rtcp_;
 961   } test(rtcp_mode);
 962
 963   RunBaseTest(&test);
 964 }
 965
 966 TEST_F(EndToEndTest, UsesRtcpCompoundMode) {
 967   RespectsRtcpMode(newapi::kRtcpCompound);
 968 }
 969
 970 TEST_F(EndToEndTest, UsesRtcpReducedSizeMode) {
 971   RespectsRtcpMode(newapi::kRtcpReducedSize);
 972 }
 973
 974 // Test sets up a Call multiple senders with different resolutions and SSRCs.
 975 // Another is set up to receive all three of these with different renderers.
 976 // Each renderer verifies that it receives the expected resolution, and as soon
 977 // as every renderer has received a frame, the test finishes.
 978 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
 979   static const size_t kNumStreams = 3;
 980
 981   class VideoOutputObserver : public VideoRenderer {
 982    public:
 983     VideoOutputObserver(test::FrameGeneratorCapturer** capturer,
 984                         int width,
 985                         int height)
 986         : capturer_(capturer),
 987           width_(width),
 988           height_(height),
 989           done_(EventWrapper::Create()) {}
 990
 991     virtual void RenderFrame(const I420VideoFrame& video_frame,
 992                              int time_to_render_ms) OVERRIDE {
 993       EXPECT_EQ(width_, video_frame.width());
 994       EXPECT_EQ(height_, video_frame.height());
 995       (*capturer_)->Stop();
 996       done_->Set();
 997     }
 998
 999     EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); }
1000
1001    private:
1002     test::FrameGeneratorCapturer** capturer_;
1003     int width_;
1004     int height_;
1005     scoped_ptr<EventWrapper> done_;
1006   };
1007
1008   struct {
1009     uint32_t ssrc;
1010     int width;
1011     int height;
1012   } codec_settings[kNumStreams] = {{1, 640, 480}, {2, 320, 240}, {3, 240, 160}};
1013
1014   test::DirectTransport sender_transport, receiver_transport;
1015   scoped_ptr<Call> sender_call(Call::Create(Call::Config(&sender_transport)));
1016   scoped_ptr<Call> receiver_call(
1017       Call::Create(Call::Config(&receiver_transport)));
1018   sender_transport.SetReceiver(receiver_call->Receiver());
1019   receiver_transport.SetReceiver(sender_call->Receiver());
1020
1021   VideoSendStream* send_streams[kNumStreams];
1022   VideoReceiveStream* receive_streams[kNumStreams];
1023
1024   VideoOutputObserver* observers[kNumStreams];
1025   test::FrameGeneratorCapturer* frame_generators[kNumStreams];
1026
1027   scoped_ptr<VideoEncoder> encoders[kNumStreams];
1028   for (size_t i = 0; i < kNumStreams; ++i)
1029     encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8));
1030
1031   ScopedVector<VideoDecoder> allocated_decoders;
1032   for (size_t i = 0; i < kNumStreams; ++i) {
1033     uint32_t ssrc = codec_settings[i].ssrc;
1034     int width = codec_settings[i].width;
1035     int height = codec_settings[i].height;
1036     observers[i] = new VideoOutputObserver(&frame_generators[i], width, height);
1037
1038     VideoSendStream::Config send_config;
1039     send_config.rtp.ssrcs.push_back(ssrc);
1040     send_config.encoder_settings.encoder = encoders[i].get();
1041     send_config.encoder_settings.payload_name = "VP8";
1042     send_config.encoder_settings.payload_type = 124;
1043     VideoEncoderConfig encoder_config;
1044     encoder_config.streams = test::CreateVideoStreams(1);
1045     VideoStream* stream = &encoder_config.streams[0];
1046     stream->width = width;
1047     stream->height = height;
1048     stream->max_framerate = 5;
1049     stream->min_bitrate_bps = stream->target_bitrate_bps =
1050         stream->max_bitrate_bps = 100000;
1051     send_streams[i] =
1052         sender_call->CreateVideoSendStream(send_config, encoder_config);
1053     send_streams[i]->Start();
1054
1055     VideoReceiveStream::Config receive_config;
1056     receive_config.renderer = observers[i];
1057     receive_config.rtp.remote_ssrc = ssrc;
1058     receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
1059     VideoReceiveStream::Decoder decoder =
1060         test::CreateMatchingDecoder(send_config.encoder_settings);
1061     allocated_decoders.push_back(decoder.decoder);
1062     receive_config.decoders.push_back(decoder);
1063     receive_streams[i] =
1064         receiver_call->CreateVideoReceiveStream(receive_config);
1065     receive_streams[i]->Start();
1066
1067     frame_generators[i] = test::FrameGeneratorCapturer::Create(
1068         send_streams[i]->Input(), width, height, 30, Clock::GetRealTimeClock());
1069     frame_generators[i]->Start();
1070   }
1071
1072   for (size_t i = 0; i < kNumStreams; ++i) {
1073     EXPECT_EQ(kEventSignaled, observers[i]->Wait())
1074         << "Timed out while waiting for observer " << i << " to render.";
1075   }
1076
1077   for (size_t i = 0; i < kNumStreams; ++i) {
1078     frame_generators[i]->Stop();
1079     sender_call->DestroyVideoSendStream(send_streams[i]);
1080     receiver_call->DestroyVideoReceiveStream(receive_streams[i]);
1081     delete frame_generators[i];
1082     delete observers[i];
1083   }
1084
1085   sender_transport.StopSending();
1086   receiver_transport.StopSending();
1087 }
1088
1089 TEST_F(EndToEndTest, ObserversEncodedFrames) {
1090   class EncodedFrameTestObserver : public EncodedFrameObserver {
1091    public:
1092     EncodedFrameTestObserver()
1093         : length_(0),
1094           frame_type_(kFrameEmpty),
1095           called_(EventWrapper::Create()) {}
1096     virtual ~EncodedFrameTestObserver() {}
1097
1098     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
1099       frame_type_ = encoded_frame.frame_type_;
1100       length_ = encoded_frame.length_;
1101       buffer_.reset(new uint8_t[length_]);
1102       memcpy(buffer_.get(), encoded_frame.data_, length_);
1103       called_->Set();
1104     }
1105
1106     EventTypeWrapper Wait() { return called_->Wait(kDefaultTimeoutMs); }
1107
1108     void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
1109       ASSERT_EQ(length_, observer.length_)
1110           << "Observed frames are of different lengths.";
1111       EXPECT_EQ(frame_type_, observer.frame_type_)
1112           << "Observed frames have different frame types.";
1113       EXPECT_EQ(0, memcmp(buffer_.get(), observer.buffer_.get(), length_))
1114           << "Observed encoded frames have different content.";
1115     }
1116
1117    private:
1118     scoped_ptr<uint8_t[]> buffer_;
1119     size_t length_;
1120     FrameType frame_type_;
1121     scoped_ptr<EventWrapper> called_;
1122   };
1123
1124   EncodedFrameTestObserver post_encode_observer;
1125   EncodedFrameTestObserver pre_decode_observer;
1126
1127   test::DirectTransport sender_transport, receiver_transport;
1128
1129   CreateCalls(Call::Config(&sender_transport),
1130               Call::Config(&receiver_transport));
1131
1132   sender_transport.SetReceiver(receiver_call_->Receiver());
1133   receiver_transport.SetReceiver(sender_call_->Receiver());
1134
1135   CreateSendConfig(1);
1136   CreateMatchingReceiveConfigs();
1137   send_config_.post_encode_callback = &post_encode_observer;
1138   receive_configs_[0].pre_decode_callback = &pre_decode_observer;
1139
1140   CreateStreams();
1141   Start();
1142
1143   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
1144       encoder_config_.streams[0].width, encoder_config_.streams[0].height));
1145   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
1146
1147   EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
1148       << "Timed out while waiting for send-side encoded-frame callback.";
1149
1150   EXPECT_EQ(kEventSignaled, pre_decode_observer.Wait())
1151       << "Timed out while waiting for pre-decode encoded-frame callback.";
1152
1153   post_encode_observer.ExpectEqualFrames(pre_decode_observer);
1154
1155   Stop();
1156
1157   sender_transport.StopSending();
1158   receiver_transport.StopSending();
1159
1160   DestroyStreams();
1161 }
1162
1163 TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
1164   class RembObserver : public test::EndToEndTest {
1165    public:
1166     RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
1167
1168     virtual Action OnReceiveRtcp(const uint8_t* packet,
1169                                  size_t length) OVERRIDE {
1170       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1171       EXPECT_TRUE(parser.IsValid());
1172
1173       bool received_psfb = false;
1174       bool received_remb = false;
1175       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1176       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1177         if (packet_type == RTCPUtility::kRtcpPsfbRembCode) {
1178           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1179           EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalSsrc);
1180           received_psfb = true;
1181         } else if (packet_type == RTCPUtility::kRtcpPsfbRembItemCode) {
1182           const RTCPUtility::RTCPPacket& packet = parser.Packet();
1183           EXPECT_GT(packet.REMBItem.BitRate, 0u);
1184           EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
1185           EXPECT_EQ(packet.REMBItem.SSRCs[0], kSendSsrcs[0]);
1186           received_remb = true;
1187         }
1188         packet_type = parser.Iterate();
1189       }
1190       if (received_psfb && received_remb)
1191         observation_complete_->Set();
1192       return SEND_PACKET;
1193     }
1194     virtual void PerformTest() OVERRIDE {
1195       EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for a "
1196                                            "receiver RTCP REMB packet to be "
1197                                            "sent.";
1198     }
1199   } test;
1200
1201   RunBaseTest(&test);
1202 }
1203
1204 TEST_F(EndToEndTest, VerifyBandwidthStats) {
1205   class RtcpObserver : public test::EndToEndTest, public PacketReceiver {
1206    public:
1207     RtcpObserver()
1208         : EndToEndTest(kDefaultTimeoutMs),
1209           sender_call_(NULL),
1210           receiver_call_(NULL),
1211           has_seen_pacer_delay_(false) {}
1212
1213     virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
1214                                          size_t length) OVERRIDE {
1215       Call::Stats sender_stats = sender_call_->GetStats();
1216       Call::Stats receiver_stats = receiver_call_->GetStats();
1217       if (!has_seen_pacer_delay_)
1218         has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0;
1219       if (sender_stats.send_bandwidth_bps > 0 &&
1220           receiver_stats.recv_bandwidth_bps > 0 && has_seen_pacer_delay_)
1221         observation_complete_->Set();
1222       return receiver_call_->Receiver()->DeliverPacket(packet, length);
1223     }
1224
1225     virtual void OnCallsCreated(Call* sender_call,
1226                                 Call* receiver_call) OVERRIDE {
1227       sender_call_ = sender_call;
1228       receiver_call_ = receiver_call;
1229     }
1230
1231     virtual void PerformTest() OVERRIDE {
1232       EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
1233                                            "non-zero bandwidth stats.";
1234     }
1235
1236     virtual void SetReceivers(
1237         PacketReceiver* send_transport_receiver,
1238         PacketReceiver* receive_transport_receiver) OVERRIDE {
1239       test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
1240     }
1241
1242    private:
1243     Call* sender_call_;
1244     Call* receiver_call_;
1245     bool has_seen_pacer_delay_;
1246   } test;
1247
1248   RunBaseTest(&test);
1249 }
1250
1251 void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
1252   static const int kNumRtcpReportPacketsToObserve = 5;
1253   class RtcpXrObserver : public test::EndToEndTest {
1254    public:
1255     explicit RtcpXrObserver(bool enable_rrtr)
1256         : EndToEndTest(kDefaultTimeoutMs),
1257           enable_rrtr_(enable_rrtr),
1258           sent_rtcp_sr_(0),
1259           sent_rtcp_rr_(0),
1260           sent_rtcp_rrtr_(0),
1261           sent_rtcp_dlrr_(0) {}
1262
1263    private:
1264     // Receive stream should send RR packets (and RRTR packets if enabled).
1265     virtual Action OnReceiveRtcp(const uint8_t* packet,
1266                                  size_t length) OVERRIDE {
1267       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1268       EXPECT_TRUE(parser.IsValid());
1269
1270       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1271       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1272         if (packet_type == RTCPUtility::kRtcpRrCode) {
1273           ++sent_rtcp_rr_;
1274         } else if (packet_type ==
1275                    RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
1276           ++sent_rtcp_rrtr_;
1277         }
1278         EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode);
1279         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrDlrrReportBlockItemCode);
1280         packet_type = parser.Iterate();
1281       }
1282       return SEND_PACKET;
1283     }
1284     // Send stream should send SR packets (and DLRR packets if enabled).
1285     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) {
1286       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1287       EXPECT_TRUE(parser.IsValid());
1288
1289       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1290       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1291         if (packet_type == RTCPUtility::kRtcpSrCode) {
1292           ++sent_rtcp_sr_;
1293         } else if (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
1294           ++sent_rtcp_dlrr_;
1295         }
1296         EXPECT_NE(packet_type, RTCPUtility::kRtcpXrReceiverReferenceTimeCode);
1297         packet_type = parser.Iterate();
1298       }
1299       if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
1300           sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) {
1301         if (enable_rrtr_) {
1302           EXPECT_GT(sent_rtcp_rrtr_, 0);
1303           EXPECT_GT(sent_rtcp_dlrr_, 0);
1304         } else {
1305           EXPECT_EQ(0, sent_rtcp_rrtr_);
1306           EXPECT_EQ(0, sent_rtcp_dlrr_);
1307         }
1308         observation_complete_->Set();
1309       }
1310       return SEND_PACKET;
1311     }
1312
1313     virtual void ModifyConfigs(
1314         VideoSendStream::Config* send_config,
1315         std::vector<VideoReceiveStream::Config>* receive_configs,
1316         VideoEncoderConfig* encoder_config) OVERRIDE {
1317       (*receive_configs)[0].rtp.rtcp_mode = newapi::kRtcpReducedSize;
1318       (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report =
1319           enable_rrtr_;
1320     }
1321
1322     virtual void PerformTest() OVERRIDE {
1323       EXPECT_EQ(kEventSignaled, Wait())
1324           << "Timed out while waiting for RTCP SR/RR packets to be sent.";
1325     }
1326
1327     bool enable_rrtr_;
1328     int sent_rtcp_sr_;
1329     int sent_rtcp_rr_;
1330     int sent_rtcp_rrtr_;
1331     int sent_rtcp_dlrr_;
1332   } test(enable_rrtr);
1333
1334   RunBaseTest(&test);
1335 }
1336
1337 void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
1338                                      bool send_single_ssrc_first) {
1339   class SendsSetSsrcs : public test::EndToEndTest {
1340    public:
1341     SendsSetSsrcs(const uint32_t* ssrcs,
1342                   size_t num_ssrcs,
1343                   bool send_single_ssrc_first)
1344         : EndToEndTest(kDefaultTimeoutMs),
1345           num_ssrcs_(num_ssrcs),
1346           send_single_ssrc_first_(send_single_ssrc_first),
1347           ssrcs_to_observe_(num_ssrcs),
1348           expect_single_ssrc_(send_single_ssrc_first) {
1349       for (size_t i = 0; i < num_ssrcs; ++i)
1350         valid_ssrcs_[ssrcs[i]] = true;
1351     }
1352
1353    private:
1354     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1355       RTPHeader header;
1356       EXPECT_TRUE(parser_->Parse(packet, length, &header));
1357
1358       EXPECT_TRUE(valid_ssrcs_[header.ssrc])
1359           << "Received unknown SSRC: " << header.ssrc;
1360
1361       if (!valid_ssrcs_[header.ssrc])
1362         observation_complete_->Set();
1363
1364       if (!is_observed_[header.ssrc]) {
1365         is_observed_[header.ssrc] = true;
1366         --ssrcs_to_observe_;
1367         if (expect_single_ssrc_) {
1368           expect_single_ssrc_ = false;
1369           observation_complete_->Set();
1370         }
1371       }
1372
1373       if (ssrcs_to_observe_ == 0)
1374         observation_complete_->Set();
1375
1376       return SEND_PACKET;
1377     }
1378
1379     virtual size_t GetNumStreams() const OVERRIDE { return num_ssrcs_; }
1380
1381     virtual void ModifyConfigs(
1382         VideoSendStream::Config* send_config,
1383         std::vector<VideoReceiveStream::Config>* receive_configs,
1384         VideoEncoderConfig* encoder_config) OVERRIDE {
1385       if (num_ssrcs_ > 1) {
1386         // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
1387         for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
1388           encoder_config->streams[i].min_bitrate_bps = 10000;
1389           encoder_config->streams[i].target_bitrate_bps = 15000;
1390           encoder_config->streams[i].max_bitrate_bps = 20000;
1391         }
1392       }
1393
1394       encoder_config_all_streams_ = *encoder_config;
1395       if (send_single_ssrc_first_)
1396         encoder_config->streams.resize(1);
1397     }
1398
1399     virtual void OnStreamsCreated(
1400         VideoSendStream* send_stream,
1401         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
1402       send_stream_ = send_stream;
1403     }
1404
1405     virtual void PerformTest() OVERRIDE {
1406       EXPECT_EQ(kEventSignaled, Wait())
1407           << "Timed out while waiting for "
1408           << (send_single_ssrc_first_ ? "first SSRC." : "SSRCs.");
1409
1410       if (send_single_ssrc_first_) {
1411         // Set full simulcast and continue with the rest of the SSRCs.
1412         send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_);
1413         EXPECT_EQ(kEventSignaled, Wait())
1414             << "Timed out while waiting on additional SSRCs.";
1415       }
1416     }
1417
1418    private:
1419     std::map<uint32_t, bool> valid_ssrcs_;
1420     std::map<uint32_t, bool> is_observed_;
1421
1422     const size_t num_ssrcs_;
1423     const bool send_single_ssrc_first_;
1424
1425     size_t ssrcs_to_observe_;
1426     bool expect_single_ssrc_;
1427
1428     VideoSendStream* send_stream_;
1429     VideoEncoderConfig encoder_config_all_streams_;
1430   } test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
1431
1432   RunBaseTest(&test);
1433 }
1434
1435 TEST_F(EndToEndTest, GetStats) {
1436   class StatsObserver : public test::EndToEndTest, public I420FrameCallback {
1437    public:
1438     StatsObserver()
1439         : EndToEndTest(kLongTimeoutMs),
1440           receive_stream_(NULL),
1441           send_stream_(NULL),
1442           expected_receive_ssrc_(),
1443           expected_send_ssrcs_(),
1444           check_stats_event_(EventWrapper::Create()) {}
1445
1446    private:
1447     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1448       check_stats_event_->Set();
1449       return SEND_PACKET;
1450     }
1451
1452     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
1453       check_stats_event_->Set();
1454       return SEND_PACKET;
1455     }
1456
1457     virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) OVERRIDE {
1458       check_stats_event_->Set();
1459       return SEND_PACKET;
1460     }
1461
1462     virtual Action OnReceiveRtcp(const uint8_t* packet,
1463                                  size_t length) OVERRIDE {
1464       check_stats_event_->Set();
1465       return SEND_PACKET;
1466     }
1467
1468     virtual void FrameCallback(I420VideoFrame* video_frame) OVERRIDE {
1469       // Ensure that we have at least 5ms send side delay.
1470       int64_t render_time = video_frame->render_time_ms();
1471       if (render_time > 0)
1472         video_frame->set_render_time_ms(render_time - 5);
1473     }
1474
1475     bool CheckReceiveStats() {
1476       assert(receive_stream_ != NULL);
1477       VideoReceiveStream::Stats stats = receive_stream_->GetStats();
1478       EXPECT_EQ(expected_receive_ssrc_, stats.ssrc);
1479
1480       // Make sure all fields have been populated.
1481
1482       receive_stats_filled_["IncomingRate"] |=
1483           stats.network_frame_rate != 0 || stats.total_bitrate_bps != 0;
1484
1485       receive_stats_filled_["FrameCallback"] |= stats.decode_frame_rate != 0;
1486
1487       receive_stats_filled_["FrameRendered"] |= stats.render_frame_rate != 0;
1488
1489       receive_stats_filled_["StatisticsUpdated"] |=
1490           stats.rtcp_stats.cumulative_lost != 0 ||
1491           stats.rtcp_stats.extended_max_sequence_number != 0 ||
1492           stats.rtcp_stats.fraction_lost != 0 || stats.rtcp_stats.jitter != 0;
1493
1494       receive_stats_filled_["DataCountersUpdated"] |=
1495           stats.rtp_stats.bytes != 0 || stats.rtp_stats.fec_packets != 0 ||
1496           stats.rtp_stats.header_bytes != 0 || stats.rtp_stats.packets != 0 ||
1497           stats.rtp_stats.padding_bytes != 0 ||
1498           stats.rtp_stats.retransmitted_packets != 0;
1499
1500       receive_stats_filled_["CodecStats"] |=
1501           stats.avg_delay_ms != 0 || stats.discarded_packets != 0 ||
1502           stats.key_frames != 0 || stats.delta_frames != 0;
1503
1504       return AllStatsFilled(receive_stats_filled_);
1505     }
1506
1507     bool CheckSendStats() {
1508       assert(send_stream_ != NULL);
1509       VideoSendStream::Stats stats = send_stream_->GetStats();
1510
1511       send_stats_filled_["NumStreams"] |=
1512           stats.substreams.size() == expected_send_ssrcs_.size();
1513
1514       for (std::map<uint32_t, SsrcStats>::const_iterator it =
1515                stats.substreams.begin();
1516            it != stats.substreams.end();
1517            ++it) {
1518         EXPECT_TRUE(expected_send_ssrcs_.find(it->first) !=
1519                     expected_send_ssrcs_.end());
1520
1521         send_stats_filled_[CompoundKey("IncomingRate", it->first)] |=
1522             stats.input_frame_rate != 0;
1523
1524         const SsrcStats& stream_stats = it->second;
1525
1526         send_stats_filled_[CompoundKey("StatisticsUpdated", it->first)] |=
1527             stream_stats.rtcp_stats.cumulative_lost != 0 ||
1528             stream_stats.rtcp_stats.extended_max_sequence_number != 0 ||
1529             stream_stats.rtcp_stats.fraction_lost != 0;
1530
1531         send_stats_filled_[CompoundKey("DataCountersUpdated", it->first)] |=
1532             stream_stats.rtp_stats.fec_packets != 0 ||
1533             stream_stats.rtp_stats.padding_bytes != 0 ||
1534             stream_stats.rtp_stats.retransmitted_packets != 0 ||
1535             stream_stats.rtp_stats.packets != 0;
1536
1537         send_stats_filled_[CompoundKey("BitrateStatisticsObserver",
1538                                        it->first)] |=
1539             stream_stats.total_bitrate_bps != 0;
1540
1541         send_stats_filled_[CompoundKey("FrameCountObserver", it->first)] |=
1542             stream_stats.delta_frames != 0 || stream_stats.key_frames != 0;
1543
1544         send_stats_filled_[CompoundKey("OutgoingRate", it->first)] |=
1545             stats.encode_frame_rate != 0;
1546
1547         send_stats_filled_[CompoundKey("Delay", it->first)] |=
1548             stream_stats.avg_delay_ms != 0 || stream_stats.max_delay_ms != 0;
1549       }
1550
1551       return AllStatsFilled(send_stats_filled_);
1552     }
1553
1554     std::string CompoundKey(const char* name, uint32_t ssrc) {
1555       std::ostringstream oss;
1556       oss << name << "_" << ssrc;
1557       return oss.str();
1558     }
1559
1560     bool AllStatsFilled(const std::map<std::string, bool>& stats_map) {
1561       for (std::map<std::string, bool>::const_iterator it = stats_map.begin();
1562            it != stats_map.end();
1563            ++it) {
1564         if (!it->second)
1565           return false;
1566       }
1567       return true;
1568     }
1569
1570     virtual void ModifyConfigs(
1571         VideoSendStream::Config* send_config,
1572         std::vector<VideoReceiveStream::Config>* receive_configs,
1573         VideoEncoderConfig* encoder_config) OVERRIDE {
1574       send_config->pre_encode_callback = this;  // Used to inject delay.
1575       send_config->rtp.c_name = "SomeCName";
1576
1577       expected_receive_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
1578       const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs;
1579       for (size_t i = 0; i < ssrcs.size(); ++i)
1580         expected_send_ssrcs_.insert(ssrcs[i]);
1581
1582       expected_cname_ = send_config->rtp.c_name;
1583     }
1584
1585     virtual void OnStreamsCreated(
1586         VideoSendStream* send_stream,
1587         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
1588       send_stream_ = send_stream;
1589       receive_stream_ = receive_streams[0];
1590     }
1591
1592     virtual void PerformTest() OVERRIDE {
1593       Clock* clock = Clock::GetRealTimeClock();
1594       int64_t now = clock->TimeInMilliseconds();
1595       int64_t stop_time = now + test::CallTest::kLongTimeoutMs;
1596       bool receive_ok = false;
1597       bool send_ok = false;
1598
1599       while (now < stop_time) {
1600         if (!receive_ok)
1601           receive_ok = CheckReceiveStats();
1602         if (!send_ok)
1603           send_ok = CheckSendStats();
1604
1605         if (receive_ok && send_ok)
1606           return;
1607
1608         int64_t time_until_timout_ = stop_time - now;
1609         if (time_until_timout_ > 0)
1610           check_stats_event_->Wait(time_until_timout_);
1611         now = clock->TimeInMilliseconds();
1612       }
1613
1614       ADD_FAILURE() << "Timed out waiting for filled stats.";
1615       for (std::map<std::string, bool>::const_iterator it =
1616                receive_stats_filled_.begin();
1617            it != receive_stats_filled_.end();
1618            ++it) {
1619         if (!it->second) {
1620           ADD_FAILURE() << "Missing receive stats: " << it->first;
1621         }
1622       }
1623
1624       for (std::map<std::string, bool>::const_iterator it =
1625                send_stats_filled_.begin();
1626            it != send_stats_filled_.end();
1627            ++it) {
1628         if (!it->second) {
1629           ADD_FAILURE() << "Missing send stats: " << it->first;
1630         }
1631       }
1632     }
1633
1634     VideoReceiveStream* receive_stream_;
1635     std::map<std::string, bool> receive_stats_filled_;
1636
1637     VideoSendStream* send_stream_;
1638     std::map<std::string, bool> send_stats_filled_;
1639
1640     uint32_t expected_receive_ssrc_;
1641     std::set<uint32_t> expected_send_ssrcs_;
1642     std::string expected_cname_;
1643
1644     scoped_ptr<EventWrapper> check_stats_event_;
1645   } test;
1646
1647   RunBaseTest(&test);
1648 }
1649
1650 TEST_F(EndToEndTest, ReceiverReferenceTimeReportEnabled) {
1651   TestXrReceiverReferenceTimeReport(true);
1652 }
1653
1654 TEST_F(EndToEndTest, ReceiverReferenceTimeReportDisabled) {
1655   TestXrReceiverReferenceTimeReport(false);
1656 }
1657
1658 TEST_F(EndToEndTest, TestReceivedRtpPacketStats) {
1659   static const size_t kNumRtpPacketsToSend = 5;
1660   class ReceivedRtpStatsObserver : public test::EndToEndTest {
1661    public:
1662     ReceivedRtpStatsObserver()
1663         : EndToEndTest(kDefaultTimeoutMs),
1664           receive_stream_(NULL),
1665           sent_rtp_(0) {}
1666
1667    private:
1668     virtual void OnStreamsCreated(
1669         VideoSendStream* send_stream,
1670         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
1671       receive_stream_ = receive_streams[0];
1672     }
1673
1674     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1675       if (sent_rtp_ >= kNumRtpPacketsToSend) {
1676         VideoReceiveStream::Stats stats = receive_stream_->GetStats();
1677         if (kNumRtpPacketsToSend == stats.rtp_stats.packets) {
1678           observation_complete_->Set();
1679         }
1680         return DROP_PACKET;
1681       }
1682       ++sent_rtp_;
1683       return SEND_PACKET;
1684     }
1685
1686     virtual void PerformTest() OVERRIDE {
1687       EXPECT_EQ(kEventSignaled, Wait())
1688           << "Timed out while verifying number of received RTP packets.";
1689     }
1690
1691     VideoReceiveStream* receive_stream_;
1692     uint32_t sent_rtp_;
1693   } test;
1694
1695   RunBaseTest(&test);
1696 }
1697
1698 TEST_F(EndToEndTest, SendsSetSsrc) { TestSendsSetSsrcs(1, false); }
1699
1700 TEST_F(EndToEndTest, SendsSetSimulcastSsrcs) {
1701   TestSendsSetSsrcs(kNumSsrcs, false);
1702 }
1703
1704 TEST_F(EndToEndTest, CanSwitchToUseAllSsrcs) {
1705   TestSendsSetSsrcs(kNumSsrcs, true);
1706 }
1707
1708 TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
1709   class ObserveRedundantPayloads: public test::EndToEndTest {
1710    public:
1711     ObserveRedundantPayloads()
1712         : EndToEndTest(kDefaultTimeoutMs), ssrcs_to_observe_(kNumSsrcs) {
1713           for (size_t i = 0; i < kNumSsrcs; ++i) {
1714             registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true;
1715           }
1716         }
1717
1718    private:
1719     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1720       RTPHeader header;
1721       EXPECT_TRUE(parser_->Parse(packet, length, &header));
1722
1723       if (!registered_rtx_ssrc_[header.ssrc])
1724         return SEND_PACKET;
1725
1726       EXPECT_LE(static_cast<size_t>(header.headerLength + header.paddingLength),
1727                 length);
1728       const bool packet_is_redundant_payload =
1729           static_cast<size_t>(header.headerLength + header.paddingLength) <
1730           length;
1731
1732       if (!packet_is_redundant_payload)
1733         return SEND_PACKET;
1734
1735       if (!observed_redundant_retransmission_[header.ssrc]) {
1736         observed_redundant_retransmission_[header.ssrc] = true;
1737         if (--ssrcs_to_observe_ == 0)
1738           observation_complete_->Set();
1739       }
1740
1741       return SEND_PACKET;
1742     }
1743
1744     virtual size_t GetNumStreams() const OVERRIDE { return kNumSsrcs; }
1745
1746     virtual void ModifyConfigs(
1747         VideoSendStream::Config* send_config,
1748         std::vector<VideoReceiveStream::Config>* receive_configs,
1749         VideoEncoderConfig* encoder_config) OVERRIDE {
1750       // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
1751       for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
1752         encoder_config->streams[i].min_bitrate_bps = 10000;
1753         encoder_config->streams[i].target_bitrate_bps = 15000;
1754         encoder_config->streams[i].max_bitrate_bps = 20000;
1755       }
1756
1757       send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
1758       send_config->rtp.rtx.pad_with_redundant_payloads = true;
1759
1760       for (size_t i = 0; i < kNumSsrcs; ++i)
1761         send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
1762
1763       // Significantly higher than max bitrates for all video streams -> forcing
1764       // padding to trigger redundant padding on all RTX SSRCs.
1765       encoder_config->min_transmit_bitrate_bps = 100000;
1766     }
1767
1768     virtual void PerformTest() OVERRIDE {
1769       EXPECT_EQ(kEventSignaled, Wait())
1770           << "Timed out while waiting for redundant payloads on all SSRCs.";
1771     }
1772
1773    private:
1774     size_t ssrcs_to_observe_;
1775     std::map<uint32_t, bool> observed_redundant_retransmission_;
1776     std::map<uint32_t, bool> registered_rtx_ssrc_;
1777   } test;
1778
1779   RunBaseTest(&test);
1780 }
1781
1782 void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
1783   static const uint32_t kMaxSequenceNumberGap = 100;
1784   static const uint64_t kMaxTimestampGap = kDefaultTimeoutMs * 90;
1785   class RtpSequenceObserver : public test::RtpRtcpObserver {
1786    public:
1787     explicit RtpSequenceObserver(bool use_rtx)
1788         : test::RtpRtcpObserver(kDefaultTimeoutMs),
1789           crit_(CriticalSectionWrapper::CreateCriticalSection()),
1790           ssrcs_to_observe_(kNumSsrcs) {
1791       for (size_t i = 0; i < kNumSsrcs; ++i) {
1792         configured_ssrcs_[kSendSsrcs[i]] = true;
1793         if (use_rtx)
1794           configured_ssrcs_[kSendRtxSsrcs[i]] = true;
1795       }
1796     }
1797
1798     void ResetExpectedSsrcs(size_t num_expected_ssrcs) {
1799       CriticalSectionScoped lock(crit_.get());
1800       ssrc_observed_.clear();
1801       ssrcs_to_observe_ = num_expected_ssrcs;
1802     }
1803
1804    private:
1805     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1806       RTPHeader header;
1807       EXPECT_TRUE(parser_->Parse(packet, length, &header));
1808       const uint32_t ssrc = header.ssrc;
1809       const uint16_t sequence_number = header.sequenceNumber;
1810       const uint32_t timestamp = header.timestamp;
1811       const bool only_padding =
1812           static_cast<size_t>(header.headerLength + header.paddingLength) ==
1813           length;
1814
1815       EXPECT_TRUE(configured_ssrcs_[ssrc])
1816           << "Received SSRC that wasn't configured: " << ssrc;
1817
1818       std::map<uint32_t, uint16_t>::iterator it =
1819           last_observed_sequence_number_.find(header.ssrc);
1820       if (it == last_observed_sequence_number_.end()) {
1821         last_observed_sequence_number_[ssrc] = sequence_number;
1822         last_observed_timestamp_[ssrc] = timestamp;
1823       } else {
1824         // Verify sequence numbers are reasonably close.
1825         uint32_t extended_sequence_number = sequence_number;
1826         // Check for roll-over.
1827         if (sequence_number < last_observed_sequence_number_[ssrc])
1828           extended_sequence_number += 0xFFFFu + 1;
1829         EXPECT_LE(
1830             extended_sequence_number - last_observed_sequence_number_[ssrc],
1831             kMaxSequenceNumberGap)
1832             << "Gap in sequence numbers ("
1833             << last_observed_sequence_number_[ssrc] << " -> " << sequence_number
1834             << ") too large for SSRC: " << ssrc << ".";
1835         last_observed_sequence_number_[ssrc] = sequence_number;
1836
1837         // TODO(pbos): Remove this check if we ever have monotonically
1838         // increasing timestamps. Right now padding packets add a delta which
1839         // can cause reordering between padding packets and regular packets,
1840         // hence we drop padding-only packets to not flake.
1841         if (only_padding) {
1842           // Verify that timestamps are reasonably close.
1843           uint64_t extended_timestamp = timestamp;
1844           // Check for roll-over.
1845           if (timestamp < last_observed_timestamp_[ssrc])
1846             extended_timestamp += static_cast<uint64_t>(0xFFFFFFFFu) + 1;
1847           EXPECT_LE(extended_timestamp - last_observed_timestamp_[ssrc],
1848                     kMaxTimestampGap)
1849               << "Gap in timestamps (" << last_observed_timestamp_[ssrc]
1850               << " -> " << timestamp << ") too large for SSRC: " << ssrc << ".";
1851         }
1852         last_observed_timestamp_[ssrc] = timestamp;
1853       }
1854
1855       CriticalSectionScoped lock(crit_.get());
1856       // Wait for media packets on all ssrcs.
1857       if (!ssrc_observed_[ssrc] && !only_padding) {
1858         ssrc_observed_[ssrc] = true;
1859         if (--ssrcs_to_observe_ == 0)
1860           observation_complete_->Set();
1861       }
1862
1863       return SEND_PACKET;
1864     }
1865
1866     std::map<uint32_t, uint16_t> last_observed_sequence_number_;
1867     std::map<uint32_t, uint32_t> last_observed_timestamp_;
1868     std::map<uint32_t, bool> configured_ssrcs_;
1869
1870     scoped_ptr<CriticalSectionWrapper> crit_;
1871     size_t ssrcs_to_observe_ GUARDED_BY(crit_);
1872     std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
1873   } observer(use_rtx);
1874
1875   CreateCalls(Call::Config(observer.SendTransport()),
1876               Call::Config(observer.ReceiveTransport()));
1877   observer.SetReceivers(sender_call_->Receiver(), NULL);
1878
1879   CreateSendConfig(kNumSsrcs);
1880
1881   if (use_rtx) {
1882     for (size_t i = 0; i < kNumSsrcs; ++i) {
1883       send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
1884     }
1885     send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
1886   }
1887
1888   // Lower bitrates so that all streams send initially.
1889   for (size_t i = 0; i < encoder_config_.streams.size(); ++i) {
1890     encoder_config_.streams[i].min_bitrate_bps = 10000;
1891     encoder_config_.streams[i].target_bitrate_bps = 15000;
1892     encoder_config_.streams[i].max_bitrate_bps = 20000;
1893   }
1894
1895   // Use the same total bitrates when sending a single stream to avoid lowering
1896   // the bitrate estimate and requiring a subsequent rampup.
1897   VideoEncoderConfig one_stream = encoder_config_;
1898   one_stream.streams.resize(1);
1899   for (size_t i = 1; i < encoder_config_.streams.size(); ++i) {
1900     one_stream.streams.front().min_bitrate_bps +=
1901         encoder_config_.streams[i].min_bitrate_bps;
1902     one_stream.streams.front().target_bitrate_bps +=
1903         encoder_config_.streams[i].target_bitrate_bps;
1904     one_stream.streams.front().max_bitrate_bps +=
1905         encoder_config_.streams[i].max_bitrate_bps;
1906   }
1907
1908   CreateMatchingReceiveConfigs();
1909
1910   CreateStreams();
1911   CreateFrameGeneratorCapturer();
1912
1913   Start();
1914   EXPECT_EQ(kEventSignaled, observer.Wait())
1915       << "Timed out waiting for all SSRCs to send packets.";
1916
1917   // Test stream resetting more than once to make sure that the state doesn't
1918   // get set once (this could be due to using std::map::insert for instance).
1919   for (size_t i = 0; i < 3; ++i) {
1920     frame_generator_capturer_->Stop();
1921     sender_call_->DestroyVideoSendStream(send_stream_);
1922
1923     // Re-create VideoSendStream with only one stream.
1924     send_stream_ =
1925         sender_call_->CreateVideoSendStream(send_config_, one_stream);
1926     send_stream_->Start();
1927     CreateFrameGeneratorCapturer();
1928     frame_generator_capturer_->Start();
1929
1930     observer.ResetExpectedSsrcs(1);
1931     EXPECT_EQ(kEventSignaled, observer.Wait())
1932         << "Timed out waiting for single RTP packet.";
1933
1934     // Reconfigure back to use all streams.
1935     send_stream_->ReconfigureVideoEncoder(encoder_config_);
1936     observer.ResetExpectedSsrcs(kNumSsrcs);
1937     EXPECT_EQ(kEventSignaled, observer.Wait())
1938         << "Timed out waiting for all SSRCs to send packets.";
1939
1940     // Reconfigure down to one stream.
1941     send_stream_->ReconfigureVideoEncoder(one_stream);
1942     observer.ResetExpectedSsrcs(1);
1943     EXPECT_EQ(kEventSignaled, observer.Wait())
1944         << "Timed out waiting for single RTP packet.";
1945
1946     // Reconfigure back to use all streams.
1947     send_stream_->ReconfigureVideoEncoder(encoder_config_);
1948     observer.ResetExpectedSsrcs(kNumSsrcs);
1949     EXPECT_EQ(kEventSignaled, observer.Wait())
1950         << "Timed out waiting for all SSRCs to send packets.";
1951   }
1952
1953   observer.StopSending();
1954
1955   Stop();
1956   DestroyStreams();
1957 }
1958
1959 TEST_F(EndToEndTest, DISABLED_RestartingSendStreamPreservesRtpState) {
1960   TestRtpStatePreservation(false);
1961 }
1962
1963 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) {
1964   TestRtpStatePreservation(true);
1965 }
1966
1967 TEST_F(EndToEndTest, RespectsNetworkState) {
1968   // TODO(pbos): Remove accepted downtime packets etc. when signaling network
1969   // down blocks until no more packets will be sent.
1970
1971   // Pacer will send from its packet list and then send required padding before
1972   // checking paused_ again. This should be enough for one round of pacing,
1973   // otherwise increase.
1974   static const int kNumAcceptedDowntimeRtp = 5;
1975   // A single RTCP may be in the pipeline.
1976   static const int kNumAcceptedDowntimeRtcp = 1;
1977   class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
1978    public:
1979     NetworkStateTest()
1980         : EndToEndTest(kDefaultTimeoutMs),
1981           FakeEncoder(Clock::GetRealTimeClock()),
1982           test_crit_(CriticalSectionWrapper::CreateCriticalSection()),
1983           encoded_frames_(EventWrapper::Create()),
1984           sender_packets_(EventWrapper::Create()),
1985           receiver_packets_(EventWrapper::Create()),
1986           sender_state_(Call::kNetworkUp),
1987           down_sender_rtp_(0),
1988           down_sender_rtcp_(0),
1989           receiver_state_(Call::kNetworkUp),
1990           down_receiver_rtcp_(0),
1991           down_frames_(0) {}
1992
1993     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1994       CriticalSectionScoped lock(test_crit_.get());
1995       if (sender_state_ == Call::kNetworkDown) {
1996         ++down_sender_rtp_;
1997         EXPECT_LE(down_sender_rtp_, kNumAcceptedDowntimeRtp)
1998             << "RTP sent during sender-side downtime.";
1999         if (down_sender_rtp_> kNumAcceptedDowntimeRtp)
2000           sender_packets_->Set();
2001       } else {
2002         sender_packets_->Set();
2003       }
2004       return SEND_PACKET;
2005     }
2006
2007     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
2008       CriticalSectionScoped lock(test_crit_.get());
2009       if (sender_state_ == Call::kNetworkDown) {
2010         ++down_sender_rtcp_;
2011         EXPECT_LE(down_sender_rtcp_, kNumAcceptedDowntimeRtcp)
2012             << "RTCP sent during sender-side downtime.";
2013         if (down_sender_rtcp_ > kNumAcceptedDowntimeRtcp)
2014           sender_packets_->Set();
2015       } else {
2016         sender_packets_->Set();
2017       }
2018       return SEND_PACKET;
2019     }
2020
2021     virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) OVERRIDE {
2022       ADD_FAILURE() << "Unexpected receiver RTP, should not be sending.";
2023       return SEND_PACKET;
2024     }
2025
2026     virtual Action OnReceiveRtcp(const uint8_t* packet,
2027                                  size_t length) OVERRIDE {
2028       CriticalSectionScoped lock(test_crit_.get());
2029       if (receiver_state_ == Call::kNetworkDown) {
2030         ++down_receiver_rtcp_;
2031         EXPECT_LE(down_receiver_rtcp_, kNumAcceptedDowntimeRtcp)
2032             << "RTCP sent during receiver-side downtime.";
2033         if (down_receiver_rtcp_ > kNumAcceptedDowntimeRtcp)
2034           receiver_packets_->Set();
2035       } else {
2036         receiver_packets_->Set();
2037       }
2038       return SEND_PACKET;
2039     }
2040
2041     virtual void OnCallsCreated(Call* sender_call,
2042                                 Call* receiver_call) OVERRIDE {
2043       sender_call_ = sender_call;
2044       receiver_call_ = receiver_call;
2045     }
2046
2047     virtual void ModifyConfigs(
2048         VideoSendStream::Config* send_config,
2049         std::vector<VideoReceiveStream::Config>* receive_configs,
2050         VideoEncoderConfig* encoder_config) OVERRIDE {
2051       send_config->encoder_settings.encoder = this;
2052     }
2053
2054     virtual void PerformTest() OVERRIDE {
2055       EXPECT_EQ(kEventSignaled, encoded_frames_->Wait(kDefaultTimeoutMs))
2056           << "No frames received by the encoder.";
2057       EXPECT_EQ(kEventSignaled, sender_packets_->Wait(kDefaultTimeoutMs))
2058           << "Timed out waiting for send-side packets.";
2059       EXPECT_EQ(kEventSignaled, receiver_packets_->Wait(kDefaultTimeoutMs))
2060           << "Timed out waiting for receiver-side packets.";
2061
2062       // Sender-side network down.
2063       sender_call_->SignalNetworkState(Call::kNetworkDown);
2064       {
2065         CriticalSectionScoped lock(test_crit_.get());
2066         sender_packets_->Reset();  // Earlier packets should not count.
2067         sender_state_ = Call::kNetworkDown;
2068       }
2069       EXPECT_EQ(kEventTimeout, sender_packets_->Wait(kSilenceTimeoutMs))
2070           << "Packets sent during sender-network downtime.";
2071       EXPECT_EQ(kEventSignaled, receiver_packets_->Wait(kDefaultTimeoutMs))
2072           << "Timed out waiting for receiver-side packets.";
2073       // Receiver-side network down.
2074       receiver_call_->SignalNetworkState(Call::kNetworkDown);
2075       {
2076         CriticalSectionScoped lock(test_crit_.get());
2077         receiver_packets_->Reset();  // Earlier packets should not count.
2078         receiver_state_ = Call::kNetworkDown;
2079       }
2080       EXPECT_EQ(kEventTimeout, receiver_packets_->Wait(kSilenceTimeoutMs))
2081           << "Packets sent during receiver-network downtime.";
2082
2083       // Network back up again for both.
2084       {
2085         CriticalSectionScoped lock(test_crit_.get());
2086         sender_packets_->Reset();  // Earlier packets should not count.
2087         receiver_packets_->Reset();  // Earlier packets should not count.
2088         sender_state_ = receiver_state_ = Call::kNetworkUp;
2089       }
2090       sender_call_->SignalNetworkState(Call::kNetworkUp);
2091       receiver_call_->SignalNetworkState(Call::kNetworkUp);
2092       EXPECT_EQ(kEventSignaled, sender_packets_->Wait(kDefaultTimeoutMs))
2093           << "Timed out waiting for send-side packets.";
2094       EXPECT_EQ(kEventSignaled, receiver_packets_->Wait(kDefaultTimeoutMs))
2095           << "Timed out waiting for receiver-side packets.";
2096     }
2097
2098     virtual int32_t Encode(const I420VideoFrame& input_image,
2099                            const CodecSpecificInfo* codec_specific_info,
2100                            const std::vector<VideoFrameType>* frame_types)
2101         OVERRIDE {
2102       {
2103         CriticalSectionScoped lock(test_crit_.get());
2104         if (sender_state_ == Call::kNetworkDown) {
2105           ++down_frames_;
2106           EXPECT_LE(down_frames_, 1)
2107               << "Encoding more than one frame while network is down.";
2108           if (down_frames_ > 1)
2109             encoded_frames_->Set();
2110         } else {
2111           encoded_frames_->Set();
2112         }
2113       }
2114       return test::FakeEncoder::Encode(
2115           input_image, codec_specific_info, frame_types);
2116     }
2117
2118    private:
2119     const scoped_ptr<CriticalSectionWrapper> test_crit_;
2120     scoped_ptr<EventWrapper> encoded_frames_;
2121     scoped_ptr<EventWrapper> sender_packets_;
2122     scoped_ptr<EventWrapper> receiver_packets_;
2123     Call* sender_call_;
2124     Call* receiver_call_;
2125     Call::NetworkState sender_state_ GUARDED_BY(test_crit_);
2126     int down_sender_rtp_ GUARDED_BY(test_crit_);
2127     int down_sender_rtcp_ GUARDED_BY(test_crit_);
2128     Call::NetworkState receiver_state_ GUARDED_BY(test_crit_);
2129     int down_receiver_rtcp_ GUARDED_BY(test_crit_);
2130     int down_frames_ GUARDED_BY(test_crit_);
2131   } test;
2132
2133   RunBaseTest(&test);
2134 }
2135
2136 TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) {
2137   class UnusedEncoder : public test::FakeEncoder {
2138     public:
2139      UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {}
2140     virtual int32_t Encode(const I420VideoFrame& input_image,
2141                            const CodecSpecificInfo* codec_specific_info,
2142                            const std::vector<VideoFrameType>* frame_types)
2143         OVERRIDE {
2144       ADD_FAILURE() << "Unexpected frame encode.";
2145       return test::FakeEncoder::Encode(
2146           input_image, codec_specific_info, frame_types);
2147     }
2148   };
2149
2150   UnusedTransport transport;
2151   CreateSenderCall(Call::Config(&transport));
2152   sender_call_->SignalNetworkState(Call::kNetworkDown);
2153
2154   CreateSendConfig(1);
2155   UnusedEncoder unused_encoder;
2156   send_config_.encoder_settings.encoder = &unused_encoder;
2157   CreateStreams();
2158   CreateFrameGeneratorCapturer();
2159
2160   Start();
2161   SleepMs(kSilenceTimeoutMs);
2162   Stop();
2163
2164   DestroyStreams();
2165 }
2166
2167 TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) {
2168   test::DirectTransport sender_transport;
2169   CreateSenderCall(Call::Config(&sender_transport));
2170   UnusedTransport transport;
2171   CreateReceiverCall(Call::Config(&transport));
2172   sender_transport.SetReceiver(receiver_call_->Receiver());
2173
2174   receiver_call_->SignalNetworkState(Call::kNetworkDown);
2175
2176   CreateSendConfig(1);
2177   CreateMatchingReceiveConfigs();
2178   CreateStreams();
2179   CreateFrameGeneratorCapturer();
2180
2181   Start();
2182   SleepMs(kSilenceTimeoutMs);
2183   Stop();
2184
2185   sender_transport.StopSending();
2186
2187   DestroyStreams();
2188 }
2189
2190 // TODO(pbos): Remove this regression test when VideoEngine is no longer used as
2191 // a backend. This is to test that we hand channels back properly.
2192 TEST_F(EndToEndTest, CanCreateAndDestroyManyVideoStreams) {
2193   test::NullTransport transport;
2194   scoped_ptr<Call> call(Call::Create(Call::Config(&transport)));
2195   test::FakeDecoder fake_decoder;
2196   test::FakeEncoder fake_encoder(Clock::GetRealTimeClock());
2197   for (size_t i = 0; i < 100; ++i) {
2198     VideoSendStream::Config send_config;
2199     send_config.encoder_settings.encoder = &fake_encoder;
2200     send_config.encoder_settings.payload_name = "FAKE";
2201     send_config.encoder_settings.payload_type = 123;
2202
2203     VideoEncoderConfig encoder_config;
2204     encoder_config.streams = test::CreateVideoStreams(1);
2205     send_config.rtp.ssrcs.push_back(1);
2206     VideoSendStream* send_stream =
2207         call->CreateVideoSendStream(send_config, encoder_config);
2208     call->DestroyVideoSendStream(send_stream);
2209
2210     VideoReceiveStream::Config receive_config;
2211     receive_config.rtp.remote_ssrc = 1;
2212     receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
2213     VideoReceiveStream::Decoder decoder;
2214     decoder.decoder = &fake_decoder;
2215     decoder.payload_type = 123;
2216     decoder.payload_name = "FAKE";
2217     receive_config.decoders.push_back(decoder);
2218     VideoReceiveStream* receive_stream =
2219         call->CreateVideoReceiveStream(receive_config);
2220     call->DestroyVideoReceiveStream(receive_stream);
2221   }
2222 }
2223
2224 }  // namespace webrtc