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