src/third_party/webrtc/video/video_send_stream_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 <algorithm>  // max
  11
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 #include "webrtc/call.h"
  15 #include "webrtc/common_video/interface/i420_video_frame.h"
  16 #include "webrtc/common_video/interface/native_handle.h"
  17 #include "webrtc/common_video/interface/texture_video_frame.h"
  18 #include "webrtc/frame_callback.h"
  19 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
  20 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
  21 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
  22 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.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/ref_count.h"
  26 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  27 #include "webrtc/system_wrappers/interface/scoped_vector.h"
  28 #include "webrtc/system_wrappers/interface/sleep.h"
  29 #include "webrtc/system_wrappers/interface/thread_wrapper.h"
  30 #include "webrtc/system_wrappers/interface/logging.h"
  31 #include "webrtc/test/call_test.h"
  32 #include "webrtc/test/configurable_frame_size_encoder.h"
  33 #include "webrtc/test/null_transport.h"
  34 #include "webrtc/test/testsupport/perf_test.h"
  35 #include "webrtc/video/transport_adapter.h"
  36 #include "webrtc/video_send_stream.h"
  37
  38 namespace webrtc {
  39
  40 enum VideoFormat { kGeneric, kVP8, };
  41
  42 void ExpectEqualFrames(const I420VideoFrame& frame1,
  43                        const I420VideoFrame& frame2);
  44 void ExpectEqualTextureFrames(const I420VideoFrame& frame1,
  45                               const I420VideoFrame& frame2);
  46 void ExpectEqualBufferFrames(const I420VideoFrame& frame1,
  47                              const I420VideoFrame& frame2);
  48 void ExpectEqualFramesVector(const std::vector<I420VideoFrame*>& frames1,
  49                              const std::vector<I420VideoFrame*>& frames2);
  50 I420VideoFrame* CreateI420VideoFrame(int width, int height, uint8_t data);
  51
  52 class FakeNativeHandle : public NativeHandle {
  53  public:
  54   FakeNativeHandle() {}
  55   virtual ~FakeNativeHandle() {}
  56   virtual void* GetHandle() { return NULL; }
  57 };
  58
  59 class VideoSendStreamTest : public test::CallTest {
  60  protected:
  61   void TestNackRetransmission(uint32_t retransmit_ssrc,
  62                               uint8_t retransmit_payload_type);
  63   void TestPacketFragmentationSize(VideoFormat format, bool with_fec);
  64 };
  65
  66 TEST_F(VideoSendStreamTest, CanStartStartedStream) {
  67   test::NullTransport transport;
  68   Call::Config call_config(&transport);
  69   CreateSenderCall(call_config);
  70
  71   CreateSendConfig(1);
  72   CreateStreams();
  73   send_stream_->Start();
  74   send_stream_->Start();
  75   DestroyStreams();
  76 }
  77
  78 TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
  79   test::NullTransport transport;
  80   Call::Config call_config(&transport);
  81   CreateSenderCall(call_config);
  82
  83   CreateSendConfig(1);
  84   CreateStreams();
  85   send_stream_->Stop();
  86   send_stream_->Stop();
  87   DestroyStreams();
  88 }
  89
  90 TEST_F(VideoSendStreamTest, SupportsCName) {
  91   static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
  92   class CNameObserver : public test::SendTest {
  93    public:
  94     CNameObserver() : SendTest(kDefaultTimeoutMs) {}
  95
  96    private:
  97     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
  98       RTCPUtility::RTCPParserV2 parser(packet, length, true);
  99       EXPECT_TRUE(parser.IsValid());
 100
 101       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
 102       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
 103         if (packet_type == RTCPUtility::kRtcpSdesChunkCode) {
 104           EXPECT_EQ(parser.Packet().CName.CName, kCName);
 105           observation_complete_->Set();
 106         }
 107
 108         packet_type = parser.Iterate();
 109       }
 110
 111       return SEND_PACKET;
 112     }
 113
 114     virtual void ModifyConfigs(
 115         VideoSendStream::Config* send_config,
 116         std::vector<VideoReceiveStream::Config>* receive_configs,
 117         VideoEncoderConfig* encoder_config) OVERRIDE {
 118       send_config->rtp.c_name = kCName;
 119     }
 120
 121     virtual void PerformTest() OVERRIDE {
 122       EXPECT_EQ(kEventSignaled, Wait())
 123           << "Timed out while waiting for RTCP with CNAME.";
 124     }
 125   } test;
 126
 127   RunBaseTest(&test);
 128 }
 129
 130 TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
 131   static const uint8_t kAbsSendTimeExtensionId = 13;
 132   class AbsoluteSendTimeObserver : public test::SendTest {
 133    public:
 134     AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) {
 135       EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
 136           kRtpExtensionAbsoluteSendTime, kAbsSendTimeExtensionId));
 137     }
 138
 139     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 140       RTPHeader header;
 141       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 142
 143       EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
 144       EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
 145       EXPECT_EQ(header.extension.transmissionTimeOffset, 0);
 146       EXPECT_GT(header.extension.absoluteSendTime, 0u);
 147       observation_complete_->Set();
 148
 149       return SEND_PACKET;
 150     }
 151
 152     virtual void ModifyConfigs(
 153         VideoSendStream::Config* send_config,
 154         std::vector<VideoReceiveStream::Config>* receive_configs,
 155         VideoEncoderConfig* encoder_config) OVERRIDE {
 156       send_config->rtp.extensions.push_back(
 157           RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
 158     }
 159
 160     virtual void PerformTest() OVERRIDE {
 161       EXPECT_EQ(kEventSignaled, Wait())
 162           << "Timed out while waiting for single RTP packet.";
 163     }
 164   } test;
 165
 166   RunBaseTest(&test);
 167 }
 168
 169 TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
 170   static const uint8_t kTOffsetExtensionId = 13;
 171   class TransmissionTimeOffsetObserver : public test::SendTest {
 172    public:
 173     TransmissionTimeOffsetObserver()
 174         : SendTest(kDefaultTimeoutMs), encoder_(Clock::GetRealTimeClock()) {
 175       EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
 176           kRtpExtensionTransmissionTimeOffset, kTOffsetExtensionId));
 177     }
 178
 179    private:
 180     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 181       RTPHeader header;
 182       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 183
 184       EXPECT_TRUE(header.extension.hasTransmissionTimeOffset);
 185       EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
 186       EXPECT_GT(header.extension.transmissionTimeOffset, 0);
 187       EXPECT_EQ(header.extension.absoluteSendTime, 0u);
 188       observation_complete_->Set();
 189
 190       return SEND_PACKET;
 191     }
 192
 193     virtual void ModifyConfigs(
 194         VideoSendStream::Config* send_config,
 195         std::vector<VideoReceiveStream::Config>* receive_configs,
 196         VideoEncoderConfig* encoder_config) OVERRIDE {
 197       send_config->encoder_settings.encoder = &encoder_;
 198       send_config->rtp.extensions.push_back(
 199           RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId));
 200     }
 201
 202     virtual void PerformTest() OVERRIDE {
 203       EXPECT_EQ(kEventSignaled, Wait())
 204           << "Timed out while waiting single RTP packet.";
 205     }
 206
 207     class DelayedEncoder : public test::FakeEncoder {
 208      public:
 209       explicit DelayedEncoder(Clock* clock) : test::FakeEncoder(clock) {}
 210       virtual int32_t Encode(
 211           const I420VideoFrame& input_image,
 212           const CodecSpecificInfo* codec_specific_info,
 213           const std::vector<VideoFrameType>* frame_types) OVERRIDE {
 214         // A delay needs to be introduced to assure that we get a timestamp
 215         // offset.
 216         SleepMs(5);
 217         return FakeEncoder::Encode(
 218             input_image, codec_specific_info, frame_types);
 219       }
 220     };
 221
 222     DelayedEncoder encoder_;
 223   } test;
 224
 225   RunBaseTest(&test);
 226 }
 227
 228 class FakeReceiveStatistics : public NullReceiveStatistics {
 229  public:
 230   FakeReceiveStatistics(uint32_t send_ssrc,
 231                         uint32_t last_sequence_number,
 232                         uint32_t cumulative_lost,
 233                         uint8_t fraction_lost)
 234       : lossy_stats_(new LossyStatistician(last_sequence_number,
 235                                            cumulative_lost,
 236                                            fraction_lost)) {
 237     stats_map_[send_ssrc] = lossy_stats_.get();
 238   }
 239
 240   virtual StatisticianMap GetActiveStatisticians() const OVERRIDE {
 241     return stats_map_;
 242   }
 243
 244   virtual StreamStatistician* GetStatistician(uint32_t ssrc) const OVERRIDE {
 245     return lossy_stats_.get();
 246   }
 247
 248  private:
 249   class LossyStatistician : public StreamStatistician {
 250    public:
 251     LossyStatistician(uint32_t extended_max_sequence_number,
 252                       uint32_t cumulative_lost,
 253                       uint8_t fraction_lost) {
 254       stats_.fraction_lost = fraction_lost;
 255       stats_.cumulative_lost = cumulative_lost;
 256       stats_.extended_max_sequence_number = extended_max_sequence_number;
 257     }
 258     virtual bool GetStatistics(RtcpStatistics* statistics,
 259                                bool reset) OVERRIDE {
 260       *statistics = stats_;
 261       return true;
 262     }
 263     virtual void GetDataCounters(uint32_t* bytes_received,
 264                                  uint32_t* packets_received) const OVERRIDE {
 265       *bytes_received = 0;
 266       *packets_received = 0;
 267     }
 268     virtual uint32_t BitrateReceived() const OVERRIDE { return 0; }
 269     virtual void ResetStatistics() OVERRIDE {}
 270     virtual bool IsRetransmitOfOldPacket(const RTPHeader& header,
 271                                          int min_rtt) const OVERRIDE {
 272       return false;
 273     }
 274
 275     virtual bool IsPacketInOrder(uint16_t sequence_number) const OVERRIDE {
 276       return true;
 277     }
 278
 279     RtcpStatistics stats_;
 280   };
 281
 282   scoped_ptr<LossyStatistician> lossy_stats_;
 283   StatisticianMap stats_map_;
 284 };
 285
 286 TEST_F(VideoSendStreamTest, SwapsI420VideoFrames) {
 287   static const size_t kWidth = 320;
 288   static const size_t kHeight = 240;
 289
 290   test::NullTransport transport;
 291   Call::Config call_config(&transport);
 292   CreateSenderCall(call_config);
 293
 294   CreateSendConfig(1);
 295   CreateStreams();
 296   send_stream_->Start();
 297
 298   I420VideoFrame frame;
 299   frame.CreateEmptyFrame(
 300       kWidth, kHeight, kWidth, (kWidth + 1) / 2, (kWidth + 1) / 2);
 301   uint8_t* old_y_buffer = frame.buffer(kYPlane);
 302
 303   send_stream_->Input()->SwapFrame(&frame);
 304
 305   EXPECT_NE(frame.buffer(kYPlane), old_y_buffer);
 306
 307   DestroyStreams();
 308 }
 309
 310 TEST_F(VideoSendStreamTest, SupportsFec) {
 311   class FecObserver : public test::SendTest {
 312    public:
 313     FecObserver()
 314         : SendTest(kDefaultTimeoutMs),
 315           transport_adapter_(SendTransport()),
 316           send_count_(0),
 317           received_media_(false),
 318           received_fec_(false) {
 319       transport_adapter_.Enable();
 320     }
 321
 322    private:
 323     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 324       RTPHeader header;
 325       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 326
 327       // Send lossy receive reports to trigger FEC enabling.
 328       if (send_count_++ % 2 != 0) {
 329         // Receive statistics reporting having lost 50% of the packets.
 330         FakeReceiveStatistics lossy_receive_stats(
 331             kSendSsrcs[0], header.sequenceNumber, send_count_ / 2, 127);
 332         RTCPSender rtcp_sender(
 333             0, false, Clock::GetRealTimeClock(), &lossy_receive_stats);
 334         EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_));
 335
 336         rtcp_sender.SetRTCPStatus(kRtcpNonCompound);
 337         rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
 338
 339         RTCPSender::FeedbackState feedback_state;
 340
 341         EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
 342       }
 343
 344       EXPECT_EQ(kRedPayloadType, header.payloadType);
 345
 346       uint8_t encapsulated_payload_type = packet[header.headerLength];
 347
 348       if (encapsulated_payload_type == kUlpfecPayloadType) {
 349         received_fec_ = true;
 350       } else {
 351         received_media_ = true;
 352       }
 353
 354       if (received_media_ && received_fec_)
 355         observation_complete_->Set();
 356
 357       return SEND_PACKET;
 358     }
 359
 360     virtual void ModifyConfigs(
 361         VideoSendStream::Config* send_config,
 362         std::vector<VideoReceiveStream::Config>* receive_configs,
 363         VideoEncoderConfig* encoder_config) OVERRIDE {
 364       send_config->rtp.fec.red_payload_type = kRedPayloadType;
 365       send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 366     }
 367
 368     virtual void PerformTest() OVERRIDE {
 369       EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
 370     }
 371
 372     internal::TransportAdapter transport_adapter_;
 373     int send_count_;
 374     bool received_media_;
 375     bool received_fec_;
 376   } test;
 377
 378   RunBaseTest(&test);
 379 }
 380
 381 void VideoSendStreamTest::TestNackRetransmission(
 382     uint32_t retransmit_ssrc,
 383     uint8_t retransmit_payload_type) {
 384   class NackObserver : public test::SendTest {
 385    public:
 386     explicit NackObserver(uint32_t retransmit_ssrc,
 387                           uint8_t retransmit_payload_type)
 388         : SendTest(kDefaultTimeoutMs),
 389           transport_adapter_(SendTransport()),
 390           send_count_(0),
 391           retransmit_ssrc_(retransmit_ssrc),
 392           retransmit_payload_type_(retransmit_payload_type),
 393           nacked_sequence_number_(-1) {
 394       transport_adapter_.Enable();
 395     }
 396
 397    private:
 398     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 399       RTPHeader header;
 400       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 401
 402       // Nack second packet after receiving the third one.
 403       if (++send_count_ == 3) {
 404         uint16_t nack_sequence_number = header.sequenceNumber - 1;
 405         nacked_sequence_number_ = nack_sequence_number;
 406         NullReceiveStatistics null_stats;
 407         RTCPSender rtcp_sender(
 408             0, false, Clock::GetRealTimeClock(), &null_stats);
 409         EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_));
 410
 411         rtcp_sender.SetRTCPStatus(kRtcpNonCompound);
 412         rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
 413
 414         RTCPSender::FeedbackState feedback_state;
 415
 416         EXPECT_EQ(0,
 417                   rtcp_sender.SendRTCP(
 418                       feedback_state, kRtcpNack, 1, &nack_sequence_number));
 419       }
 420
 421       uint16_t sequence_number = header.sequenceNumber;
 422
 423       if (header.ssrc == retransmit_ssrc_ &&
 424           retransmit_ssrc_ != kSendSsrcs[0]) {
 425         // Not kSendSsrcs[0], assume correct RTX packet. Extract sequence
 426         // number.
 427         const uint8_t* rtx_header = packet + header.headerLength;
 428         sequence_number = (rtx_header[0] << 8) + rtx_header[1];
 429       }
 430
 431       if (sequence_number == nacked_sequence_number_) {
 432         EXPECT_EQ(retransmit_ssrc_, header.ssrc);
 433         EXPECT_EQ(retransmit_payload_type_, header.payloadType);
 434         observation_complete_->Set();
 435       }
 436
 437       return SEND_PACKET;
 438     }
 439
 440     virtual void ModifyConfigs(
 441         VideoSendStream::Config* send_config,
 442         std::vector<VideoReceiveStream::Config>* receive_configs,
 443         VideoEncoderConfig* encoder_config) OVERRIDE {
 444       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 445       send_config->rtp.rtx.payload_type = retransmit_payload_type_;
 446       if (retransmit_ssrc_ != kSendSsrcs[0])
 447         send_config->rtp.rtx.ssrcs.push_back(retransmit_ssrc_);
 448     }
 449
 450     virtual void PerformTest() OVERRIDE {
 451       EXPECT_EQ(kEventSignaled, Wait())
 452           << "Timed out while waiting for NACK retransmission.";
 453     }
 454
 455     internal::TransportAdapter transport_adapter_;
 456     int send_count_;
 457     uint32_t retransmit_ssrc_;
 458     uint8_t retransmit_payload_type_;
 459     int nacked_sequence_number_;
 460   } test(retransmit_ssrc, retransmit_payload_type);
 461
 462   RunBaseTest(&test);
 463 }
 464
 465 TEST_F(VideoSendStreamTest, RetransmitsNack) {
 466   // Normal NACKs should use the send SSRC.
 467   TestNackRetransmission(kSendSsrcs[0], kFakeSendPayloadType);
 468 }
 469
 470 TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) {
 471   // NACKs over RTX should use a separate SSRC.
 472   TestNackRetransmission(kSendRtxSsrcs[0], kSendRtxPayloadType);
 473 }
 474
 475 void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
 476                                                       bool with_fec) {
 477   // Use a fake encoder to output a frame of every size in the range [90, 290],
 478   // for each size making sure that the exact number of payload bytes received
 479   // is correct and that packets are fragmented to respect max packet size.
 480   static const uint32_t kMaxPacketSize = 128;
 481   static const uint32_t start = 90;
 482   static const uint32_t stop = 290;
 483
 484   // Observer that verifies that the expected number of packets and bytes
 485   // arrive for each frame size, from start_size to stop_size.
 486   class FrameFragmentationTest : public test::SendTest,
 487                                  public EncodedFrameObserver {
 488    public:
 489     FrameFragmentationTest(uint32_t max_packet_size,
 490                            uint32_t start_size,
 491                            uint32_t stop_size,
 492                            bool test_generic_packetization,
 493                            bool use_fec)
 494         : SendTest(kLongTimeoutMs),
 495           transport_adapter_(SendTransport()),
 496           encoder_(stop),
 497           max_packet_size_(max_packet_size),
 498           stop_size_(stop_size),
 499           test_generic_packetization_(test_generic_packetization),
 500           use_fec_(use_fec),
 501           packet_count_(0),
 502           accumulated_size_(0),
 503           accumulated_payload_(0),
 504           fec_packet_received_(false),
 505           current_size_rtp_(start_size),
 506           current_size_frame_(start_size) {
 507       // Fragmentation required, this test doesn't make sense without it.
 508       encoder_.SetFrameSize(start);
 509       assert(stop_size > max_packet_size);
 510       transport_adapter_.Enable();
 511     }
 512
 513    private:
 514     virtual Action OnSendRtp(const uint8_t* packet, size_t size) OVERRIDE {
 515       uint32_t length = static_cast<int>(size);
 516       RTPHeader header;
 517       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 518
 519       EXPECT_LE(length, max_packet_size_);
 520
 521       if (use_fec_) {
 522         uint8_t payload_type = packet[header.headerLength];
 523         bool is_fec = header.payloadType == kRedPayloadType &&
 524                       payload_type == kUlpfecPayloadType;
 525         if (is_fec) {
 526           fec_packet_received_ = true;
 527           return SEND_PACKET;
 528         }
 529       }
 530
 531       accumulated_size_ += length;
 532
 533       if (use_fec_)
 534         TriggerLossReport(header);
 535
 536       if (test_generic_packetization_) {
 537         uint32_t overhead = header.headerLength + header.paddingLength +
 538                           (1 /* Generic header */);
 539         if (use_fec_)
 540           overhead += 1;  // RED for FEC header.
 541         accumulated_payload_ += length - overhead;
 542       }
 543
 544       // Marker bit set indicates last packet of a frame.
 545       if (header.markerBit) {
 546         if (use_fec_ && accumulated_payload_ == current_size_rtp_ - 1) {
 547           // With FEC enabled, frame size is incremented asynchronously, so
 548           // "old" frames one byte too small may arrive. Accept, but don't
 549           // increase expected frame size.
 550           accumulated_size_ = 0;
 551           accumulated_payload_ = 0;
 552           return SEND_PACKET;
 553         }
 554
 555         EXPECT_GE(accumulated_size_, current_size_rtp_);
 556         if (test_generic_packetization_) {
 557           EXPECT_EQ(current_size_rtp_, accumulated_payload_);
 558         }
 559
 560         // Last packet of frame; reset counters.
 561         accumulated_size_ = 0;
 562         accumulated_payload_ = 0;
 563         if (current_size_rtp_ == stop_size_) {
 564           // Done! (Don't increase size again, might arrive more @ stop_size).
 565           observation_complete_->Set();
 566         } else {
 567           // Increase next expected frame size. If testing with FEC, make sure
 568           // a FEC packet has been received for this frame size before
 569           // proceeding, to make sure that redundancy packets don't exceed
 570           // size limit.
 571           if (!use_fec_) {
 572             ++current_size_rtp_;
 573           } else if (fec_packet_received_) {
 574             fec_packet_received_ = false;
 575             ++current_size_rtp_;
 576             ++current_size_frame_;
 577           }
 578         }
 579       }
 580
 581       return SEND_PACKET;
 582     }
 583
 584     void TriggerLossReport(const RTPHeader& header) {
 585       // Send lossy receive reports to trigger FEC enabling.
 586       if (packet_count_++ % 2 != 0) {
 587         // Receive statistics reporting having lost 50% of the packets.
 588         FakeReceiveStatistics lossy_receive_stats(
 589             kSendSsrcs[0], header.sequenceNumber, packet_count_ / 2, 127);
 590         RTCPSender rtcp_sender(
 591             0, false, Clock::GetRealTimeClock(), &lossy_receive_stats);
 592         EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_));
 593
 594         rtcp_sender.SetRTCPStatus(kRtcpNonCompound);
 595         rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
 596
 597         RTCPSender::FeedbackState feedback_state;
 598
 599         EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
 600       }
 601     }
 602
 603     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
 604       // Increase frame size for next encoded frame, in the context of the
 605       // encoder thread.
 606       if (!use_fec_ &&
 607           current_size_frame_.Value() < static_cast<int32_t>(stop_size_)) {
 608         ++current_size_frame_;
 609       }
 610       encoder_.SetFrameSize(current_size_frame_.Value());
 611     }
 612
 613     virtual void ModifyConfigs(
 614         VideoSendStream::Config* send_config,
 615         std::vector<VideoReceiveStream::Config>* receive_configs,
 616         VideoEncoderConfig* encoder_config) OVERRIDE {
 617       if (use_fec_) {
 618         send_config->rtp.fec.red_payload_type = kRedPayloadType;
 619         send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
 620       }
 621
 622       if (!test_generic_packetization_)
 623         send_config->encoder_settings.payload_name = "VP8";
 624
 625       send_config->encoder_settings.encoder = &encoder_;
 626       send_config->rtp.max_packet_size = kMaxPacketSize;
 627       send_config->post_encode_callback = this;
 628
 629       // Add an extension header, to make the RTP header larger than the base
 630       // length of 12 bytes.
 631       static const uint8_t kAbsSendTimeExtensionId = 13;
 632       send_config->rtp.extensions.push_back(
 633           RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
 634     }
 635
 636     virtual void PerformTest() OVERRIDE {
 637       EXPECT_EQ(kEventSignaled, Wait())
 638           << "Timed out while observing incoming RTP packets.";
 639     }
 640
 641     internal::TransportAdapter transport_adapter_;
 642     test::ConfigurableFrameSizeEncoder encoder_;
 643
 644     const uint32_t max_packet_size_;
 645     const uint32_t stop_size_;
 646     const bool test_generic_packetization_;
 647     const bool use_fec_;
 648
 649     uint32_t packet_count_;
 650     uint32_t accumulated_size_;
 651     uint32_t accumulated_payload_;
 652     bool fec_packet_received_;
 653
 654     uint32_t current_size_rtp_;
 655     Atomic32 current_size_frame_;
 656   };
 657
 658   // Don't auto increment if FEC is used; continue sending frame size until
 659   // a FEC packet has been received.
 660   FrameFragmentationTest test(
 661       kMaxPacketSize, start, stop, format == kGeneric, with_fec);
 662
 663   RunBaseTest(&test);
 664 }
 665
 666 // TODO(sprang): Is there any way of speeding up these tests?
 667 TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSize) {
 668   TestPacketFragmentationSize(kGeneric, false);
 669 }
 670
 671 TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSizeWithFec) {
 672   TestPacketFragmentationSize(kGeneric, true);
 673 }
 674
 675 TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSize) {
 676   TestPacketFragmentationSize(kVP8, false);
 677 }
 678
 679 TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSizeWithFec) {
 680   TestPacketFragmentationSize(kVP8, true);
 681 }
 682
 683 // The test will go through a number of phases.
 684 // 1. Start sending packets.
 685 // 2. As soon as the RTP stream has been detected, signal a low REMB value to
 686 //    suspend the stream.
 687 // 3. Wait until |kSuspendTimeFrames| have been captured without seeing any RTP
 688 //    packets.
 689 // 4. Signal a high REMB and then wait for the RTP stream to start again.
 690 //    When the stream is detected again, and the stats show that the stream
 691 //    is no longer suspended, the test ends.
 692 TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
 693   static const int kSuspendTimeFrames = 60;  // Suspend for 2 seconds @ 30 fps.
 694
 695   class RembObserver : public test::SendTest, public I420FrameCallback {
 696    public:
 697     RembObserver()
 698         : SendTest(kDefaultTimeoutMs),
 699           transport_adapter_(&transport_),
 700           clock_(Clock::GetRealTimeClock()),
 701           crit_(CriticalSectionWrapper::CreateCriticalSection()),
 702           test_state_(kBeforeSuspend),
 703           rtp_count_(0),
 704           last_sequence_number_(0),
 705           suspended_frame_count_(0),
 706           low_remb_bps_(0),
 707           high_remb_bps_(0) {
 708       transport_adapter_.Enable();
 709     }
 710
 711    private:
 712     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 713       // Receive statistics reporting having lost 0% of the packets.
 714       // This is needed for the send-side bitrate controller to work properly.
 715       CriticalSectionScoped lock(crit_.get());
 716       SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
 717       return SEND_PACKET;
 718     }
 719
 720     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 721       CriticalSectionScoped lock(crit_.get());
 722       ++rtp_count_;
 723       RTPHeader header;
 724       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 725       last_sequence_number_ = header.sequenceNumber;
 726
 727       if (test_state_ == kBeforeSuspend) {
 728         // The stream has started. Try to suspend it.
 729         SendRtcpFeedback(low_remb_bps_);
 730         test_state_ = kDuringSuspend;
 731       } else if (test_state_ == kDuringSuspend) {
 732         if (header.paddingLength == 0) {
 733           // Received non-padding packet during suspension period. Reset the
 734           // counter.
 735           suspended_frame_count_ = 0;
 736         }
 737       } else if (test_state_ == kWaitingForPacket) {
 738         if (header.paddingLength == 0) {
 739           // Non-padding packet observed. Test is almost complete. Will just
 740           // have to wait for the stats to change.
 741           test_state_ = kWaitingForStats;
 742         }
 743       } else if (test_state_ == kWaitingForStats) {
 744         VideoSendStream::Stats stats = stream_->GetStats();
 745         if (stats.suspended == false) {
 746           // Stats flipped to false. Test is complete.
 747           observation_complete_->Set();
 748         }
 749       }
 750
 751       return SEND_PACKET;
 752     }
 753
 754     // This method implements the I420FrameCallback.
 755     void FrameCallback(I420VideoFrame* video_frame) OVERRIDE {
 756       CriticalSectionScoped lock(crit_.get());
 757       if (test_state_ == kDuringSuspend &&
 758           ++suspended_frame_count_ > kSuspendTimeFrames) {
 759         VideoSendStream::Stats stats = stream_->GetStats();
 760         EXPECT_TRUE(stats.suspended);
 761         SendRtcpFeedback(high_remb_bps_);
 762         test_state_ = kWaitingForPacket;
 763       }
 764     }
 765
 766     void set_low_remb_bps(int value) {
 767       CriticalSectionScoped lock(crit_.get());
 768       low_remb_bps_ = value;
 769     }
 770
 771     void set_high_remb_bps(int value) {
 772       CriticalSectionScoped lock(crit_.get());
 773       high_remb_bps_ = value;
 774     }
 775
 776     virtual void SetReceivers(
 777         PacketReceiver* send_transport_receiver,
 778         PacketReceiver* receive_transport_receiver) OVERRIDE {
 779       transport_.SetReceiver(send_transport_receiver);
 780     }
 781
 782     virtual void OnStreamsCreated(
 783         VideoSendStream* send_stream,
 784         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
 785       stream_ = send_stream;
 786     }
 787
 788     virtual void ModifyConfigs(
 789         VideoSendStream::Config* send_config,
 790         std::vector<VideoReceiveStream::Config>* receive_configs,
 791         VideoEncoderConfig* encoder_config) OVERRIDE {
 792       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 793       send_config->pre_encode_callback = this;
 794       send_config->suspend_below_min_bitrate = true;
 795       int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps;
 796       set_low_remb_bps(min_bitrate_bps - 10000);
 797       int threshold_window = std::max(min_bitrate_bps / 10, 10000);
 798       ASSERT_GT(encoder_config->streams[0].max_bitrate_bps,
 799                 min_bitrate_bps + threshold_window + 5000);
 800       set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);
 801     }
 802
 803     virtual void PerformTest() OVERRIDE {
 804       EXPECT_EQ(kEventSignaled, Wait())
 805           << "Timed out during suspend-below-min-bitrate test.";
 806       transport_.StopSending();
 807     }
 808
 809     enum TestState {
 810       kBeforeSuspend,
 811       kDuringSuspend,
 812       kWaitingForPacket,
 813       kWaitingForStats
 814     };
 815
 816     virtual void SendRtcpFeedback(int remb_value)
 817         EXCLUSIVE_LOCKS_REQUIRED(crit_) {
 818       FakeReceiveStatistics receive_stats(
 819           kSendSsrcs[0], last_sequence_number_, rtp_count_, 0);
 820       RTCPSender rtcp_sender(0, false, clock_, &receive_stats);
 821       EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_));
 822
 823       rtcp_sender.SetRTCPStatus(kRtcpNonCompound);
 824       rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
 825       if (remb_value > 0) {
 826         rtcp_sender.SetREMBStatus(true);
 827         rtcp_sender.SetREMBData(remb_value, 0, NULL);
 828       }
 829       RTCPSender::FeedbackState feedback_state;
 830       EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
 831     }
 832
 833     internal::TransportAdapter transport_adapter_;
 834     test::DirectTransport transport_;
 835     Clock* const clock_;
 836     VideoSendStream* stream_;
 837
 838     const scoped_ptr<CriticalSectionWrapper> crit_;
 839     TestState test_state_ GUARDED_BY(crit_);
 840     int rtp_count_ GUARDED_BY(crit_);
 841     int last_sequence_number_ GUARDED_BY(crit_);
 842     int suspended_frame_count_ GUARDED_BY(crit_);
 843     int low_remb_bps_ GUARDED_BY(crit_);
 844     int high_remb_bps_ GUARDED_BY(crit_);
 845   } test;
 846
 847   RunBaseTest(&test);
 848 }
 849
 850 TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
 851   class NoPaddingWhenVideoIsMuted : public test::SendTest {
 852    public:
 853     NoPaddingWhenVideoIsMuted()
 854         : SendTest(kDefaultTimeoutMs),
 855           clock_(Clock::GetRealTimeClock()),
 856           transport_adapter_(ReceiveTransport()),
 857           crit_(CriticalSectionWrapper::CreateCriticalSection()),
 858           last_packet_time_ms_(-1),
 859           capturer_(NULL) {
 860       transport_adapter_.Enable();
 861     }
 862
 863    private:
 864     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
 865       CriticalSectionScoped lock(crit_.get());
 866       last_packet_time_ms_ = clock_->TimeInMilliseconds();
 867       capturer_->Stop();
 868       return SEND_PACKET;
 869     }
 870
 871     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 872       CriticalSectionScoped lock(crit_.get());
 873       const int kVideoMutedThresholdMs = 10000;
 874       if (last_packet_time_ms_ > 0 &&
 875           clock_->TimeInMilliseconds() - last_packet_time_ms_ >
 876               kVideoMutedThresholdMs)
 877         observation_complete_->Set();
 878       // Receive statistics reporting having lost 50% of the packets.
 879       FakeReceiveStatistics receive_stats(kSendSsrcs[0], 1, 1, 0);
 880       RTCPSender rtcp_sender(
 881           0, false, Clock::GetRealTimeClock(), &receive_stats);
 882       EXPECT_EQ(0, rtcp_sender.RegisterSendTransport(&transport_adapter_));
 883
 884       rtcp_sender.SetRTCPStatus(kRtcpNonCompound);
 885       rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
 886
 887       RTCPSender::FeedbackState feedback_state;
 888
 889       EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
 890       return SEND_PACKET;
 891     }
 892
 893     virtual void SetReceivers(
 894         PacketReceiver* send_transport_receiver,
 895         PacketReceiver* receive_transport_receiver) OVERRIDE {
 896       RtpRtcpObserver::SetReceivers(send_transport_receiver,
 897                                     send_transport_receiver);
 898     }
 899
 900     virtual size_t GetNumStreams() const OVERRIDE { return 3; }
 901
 902     virtual void OnFrameGeneratorCapturerCreated(
 903         test::FrameGeneratorCapturer* frame_generator_capturer) {
 904       CriticalSectionScoped lock(crit_.get());
 905       capturer_ = frame_generator_capturer;
 906     }
 907
 908     virtual void PerformTest() OVERRIDE {
 909       EXPECT_EQ(kEventSignaled, Wait())
 910           << "Timed out while waiting for RTP packets to stop being sent.";
 911     }
 912
 913     Clock* const clock_;
 914     internal::TransportAdapter transport_adapter_;
 915     const scoped_ptr<CriticalSectionWrapper> crit_;
 916     int64_t last_packet_time_ms_ GUARDED_BY(crit_);
 917     test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
 918   } test;
 919
 920   RunBaseTest(&test);
 921 }
 922
 923 TEST_F(VideoSendStreamTest, ProducesStats) {
 924   class ProducesStats : public test::SendTest {
 925    public:
 926     ProducesStats()
 927         : SendTest(kDefaultTimeoutMs),
 928           stream_(NULL),
 929           event_(EventWrapper::Create()) {}
 930
 931     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
 932       event_->Set();
 933
 934       return SEND_PACKET;
 935     }
 936
 937    private:
 938     bool WaitForFilledStats() {
 939       Clock* clock = Clock::GetRealTimeClock();
 940       int64_t now = clock->TimeInMilliseconds();
 941       int64_t stop_time = now + kDefaultTimeoutMs;
 942       while (now < stop_time) {
 943         int64_t time_left = stop_time - now;
 944         if (time_left > 0 && event_->Wait(time_left) == kEventSignaled &&
 945             CheckStats()) {
 946           return true;
 947         }
 948         now = clock->TimeInMilliseconds();
 949       }
 950       return false;
 951     }
 952
 953     bool CheckStats() {
 954       VideoSendStream::Stats stats = stream_->GetStats();
 955       // Check that all applicable data sources have been used.
 956       if (stats.input_frame_rate > 0 && stats.encode_frame_rate > 0
 957           && !stats.substreams.empty()) {
 958         uint32_t ssrc = stats.substreams.begin()->first;
 959         EXPECT_NE(
 960             config_.rtp.ssrcs.end(),
 961             std::find(
 962                 config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end(), ssrc));
 963         // Check for data populated by various sources. RTCP excluded as this
 964         // data is received from remote side. Tested in call tests instead.
 965         const StreamStats& entry = stats.substreams[ssrc];
 966         if (entry.key_frames > 0u && entry.bitrate_bps > 0 &&
 967             entry.rtp_stats.packets > 0u && entry.avg_delay_ms > 0 &&
 968             entry.max_delay_ms > 0) {
 969           return true;
 970         }
 971       }
 972       return false;
 973     }
 974
 975     void SetConfig(const VideoSendStream::Config& config) { config_ = config; }
 976
 977     virtual void ModifyConfigs(
 978         VideoSendStream::Config* send_config,
 979         std::vector<VideoReceiveStream::Config>* receive_configs,
 980         VideoEncoderConfig* encoder_config) OVERRIDE {
 981       SetConfig(*send_config);
 982     }
 983
 984     virtual void OnStreamsCreated(
 985         VideoSendStream* send_stream,
 986         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
 987       stream_ = send_stream;
 988     }
 989
 990     virtual void PerformTest() OVERRIDE {
 991       EXPECT_TRUE(WaitForFilledStats())
 992           << "Timed out waiting for filled statistics.";
 993     }
 994
 995     VideoSendStream* stream_;
 996     VideoSendStream::Config config_;
 997     scoped_ptr<EventWrapper> event_;
 998   } test;
 999
