Home | History | Annotate | Download | only in source 
      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 
     11 #include "testing/gmock/include/gmock/gmock.h"
     12 #include "testing/gtest/include/gtest/gtest.h"
     13 
     14 #include "webrtc/common_types.h"
     15 #include "webrtc/modules/pacing/include/mock/mock_paced_sender.h"
     16 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
     17 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
     18 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
     19 #include "webrtc/system_wrappers/interface/scoped_vector.h"
     20 
     21 using ::testing::_;
     22 using ::testing::NiceMock;
     23 using ::testing::Return;
     24 using ::testing::SaveArg;
     25 
     26 namespace webrtc {
     27 namespace {
     28 const uint32_t kSenderSsrc = 0x12345;
     29 const uint32_t kReceiverSsrc = 0x23456;
     30 const uint32_t kSenderRtxSsrc = 0x32345;
     31 const uint32_t kOneWayNetworkDelayMs = 100;
     32 
     33 class RtcpRttStatsTestImpl : public RtcpRttStats {
     34  public:
     35   RtcpRttStatsTestImpl() : rtt_ms_(0) {}
     36   virtual ~RtcpRttStatsTestImpl() {}
     37 
     38   virtual void OnRttUpdate(uint32_t rtt_ms) {
     39     rtt_ms_ = rtt_ms;
     40   }
     41   virtual uint32_t LastProcessedRtt() const {
     42     return rtt_ms_;
     43   }
     44   uint32_t rtt_ms_;
     45 };
     46 
     47 class SendTransport : public Transport,
     48                       public NullRtpData {
     49  public:
     50   SendTransport() : receiver_(NULL), clock_(NULL), delay_ms_(0) {}
     51 
     52   void SetRtpRtcpModule(ModuleRtpRtcpImpl* receiver) {
     53     receiver_ = receiver;
     54   }
     55   void SimulateNetworkDelay(uint32_t delay_ms, SimulatedClock* clock) {
     56     clock_ = clock;
     57     delay_ms_ = delay_ms;
     58   }
     59   virtual int SendPacket(int /*ch*/, const void* /*data*/, int /*len*/) {
     60     return -1;
     61   }
     62   virtual int SendRTCPPacket(int /*ch*/, const void *data, int len) {
     63     if (clock_) {
     64       clock_->AdvanceTimeMilliseconds(delay_ms_);
     65     }
     66     EXPECT_TRUE(receiver_ != NULL);
     67     EXPECT_EQ(0, receiver_->IncomingRtcpPacket(
     68         static_cast<const uint8_t*>(data), len));
     69     return len;
     70   }
     71   ModuleRtpRtcpImpl* receiver_;
     72   SimulatedClock* clock_;
     73   uint32_t delay_ms_;
     74 };
     75 
     76 class RtpRtcpModule {
     77  public:
     78   RtpRtcpModule(SimulatedClock* clock)
     79       : receive_statistics_(ReceiveStatistics::Create(clock)) {
     80     RtpRtcp::Configuration config;
     81     config.audio = false;
     82     config.clock = clock;
     83     config.outgoing_transport = &transport_;
     84     config.receive_statistics = receive_statistics_.get();
     85     config.rtt_stats = &rtt_stats_;
     86 
     87     impl_.reset(new ModuleRtpRtcpImpl(config));
     88     EXPECT_EQ(0, impl_->SetRTCPStatus(kRtcpCompound));
     89 
     90     transport_.SimulateNetworkDelay(kOneWayNetworkDelayMs, clock);
     91   }
     92 
     93   RtcpPacketTypeCounter packets_sent_;
     94   RtcpPacketTypeCounter packets_received_;
     95   scoped_ptr<ReceiveStatistics> receive_statistics_;
     96   SendTransport transport_;
     97   RtcpRttStatsTestImpl rtt_stats_;
     98   scoped_ptr<ModuleRtpRtcpImpl> impl_;
     99 
    100   RtcpPacketTypeCounter RtcpSent() {
    101     impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_);
    102     return packets_sent_;
    103   }
    104   RtcpPacketTypeCounter RtcpReceived() {
    105     impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_);
    106     return packets_received_;
    107   }
    108 };
    109 }  // namespace
    110 
    111 class RtpRtcpImplTest : public ::testing::Test {
    112  protected:
    113   RtpRtcpImplTest()
    114       : clock_(1335900000),
    115         sender_(&clock_),
    116         receiver_(&clock_) {
    117     // Send module.
    118     EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
    119     sender_.impl_->SetSSRC(kSenderSsrc);
    120     sender_.impl_->SetRemoteSSRC(kReceiverSsrc);
    121     // Receive module.
    122     EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
    123     receiver_.impl_->SetSSRC(kReceiverSsrc);
    124     receiver_.impl_->SetRemoteSSRC(kSenderSsrc);
    125     // Transport settings.
    126     sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get());
    127     receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
    128   }
    129   SimulatedClock clock_;
    130   RtpRtcpModule sender_;
    131   RtpRtcpModule receiver_;
    132 };
    133 
    134 TEST_F(RtpRtcpImplTest, Rtt) {
    135   RTPHeader header;
    136   header.timestamp = 1;
    137   header.sequenceNumber = 123;
    138   header.ssrc = kSenderSsrc;
    139   header.headerLength = 12;
    140   receiver_.receive_statistics_->IncomingPacket(header, 100, false);
    141 
    142   // Sender module should send a SR.
    143   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
    144 
    145   // Receiver module should send a RR with a response to the last received SR.
    146   clock_.AdvanceTimeMilliseconds(1000);
    147   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
    148 
    149   // Verify RTT.
    150   uint16_t rtt;
    151   uint16_t avg_rtt;
    152   uint16_t min_rtt;
    153   uint16_t max_rtt;
    154   EXPECT_EQ(0,
    155       sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt));
    156   EXPECT_EQ(2 * kOneWayNetworkDelayMs, rtt);
    157   EXPECT_EQ(2 * kOneWayNetworkDelayMs, avg_rtt);
    158   EXPECT_EQ(2 * kOneWayNetworkDelayMs, min_rtt);
    159   EXPECT_EQ(2 * kOneWayNetworkDelayMs, max_rtt);
    160 
    161   // No RTT from other ssrc.
    162   EXPECT_EQ(-1,
    163       sender_.impl_->RTT(kReceiverSsrc+1, &rtt, &avg_rtt, &min_rtt, &max_rtt));
    164 
    165   // Verify RTT from rtt_stats config.
    166   EXPECT_EQ(0U, sender_.rtt_stats_.LastProcessedRtt());
    167   EXPECT_EQ(0U, sender_.impl_->rtt_ms());
    168   sender_.impl_->Process();
    169   EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.rtt_stats_.LastProcessedRtt());
    170   EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.impl_->rtt_ms());
    171 }
    172 
    173 TEST_F(RtpRtcpImplTest, SetRtcpXrRrtrStatus) {
    174   EXPECT_FALSE(receiver_.impl_->RtcpXrRrtrStatus());
    175   receiver_.impl_->SetRtcpXrRrtrStatus(true);
    176   EXPECT_TRUE(receiver_.impl_->RtcpXrRrtrStatus());
    177 }
    178 
    179 TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
    180   receiver_.impl_->SetRtcpXrRrtrStatus(true);
    181 
    182   // Receiver module should send a Receiver time reference report (RTRR).
    183   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
    184 
    185   // Sender module should send a response to the last received RTRR (DLRR).
    186   clock_.AdvanceTimeMilliseconds(1000);
    187   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
    188 
    189   // Verify RTT.
    190   EXPECT_EQ(0U, receiver_.rtt_stats_.LastProcessedRtt());
    191   EXPECT_EQ(0U, receiver_.impl_->rtt_ms());
    192   receiver_.impl_->Process();
    193   EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.rtt_stats_.LastProcessedRtt());
    194   EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms());
    195 }
    196 
    197 TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_Nack) {
    198   EXPECT_EQ(0U, sender_.RtcpReceived().nack_packets);
    199   EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
    200   // Receive module sends a NACK.
    201   const uint16_t kNackLength = 1;
    202   uint16_t nack_list[kNackLength] = {123};
    203   EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
    204   EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
    205 
    206   // Send module receives the NACK.
    207   EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
    208 }
    209 
    210 TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_FirAndPli) {
    211   EXPECT_EQ(0U, sender_.RtcpReceived().fir_packets);
    212   EXPECT_EQ(0U, receiver_.RtcpSent().fir_packets);
    213   // Receive module sends a FIR.
    214   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir));
    215   EXPECT_EQ(1U, receiver_.RtcpSent().fir_packets);
    216   // Send module receives the FIR.
    217   EXPECT_EQ(1U, sender_.RtcpReceived().fir_packets);
    218 
    219   // Receive module sends a FIR and PLI.
    220   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir | kRtcpPli));
    221   EXPECT_EQ(2U, receiver_.RtcpSent().fir_packets);
    222   EXPECT_EQ(1U, receiver_.RtcpSent().pli_packets);
    223   // Send module receives the FIR and PLI.
    224   EXPECT_EQ(2U, sender_.RtcpReceived().fir_packets);
    225   EXPECT_EQ(1U, sender_.RtcpReceived().pli_packets);
    226 }
    227 
    228 class RtpSendingTestTransport : public Transport {
    229  public:
    230   void ResetCounters() { bytes_received_.clear(); }
    231 
    232   virtual int SendPacket(int channel, const void* data, int length) {
    233     RTPHeader header;
    234     scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
    235     EXPECT_TRUE(
    236         parser->Parse(static_cast<const uint8_t*>(data), length, &header));
    237     bytes_received_[header.ssrc] += length;
    238     ++packets_received_[header.ssrc];
    239     return length;
    240   }
    241 
    242   virtual int SendRTCPPacket(int channel, const void* data, int length) {
    243     return length;
    244   }
    245 
    246   int GetPacketsReceived(uint32_t ssrc) const {
    247     std::map<uint32_t, int>::const_iterator it = packets_received_.find(ssrc);
    248     if (it == packets_received_.end())
    249       return 0;
    250     return it->second;
    251   }
    252 
    253   int GetBytesReceived(uint32_t ssrc) const {
    254     std::map<uint32_t, int>::const_iterator it = bytes_received_.find(ssrc);
    255     if (it == bytes_received_.end())
    256       return 0;
    257     return it->second;
    258   }
    259 
    260   int GetTotalBytesReceived() const {
    261     int sum = 0;
    262     for (std::map<uint32_t, int>::const_iterator it = bytes_received_.begin();
    263          it != bytes_received_.end();
    264          ++it) {
    265       sum += it->second;
    266     }
    267     return sum;
    268   }
    269 
    270  private:
    271   std::map<uint32_t, int> bytes_received_;
    272   std::map<uint32_t, int> packets_received_;
    273 };
    274 
    275 class RtpSendingTest : public ::testing::Test {
    276  protected:
    277   // Map from SSRC to number of received packets and bytes.
    278   typedef std::map<uint32_t, std::pair<int, int> > PaddingMap;
    279 
    280   RtpSendingTest() {
    281     // Send module.
    282     RtpRtcp::Configuration config;
    283     config.audio = false;
    284     config.clock = Clock::GetRealTimeClock();
    285     config.outgoing_transport = &transport_;
    286     config.receive_statistics = receive_statistics_.get();
    287     config.rtt_stats = &rtt_stats_;
    288     config.paced_sender = &pacer_;
    289     memset(&codec_, 0, sizeof(VideoCodec));
    290     codec_.plType = 100;
    291     strncpy(codec_.plName, "VP8", 3);
    292     codec_.numberOfSimulcastStreams = 3;
    293     codec_.simulcastStream[0].width = 320;
    294     codec_.simulcastStream[0].height = 180;
    295     codec_.simulcastStream[0].maxBitrate = 300;
    296     codec_.simulcastStream[1].width = 640;
    297     codec_.simulcastStream[1].height = 360;
    298     codec_.simulcastStream[1].maxBitrate = 600;
    299     codec_.simulcastStream[2].width = 1280;
    300     codec_.simulcastStream[2].height = 720;
    301     codec_.simulcastStream[2].maxBitrate = 1200;
    302     // We need numberOfSimulcastStreams + 1 RTP modules since we need one
    303     // default module.
    304     for (int i = 0; i < codec_.numberOfSimulcastStreams + 1; ++i) {
    305       RtpRtcp* sender = RtpRtcp::CreateRtpRtcp(config);
    306       EXPECT_EQ(0, sender->RegisterSendPayload(codec_));
    307       EXPECT_EQ(0, sender->SetSendingStatus(true));
    308       EXPECT_EQ(0, sender->SetSendingMediaStatus(true));
    309       sender->SetSSRC(kSenderSsrc + i);
    310       sender->SetRemoteSSRC(kReceiverSsrc + i);
    311       senders_.push_back(sender);
    312       config.default_module = senders_[0];
    313     }
    314     std::vector<uint32_t> bitrates;
    315     bitrates.push_back(codec_.simulcastStream[0].maxBitrate);
    316     bitrates.push_back(codec_.simulcastStream[1].maxBitrate);
    317     bitrates.push_back(codec_.simulcastStream[2].maxBitrate);
    318     senders_[0]->SetTargetSendBitrate(bitrates);
    319   }
    320 
    321   ~RtpSendingTest() {
    322     for (int i = senders_.size() - 1; i >= 0; --i) {
    323       delete senders_[i];
    324     }
    325   }
    326 
    327   void SendFrameOnSender(int sender_index,
    328                          const uint8_t* payload,
    329                          size_t length) {
    330     RTPVideoHeader rtp_video_header = {
    331         codec_.simulcastStream[sender_index].width,
    332         codec_.simulcastStream[sender_index].height,
    333         true,
    334         0,
    335         kRtpVideoVp8,
    336         {}};
    337     uint32_t seq_num = 0;
    338     uint32_t ssrc = 0;
    339     int64_t capture_time_ms = 0;
    340     bool retransmission = false;
    341     EXPECT_CALL(pacer_, SendPacket(_, _, _, _, _, _))
    342         .WillRepeatedly(DoAll(SaveArg<1>(&ssrc),
    343                               SaveArg<2>(&seq_num),
    344                               SaveArg<3>(&capture_time_ms),
    345                               SaveArg<5>(&retransmission),
    346                               Return(true)));
    347     EXPECT_EQ(0,
    348               senders_[sender_index]->SendOutgoingData(kVideoFrameKey,
    349                                                        codec_.plType,
    350                                                        0,
    351                                                        0,
    352                                                        payload,
    353                                                        length,
    354                                                        NULL,
    355                                                        &rtp_video_header));
    356     EXPECT_TRUE(senders_[sender_index]->TimeToSendPacket(
    357         ssrc, seq_num, capture_time_ms, retransmission));
    358   }
    359 
    360   void ExpectPadding(const PaddingMap& expected_padding) {
    361     int expected_total_bytes = 0;
    362     for (PaddingMap::const_iterator it = expected_padding.begin();
    363          it != expected_padding.end();
    364          ++it) {
    365       int packets_received = transport_.GetBytesReceived(it->first);
    366       if (it->second.first > 0) {
    367         EXPECT_GE(packets_received, it->second.first)
    368             << "On SSRC: " << it->first;
    369       }
    370       int bytes_received = transport_.GetBytesReceived(it->first);
    371       expected_total_bytes += bytes_received;
    372       if (it->second.second > 0) {
    373         EXPECT_GE(bytes_received, it->second.second)
    374             << "On SSRC: " << it->first;
    375       } else {
    376         EXPECT_EQ(0, bytes_received) << "On SSRC: " << it->first;
    377       }
    378     }
    379     EXPECT_EQ(expected_total_bytes, transport_.GetTotalBytesReceived());
    380   }
    381 
    382   scoped_ptr<ReceiveStatistics> receive_statistics_;
    383   RtcpRttStatsTestImpl rtt_stats_;
    384   std::vector<RtpRtcp*> senders_;
    385   RtpSendingTestTransport transport_;
    386   NiceMock<MockPacedSender> pacer_;
    387   VideoCodec codec_;
    388 };
    389 
    390 TEST_F(RtpSendingTest, DISABLED_RoundRobinPadding) {
    391   // We have to send on an SSRC to be allowed to pad, since a marker bit must
    392   // be sent prior to padding packets.
    393   const uint8_t payload[200] = {0};
    394   for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
    395     SendFrameOnSender(i + 1, payload, sizeof(payload));
    396   }
    397   transport_.ResetCounters();
    398   senders_[0]->TimeToSendPadding(500);
    399   PaddingMap expected_padding;
    400   expected_padding[kSenderSsrc + 1] = std::make_pair(2, 500);
    401   expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0);
    402   expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0);
    403   ExpectPadding(expected_padding);
    404   senders_[0]->TimeToSendPadding(1000);
    405   expected_padding[kSenderSsrc + 2] = std::make_pair(4, 1000);
    406   ExpectPadding(expected_padding);
    407   senders_[0]->TimeToSendPadding(1500);
    408   expected_padding[kSenderSsrc + 3] = std::make_pair(6, 1500);
    409   ExpectPadding(expected_padding);
    410 }
    411 
    412 TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtx) {
    413   // Enable RTX to allow padding to be sent prior to media.
    414   for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
    415     senders_[i]->SetRtxSendPayloadType(96);
    416     senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
    417     senders_[i]->SetRTXSendStatus(kRtxRetransmitted);
    418   }
    419   transport_.ResetCounters();
    420   senders_[0]->TimeToSendPadding(500);
    421   PaddingMap expected_padding;
    422   expected_padding[kSenderSsrc + 1] = std::make_pair(0, 0);
    423   expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0);
    424   expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0);
    425   expected_padding[kSenderRtxSsrc + 1] = std::make_pair(2, 500);
    426   expected_padding[kSenderRtxSsrc + 2] = std::make_pair(0, 0);
    427   expected_padding[kSenderRtxSsrc + 3] = std::make_pair(0, 0);
    428   ExpectPadding(expected_padding);
    429   senders_[0]->TimeToSendPadding(1000);
    430   expected_padding[kSenderRtxSsrc + 2] = std::make_pair(4, 500);
    431   ExpectPadding(expected_padding);
    432   senders_[0]->TimeToSendPadding(1500);
    433 
    434   expected_padding[kSenderRtxSsrc + 3] = std::make_pair(6, 500);
    435   ExpectPadding(expected_padding);
    436 }
    437 
    438 TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtxRedundantPayloads) {
    439   for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
    440     senders_[i]->SetRtxSendPayloadType(96);
    441     senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
    442     senders_[i]->SetRTXSendStatus(kRtxRetransmitted | kRtxRedundantPayloads);
    443     senders_[i]->SetStorePacketsStatus(true, 100);
    444   }
    445   // First send payloads so that we have something to retransmit.
    446   const size_t kPayloadSize = 500;
    447   const uint8_t payload[kPayloadSize] = {0};
    448   for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
    449     SendFrameOnSender(i + 1, payload, sizeof(payload));
    450   }
    451   transport_.ResetCounters();
    452   senders_[0]->TimeToSendPadding(500);
    453   PaddingMap expected_padding;
    454   expected_padding[kSenderSsrc + 1] = std::make_pair<int, int>(0, 0);
    455   expected_padding[kSenderSsrc + 2] = std::make_pair<int, int>(0, 0);
    456   expected_padding[kSenderSsrc + 3] = std::make_pair<int, int>(0, 0);
    457   expected_padding[kSenderRtxSsrc + 1] = std::make_pair<int, int>(1, 500);
    458   expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(0, 0);
    459   expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(0, 0);
    460   ExpectPadding(expected_padding);
    461   senders_[0]->TimeToSendPadding(1000);
    462   expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(2, 1000);
    463   ExpectPadding(expected_padding);
    464   senders_[0]->TimeToSendPadding(1500);
    465   expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(3, 1500);
    466   ExpectPadding(expected_padding);
    467 }
    468 }  // namespace webrtc
    469