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
38namespace webrtc {
39
40enum VideoFormat { kGeneric, kVP8, };
41
42void ExpectEqualFrames(const I420VideoFrame& frame1,
43                       const I420VideoFrame& frame2);
44void ExpectEqualTextureFrames(const I420VideoFrame& frame1,
45                              const I420VideoFrame& frame2);
46void ExpectEqualBufferFrames(const I420VideoFrame& frame1,
47                             const I420VideoFrame& frame2);
48void ExpectEqualFramesVector(const std::vector<I420VideoFrame*>& frames1,
49                             const std::vector<I420VideoFrame*>& frames2);
50I420VideoFrame* CreateI420VideoFrame(int width, int height, uint8_t data);
51
52class FakeNativeHandle : public NativeHandle {
53 public:
54  FakeNativeHandle() {}
55  virtual ~FakeNativeHandle() {}
56  virtual void* GetHandle() { return NULL; }
57};
58
59class 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
66TEST_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
78TEST_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
90TEST_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
130TEST_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
169TEST_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
228class 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
286TEST_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
310TEST_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
381void 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
465TEST_F(VideoSendStreamTest, RetransmitsNack) {
466  // Normal NACKs should use the send SSRC.
467  TestNackRetransmission(kSendSsrcs[0], kFakeSendPayloadType);
468}
469
470TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) {
471  // NACKs over RTX should use a separate SSRC.
472  TestNackRetransmission(kSendRtxSsrcs[0], kSendRtxPayloadType);
473}
474
475void 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?
667TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSize) {
668  TestPacketFragmentationSize(kGeneric, false);
669}
670
671TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSizeWithFec) {
672  TestPacketFragmentationSize(kGeneric, true);
673}
674
675TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSize) {
676  TestPacketFragmentationSize(kVP8, false);
677}
678
679TEST_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.
692TEST_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
850TEST_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
923TEST_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.
1010TEST_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
1095TEST_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
1171void 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
1179void 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
1186void 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
1211void 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
1218I420VideoFrame* 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
1241TEST_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
1366TEST_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
1422TEST_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
1509TEST_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
1554