1000   RunBaseTest(&test);
1001 }
1002
1003 // This test first observes "high" bitrate use at which point it sends a REMB to
1004 // indicate that it should be lowered significantly. The test then observes that
1005 // the bitrate observed is sinking well below the min-transmit-bitrate threshold
1006 // to verify that the min-transmit bitrate respects incoming REMB.
1007 //
1008 // Note that the test starts at "high" bitrate and does not ramp up to "higher"
1009 // bitrate since no receiver block or remb is sent in the initial phase.
1010 TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
1011   static const int kMinTransmitBitrateBps = 400000;
1012   static const int kHighBitrateBps = 150000;
1013   static const int kRembBitrateBps = 80000;
1014   static const int kRembRespectedBitrateBps = 100000;
1015   class BitrateObserver : public test::SendTest, public PacketReceiver {
1016    public:
1017     BitrateObserver()
1018         : SendTest(kDefaultTimeoutMs),
1019           feedback_transport_(ReceiveTransport()),
1020           bitrate_capped_(false) {
1021       RtpRtcp::Configuration config;
1022       feedback_transport_.Enable();
1023       config.outgoing_transport = &feedback_transport_;
1024       rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
1025       rtp_rtcp_->SetREMBStatus(true);
1026       rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
1027     }
1028
1029     virtual void OnStreamsCreated(
1030         VideoSendStream* send_stream,
1031         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
1032       stream_ = send_stream;
1033     }
1034
1035    private:
1036     virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
1037                                          size_t length) OVERRIDE {
1038       if (RtpHeaderParser::IsRtcp(packet, length))
1039         return DELIVERY_OK;
1040
1041       RTPHeader header;
1042       if (!parser_->Parse(packet, length, &header))
1043         return DELIVERY_PACKET_ERROR;
1044       assert(stream_ != NULL);
1045       VideoSendStream::Stats stats = stream_->GetStats();
1046       if (!stats.substreams.empty()) {
1047         EXPECT_EQ(1u, stats.substreams.size());
1048         int bitrate_bps = stats.substreams.begin()->second.bitrate_bps;
1049         test::PrintResult(
1050             "bitrate_stats_",
1051             "min_transmit_bitrate_low_remb",
1052             "bitrate_bps",
1053             static_cast<size_t>(bitrate_bps),
1054             "bps",
1055             false);
1056         if (bitrate_bps > kHighBitrateBps) {
1057           rtp_rtcp_->SetREMBData(kRembBitrateBps, 1, &header.ssrc);
1058           rtp_rtcp_->Process();
1059           bitrate_capped_ = true;
1060         } else if (bitrate_capped_ &&
1061                    bitrate_bps < kRembRespectedBitrateBps) {
1062           observation_complete_->Set();
1063         }
1064       }
1065       return DELIVERY_OK;
1066     }
1067
1068     virtual void SetReceivers(
1069         PacketReceiver* send_transport_receiver,
1070         PacketReceiver* receive_transport_receiver) OVERRIDE {
1071       RtpRtcpObserver::SetReceivers(this, send_transport_receiver);
1072     }
1073
1074     virtual void ModifyConfigs(
1075         VideoSendStream::Config* send_config,
1076         std::vector<VideoReceiveStream::Config>* receive_configs,
1077         VideoEncoderConfig* encoder_config) OVERRIDE {
1078       send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
1079     }
1080
1081     virtual void PerformTest() OVERRIDE {
1082       EXPECT_EQ(kEventSignaled, Wait())
1083           << "Timeout while waiting for low bitrate stats after REMB.";
1084     }
1085
1086     scoped_ptr<RtpRtcp> rtp_rtcp_;
1087     internal::TransportAdapter feedback_transport_;
1088     VideoSendStream* stream_;
1089     bool bitrate_capped_;
1090   } test;
1091
1092   RunBaseTest(&test);
1093 }
1094
1095 TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) {
1096   class FrameObserver : public I420FrameCallback {
1097    public:
1098     FrameObserver() : output_frame_event_(EventWrapper::Create()) {}
1099
1100     void FrameCallback(I420VideoFrame* video_frame) OVERRIDE {
1101       // Clone the frame because the caller owns it.
1102       output_frames_.push_back(video_frame->CloneFrame());
1103       output_frame_event_->Set();
1104     }
1105
1106     void WaitOutputFrame() {
1107       const unsigned long kWaitFrameTimeoutMs = 3000;
1108       EXPECT_EQ(kEventSignaled, output_frame_event_->Wait(kWaitFrameTimeoutMs))
1109           << "Timeout while waiting for output frames.";
1110     }
1111
1112     const std::vector<I420VideoFrame*>& output_frames() const {
1113       return output_frames_.get();
1114     }
1115
1116    private:
1117     // Delivered output frames.
1118     ScopedVector<I420VideoFrame> output_frames_;
1119
1120     // Indicate an output frame has arrived.
1121     scoped_ptr<EventWrapper> output_frame_event_;
1122   };
1123
1124   // Initialize send stream.
1125   test::NullTransport transport;
1126   CreateSenderCall(Call::Config(&transport));
1127
1128   CreateSendConfig(1);
1129   FrameObserver observer;
1130   send_config_.pre_encode_callback = &observer;
1131   CreateStreams();
1132
1133   // Prepare five input frames. Send I420VideoFrame and TextureVideoFrame
1134   // alternatively.
1135   ScopedVector<I420VideoFrame> input_frames;
1136   int width = static_cast<int>(encoder_config_.streams[0].width);
1137   int height = static_cast<int>(encoder_config_.streams[0].height);
1138   webrtc::RefCountImpl<FakeNativeHandle>* handle1 =
1139       new webrtc::RefCountImpl<FakeNativeHandle>();
1140   webrtc::RefCountImpl<FakeNativeHandle>* handle2 =
1141       new webrtc::RefCountImpl<FakeNativeHandle>();
1142   webrtc::RefCountImpl<FakeNativeHandle>* handle3 =
1143       new webrtc::RefCountImpl<FakeNativeHandle>();
1144   input_frames.push_back(new TextureVideoFrame(handle1, width, height, 1, 1));
1145   input_frames.push_back(new TextureVideoFrame(handle2, width, height, 2, 2));
1146   input_frames.push_back(CreateI420VideoFrame(width, height, 1));
1147   input_frames.push_back(CreateI420VideoFrame(width, height, 2));
1148   input_frames.push_back(new TextureVideoFrame(handle3, width, height, 3, 3));
1149
1150   send_stream_->Start();
1151   for (size_t i = 0; i < input_frames.size(); i++) {
1152     // Make a copy of the input frame because the buffer will be swapped.
1153     scoped_ptr<I420VideoFrame> frame(input_frames[i]->CloneFrame());
1154     send_stream_->Input()->SwapFrame(frame.get());
1155     // Do not send the next frame too fast, so the frame dropper won't drop it.
1156     if (i < input_frames.size() - 1)
1157       SleepMs(1000 / encoder_config_.streams[0].max_framerate);
1158     // Wait until the output frame is received before sending the next input
1159     // frame. Or the previous input frame may be replaced without delivering.
1160     observer.WaitOutputFrame();
1161   }
1162   send_stream_->Stop();
1163
1164   // Test if the input and output frames are the same. render_time_ms and
1165   // timestamp are not compared because capturer sets those values.
1166   ExpectEqualFramesVector(input_frames.get(), observer.output_frames());
1167
1168   DestroyStreams();
1169 }
1170
1171 void ExpectEqualFrames(const I420VideoFrame& frame1,
1172                        const I420VideoFrame& frame2) {
1173   if (frame1.native_handle() != NULL || frame2.native_handle() != NULL)
1174     ExpectEqualTextureFrames(frame1, frame2);
1175   else
1176     ExpectEqualBufferFrames(frame1, frame2);
1177 }
1178
1179 void ExpectEqualTextureFrames(const I420VideoFrame& frame1,
1180                               const I420VideoFrame& frame2) {
1181   EXPECT_EQ(frame1.native_handle(), frame2.native_handle());
1182   EXPECT_EQ(frame1.width(), frame2.width());
1183   EXPECT_EQ(frame1.height(), frame2.height());
1184 }
1185
1186 void ExpectEqualBufferFrames(const I420VideoFrame& frame1,
1187                              const I420VideoFrame& frame2) {
1188   EXPECT_EQ(frame1.width(), frame2.width());
1189   EXPECT_EQ(frame1.height(), frame2.height());
1190   EXPECT_EQ(frame1.stride(kYPlane), frame2.stride(kYPlane));
1191   EXPECT_EQ(frame1.stride(kUPlane), frame2.stride(kUPlane));
1192   EXPECT_EQ(frame1.stride(kVPlane), frame2.stride(kVPlane));
1193   EXPECT_EQ(frame1.ntp_time_ms(), frame2.ntp_time_ms());
1194   ASSERT_EQ(frame1.allocated_size(kYPlane), frame2.allocated_size(kYPlane));
1195   EXPECT_EQ(0,
1196             memcmp(frame1.buffer(kYPlane),
1197                    frame2.buffer(kYPlane),
1198                    frame1.allocated_size(kYPlane)));
1199   ASSERT_EQ(frame1.allocated_size(kUPlane), frame2.allocated_size(kUPlane));
1200   EXPECT_EQ(0,
1201             memcmp(frame1.buffer(kUPlane),
1202                    frame2.buffer(kUPlane),
1203                    frame1.allocated_size(kUPlane)));
1204   ASSERT_EQ(frame1.allocated_size(kVPlane), frame2.allocated_size(kVPlane));
1205   EXPECT_EQ(0,
1206             memcmp(frame1.buffer(kVPlane),
1207                    frame2.buffer(kVPlane),
1208                    frame1.allocated_size(kVPlane)));
1209 }
1210
1211 void ExpectEqualFramesVector(const std::vector<I420VideoFrame*>& frames1,
1212                              const std::vector<I420VideoFrame*>& frames2) {
1213   EXPECT_EQ(frames1.size(), frames2.size());
1214   for (size_t i = 0; i < std::min(frames1.size(), frames2.size()); ++i)
1215     ExpectEqualFrames(*frames1[i], *frames2[i]);
1216 }
1217
1218 I420VideoFrame* CreateI420VideoFrame(int width, int height, uint8_t data) {
1219   I420VideoFrame* frame = new I420VideoFrame();
1220   const int kSizeY = width * height * 2;
1221   const int kSizeUV = width * height;
1222   scoped_ptr<uint8_t[]> buffer(new uint8_t[kSizeY]);
1223   memset(buffer.get(), data, kSizeY);
1224   frame->CreateFrame(kSizeY,
1225                      buffer.get(),
1226                      kSizeUV,
1227                      buffer.get(),
1228                      kSizeUV,
1229                      buffer.get(),
1230                      width,
1231                      height,
1232                      width,
1233                      width / 2,
1234                      width / 2);
1235   frame->set_timestamp(data);
1236   frame->set_ntp_time_ms(data);
1237   frame->set_render_time_ms(data);
1238   return frame;
1239 }
1240
1241 TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
1242   class EncoderStateObserver : public test::SendTest, public VideoEncoder {
1243    public:
1244     EncoderStateObserver()
1245         : SendTest(kDefaultTimeoutMs),
1246           crit_(CriticalSectionWrapper::CreateCriticalSection()),
1247           initialized_(false),
1248           callback_registered_(false),
1249           num_releases_(0),
1250           released_(false) {}
1251
1252     bool IsReleased() {
1253       CriticalSectionScoped lock(crit_.get());
1254       return released_;
1255     }
1256
1257     bool IsReadyForEncode() {
1258       CriticalSectionScoped lock(crit_.get());
1259       return initialized_ && callback_registered_;
1260     }
1261
1262     size_t num_releases() {
1263       CriticalSectionScoped lock(crit_.get());
1264       return num_releases_;
1265     }
1266
1267    private:
1268     virtual int32_t InitEncode(const VideoCodec* codecSettings,
1269                                int32_t numberOfCores,
1270                                uint32_t maxPayloadSize) OVERRIDE {
1271       CriticalSectionScoped lock(crit_.get());
1272       EXPECT_FALSE(initialized_);
1273       initialized_ = true;
1274       released_ = false;
1275       return 0;
1276     }
1277
1278     virtual int32_t Encode(
1279         const I420VideoFrame& inputImage,
1280         const CodecSpecificInfo* codecSpecificInfo,
1281         const std::vector<VideoFrameType>* frame_types) OVERRIDE {
1282       EXPECT_TRUE(IsReadyForEncode());
1283
1284       observation_complete_->Set();
1285       return 0;
1286     }
1287
1288     virtual int32_t RegisterEncodeCompleteCallback(
1289         EncodedImageCallback* callback) OVERRIDE {
1290       CriticalSectionScoped lock(crit_.get());
1291       EXPECT_TRUE(initialized_);
1292       callback_registered_ = true;
1293       return 0;
1294     }
1295
1296     virtual int32_t Release() OVERRIDE {
1297       CriticalSectionScoped lock(crit_.get());
1298       EXPECT_TRUE(IsReadyForEncode());
1299       EXPECT_FALSE(released_);
1300       initialized_ = false;
1301       callback_registered_ = false;
1302       released_ = true;
1303       ++num_releases_;
1304       return 0;
1305     }
1306
1307     virtual int32_t SetChannelParameters(uint32_t packetLoss,
1308                                          int rtt) OVERRIDE {
1309       EXPECT_TRUE(IsReadyForEncode());
1310       return 0;
1311     }
1312
1313     virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) OVERRIDE {
1314       EXPECT_TRUE(IsReadyForEncode());
1315       return 0;
1316     }
1317
1318     virtual void OnStreamsCreated(
1319         VideoSendStream* send_stream,
1320         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
1321       // Encoder initialization should be done in stream construction before
1322       // starting.
1323       EXPECT_TRUE(IsReadyForEncode());
1324       stream_ = send_stream;
1325     }
1326
1327     virtual void ModifyConfigs(
1328         VideoSendStream::Config* send_config,
1329         std::vector<VideoReceiveStream::Config>* receive_configs,
1330         VideoEncoderConfig* encoder_config) OVERRIDE {
1331       send_config->encoder_settings.encoder = this;
1332       encoder_config_ = *encoder_config;
1333     }
1334
1335     virtual void PerformTest() OVERRIDE {
1336       EXPECT_EQ(kEventSignaled, Wait())
1337           << "Timed out while waiting for Encode.";
1338       EXPECT_EQ(0u, num_releases());
1339       stream_->ReconfigureVideoEncoder(encoder_config_);
1340       EXPECT_EQ(0u, num_releases());
1341       stream_->Stop();
1342       // Encoder should not be released before destroying the VideoSendStream.
1343       EXPECT_FALSE(IsReleased());
1344       EXPECT_TRUE(IsReadyForEncode());
1345       stream_->Start();
1346       // Sanity check, make sure we still encode frames with this encoder.
1347       EXPECT_EQ(kEventSignaled, Wait())
1348           << "Timed out while waiting for Encode.";
1349     }
1350
1351     scoped_ptr<CriticalSectionWrapper> crit_;
1352     VideoSendStream* stream_;
1353     bool initialized_ GUARDED_BY(crit_);
1354     bool callback_registered_ GUARDED_BY(crit_);
1355     size_t num_releases_ GUARDED_BY(crit_);
1356     bool released_ GUARDED_BY(crit_);
1357     VideoEncoderConfig encoder_config_;
1358   } test_encoder;
1359
1360   RunBaseTest(&test_encoder);
1361
1362   EXPECT_TRUE(test_encoder.IsReleased());
1363   EXPECT_EQ(1u, test_encoder.num_releases());
1364 }
1365
1366 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
1367   class VideoCodecConfigObserver : public test::SendTest,
1368                                    public test::FakeEncoder {
1369    public:
1370     VideoCodecConfigObserver()
1371         : SendTest(kDefaultTimeoutMs),
1372           FakeEncoder(Clock::GetRealTimeClock()),
1373           num_initializations_(0) {}
1374
1375    private:
1376     virtual void ModifyConfigs(
1377         VideoSendStream::Config* send_config,
1378         std::vector<VideoReceiveStream::Config>* receive_configs,
1379         VideoEncoderConfig* encoder_config) OVERRIDE {
1380       send_config->encoder_settings.encoder = this;
1381       encoder_config_ = *encoder_config;
1382     }
1383
1384     virtual void OnStreamsCreated(
1385         VideoSendStream* send_stream,
1386         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
1387       stream_ = send_stream;
1388     }
1389
1390     virtual int32_t InitEncode(const VideoCodec* config,
1391                                int32_t number_of_cores,
1392                                uint32_t max_payload_size) OVERRIDE {
1393       if (num_initializations_ == 0) {
1394         // Verify default values.
1395         EXPECT_EQ(kRealtimeVideo, config->mode);
1396       } else {
1397         // Verify that changed values are propagated.
1398         EXPECT_EQ(kScreensharing, config->mode);
1399       }
1400       ++num_initializations_;
1401       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
1402     }
1403
1404     virtual void PerformTest() OVERRIDE {
1405       EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
1406
1407       encoder_config_.content_type = VideoEncoderConfig::kScreenshare;
1408       stream_->ReconfigureVideoEncoder(encoder_config_);
1409       EXPECT_EQ(2u, num_initializations_)
1410           << "ReconfigureVideoEncoder did not reinitialize the encoder with "
1411              "new encoder settings.";
1412     }
1413
1414     size_t num_initializations_;
1415     VideoSendStream* stream_;
1416     VideoEncoderConfig encoder_config_;
1417   } test;
1418
1419   RunBaseTest(&test);
1420 }
1421
1422 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
1423   static const size_t kNumberOfTemporalLayers = 4;
1424   class VideoCodecConfigObserver : public test::SendTest,
1425                                    public test::FakeEncoder {
1426    public:
1427     VideoCodecConfigObserver()
1428         : SendTest(kDefaultTimeoutMs),
1429           FakeEncoder(Clock::GetRealTimeClock()),
1430           num_initializations_(0) {
1431       memset(&vp8_settings_, 0, sizeof(vp8_settings_));
1432     }
1433
1434    private:
1435     virtual void ModifyConfigs(
1436         VideoSendStream::Config* send_config,
1437         std::vector<VideoReceiveStream::Config>* receive_configs,
1438         VideoEncoderConfig* encoder_config) OVERRIDE {
1439       send_config->encoder_settings.encoder = this;
1440       send_config->encoder_settings.payload_name = "VP8";
1441
1442       for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
1443         encoder_config->streams[i].temporal_layers.resize(
1444             kNumberOfTemporalLayers);
1445       }
1446
1447       encoder_config->encoder_specific_settings = &vp8_settings_;
1448       encoder_config_ = *encoder_config;
1449     }
1450
1451     virtual void OnStreamsCreated(
1452         VideoSendStream* send_stream,
1453         const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
1454       stream_ = send_stream;
1455     }
1456
1457     virtual int32_t InitEncode(const VideoCodec* config,
1458                                int32_t number_of_cores,
1459                                uint32_t max_payload_size) OVERRIDE {
1460       EXPECT_EQ(kVideoCodecVP8, config->codecType);
1461
1462       // Check that the number of temporal layers has propagated properly to
1463       // VideoCodec.
1464       EXPECT_EQ(kNumberOfTemporalLayers,
1465                 config->codecSpecific.VP8.numberOfTemporalLayers);
1466
1467       for (unsigned char i = 0; i < config->numberOfSimulcastStreams; ++i) {
1468         EXPECT_EQ(kNumberOfTemporalLayers,
1469                   config->simulcastStream[i].numberOfTemporalLayers);
1470       }
1471
1472       // Set expected temporal layers as they should have been set when
1473       // reconfiguring the encoder and not match the set config.
1474       vp8_settings_.numberOfTemporalLayers = kNumberOfTemporalLayers;
1475       EXPECT_EQ(0,
1476                 memcmp(&config->codecSpecific.VP8,
1477                        &vp8_settings_,
1478                        sizeof(vp8_settings_)));
1479       ++num_initializations_;
1480       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
1481     }
1482
1483     virtual void PerformTest() OVERRIDE {
1484       EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
1485
1486       vp8_settings_.denoisingOn = true;
1487       stream_->ReconfigureVideoEncoder(encoder_config_);
1488       EXPECT_EQ(2u, num_initializations_)
1489           << "ReconfigureVideoEncoder did not reinitialize the encoder with "
1490              "new encoder settings.";
1491     }
1492
1493     int32_t Encode(const I420VideoFrame& input_image,
1494                    const CodecSpecificInfo* codec_specific_info,
1495                    const std::vector<VideoFrameType>* frame_types) OVERRIDE {
1496       // Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
1497       return 0;
1498     }
1499
1500     VideoCodecVP8 vp8_settings_;
1501     size_t num_initializations_;
1502     VideoSendStream* stream_;
1503     VideoEncoderConfig encoder_config_;
1504   } test;
1505
1506   RunBaseTest(&test);
1507 }
1508
1509 TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
1510   class RtcpByeTest : public test::SendTest {
1511    public:
1512     RtcpByeTest() : SendTest(kDefaultTimeoutMs), media_bytes_sent_(0) {}
1513
1514    private:
1515     virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
1516       RTPHeader header;
1517       EXPECT_TRUE(parser_->Parse(packet, length, &header));
1518       media_bytes_sent_ += length - header.headerLength - header.paddingLength;
1519       return SEND_PACKET;
1520     }
1521
1522     virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
1523       RTCPUtility::RTCPParserV2 parser(packet, length, true);
1524       EXPECT_TRUE(parser.IsValid());
1525
1526       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1527       uint32_t sender_octet_count = 0;
1528       while (packet_type != RTCPUtility::kRtcpNotValidCode) {
1529         if (packet_type == RTCPUtility::kRtcpSrCode) {
1530           sender_octet_count = parser.Packet().SR.SenderOctetCount;
1531           EXPECT_EQ(sender_octet_count, media_bytes_sent_);
1532           if (sender_octet_count > 0)
1533             observation_complete_->Set();
1534         }
1535
1536         packet_type = parser.Iterate();
1537       }
1538
1539       return SEND_PACKET;
1540     }
1541
1542     virtual void PerformTest() OVERRIDE {
1543       EXPECT_EQ(kEventSignaled, Wait())
1544           << "Timed out while waiting for RTCP sender report.";
1545     }
1546
1547     size_t media_bytes_sent_;
1548   } test;
1549
1550   RunBaseTest(&test);
1551 }
1552
1553 }  // namespace webrtc