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#include <vector>
12
13#include "testing/gtest/include/gtest/gtest.h"
14
15#include "webrtc/base/bind.h"
16#include "webrtc/base/checks.h"
17#include "webrtc/base/criticalsection.h"
18#include "webrtc/base/event.h"
19#include "webrtc/base/logging.h"
20#include "webrtc/base/platform_thread.h"
21#include "webrtc/base/scoped_ptr.h"
22#include "webrtc/call.h"
23#include "webrtc/call/transport_adapter.h"
24#include "webrtc/frame_callback.h"
25#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
26#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
27#include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
28#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
29#include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
30#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
31#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
32#include "webrtc/system_wrappers/include/ref_count.h"
33#include "webrtc/system_wrappers/include/sleep.h"
34#include "webrtc/test/call_test.h"
35#include "webrtc/test/configurable_frame_size_encoder.h"
36#include "webrtc/test/fake_texture_frame.h"
37#include "webrtc/test/null_transport.h"
38#include "webrtc/test/testsupport/perf_test.h"
39#include "webrtc/video/send_statistics_proxy.h"
40#include "webrtc/video_frame.h"
41#include "webrtc/video_send_stream.h"
42
43namespace webrtc {
44
45enum VideoFormat { kGeneric, kVP8, };
46
47void ExpectEqualFrames(const VideoFrame& frame1, const VideoFrame& frame2);
48void ExpectEqualTextureFrames(const VideoFrame& frame1,
49                              const VideoFrame& frame2);
50void ExpectEqualBufferFrames(const VideoFrame& frame1,
51                             const VideoFrame& frame2);
52void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1,
53                             const std::vector<VideoFrame>& frames2);
54VideoFrame CreateVideoFrame(int width, int height, uint8_t data);
55
56class VideoSendStreamTest : public test::CallTest {
57 protected:
58  void TestNackRetransmission(uint32_t retransmit_ssrc,
59                              uint8_t retransmit_payload_type);
60  void TestPacketFragmentationSize(VideoFormat format, bool with_fec);
61
62  void TestVp9NonFlexMode(uint8_t num_temporal_layers,
63                          uint8_t num_spatial_layers);
64};
65
66TEST_F(VideoSendStreamTest, CanStartStartedStream) {
67  Call::Config call_config;
68  CreateSenderCall(call_config);
69
70  test::NullTransport transport;
71  CreateSendConfig(1, 0, &transport);
72  CreateVideoStreams();
73  video_send_stream_->Start();
74  video_send_stream_->Start();
75  DestroyStreams();
76}
77
78TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
79  Call::Config call_config;
80  CreateSenderCall(call_config);
81
82  test::NullTransport transport;
83  CreateSendConfig(1, 0, &transport);
84  CreateVideoStreams();
85  video_send_stream_->Stop();
86  video_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    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::RTCPPacketTypes::kInvalid) {
103        if (packet_type == RTCPUtility::RTCPPacketTypes::kSdesChunk) {
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    void ModifyVideoConfigs(
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    void PerformTest() override {
122      EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP with CNAME.";
123    }
124  } test;
125
126  RunBaseTest(&test);
127}
128
129TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
130  class AbsoluteSendTimeObserver : public test::SendTest {
131   public:
132    AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) {
133      EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
134          kRtpExtensionAbsoluteSendTime, test::kAbsSendTimeExtensionId));
135    }
136
137    Action OnSendRtp(const uint8_t* packet, size_t length) override {
138      RTPHeader header;
139      EXPECT_TRUE(parser_->Parse(packet, length, &header));
140
141      EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
142      EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
143      EXPECT_EQ(header.extension.transmissionTimeOffset, 0);
144      EXPECT_GT(header.extension.absoluteSendTime, 0u);
145      observation_complete_.Set();
146
147      return SEND_PACKET;
148    }
149
150    void ModifyVideoConfigs(
151        VideoSendStream::Config* send_config,
152        std::vector<VideoReceiveStream::Config>* receive_configs,
153        VideoEncoderConfig* encoder_config) override {
154      send_config->rtp.extensions.clear();
155      send_config->rtp.extensions.push_back(RtpExtension(
156          RtpExtension::kAbsSendTime, test::kAbsSendTimeExtensionId));
157    }
158
159    void PerformTest() override {
160      EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet.";
161    }
162  } test;
163
164  RunBaseTest(&test);
165}
166
167TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
168  static const int kEncodeDelayMs = 5;
169  class TransmissionTimeOffsetObserver : public test::SendTest {
170   public:
171    TransmissionTimeOffsetObserver()
172        : SendTest(kDefaultTimeoutMs),
173          encoder_(Clock::GetRealTimeClock(), kEncodeDelayMs) {
174      EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
175          kRtpExtensionTransmissionTimeOffset, test::kTOffsetExtensionId));
176    }
177
178   private:
179    Action OnSendRtp(const uint8_t* packet, size_t length) override {
180      RTPHeader header;
181      EXPECT_TRUE(parser_->Parse(packet, length, &header));
182
183      EXPECT_TRUE(header.extension.hasTransmissionTimeOffset);
184      EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
185      EXPECT_GT(header.extension.transmissionTimeOffset, 0);
186      EXPECT_EQ(header.extension.absoluteSendTime, 0u);
187      observation_complete_.Set();
188
189      return SEND_PACKET;
190    }
191
192    void ModifyVideoConfigs(
193        VideoSendStream::Config* send_config,
194        std::vector<VideoReceiveStream::Config>* receive_configs,
195        VideoEncoderConfig* encoder_config) override {
196      send_config->encoder_settings.encoder = &encoder_;
197      send_config->rtp.extensions.clear();
198      send_config->rtp.extensions.push_back(
199          RtpExtension(RtpExtension::kTOffset, test::kTOffsetExtensionId));
200    }
201
202    void PerformTest() override {
203      EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
204    }
205
206    test::DelayedEncoder encoder_;
207  } test;
208
209  RunBaseTest(&test);
210}
211
212TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
213  static const uint8_t kExtensionId = 13;
214  class TransportWideSequenceNumberObserver : public test::SendTest {
215   public:
216    TransportWideSequenceNumberObserver()
217        : SendTest(kDefaultTimeoutMs), encoder_(Clock::GetRealTimeClock()) {
218      EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
219          kRtpExtensionTransportSequenceNumber, kExtensionId));
220    }
221
222   private:
223    Action OnSendRtp(const uint8_t* packet, size_t length) override {
224      RTPHeader header;
225      EXPECT_TRUE(parser_->Parse(packet, length, &header));
226
227      EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
228      EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
229      EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
230
231      observation_complete_.Set();
232
233      return SEND_PACKET;
234    }
235
236    void ModifyVideoConfigs(
237        VideoSendStream::Config* send_config,
238        std::vector<VideoReceiveStream::Config>* receive_configs,
239        VideoEncoderConfig* encoder_config) override {
240      send_config->encoder_settings.encoder = &encoder_;
241      send_config->rtp.extensions.clear();
242      send_config->rtp.extensions.push_back(
243          RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
244    }
245
246    void PerformTest() override {
247      EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
248    }
249
250    test::FakeEncoder encoder_;
251  } test;
252
253  RunBaseTest(&test);
254}
255
256class FakeReceiveStatistics : public NullReceiveStatistics {
257 public:
258  FakeReceiveStatistics(uint32_t send_ssrc,
259                        uint32_t last_sequence_number,
260                        uint32_t cumulative_lost,
261                        uint8_t fraction_lost)
262      : lossy_stats_(new LossyStatistician(last_sequence_number,
263                                           cumulative_lost,
264                                           fraction_lost)) {
265    stats_map_[send_ssrc] = lossy_stats_.get();
266  }
267
268  StatisticianMap GetActiveStatisticians() const override { return stats_map_; }
269
270  StreamStatistician* GetStatistician(uint32_t ssrc) const override {
271    return lossy_stats_.get();
272  }
273
274 private:
275  class LossyStatistician : public StreamStatistician {
276   public:
277    LossyStatistician(uint32_t extended_max_sequence_number,
278                      uint32_t cumulative_lost,
279                      uint8_t fraction_lost) {
280      stats_.fraction_lost = fraction_lost;
281      stats_.cumulative_lost = cumulative_lost;
282      stats_.extended_max_sequence_number = extended_max_sequence_number;
283    }
284    bool GetStatistics(RtcpStatistics* statistics, bool reset) override {
285      *statistics = stats_;
286      return true;
287    }
288    void GetDataCounters(size_t* bytes_received,
289                         uint32_t* packets_received) const override {
290      *bytes_received = 0;
291      *packets_received = 0;
292    }
293    void GetReceiveStreamDataCounters(
294        StreamDataCounters* data_counters) const override {}
295    uint32_t BitrateReceived() const override { return 0; }
296    bool IsRetransmitOfOldPacket(const RTPHeader& header,
297                                 int64_t min_rtt) const override {
298      return false;
299    }
300
301    bool IsPacketInOrder(uint16_t sequence_number) const override {
302      return true;
303    }
304
305    RtcpStatistics stats_;
306  };
307
308  rtc::scoped_ptr<LossyStatistician> lossy_stats_;
309  StatisticianMap stats_map_;
310};
311
312class FecObserver : public test::SendTest {
313 public:
314  explicit FecObserver(bool header_extensions_enabled)
315      : SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
316        send_count_(0),
317        received_media_(false),
318        received_fec_(false),
319        header_extensions_enabled_(header_extensions_enabled) {}
320
321 private:
322  Action OnSendRtp(const uint8_t* packet, size_t length) override {
323    RTPHeader header;
324    EXPECT_TRUE(parser_->Parse(packet, length, &header));
325
326    // Send lossy receive reports to trigger FEC enabling.
327    if (send_count_++ % 2 != 0) {
328      // Receive statistics reporting having lost 50% of the packets.
329      FakeReceiveStatistics lossy_receive_stats(
330          VideoSendStreamTest::kVideoSendSsrcs[0], header.sequenceNumber,
331          send_count_ / 2, 127);
332      RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
333                             &lossy_receive_stats, nullptr,
334                             transport_adapter_.get());
335
336      rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
337      rtcp_sender.SetRemoteSSRC(VideoSendStreamTest::kVideoSendSsrcs[0]);
338
339      RTCPSender::FeedbackState feedback_state;
340
341      EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
342    }
343
344    int encapsulated_payload_type = -1;
345    if (header.payloadType == VideoSendStreamTest::kRedPayloadType) {
346      encapsulated_payload_type = static_cast<int>(packet[header.headerLength]);
347      if (encapsulated_payload_type !=
348          VideoSendStreamTest::kFakeVideoSendPayloadType)
349        EXPECT_EQ(VideoSendStreamTest::kUlpfecPayloadType,
350                  encapsulated_payload_type);
351    } else {
352      EXPECT_EQ(VideoSendStreamTest::kFakeVideoSendPayloadType,
353                header.payloadType);
354    }
355
356    if (header_extensions_enabled_) {
357      EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
358      uint32_t kHalf24BitsSpace = 0xFFFFFF / 2;
359      if (header.extension.absoluteSendTime <= kHalf24BitsSpace &&
360          prev_header_.extension.absoluteSendTime > kHalf24BitsSpace) {
361        // 24 bits wrap.
362        EXPECT_GT(prev_header_.extension.absoluteSendTime,
363                  header.extension.absoluteSendTime);
364      } else {
365        EXPECT_GE(header.extension.absoluteSendTime,
366                  prev_header_.extension.absoluteSendTime);
367      }
368      EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
369      uint16_t seq_num_diff = header.extension.transportSequenceNumber -
370                              prev_header_.extension.transportSequenceNumber;
371      EXPECT_EQ(1, seq_num_diff);
372    }
373
374    if (encapsulated_payload_type != -1) {
375      if (encapsulated_payload_type ==
376          VideoSendStreamTest::kUlpfecPayloadType) {
377        received_fec_ = true;
378      } else {
379        received_media_ = true;
380      }
381    }
382
383    if (received_media_ && received_fec_ && send_count_ > 100)
384      observation_complete_.Set();
385
386    prev_header_ = header;
387
388    return SEND_PACKET;
389  }
390
391  void ModifyVideoConfigs(
392      VideoSendStream::Config* send_config,
393      std::vector<VideoReceiveStream::Config>* receive_configs,
394      VideoEncoderConfig* encoder_config) override {
395    transport_adapter_.reset(
396        new internal::TransportAdapter(send_config->send_transport));
397    transport_adapter_->Enable();
398    send_config->rtp.fec.red_payload_type =
399        VideoSendStreamTest::kRedPayloadType;
400    send_config->rtp.fec.ulpfec_payload_type =
401        VideoSendStreamTest::kUlpfecPayloadType;
402    if (header_extensions_enabled_) {
403      send_config->rtp.extensions.push_back(RtpExtension(
404          RtpExtension::kAbsSendTime, test::kAbsSendTimeExtensionId));
405      send_config->rtp.extensions.push_back(
406          RtpExtension(RtpExtension::kTransportSequenceNumber,
407                       test::kTransportSequenceNumberExtensionId));
408    }
409  }
410
411  void PerformTest() override {
412    EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
413  }
414
415  rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
416  int send_count_;
417  bool received_media_;
418  bool received_fec_;
419  bool header_extensions_enabled_;
420  RTPHeader prev_header_;
421};
422
423TEST_F(VideoSendStreamTest, SupportsFecWithExtensions) {
424  FecObserver test(true);
425
426  RunBaseTest(&test);
427}
428
429TEST_F(VideoSendStreamTest, SupportsFecWithoutExtensions) {
430  FecObserver test(false);
431
432  RunBaseTest(&test);
433}
434
435void VideoSendStreamTest::TestNackRetransmission(
436    uint32_t retransmit_ssrc,
437    uint8_t retransmit_payload_type) {
438  class NackObserver : public test::SendTest {
439   public:
440    explicit NackObserver(uint32_t retransmit_ssrc,
441                          uint8_t retransmit_payload_type)
442        : SendTest(kDefaultTimeoutMs),
443          send_count_(0),
444          retransmit_ssrc_(retransmit_ssrc),
445          retransmit_payload_type_(retransmit_payload_type),
446          nacked_sequence_number_(-1) {
447    }
448
449   private:
450    Action OnSendRtp(const uint8_t* packet, size_t length) override {
451      RTPHeader header;
452      EXPECT_TRUE(parser_->Parse(packet, length, &header));
453
454      // Nack second packet after receiving the third one.
455      if (++send_count_ == 3) {
456        uint16_t nack_sequence_number = header.sequenceNumber - 1;
457        nacked_sequence_number_ = nack_sequence_number;
458        NullReceiveStatistics null_stats;
459        RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &null_stats,
460                               nullptr, transport_adapter_.get());
461
462        rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
463        rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]);
464
465        RTCPSender::FeedbackState feedback_state;
466
467        EXPECT_EQ(0,
468                  rtcp_sender.SendRTCP(
469                      feedback_state, kRtcpNack, 1, &nack_sequence_number));
470      }
471
472      uint16_t sequence_number = header.sequenceNumber;
473
474      if (header.ssrc == retransmit_ssrc_ &&
475          retransmit_ssrc_ != kVideoSendSsrcs[0]) {
476        // Not kVideoSendSsrcs[0], assume correct RTX packet. Extract sequence
477        // number.
478        const uint8_t* rtx_header = packet + header.headerLength;
479        sequence_number = (rtx_header[0] << 8) + rtx_header[1];
480      }
481
482      if (sequence_number == nacked_sequence_number_) {
483        EXPECT_EQ(retransmit_ssrc_, header.ssrc);
484        EXPECT_EQ(retransmit_payload_type_, header.payloadType);
485        observation_complete_.Set();
486      }
487
488      return SEND_PACKET;
489    }
490
491    void ModifyVideoConfigs(
492        VideoSendStream::Config* send_config,
493        std::vector<VideoReceiveStream::Config>* receive_configs,
494        VideoEncoderConfig* encoder_config) override {
495      transport_adapter_.reset(
496          new internal::TransportAdapter(send_config->send_transport));
497      transport_adapter_->Enable();
498      send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
499      send_config->rtp.rtx.payload_type = retransmit_payload_type_;
500      if (retransmit_ssrc_ != kVideoSendSsrcs[0])
501        send_config->rtp.rtx.ssrcs.push_back(retransmit_ssrc_);
502    }
503
504    void PerformTest() override {
505      EXPECT_TRUE(Wait()) << "Timed out while waiting for NACK retransmission.";
506    }
507
508    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
509    int send_count_;
510    uint32_t retransmit_ssrc_;
511    uint8_t retransmit_payload_type_;
512    int nacked_sequence_number_;
513  } test(retransmit_ssrc, retransmit_payload_type);
514
515  RunBaseTest(&test);
516}
517
518TEST_F(VideoSendStreamTest, RetransmitsNack) {
519  // Normal NACKs should use the send SSRC.
520  TestNackRetransmission(kVideoSendSsrcs[0], kFakeVideoSendPayloadType);
521}
522
523TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) {
524  // NACKs over RTX should use a separate SSRC.
525  TestNackRetransmission(kSendRtxSsrcs[0], kSendRtxPayloadType);
526}
527
528void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
529                                                      bool with_fec) {
530  // Use a fake encoder to output a frame of every size in the range [90, 290],
531  // for each size making sure that the exact number of payload bytes received
532  // is correct and that packets are fragmented to respect max packet size.
533  static const size_t kMaxPacketSize = 128;
534  static const size_t start = 90;
535  static const size_t stop = 290;
536
537  // Observer that verifies that the expected number of packets and bytes
538  // arrive for each frame size, from start_size to stop_size.
539  class FrameFragmentationTest : public test::SendTest,
540                                 public EncodedFrameObserver {
541   public:
542    FrameFragmentationTest(size_t max_packet_size,
543                           size_t start_size,
544                           size_t stop_size,
545                           bool test_generic_packetization,
546                           bool use_fec)
547        : SendTest(kLongTimeoutMs),
548          encoder_(stop),
549          max_packet_size_(max_packet_size),
550          stop_size_(stop_size),
551          test_generic_packetization_(test_generic_packetization),
552          use_fec_(use_fec),
553          packet_count_(0),
554          accumulated_size_(0),
555          accumulated_payload_(0),
556          fec_packet_received_(false),
557          current_size_rtp_(start_size),
558          current_size_frame_(static_cast<int32_t>(start_size)) {
559      // Fragmentation required, this test doesn't make sense without it.
560      encoder_.SetFrameSize(start_size);
561      RTC_DCHECK_GT(stop_size, max_packet_size);
562    }
563
564   private:
565    Action OnSendRtp(const uint8_t* packet, size_t size) override {
566      size_t length = size;
567      RTPHeader header;
568      EXPECT_TRUE(parser_->Parse(packet, length, &header));
569
570      EXPECT_LE(length, max_packet_size_);
571
572      if (use_fec_) {
573        uint8_t payload_type = packet[header.headerLength];
574        bool is_fec = header.payloadType == kRedPayloadType &&
575                      payload_type == kUlpfecPayloadType;
576        if (is_fec) {
577          fec_packet_received_ = true;
578          return SEND_PACKET;
579        }
580      }
581
582      accumulated_size_ += length;
583
584      if (use_fec_)
585        TriggerLossReport(header);
586
587      if (test_generic_packetization_) {
588        size_t overhead = header.headerLength + header.paddingLength;
589        // Only remove payload header and RED header if the packet actually
590        // contains payload.
591        if (length > overhead) {
592          overhead += (1 /* Generic header */);
593          if (use_fec_)
594            overhead += 1;  // RED for FEC header.
595        }
596        EXPECT_GE(length, overhead);
597        accumulated_payload_ += length - overhead;
598      }
599
600      // Marker bit set indicates last packet of a frame.
601      if (header.markerBit) {
602        if (use_fec_ && accumulated_payload_ == current_size_rtp_ - 1) {
603          // With FEC enabled, frame size is incremented asynchronously, so
604          // "old" frames one byte too small may arrive. Accept, but don't
605          // increase expected frame size.
606          accumulated_size_ = 0;
607          accumulated_payload_ = 0;
608          return SEND_PACKET;
609        }
610
611        EXPECT_GE(accumulated_size_, current_size_rtp_);
612        if (test_generic_packetization_) {
613          EXPECT_EQ(current_size_rtp_, accumulated_payload_);
614        }
615
616        // Last packet of frame; reset counters.
617        accumulated_size_ = 0;
618        accumulated_payload_ = 0;
619        if (current_size_rtp_ == stop_size_) {
620          // Done! (Don't increase size again, might arrive more @ stop_size).
621          observation_complete_.Set();
622        } else {
623          // Increase next expected frame size. If testing with FEC, make sure
624          // a FEC packet has been received for this frame size before
625          // proceeding, to make sure that redundancy packets don't exceed
626          // size limit.
627          if (!use_fec_) {
628            ++current_size_rtp_;
629          } else if (fec_packet_received_) {
630            fec_packet_received_ = false;
631            ++current_size_rtp_;
632            ++current_size_frame_;
633          }
634        }
635      }
636
637      return SEND_PACKET;
638    }
639
640    void TriggerLossReport(const RTPHeader& header) {
641      // Send lossy receive reports to trigger FEC enabling.
642      if (packet_count_++ % 2 != 0) {
643        // Receive statistics reporting having lost 50% of the packets.
644        FakeReceiveStatistics lossy_receive_stats(
645            kVideoSendSsrcs[0], header.sequenceNumber, packet_count_ / 2, 127);
646        RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
647                               &lossy_receive_stats, nullptr,
648                               transport_adapter_.get());
649
650        rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
651        rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]);
652
653        RTCPSender::FeedbackState feedback_state;
654
655        EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
656      }
657    }
658
659    virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
660      // Increase frame size for next encoded frame, in the context of the
661      // encoder thread.
662      if (!use_fec_ &&
663          current_size_frame_.Value() < static_cast<int32_t>(stop_size_)) {
664        ++current_size_frame_;
665      }
666      encoder_.SetFrameSize(static_cast<size_t>(current_size_frame_.Value()));
667    }
668
669    Call::Config GetSenderCallConfig() override {
670      Call::Config config;
671      const int kMinBitrateBps = 30000;
672      config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
673      return config;
674    }
675
676    void ModifyVideoConfigs(
677        VideoSendStream::Config* send_config,
678        std::vector<VideoReceiveStream::Config>* receive_configs,
679        VideoEncoderConfig* encoder_config) override {
680      transport_adapter_.reset(
681          new internal::TransportAdapter(send_config->send_transport));
682      transport_adapter_->Enable();
683      if (use_fec_) {
684        send_config->rtp.fec.red_payload_type = kRedPayloadType;
685        send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
686      }
687
688      if (!test_generic_packetization_)
689        send_config->encoder_settings.payload_name = "VP8";
690
691      send_config->encoder_settings.encoder = &encoder_;
692      send_config->rtp.max_packet_size = kMaxPacketSize;
693      send_config->post_encode_callback = this;
694
695      // Make sure there is at least one extension header, to make the RTP
696      // header larger than the base length of 12 bytes.
697      EXPECT_FALSE(send_config->rtp.extensions.empty());
698    }
699
700    void PerformTest() override {
701      EXPECT_TRUE(Wait()) << "Timed out while observing incoming RTP packets.";
702    }
703
704    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
705    test::ConfigurableFrameSizeEncoder encoder_;
706
707    const size_t max_packet_size_;
708    const size_t stop_size_;
709    const bool test_generic_packetization_;
710    const bool use_fec_;
711
712    uint32_t packet_count_;
713    size_t accumulated_size_;
714    size_t accumulated_payload_;
715    bool fec_packet_received_;
716
717    size_t current_size_rtp_;
718    Atomic32 current_size_frame_;
719  };
720
721  // Don't auto increment if FEC is used; continue sending frame size until
722  // a FEC packet has been received.
723  FrameFragmentationTest test(
724      kMaxPacketSize, start, stop, format == kGeneric, with_fec);
725
726  RunBaseTest(&test);
727}
728
729// TODO(sprang): Is there any way of speeding up these tests?
730TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSize) {
731  TestPacketFragmentationSize(kGeneric, false);
732}
733
734TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSizeWithFec) {
735  TestPacketFragmentationSize(kGeneric, true);
736}
737
738TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSize) {
739  TestPacketFragmentationSize(kVP8, false);
740}
741
742TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSizeWithFec) {
743  TestPacketFragmentationSize(kVP8, true);
744}
745
746// The test will go through a number of phases.
747// 1. Start sending packets.
748// 2. As soon as the RTP stream has been detected, signal a low REMB value to
749//    suspend the stream.
750// 3. Wait until |kSuspendTimeFrames| have been captured without seeing any RTP
751//    packets.
752// 4. Signal a high REMB and then wait for the RTP stream to start again.
753//    When the stream is detected again, and the stats show that the stream
754//    is no longer suspended, the test ends.
755TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
756  static const int kSuspendTimeFrames = 60;  // Suspend for 2 seconds @ 30 fps.
757
758  class RembObserver : public test::SendTest, public I420FrameCallback {
759   public:
760    RembObserver()
761        : SendTest(kDefaultTimeoutMs),
762          clock_(Clock::GetRealTimeClock()),
763          test_state_(kBeforeSuspend),
764          rtp_count_(0),
765          last_sequence_number_(0),
766          suspended_frame_count_(0),
767          low_remb_bps_(0),
768          high_remb_bps_(0) {
769    }
770
771   private:
772    Action OnSendRtp(const uint8_t* packet, size_t length) override {
773      rtc::CritScope lock(&crit_);
774      ++rtp_count_;
775      RTPHeader header;
776      EXPECT_TRUE(parser_->Parse(packet, length, &header));
777      last_sequence_number_ = header.sequenceNumber;
778
779      if (test_state_ == kBeforeSuspend) {
780        // The stream has started. Try to suspend it.
781        SendRtcpFeedback(low_remb_bps_);
782        test_state_ = kDuringSuspend;
783      } else if (test_state_ == kDuringSuspend) {
784        if (header.paddingLength == 0) {
785          // Received non-padding packet during suspension period. Reset the
786          // counter.
787          suspended_frame_count_ = 0;
788        }
789        SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
790      } else if (test_state_ == kWaitingForPacket) {
791        if (header.paddingLength == 0) {
792          // Non-padding packet observed. Test is almost complete. Will just
793          // have to wait for the stats to change.
794          test_state_ = kWaitingForStats;
795        }
796        SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
797      } else if (test_state_ == kWaitingForStats) {
798        VideoSendStream::Stats stats = stream_->GetStats();
799        if (stats.suspended == false) {
800          // Stats flipped to false. Test is complete.
801          observation_complete_.Set();
802        }
803        SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
804      }
805
806      return SEND_PACKET;
807    }
808
809    // This method implements the I420FrameCallback.
810    void FrameCallback(VideoFrame* video_frame) override {
811      rtc::CritScope lock(&crit_);
812      if (test_state_ == kDuringSuspend &&
813          ++suspended_frame_count_ > kSuspendTimeFrames) {
814        VideoSendStream::Stats stats = stream_->GetStats();
815        EXPECT_TRUE(stats.suspended);
816        SendRtcpFeedback(high_remb_bps_);
817        test_state_ = kWaitingForPacket;
818      }
819    }
820
821    void set_low_remb_bps(int value) {
822      rtc::CritScope lock(&crit_);
823      low_remb_bps_ = value;
824    }
825
826    void set_high_remb_bps(int value) {
827      rtc::CritScope lock(&crit_);
828      high_remb_bps_ = value;
829    }
830
831    void OnVideoStreamsCreated(
832        VideoSendStream* send_stream,
833        const std::vector<VideoReceiveStream*>& receive_streams) override {
834      stream_ = send_stream;
835    }
836
837    void ModifyVideoConfigs(
838        VideoSendStream::Config* send_config,
839        std::vector<VideoReceiveStream::Config>* receive_configs,
840        VideoEncoderConfig* encoder_config) override {
841      transport_adapter_.reset(
842          new internal::TransportAdapter(send_config->send_transport));
843      transport_adapter_->Enable();
844      send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
845      send_config->pre_encode_callback = this;
846      send_config->suspend_below_min_bitrate = true;
847      int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps;
848      set_low_remb_bps(min_bitrate_bps - 10000);
849      int threshold_window = std::max(min_bitrate_bps / 10, 10000);
850      ASSERT_GT(encoder_config->streams[0].max_bitrate_bps,
851                min_bitrate_bps + threshold_window + 5000);
852      set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);
853    }
854
855    void PerformTest() override {
856      EXPECT_TRUE(Wait()) << "Timed out during suspend-below-min-bitrate test.";
857    }
858
859    enum TestState {
860      kBeforeSuspend,
861      kDuringSuspend,
862      kWaitingForPacket,
863      kWaitingForStats
864    };
865
866    virtual void SendRtcpFeedback(int remb_value)
867        EXCLUSIVE_LOCKS_REQUIRED(crit_) {
868      FakeReceiveStatistics receive_stats(kVideoSendSsrcs[0],
869                                          last_sequence_number_, rtp_count_, 0);
870      RTCPSender rtcp_sender(false, clock_, &receive_stats, nullptr,
871                             transport_adapter_.get());
872
873      rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
874      rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]);
875      if (remb_value > 0) {
876        rtcp_sender.SetREMBStatus(true);
877        rtcp_sender.SetREMBData(remb_value, std::vector<uint32_t>());
878      }
879      RTCPSender::FeedbackState feedback_state;
880      EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
881    }
882
883    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
884    Clock* const clock_;
885    VideoSendStream* stream_;
886
887    rtc::CriticalSection crit_;
888    TestState test_state_ GUARDED_BY(crit_);
889    int rtp_count_ GUARDED_BY(crit_);
890    int last_sequence_number_ GUARDED_BY(crit_);
891    int suspended_frame_count_ GUARDED_BY(crit_);
892    int low_remb_bps_ GUARDED_BY(crit_);
893    int high_remb_bps_ GUARDED_BY(crit_);
894  } test;
895
896  RunBaseTest(&test);
897}
898
899TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
900  class NoPaddingWhenVideoIsMuted : public test::SendTest {
901   public:
902    NoPaddingWhenVideoIsMuted()
903        : SendTest(kDefaultTimeoutMs),
904          clock_(Clock::GetRealTimeClock()),
905          last_packet_time_ms_(-1),
906          capturer_(nullptr) {
907    }
908
909   private:
910    Action OnSendRtp(const uint8_t* packet, size_t length) override {
911      rtc::CritScope lock(&crit_);
912      last_packet_time_ms_ = clock_->TimeInMilliseconds();
913      capturer_->Stop();
914      return SEND_PACKET;
915    }
916
917    Action OnSendRtcp(const uint8_t* packet, size_t length) override {
918      rtc::CritScope lock(&crit_);
919      const int kVideoMutedThresholdMs = 10000;
920      if (last_packet_time_ms_ > 0 &&
921          clock_->TimeInMilliseconds() - last_packet_time_ms_ >
922              kVideoMutedThresholdMs)
923        observation_complete_.Set();
924      // Receive statistics reporting having lost 50% of the packets.
925      FakeReceiveStatistics receive_stats(kVideoSendSsrcs[0], 1, 1, 0);
926      RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &receive_stats,
927                             nullptr, transport_adapter_.get());
928
929      rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
930      rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]);
931
932      RTCPSender::FeedbackState feedback_state;
933
934      EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
935      return SEND_PACKET;
936    }
937
938    test::PacketTransport* CreateReceiveTransport() override {
939      test::PacketTransport* transport = new test::PacketTransport(
940          nullptr, this, test::PacketTransport::kReceiver,
941          FakeNetworkPipe::Config());
942      transport_adapter_.reset(new internal::TransportAdapter(transport));
943      transport_adapter_->Enable();
944      return transport;
945    }
946
947    size_t GetNumVideoStreams() const override { return 3; }
948
949    virtual void OnFrameGeneratorCapturerCreated(
950        test::FrameGeneratorCapturer* frame_generator_capturer) {
951      rtc::CritScope lock(&crit_);
952      capturer_ = frame_generator_capturer;
953    }
954
955    void PerformTest() override {
956      EXPECT_TRUE(Wait())
957          << "Timed out while waiting for RTP packets to stop being sent.";
958    }
959
960    Clock* const clock_;
961    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
962    rtc::CriticalSection crit_;
963    int64_t last_packet_time_ms_ GUARDED_BY(crit_);
964    test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
965  } test;
966
967  RunBaseTest(&test);
968}
969
970// This test first observes "high" bitrate use at which point it sends a REMB to
971// indicate that it should be lowered significantly. The test then observes that
972// the bitrate observed is sinking well below the min-transmit-bitrate threshold
973// to verify that the min-transmit bitrate respects incoming REMB.
974//
975// Note that the test starts at "high" bitrate and does not ramp up to "higher"
976// bitrate since no receiver block or remb is sent in the initial phase.
977TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
978  static const int kMinTransmitBitrateBps = 400000;
979  static const int kHighBitrateBps = 150000;
980  static const int kRembBitrateBps = 80000;
981  static const int kRembRespectedBitrateBps = 100000;
982  class BitrateObserver : public test::SendTest {
983   public:
984    BitrateObserver()
985        : SendTest(kDefaultTimeoutMs),
986          bitrate_capped_(false) {
987    }
988
989   private:
990    virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
991      if (RtpHeaderParser::IsRtcp(packet, length))
992        return DROP_PACKET;
993
994      RTPHeader header;
995      if (!parser_->Parse(packet, length, &header))
996        return DROP_PACKET;
997      RTC_DCHECK(stream_ != nullptr);
998      VideoSendStream::Stats stats = stream_->GetStats();
999      if (!stats.substreams.empty()) {
1000        EXPECT_EQ(1u, stats.substreams.size());
1001        int total_bitrate_bps =
1002            stats.substreams.begin()->second.total_bitrate_bps;
1003        test::PrintResult("bitrate_stats_",
1004                          "min_transmit_bitrate_low_remb",
1005                          "bitrate_bps",
1006                          static_cast<size_t>(total_bitrate_bps),
1007                          "bps",
1008                          false);
1009        if (total_bitrate_bps > kHighBitrateBps) {
1010          rtp_rtcp_->SetREMBData(kRembBitrateBps,
1011                                 std::vector<uint32_t>(1, header.ssrc));
1012          rtp_rtcp_->Process();
1013          bitrate_capped_ = true;
1014        } else if (bitrate_capped_ &&
1015                   total_bitrate_bps < kRembRespectedBitrateBps) {
1016          observation_complete_.Set();
1017        }
1018      }
1019      // Packets don't have to be delivered since the test is the receiver.
1020      return DROP_PACKET;
1021    }
1022
1023    void OnVideoStreamsCreated(
1024        VideoSendStream* send_stream,
1025        const std::vector<VideoReceiveStream*>& receive_streams) override {
1026      stream_ = send_stream;
1027      RtpRtcp::Configuration config;
1028      config.outgoing_transport = feedback_transport_.get();
1029      rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
1030      rtp_rtcp_->SetREMBStatus(true);
1031      rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
1032    }
1033
1034    void ModifyVideoConfigs(
1035        VideoSendStream::Config* send_config,
1036        std::vector<VideoReceiveStream::Config>* receive_configs,
1037        VideoEncoderConfig* encoder_config) override {
1038      feedback_transport_.reset(
1039          new internal::TransportAdapter(send_config->send_transport));
1040      feedback_transport_->Enable();
1041      encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
1042    }
1043
1044    void PerformTest() override {
1045      EXPECT_TRUE(Wait())
1046          << "Timeout while waiting for low bitrate stats after REMB.";
1047    }
1048
1049    rtc::scoped_ptr<RtpRtcp> rtp_rtcp_;
1050    rtc::scoped_ptr<internal::TransportAdapter> feedback_transport_;
1051    VideoSendStream* stream_;
1052    bool bitrate_capped_;
1053  } test;
1054
1055  RunBaseTest(&test);
1056}
1057
1058TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
1059  class StartBitrateObserver : public test::FakeEncoder {
1060   public:
1061    StartBitrateObserver()
1062        : FakeEncoder(Clock::GetRealTimeClock()), start_bitrate_kbps_(0) {}
1063    int32_t InitEncode(const VideoCodec* config,
1064                       int32_t number_of_cores,
1065                       size_t max_payload_size) override {
1066      rtc::CritScope lock(&crit_);
1067      start_bitrate_kbps_ = config->startBitrate;
1068      return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
1069    }
1070
1071    int32_t SetRates(uint32_t new_target_bitrate, uint32_t framerate) override {
1072      rtc::CritScope lock(&crit_);
1073      start_bitrate_kbps_ = new_target_bitrate;
1074      return FakeEncoder::SetRates(new_target_bitrate, framerate);
1075    }
1076
1077    int GetStartBitrateKbps() const {
1078      rtc::CritScope lock(&crit_);
1079      return start_bitrate_kbps_;
1080    }
1081
1082   private:
1083    mutable rtc::CriticalSection crit_;
1084    int start_bitrate_kbps_ GUARDED_BY(crit_);
1085  };
1086
1087  CreateSenderCall(Call::Config());
1088
1089  test::NullTransport transport;
1090  CreateSendConfig(1, 0, &transport);
1091
1092  Call::Config::BitrateConfig bitrate_config;
1093  bitrate_config.start_bitrate_bps =
1094      2 * video_encoder_config_.streams[0].max_bitrate_bps;
1095  sender_call_->SetBitrateConfig(bitrate_config);
1096
1097  StartBitrateObserver encoder;
1098  video_send_config_.encoder_settings.encoder = &encoder;
1099
1100  CreateVideoStreams();
1101
1102  EXPECT_EQ(video_encoder_config_.streams[0].max_bitrate_bps / 1000,
1103            encoder.GetStartBitrateKbps());
1104
1105  video_encoder_config_.streams[0].max_bitrate_bps =
1106      2 * bitrate_config.start_bitrate_bps;
1107  video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_);
1108
1109  // New bitrate should be reconfigured above the previous max. As there's no
1110  // network connection this shouldn't be flaky, as no bitrate should've been
1111  // reported in between.
1112  EXPECT_EQ(bitrate_config.start_bitrate_bps / 1000,
1113            encoder.GetStartBitrateKbps());
1114
1115  DestroyStreams();
1116}
1117
1118TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
1119  class FrameObserver : public I420FrameCallback {
1120   public:
1121    FrameObserver() : output_frame_event_(false, false) {}
1122
1123    void FrameCallback(VideoFrame* video_frame) override {
1124      output_frames_.push_back(*video_frame);
1125      output_frame_event_.Set();
1126    }
1127
1128    void WaitOutputFrame() {
1129      const int kWaitFrameTimeoutMs = 3000;
1130      EXPECT_TRUE(output_frame_event_.Wait(kWaitFrameTimeoutMs))
1131          << "Timeout while waiting for output frames.";
1132    }
1133
1134    const std::vector<VideoFrame>& output_frames() const {
1135      return output_frames_;
1136    }
1137
1138   private:
1139    // Delivered output frames.
1140    std::vector<VideoFrame> output_frames_;
1141
1142    // Indicate an output frame has arrived.
1143    rtc::Event output_frame_event_;
1144  };
1145
1146  // Initialize send stream.
1147  CreateSenderCall(Call::Config());
1148
1149  test::NullTransport transport;
1150  CreateSendConfig(1, 0, &transport);
1151  FrameObserver observer;
1152  video_send_config_.pre_encode_callback = &observer;
1153  CreateVideoStreams();
1154
1155  // Prepare five input frames. Send ordinary VideoFrame and texture frames
1156  // alternatively.
1157  std::vector<VideoFrame> input_frames;
1158  int width = static_cast<int>(video_encoder_config_.streams[0].width);
1159  int height = static_cast<int>(video_encoder_config_.streams[0].height);
1160  test::FakeNativeHandle* handle1 = new test::FakeNativeHandle();
1161  test::FakeNativeHandle* handle2 = new test::FakeNativeHandle();
1162  test::FakeNativeHandle* handle3 = new test::FakeNativeHandle();
1163  input_frames.push_back(test::FakeNativeHandle::CreateFrame(
1164      handle1, width, height, 1, 1, kVideoRotation_0));
1165  input_frames.push_back(test::FakeNativeHandle::CreateFrame(
1166      handle2, width, height, 2, 2, kVideoRotation_0));
1167  input_frames.push_back(CreateVideoFrame(width, height, 3));
1168  input_frames.push_back(CreateVideoFrame(width, height, 4));
1169  input_frames.push_back(test::FakeNativeHandle::CreateFrame(
1170      handle3, width, height, 5, 5, kVideoRotation_0));
1171
1172  video_send_stream_->Start();
1173  for (size_t i = 0; i < input_frames.size(); i++) {
1174    video_send_stream_->Input()->IncomingCapturedFrame(input_frames[i]);
1175    // Do not send the next frame too fast, so the frame dropper won't drop it.
1176    if (i < input_frames.size() - 1)
1177      SleepMs(1000 / video_encoder_config_.streams[0].max_framerate);
1178    // Wait until the output frame is received before sending the next input
1179    // frame. Or the previous input frame may be replaced without delivering.
1180    observer.WaitOutputFrame();
1181  }
1182  video_send_stream_->Stop();
1183
1184  // Test if the input and output frames are the same. render_time_ms and
1185  // timestamp are not compared because capturer sets those values.
1186  ExpectEqualFramesVector(input_frames, observer.output_frames());
1187
1188  DestroyStreams();
1189}
1190
1191void ExpectEqualFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
1192  if (frame1.native_handle() != nullptr || frame2.native_handle() != nullptr)
1193    ExpectEqualTextureFrames(frame1, frame2);
1194  else
1195    ExpectEqualBufferFrames(frame1, frame2);
1196}
1197
1198void ExpectEqualTextureFrames(const VideoFrame& frame1,
1199                              const VideoFrame& frame2) {
1200  EXPECT_EQ(frame1.native_handle(), frame2.native_handle());
1201  EXPECT_EQ(frame1.width(), frame2.width());
1202  EXPECT_EQ(frame1.height(), frame2.height());
1203  EXPECT_EQ(frame1.render_time_ms(), frame2.render_time_ms());
1204}
1205
1206void ExpectEqualBufferFrames(const VideoFrame& frame1,
1207                             const VideoFrame& frame2) {
1208  EXPECT_EQ(frame1.width(), frame2.width());
1209  EXPECT_EQ(frame1.height(), frame2.height());
1210  EXPECT_EQ(frame1.stride(kYPlane), frame2.stride(kYPlane));
1211  EXPECT_EQ(frame1.stride(kUPlane), frame2.stride(kUPlane));
1212  EXPECT_EQ(frame1.stride(kVPlane), frame2.stride(kVPlane));
1213  EXPECT_EQ(frame1.render_time_ms(), frame2.render_time_ms());
1214  ASSERT_EQ(frame1.allocated_size(kYPlane), frame2.allocated_size(kYPlane));
1215  EXPECT_EQ(0,
1216            memcmp(frame1.buffer(kYPlane),
1217                   frame2.buffer(kYPlane),
1218                   frame1.allocated_size(kYPlane)));
1219  ASSERT_EQ(frame1.allocated_size(kUPlane), frame2.allocated_size(kUPlane));
1220  EXPECT_EQ(0,
1221            memcmp(frame1.buffer(kUPlane),
1222                   frame2.buffer(kUPlane),
1223                   frame1.allocated_size(kUPlane)));
1224  ASSERT_EQ(frame1.allocated_size(kVPlane), frame2.allocated_size(kVPlane));
1225  EXPECT_EQ(0,
1226            memcmp(frame1.buffer(kVPlane),
1227                   frame2.buffer(kVPlane),
1228                   frame1.allocated_size(kVPlane)));
1229}
1230
1231void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1,
1232                             const std::vector<VideoFrame>& frames2) {
1233  EXPECT_EQ(frames1.size(), frames2.size());
1234  for (size_t i = 0; i < std::min(frames1.size(), frames2.size()); ++i)
1235    ExpectEqualFrames(frames1[i], frames2[i]);
1236}
1237
1238VideoFrame CreateVideoFrame(int width, int height, uint8_t data) {
1239  const int kSizeY = width * height * 2;
1240  rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[kSizeY]);
1241  memset(buffer.get(), data, kSizeY);
1242  VideoFrame frame;
1243  frame.CreateFrame(buffer.get(), buffer.get(), buffer.get(), width, height,
1244                    width, width / 2, width / 2);
1245  frame.set_timestamp(data);
1246  frame.set_render_time_ms(data);
1247  return frame;
1248}
1249
1250TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
1251  class EncoderStateObserver : public test::SendTest, public VideoEncoder {
1252   public:
1253    EncoderStateObserver()
1254        : SendTest(kDefaultTimeoutMs),
1255          initialized_(false),
1256          callback_registered_(false),
1257          num_releases_(0),
1258          released_(false) {}
1259
1260    bool IsReleased() {
1261      rtc::CritScope lock(&crit_);
1262      return released_;
1263    }
1264
1265    bool IsReadyForEncode() {
1266      rtc::CritScope lock(&crit_);
1267      return initialized_ && callback_registered_;
1268    }
1269
1270    size_t num_releases() {
1271      rtc::CritScope lock(&crit_);
1272      return num_releases_;
1273    }
1274
1275   private:
1276    int32_t InitEncode(const VideoCodec* codecSettings,
1277                       int32_t numberOfCores,
1278                       size_t maxPayloadSize) override {
1279      rtc::CritScope lock(&crit_);
1280      EXPECT_FALSE(initialized_);
1281      initialized_ = true;
1282      released_ = false;
1283      return 0;
1284    }
1285
1286    int32_t Encode(const VideoFrame& inputImage,
1287                   const CodecSpecificInfo* codecSpecificInfo,
1288                   const std::vector<FrameType>* frame_types) override {
1289      EXPECT_TRUE(IsReadyForEncode());
1290
1291      observation_complete_.Set();
1292      return 0;
1293    }
1294
1295    int32_t RegisterEncodeCompleteCallback(
1296        EncodedImageCallback* callback) override {
1297      rtc::CritScope lock(&crit_);
1298      EXPECT_TRUE(initialized_);
1299      callback_registered_ = true;
1300      return 0;
1301    }
1302
1303    int32_t Release() override {
1304      rtc::CritScope lock(&crit_);
1305      EXPECT_TRUE(IsReadyForEncode());
1306      EXPECT_FALSE(released_);
1307      initialized_ = false;
1308      callback_registered_ = false;
1309      released_ = true;
1310      ++num_releases_;
1311      return 0;
1312    }
1313
1314    int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override {
1315      EXPECT_TRUE(IsReadyForEncode());
1316      return 0;
1317    }
1318
1319    int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override {
1320      EXPECT_TRUE(IsReadyForEncode());
1321      return 0;
1322    }
1323
1324    void OnVideoStreamsCreated(
1325        VideoSendStream* send_stream,
1326        const std::vector<VideoReceiveStream*>& receive_streams) override {
1327      // Encoder initialization should be done in stream construction before
1328      // starting.
1329      EXPECT_TRUE(IsReadyForEncode());
1330      stream_ = send_stream;
1331    }
1332
1333    void ModifyVideoConfigs(
1334        VideoSendStream::Config* send_config,
1335        std::vector<VideoReceiveStream::Config>* receive_configs,
1336        VideoEncoderConfig* encoder_config) override {
1337      send_config->encoder_settings.encoder = this;
1338      encoder_config_ = *encoder_config;
1339    }
1340
1341    void PerformTest() override {
1342      EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
1343      EXPECT_EQ(0u, num_releases());
1344      stream_->ReconfigureVideoEncoder(encoder_config_);
1345      EXPECT_EQ(0u, num_releases());
1346      stream_->Stop();
1347      // Encoder should not be released before destroying the VideoSendStream.
1348      EXPECT_FALSE(IsReleased());
1349      EXPECT_TRUE(IsReadyForEncode());
1350      stream_->Start();
1351      // Sanity check, make sure we still encode frames with this encoder.
1352      EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
1353    }
1354
1355    rtc::CriticalSection crit_;
1356    VideoSendStream* stream_;
1357    bool initialized_ GUARDED_BY(crit_);
1358    bool callback_registered_ GUARDED_BY(crit_);
1359    size_t num_releases_ GUARDED_BY(crit_);
1360    bool released_ GUARDED_BY(crit_);
1361    VideoEncoderConfig encoder_config_;
1362  } test_encoder;
1363
1364  RunBaseTest(&test_encoder);
1365
1366  EXPECT_TRUE(test_encoder.IsReleased());
1367  EXPECT_EQ(1u, test_encoder.num_releases());
1368}
1369
1370TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
1371  class VideoCodecConfigObserver : public test::SendTest,
1372                                   public test::FakeEncoder {
1373   public:
1374    VideoCodecConfigObserver()
1375        : SendTest(kDefaultTimeoutMs),
1376          FakeEncoder(Clock::GetRealTimeClock()),
1377          num_initializations_(0) {}
1378
1379   private:
1380    void ModifyVideoConfigs(
1381        VideoSendStream::Config* send_config,
1382        std::vector<VideoReceiveStream::Config>* receive_configs,
1383        VideoEncoderConfig* encoder_config) override {
1384      send_config->encoder_settings.encoder = this;
1385      encoder_config_ = *encoder_config;
1386    }
1387
1388    void OnVideoStreamsCreated(
1389        VideoSendStream* send_stream,
1390        const std::vector<VideoReceiveStream*>& receive_streams) override {
1391      stream_ = send_stream;
1392    }
1393
1394    int32_t InitEncode(const VideoCodec* config,
1395                       int32_t number_of_cores,
1396                       size_t max_payload_size) override {
1397      if (num_initializations_ == 0) {
1398        // Verify default values.
1399        EXPECT_EQ(kRealtimeVideo, config->mode);
1400      } else {
1401        // Verify that changed values are propagated.
1402        EXPECT_EQ(kScreensharing, config->mode);
1403      }
1404      ++num_initializations_;
1405      return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
1406    }
1407
1408    void PerformTest() override {
1409      EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
1410
1411      encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
1412      stream_->ReconfigureVideoEncoder(encoder_config_);
1413      EXPECT_EQ(2u, num_initializations_)
1414          << "ReconfigureVideoEncoder did not reinitialize the encoder with "
1415             "new encoder settings.";
1416    }
1417
1418    size_t num_initializations_;
1419    VideoSendStream* stream_;
1420    VideoEncoderConfig encoder_config_;
1421  } test;
1422
1423  RunBaseTest(&test);
1424}
1425
1426static const size_t kVideoCodecConfigObserverNumberOfTemporalLayers = 4;
1427template <typename T>
1428class VideoCodecConfigObserver : public test::SendTest,
1429                                 public test::FakeEncoder {
1430 public:
1431  VideoCodecConfigObserver(VideoCodecType video_codec_type,
1432                           const char* codec_name)
1433      : SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
1434        FakeEncoder(Clock::GetRealTimeClock()),
1435        video_codec_type_(video_codec_type),
1436        codec_name_(codec_name),
1437        num_initializations_(0) {
1438    memset(&encoder_settings_, 0, sizeof(encoder_settings_));
1439  }
1440
1441 private:
1442  void ModifyVideoConfigs(
1443      VideoSendStream::Config* send_config,
1444      std::vector<VideoReceiveStream::Config>* receive_configs,
1445      VideoEncoderConfig* encoder_config) override {
1446    send_config->encoder_settings.encoder = this;
1447    send_config->encoder_settings.payload_name = codec_name_;
1448
1449    for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
1450      encoder_config->streams[i].temporal_layer_thresholds_bps.resize(
1451          kVideoCodecConfigObserverNumberOfTemporalLayers - 1);
1452    }
1453
1454    encoder_config->encoder_specific_settings = &encoder_settings_;
1455    encoder_config_ = *encoder_config;
1456  }
1457
1458  void OnVideoStreamsCreated(
1459      VideoSendStream* send_stream,
1460      const std::vector<VideoReceiveStream*>& receive_streams) override {
1461    stream_ = send_stream;
1462  }
1463
1464  int32_t InitEncode(const VideoCodec* config,
1465                     int32_t number_of_cores,
1466                     size_t max_payload_size) override {
1467    EXPECT_EQ(video_codec_type_, config->codecType);
1468    VerifyCodecSpecifics(*config);
1469    ++num_initializations_;
1470    return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
1471  }
1472
1473  void VerifyCodecSpecifics(const VideoCodec& config) const;
1474
1475  void PerformTest() override {
1476    EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
1477
1478    encoder_settings_.frameDroppingOn = true;
1479    stream_->ReconfigureVideoEncoder(encoder_config_);
1480    EXPECT_EQ(2u, num_initializations_)
1481        << "ReconfigureVideoEncoder did not reinitialize the encoder with "
1482           "new encoder settings.";
1483  }
1484
1485  int32_t Encode(const VideoFrame& input_image,
1486                 const CodecSpecificInfo* codec_specific_info,
1487                 const std::vector<FrameType>* frame_types) override {
1488    // Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
1489    return 0;
1490  }
1491
1492  T encoder_settings_;
1493  const VideoCodecType video_codec_type_;
1494  const char* const codec_name_;
1495  size_t num_initializations_;
1496  VideoSendStream* stream_;
1497  VideoEncoderConfig encoder_config_;
1498};
1499
1500template <>
1501void VideoCodecConfigObserver<VideoCodecH264>::VerifyCodecSpecifics(
1502    const VideoCodec& config) const {
1503  EXPECT_EQ(0, memcmp(&config.codecSpecific.H264, &encoder_settings_,
1504                      sizeof(encoder_settings_)));
1505}
1506template <>
1507void VideoCodecConfigObserver<VideoCodecVP8>::VerifyCodecSpecifics(
1508    const VideoCodec& config) const {
1509  // Check that the number of temporal layers has propagated properly to
1510  // VideoCodec.
1511  EXPECT_EQ(kVideoCodecConfigObserverNumberOfTemporalLayers,
1512            config.codecSpecific.VP8.numberOfTemporalLayers);
1513
1514  for (unsigned char i = 0; i < config.numberOfSimulcastStreams; ++i) {
1515    EXPECT_EQ(kVideoCodecConfigObserverNumberOfTemporalLayers,
1516              config.simulcastStream[i].numberOfTemporalLayers);
1517  }
1518
1519  // Set expected temporal layers as they should have been set when
1520  // reconfiguring the encoder and not match the set config.
1521  VideoCodecVP8 encoder_settings = encoder_settings_;
1522  encoder_settings.numberOfTemporalLayers =
1523      kVideoCodecConfigObserverNumberOfTemporalLayers;
1524  EXPECT_EQ(0, memcmp(&config.codecSpecific.VP8, &encoder_settings,
1525                      sizeof(encoder_settings_)));
1526}
1527template <>
1528void VideoCodecConfigObserver<VideoCodecVP9>::VerifyCodecSpecifics(
1529    const VideoCodec& config) const {
1530  // Check that the number of temporal layers has propagated properly to
1531  // VideoCodec.
1532  EXPECT_EQ(kVideoCodecConfigObserverNumberOfTemporalLayers,
1533            config.codecSpecific.VP9.numberOfTemporalLayers);
1534
1535  for (unsigned char i = 0; i < config.numberOfSimulcastStreams; ++i) {
1536    EXPECT_EQ(kVideoCodecConfigObserverNumberOfTemporalLayers,
1537              config.simulcastStream[i].numberOfTemporalLayers);
1538  }
1539
1540  // Set expected temporal layers as they should have been set when
1541  // reconfiguring the encoder and not match the set config.
1542  VideoCodecVP9 encoder_settings = encoder_settings_;
1543  encoder_settings.numberOfTemporalLayers =
1544      kVideoCodecConfigObserverNumberOfTemporalLayers;
1545  EXPECT_EQ(0, memcmp(&config.codecSpecific.VP9, &encoder_settings,
1546                      sizeof(encoder_settings_)));
1547}
1548
1549TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
1550  VideoCodecConfigObserver<VideoCodecVP8> test(kVideoCodecVP8, "VP8");
1551  RunBaseTest(&test);
1552}
1553
1554TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp9Config) {
1555  VideoCodecConfigObserver<VideoCodecVP9> test(kVideoCodecVP9, "VP9");
1556  RunBaseTest(&test);
1557}
1558
1559TEST_F(VideoSendStreamTest, EncoderSetupPropagatesH264Config) {
1560  VideoCodecConfigObserver<VideoCodecH264> test(kVideoCodecH264, "H264");
1561  RunBaseTest(&test);
1562}
1563
1564TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
1565  class RtcpSenderReportTest : public test::SendTest {
1566   public:
1567    RtcpSenderReportTest() : SendTest(kDefaultTimeoutMs),
1568                             rtp_packets_sent_(0),
1569                             media_bytes_sent_(0) {}
1570
1571   private:
1572    Action OnSendRtp(const uint8_t* packet, size_t length) override {
1573      rtc::CritScope lock(&crit_);
1574      RTPHeader header;
1575      EXPECT_TRUE(parser_->Parse(packet, length, &header));
1576      ++rtp_packets_sent_;
1577      media_bytes_sent_ += length - header.headerLength - header.paddingLength;
1578      return SEND_PACKET;
1579    }
1580
1581    Action OnSendRtcp(const uint8_t* packet, size_t length) override {
1582      rtc::CritScope lock(&crit_);
1583      RTCPUtility::RTCPParserV2 parser(packet, length, true);
1584      EXPECT_TRUE(parser.IsValid());
1585
1586      RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
1587      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
1588        if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
1589          // Only compare sent media bytes if SenderPacketCount matches the
1590          // number of sent rtp packets (a new rtp packet could be sent before
1591          // the rtcp packet).
1592          if (parser.Packet().SR.SenderOctetCount > 0 &&
1593              parser.Packet().SR.SenderPacketCount == rtp_packets_sent_) {
1594            EXPECT_EQ(media_bytes_sent_, parser.Packet().SR.SenderOctetCount);
1595            observation_complete_.Set();
1596          }
1597        }
1598        packet_type = parser.Iterate();
1599      }
1600
1601      return SEND_PACKET;
1602    }
1603
1604    void PerformTest() override {
1605      EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP sender report.";
1606    }
1607
1608    rtc::CriticalSection crit_;
1609    size_t rtp_packets_sent_ GUARDED_BY(&crit_);
1610    size_t media_bytes_sent_ GUARDED_BY(&crit_);
1611  } test;
1612
1613  RunBaseTest(&test);
1614}
1615
1616TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
1617  static const int kScreencastTargetBitrateKbps = 200;
1618  class ScreencastTargetBitrateTest : public test::SendTest,
1619                                      public test::FakeEncoder {
1620   public:
1621    ScreencastTargetBitrateTest()
1622        : SendTest(kDefaultTimeoutMs),
1623          test::FakeEncoder(Clock::GetRealTimeClock()) {}
1624
1625   private:
1626    int32_t InitEncode(const VideoCodec* config,
1627                       int32_t number_of_cores,
1628                       size_t max_payload_size) override {
1629      EXPECT_EQ(static_cast<unsigned int>(kScreencastTargetBitrateKbps),
1630                config->targetBitrate);
1631      observation_complete_.Set();
1632      return test::FakeEncoder::InitEncode(
1633          config, number_of_cores, max_payload_size);
1634    }
1635    void ModifyVideoConfigs(
1636        VideoSendStream::Config* send_config,
1637        std::vector<VideoReceiveStream::Config>* receive_configs,
1638        VideoEncoderConfig* encoder_config) override {
1639      send_config->encoder_settings.encoder = this;
1640      EXPECT_EQ(1u, encoder_config->streams.size());
1641      EXPECT_TRUE(
1642          encoder_config->streams[0].temporal_layer_thresholds_bps.empty());
1643      encoder_config->streams[0].temporal_layer_thresholds_bps.push_back(
1644          kScreencastTargetBitrateKbps * 1000);
1645      encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
1646    }
1647
1648    void PerformTest() override {
1649      EXPECT_TRUE(Wait())
1650          << "Timed out while waiting for the encoder to be initialized.";
1651    }
1652  } test;
1653
1654  RunBaseTest(&test);
1655}
1656
1657// Disabled on LinuxAsan:
1658// https://bugs.chromium.org/p/webrtc/issues/detail?id=5382
1659#if defined(ADDRESS_SANITIZER) && defined(WEBRTC_LINUX)
1660#define MAYBE_ReconfigureBitratesSetsEncoderBitratesCorrectly \
1661  DISABLED_ReconfigureBitratesSetsEncoderBitratesCorrectly
1662#else
1663#define MAYBE_ReconfigureBitratesSetsEncoderBitratesCorrectly \
1664  ReconfigureBitratesSetsEncoderBitratesCorrectly
1665#endif
1666
1667TEST_F(VideoSendStreamTest,
1668       MAYBE_ReconfigureBitratesSetsEncoderBitratesCorrectly) {
1669  // These are chosen to be "kind of odd" to not be accidentally checked against
1670  // default values.
1671  static const int kMinBitrateKbps = 137;
1672  static const int kStartBitrateKbps = 345;
1673  static const int kLowerMaxBitrateKbps = 312;
1674  static const int kMaxBitrateKbps = 413;
1675  static const int kIncreasedStartBitrateKbps = 451;
1676  static const int kIncreasedMaxBitrateKbps = 597;
1677  class EncoderBitrateThresholdObserver : public test::SendTest,
1678                                          public test::FakeEncoder {
1679   public:
1680    EncoderBitrateThresholdObserver()
1681        : SendTest(kDefaultTimeoutMs),
1682          FakeEncoder(Clock::GetRealTimeClock()),
1683          num_initializations_(0) {}
1684
1685   private:
1686    int32_t InitEncode(const VideoCodec* codecSettings,
1687                       int32_t numberOfCores,
1688                       size_t maxPayloadSize) override {
1689      if (num_initializations_ == 0) {
1690        EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps),
1691                  codecSettings->minBitrate);
1692        EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps),
1693                  codecSettings->startBitrate);
1694        EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps),
1695                  codecSettings->maxBitrate);
1696        observation_complete_.Set();
1697      } else if (num_initializations_ == 1) {
1698        EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps),
1699                  codecSettings->maxBitrate);
1700        // The start bitrate should be kept (-1) and capped to the max bitrate.
1701        // Since this is not an end-to-end call no receiver should have been
1702        // returning a REMB that could lower this estimate.
1703        EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate);
1704      } else if (num_initializations_ == 2) {
1705        EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps),
1706                  codecSettings->maxBitrate);
1707        EXPECT_EQ(static_cast<unsigned int>(kIncreasedStartBitrateKbps),
1708                  codecSettings->startBitrate);
1709      }
1710      ++num_initializations_;
1711      return FakeEncoder::InitEncode(codecSettings, numberOfCores,
1712                                     maxPayloadSize);
1713    }
1714
1715    Call::Config GetSenderCallConfig() override {
1716      Call::Config config;
1717      config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
1718      config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
1719      config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;
1720      return config;
1721    }
1722
1723    void ModifyVideoConfigs(
1724        VideoSendStream::Config* send_config,
1725        std::vector<VideoReceiveStream::Config>* receive_configs,
1726        VideoEncoderConfig* encoder_config) override {
1727      send_config->encoder_settings.encoder = this;
1728      // Set bitrates lower/higher than min/max to make sure they are properly
1729      // capped.
1730      encoder_config->streams.front().min_bitrate_bps = kMinBitrateKbps * 1000;
1731      encoder_config->streams.front().max_bitrate_bps = kMaxBitrateKbps * 1000;
1732      encoder_config_ = *encoder_config;
1733    }
1734
1735    void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
1736      call_ = sender_call;
1737    }
1738
1739    void OnVideoStreamsCreated(
1740        VideoSendStream* send_stream,
1741        const std::vector<VideoReceiveStream*>& receive_streams) override {
1742      send_stream_ = send_stream;
1743    }
1744
1745    void PerformTest() override {
1746      Call::Config::BitrateConfig bitrate_config;
1747      bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000;
1748      bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;
1749      call_->SetBitrateConfig(bitrate_config);
1750      EXPECT_TRUE(Wait())
1751          << "Timed out while waiting encoder to be configured.";
1752      encoder_config_.streams[0].min_bitrate_bps = 0;
1753      encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000;
1754      send_stream_->ReconfigureVideoEncoder(encoder_config_);
1755      EXPECT_EQ(2, num_initializations_)
1756          << "Encoder should have been reconfigured with the new value.";
1757      encoder_config_.streams[0].target_bitrate_bps =
1758          encoder_config_.streams[0].min_bitrate_bps;
1759      encoder_config_.streams[0].max_bitrate_bps =
1760          kIncreasedMaxBitrateKbps * 1000;
1761      send_stream_->ReconfigureVideoEncoder(encoder_config_);
1762      EXPECT_EQ(3, num_initializations_)
1763          << "Encoder should have been reconfigured with the new value.";
1764    }
1765
1766    int num_initializations_;
1767    webrtc::Call* call_;
1768    webrtc::VideoSendStream* send_stream_;
1769    webrtc::VideoEncoderConfig encoder_config_;
1770  } test;
1771
1772  RunBaseTest(&test);
1773}
1774
1775TEST_F(VideoSendStreamTest, ReportsSentResolution) {
1776  static const size_t kNumStreams = 3;
1777  // Unusual resolutions to make sure that they are the ones being reported.
1778  static const struct {
1779    int width;
1780    int height;
1781  } kEncodedResolution[kNumStreams] = {
1782      {241, 181}, {300, 121}, {121, 221}};
1783  class ScreencastTargetBitrateTest : public test::SendTest,
1784                                      public test::FakeEncoder {
1785   public:
1786    ScreencastTargetBitrateTest()
1787        : SendTest(kDefaultTimeoutMs),
1788          test::FakeEncoder(Clock::GetRealTimeClock()) {}
1789
1790   private:
1791    int32_t Encode(const VideoFrame& input_image,
1792                   const CodecSpecificInfo* codecSpecificInfo,
1793                   const std::vector<FrameType>* frame_types) override {
1794      CodecSpecificInfo specifics;
1795      memset(&specifics, 0, sizeof(specifics));
1796      specifics.codecType = kVideoCodecGeneric;
1797
1798      uint8_t buffer[16] = {0};
1799      EncodedImage encoded(buffer, sizeof(buffer), sizeof(buffer));
1800      encoded._timeStamp = input_image.timestamp();
1801      encoded.capture_time_ms_ = input_image.render_time_ms();
1802
1803      for (size_t i = 0; i < kNumStreams; ++i) {
1804        specifics.codecSpecific.generic.simulcast_idx = static_cast<uint8_t>(i);
1805        encoded._frameType = (*frame_types)[i];
1806        encoded._encodedWidth = kEncodedResolution[i].width;
1807        encoded._encodedHeight = kEncodedResolution[i].height;
1808        RTC_DCHECK(callback_ != nullptr);
1809        if (callback_->Encoded(encoded, &specifics, nullptr) != 0)
1810          return -1;
1811      }
1812
1813      observation_complete_.Set();
1814      return 0;
1815    }
1816    void ModifyVideoConfigs(
1817        VideoSendStream::Config* send_config,
1818        std::vector<VideoReceiveStream::Config>* receive_configs,
1819        VideoEncoderConfig* encoder_config) override {
1820      send_config->encoder_settings.encoder = this;
1821      EXPECT_EQ(kNumStreams, encoder_config->streams.size());
1822    }
1823
1824    size_t GetNumVideoStreams() const override { return kNumStreams; }
1825
1826    void PerformTest() override {
1827      EXPECT_TRUE(Wait())
1828          << "Timed out while waiting for the encoder to send one frame.";
1829      VideoSendStream::Stats stats = send_stream_->GetStats();
1830
1831      for (size_t i = 0; i < kNumStreams; ++i) {
1832        ASSERT_TRUE(stats.substreams.find(kVideoSendSsrcs[i]) !=
1833                    stats.substreams.end())
1834            << "No stats for SSRC: " << kVideoSendSsrcs[i]
1835            << ", stats should exist as soon as frames have been encoded.";
1836        VideoSendStream::StreamStats ssrc_stats =
1837            stats.substreams[kVideoSendSsrcs[i]];
1838        EXPECT_EQ(kEncodedResolution[i].width, ssrc_stats.width);
1839        EXPECT_EQ(kEncodedResolution[i].height, ssrc_stats.height);
1840      }
1841    }
1842
1843    void OnVideoStreamsCreated(
1844        VideoSendStream* send_stream,
1845        const std::vector<VideoReceiveStream*>& receive_streams) override {
1846      send_stream_ = send_stream;
1847    }
1848
1849    VideoSendStream* send_stream_;
1850  } test;
1851
1852  RunBaseTest(&test);
1853}
1854
1855class Vp9HeaderObserver : public test::SendTest {
1856 public:
1857  Vp9HeaderObserver()
1858      : SendTest(VideoSendStreamTest::kLongTimeoutMs),
1859        vp9_encoder_(VP9Encoder::Create()),
1860        vp9_settings_(VideoEncoder::GetDefaultVp9Settings()),
1861        packets_sent_(0),
1862        frames_sent_(0) {}
1863
1864  virtual void ModifyVideoConfigsHook(
1865      VideoSendStream::Config* send_config,
1866      std::vector<VideoReceiveStream::Config>* receive_configs,
1867      VideoEncoderConfig* encoder_config) {}
1868
1869  virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0;
1870
1871 private:
1872  const int kVp9PayloadType = 105;
1873
1874  void ModifyVideoConfigs(
1875      VideoSendStream::Config* send_config,
1876      std::vector<VideoReceiveStream::Config>* receive_configs,
1877      VideoEncoderConfig* encoder_config) override {
1878    encoder_config->encoder_specific_settings = &vp9_settings_;
1879    send_config->encoder_settings.encoder = vp9_encoder_.get();
1880    send_config->encoder_settings.payload_name = "VP9";
1881    send_config->encoder_settings.payload_type = kVp9PayloadType;
1882    ModifyVideoConfigsHook(send_config, receive_configs, encoder_config);
1883    EXPECT_EQ(1u, encoder_config->streams.size());
1884    encoder_config->streams[0].temporal_layer_thresholds_bps.resize(
1885        vp9_settings_.numberOfTemporalLayers - 1);
1886    encoder_config_ = *encoder_config;
1887  }
1888
1889  void PerformTest() override {
1890    EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames "
1891                        << frames_sent_;
1892  }
1893
1894  Action OnSendRtp(const uint8_t* packet, size_t length) override {
1895    RTPHeader header;
1896    EXPECT_TRUE(parser_->Parse(packet, length, &header));
1897
1898    EXPECT_EQ(kVp9PayloadType, header.payloadType);
1899    const uint8_t* payload = packet + header.headerLength;
1900    size_t payload_length = length - header.headerLength - header.paddingLength;
1901
1902    bool new_packet = packets_sent_ == 0 ||
1903                      IsNewerSequenceNumber(header.sequenceNumber,
1904                                            last_header_.sequenceNumber);
1905    if (payload_length > 0 && new_packet) {
1906      RtpDepacketizer::ParsedPayload parsed;
1907      RtpDepacketizerVp9 depacketizer;
1908      EXPECT_TRUE(depacketizer.Parse(&parsed, payload, payload_length));
1909      EXPECT_EQ(RtpVideoCodecTypes::kRtpVideoVp9, parsed.type.Video.codec);
1910      // Verify common fields for all configurations.
1911      VerifyCommonHeader(parsed.type.Video.codecHeader.VP9);
1912      CompareConsecutiveFrames(header, parsed.type.Video);
1913      // Verify configuration specific settings.
1914      InspectHeader(parsed.type.Video.codecHeader.VP9);
1915
1916      ++packets_sent_;
1917      if (header.markerBit) {
1918        ++frames_sent_;
1919      }
1920      last_header_ = header;
1921      last_vp9_ = parsed.type.Video.codecHeader.VP9;
1922    }
1923    return SEND_PACKET;
1924  }
1925
1926 protected:
1927  bool ContinuousPictureId(const RTPVideoHeaderVP9& vp9) const {
1928    if (last_vp9_.picture_id > vp9.picture_id) {
1929      return vp9.picture_id == 0;  // Wrap.
1930    } else {
1931      return vp9.picture_id == last_vp9_.picture_id + 1;
1932    }
1933  }
1934
1935  void VerifySpatialIdxWithinFrame(const RTPVideoHeaderVP9& vp9) const {
1936    bool new_layer = vp9.spatial_idx != last_vp9_.spatial_idx;
1937    EXPECT_EQ(new_layer, vp9.beginning_of_frame);
1938    EXPECT_EQ(new_layer, last_vp9_.end_of_frame);
1939    EXPECT_EQ(new_layer ? last_vp9_.spatial_idx + 1 : last_vp9_.spatial_idx,
1940              vp9.spatial_idx);
1941  }
1942
1943  void VerifyFixedTemporalLayerStructure(const RTPVideoHeaderVP9& vp9,
1944                                         uint8_t num_layers) const {
1945    switch (num_layers) {
1946      case 0:
1947        VerifyTemporalLayerStructure0(vp9);
1948        break;
1949      case 1:
1950        VerifyTemporalLayerStructure1(vp9);
1951        break;
1952      case 2:
1953        VerifyTemporalLayerStructure2(vp9);
1954        break;
1955      case 3:
1956        VerifyTemporalLayerStructure3(vp9);
1957        break;
1958      default:
1959        RTC_NOTREACHED();
1960    }
1961  }
1962
1963  void VerifyTemporalLayerStructure0(const RTPVideoHeaderVP9& vp9) const {
1964    EXPECT_EQ(kNoTl0PicIdx, vp9.tl0_pic_idx);
1965    EXPECT_EQ(kNoTemporalIdx, vp9.temporal_idx);  // no tid
1966    EXPECT_FALSE(vp9.temporal_up_switch);
1967  }
1968
1969  void VerifyTemporalLayerStructure1(const RTPVideoHeaderVP9& vp9) const {
1970    EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx);
1971    EXPECT_EQ(0, vp9.temporal_idx);  // 0,0,0,...
1972    EXPECT_FALSE(vp9.temporal_up_switch);
1973  }
1974
1975  void VerifyTemporalLayerStructure2(const RTPVideoHeaderVP9& vp9) const {
1976    EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx);
1977    EXPECT_GE(vp9.temporal_idx, 0);  // 0,1,0,1,... (tid reset on I-frames).
1978    EXPECT_LE(vp9.temporal_idx, 1);
1979    EXPECT_EQ(vp9.temporal_idx > 0, vp9.temporal_up_switch);
1980    if (IsNewPictureId(vp9)) {
1981      uint8_t expected_tid =
1982          (!vp9.inter_pic_predicted || last_vp9_.temporal_idx == 1) ? 0 : 1;
1983      EXPECT_EQ(expected_tid, vp9.temporal_idx);
1984    }
1985  }
1986
1987  void VerifyTemporalLayerStructure3(const RTPVideoHeaderVP9& vp9) const {
1988    EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx);
1989    EXPECT_GE(vp9.temporal_idx, 0);  // 0,2,1,2,... (tid reset on I-frames).
1990    EXPECT_LE(vp9.temporal_idx, 2);
1991    if (IsNewPictureId(vp9) && vp9.inter_pic_predicted) {
1992      EXPECT_NE(vp9.temporal_idx, last_vp9_.temporal_idx);
1993      switch (vp9.temporal_idx) {
1994        case 0:
1995          EXPECT_EQ(2, last_vp9_.temporal_idx);
1996          EXPECT_FALSE(vp9.temporal_up_switch);
1997          break;
1998        case 1:
1999          EXPECT_EQ(2, last_vp9_.temporal_idx);
2000          EXPECT_TRUE(vp9.temporal_up_switch);
2001          break;
2002        case 2:
2003          EXPECT_EQ(last_vp9_.temporal_idx == 0, vp9.temporal_up_switch);
2004          break;
2005      }
2006    }
2007  }
2008
2009  void VerifyTl0Idx(const RTPVideoHeaderVP9& vp9) const {
2010    if (vp9.tl0_pic_idx == kNoTl0PicIdx)
2011      return;
2012
2013    uint8_t expected_tl0_idx = last_vp9_.tl0_pic_idx;
2014    if (vp9.temporal_idx == 0)
2015      ++expected_tl0_idx;
2016    EXPECT_EQ(expected_tl0_idx, vp9.tl0_pic_idx);
2017  }
2018
2019  bool IsNewPictureId(const RTPVideoHeaderVP9& vp9) const {
2020    return frames_sent_ > 0 && (vp9.picture_id != last_vp9_.picture_id);
2021  }
2022
2023  // Flexible mode (F=1):    Non-flexible mode (F=0):
2024  //
2025  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
2026  //      |I|P|L|F|B|E|V|-|     |I|P|L|F|B|E|V|-|
2027  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
2028  // I:   |M| PICTURE ID  |  I: |M| PICTURE ID  |
2029  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
2030  // M:   | EXTENDED PID  |  M: | EXTENDED PID  |
2031  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
2032  // L:   |  T  |U|  S  |D|  L: |  T  |U|  S  |D|
2033  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
2034  // P,F: | P_DIFF    |X|N|     |   TL0PICIDX   |
2035  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
2036  // X:   |EXTENDED P_DIFF|  V: | SS  ..        |
2037  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
2038  // V:   | SS  ..        |
2039  //      +-+-+-+-+-+-+-+-+
2040  void VerifyCommonHeader(const RTPVideoHeaderVP9& vp9) const {
2041    EXPECT_EQ(kMaxTwoBytePictureId, vp9.max_picture_id);       // M:1
2042    EXPECT_NE(kNoPictureId, vp9.picture_id);                   // I:1
2043    EXPECT_EQ(vp9_settings_.flexibleMode, vp9.flexible_mode);  // F
2044    EXPECT_GE(vp9.spatial_idx, 0);                             // S
2045    EXPECT_LT(vp9.spatial_idx, vp9_settings_.numberOfSpatialLayers);
2046    if (vp9.ss_data_available)  // V
2047      VerifySsData(vp9);
2048
2049    if (frames_sent_ == 0)
2050      EXPECT_FALSE(vp9.inter_pic_predicted);  // P
2051
2052    if (!vp9.inter_pic_predicted) {
2053      EXPECT_TRUE(vp9.temporal_idx == 0 || vp9.temporal_idx == kNoTemporalIdx);
2054      EXPECT_FALSE(vp9.temporal_up_switch);
2055    }
2056  }
2057
2058  // Scalability structure (SS).
2059  //
2060  //      +-+-+-+-+-+-+-+-+
2061  // V:   | N_S |Y|G|-|-|-|
2062  //      +-+-+-+-+-+-+-+-+
2063  // Y:   |    WIDTH      |  N_S + 1 times
2064  //      +-+-+-+-+-+-+-+-+
2065  //      |    HEIGHT     |
2066  //      +-+-+-+-+-+-+-+-+
2067  // G:   |      N_G      |
2068  //      +-+-+-+-+-+-+-+-+
2069  // N_G: |  T  |U| R |-|-|  N_G times
2070  //      +-+-+-+-+-+-+-+-+
2071  //      |    P_DIFF     |  R times
2072  //      +-+-+-+-+-+-+-+-+
2073  void VerifySsData(const RTPVideoHeaderVP9& vp9) const {
2074    EXPECT_TRUE(vp9.ss_data_available);             // V
2075    EXPECT_EQ(vp9_settings_.numberOfSpatialLayers,  // N_S + 1
2076              vp9.num_spatial_layers);
2077    EXPECT_TRUE(vp9.spatial_layer_resolution_present);  // Y:1
2078    size_t expected_width = encoder_config_.streams[0].width;
2079    size_t expected_height = encoder_config_.streams[0].height;
2080    for (int i = vp9.num_spatial_layers - 1; i >= 0; --i) {
2081      EXPECT_EQ(expected_width, vp9.width[i]);    // WIDTH
2082      EXPECT_EQ(expected_height, vp9.height[i]);  // HEIGHT
2083      expected_width /= 2;
2084      expected_height /= 2;
2085    }
2086  }
2087
2088  void CompareConsecutiveFrames(const RTPHeader& header,
2089                                const RTPVideoHeader& video) const {
2090    const RTPVideoHeaderVP9& vp9 = video.codecHeader.VP9;
2091
2092    bool new_frame = packets_sent_ == 0 ||
2093                     IsNewerTimestamp(header.timestamp, last_header_.timestamp);
2094    EXPECT_EQ(new_frame, video.isFirstPacket);
2095    if (!new_frame) {
2096      EXPECT_FALSE(last_header_.markerBit);
2097      EXPECT_EQ(last_header_.timestamp, header.timestamp);
2098      EXPECT_EQ(last_vp9_.picture_id, vp9.picture_id);
2099      EXPECT_EQ(last_vp9_.temporal_idx, vp9.temporal_idx);
2100      EXPECT_EQ(last_vp9_.tl0_pic_idx, vp9.tl0_pic_idx);
2101      VerifySpatialIdxWithinFrame(vp9);
2102      return;
2103    }
2104    // New frame.
2105    EXPECT_TRUE(vp9.beginning_of_frame);
2106
2107    // Compare with last packet in previous frame.
2108    if (frames_sent_ == 0)
2109      return;
2110    EXPECT_TRUE(last_vp9_.end_of_frame);
2111    EXPECT_TRUE(last_header_.markerBit);
2112    EXPECT_TRUE(ContinuousPictureId(vp9));
2113    VerifyTl0Idx(vp9);
2114  }
2115
2116  rtc::scoped_ptr<VP9Encoder> vp9_encoder_;
2117  VideoCodecVP9 vp9_settings_;
2118  webrtc::VideoEncoderConfig encoder_config_;
2119  RTPHeader last_header_;
2120  RTPVideoHeaderVP9 last_vp9_;
2121  size_t packets_sent_;
2122  size_t frames_sent_;
2123};
2124
2125TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) {
2126  const uint8_t kNumTemporalLayers = 1;
2127  const uint8_t kNumSpatialLayers = 1;
2128  TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
2129}
2130
2131TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl1SLayers) {
2132  const uint8_t kNumTemporalLayers = 2;
2133  const uint8_t kNumSpatialLayers = 1;
2134  TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
2135}
2136
2137TEST_F(VideoSendStreamTest, Vp9NonFlexMode_3Tl1SLayers) {
2138  const uint8_t kNumTemporalLayers = 3;
2139  const uint8_t kNumSpatialLayers = 1;
2140  TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
2141}
2142
2143TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl2SLayers) {
2144  const uint8_t kNumTemporalLayers = 1;
2145  const uint8_t kNumSpatialLayers = 2;
2146  TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
2147}
2148
2149TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl2SLayers) {
2150  const uint8_t kNumTemporalLayers = 2;
2151  const uint8_t kNumSpatialLayers = 2;
2152  TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
2153}
2154
2155TEST_F(VideoSendStreamTest, Vp9NonFlexMode_3Tl2SLayers) {
2156  const uint8_t kNumTemporalLayers = 3;
2157  const uint8_t kNumSpatialLayers = 2;
2158  TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
2159}
2160
2161void VideoSendStreamTest::TestVp9NonFlexMode(uint8_t num_temporal_layers,
2162                                             uint8_t num_spatial_layers) {
2163  static const size_t kNumFramesToSend = 100;
2164  // Set to < kNumFramesToSend and coprime to length of temporal layer
2165  // structures to verify temporal id reset on key frame.
2166  static const int kKeyFrameInterval = 31;
2167  class NonFlexibleMode : public Vp9HeaderObserver {
2168   public:
2169    NonFlexibleMode(uint8_t num_temporal_layers, uint8_t num_spatial_layers)
2170        : num_temporal_layers_(num_temporal_layers),
2171          num_spatial_layers_(num_spatial_layers),
2172          l_field_(num_temporal_layers > 1 || num_spatial_layers > 1) {}
2173    void ModifyVideoConfigsHook(
2174        VideoSendStream::Config* send_config,
2175        std::vector<VideoReceiveStream::Config>* receive_configs,
2176        VideoEncoderConfig* encoder_config) override {
2177      vp9_settings_.flexibleMode = false;
2178      vp9_settings_.frameDroppingOn = false;
2179      vp9_settings_.keyFrameInterval = kKeyFrameInterval;
2180      vp9_settings_.numberOfTemporalLayers = num_temporal_layers_;
2181      vp9_settings_.numberOfSpatialLayers = num_spatial_layers_;
2182    }
2183
2184    void InspectHeader(const RTPVideoHeaderVP9& vp9) override {
2185      bool ss_data_expected = !vp9.inter_pic_predicted &&
2186                              vp9.beginning_of_frame && vp9.spatial_idx == 0;
2187      EXPECT_EQ(ss_data_expected, vp9.ss_data_available);
2188      EXPECT_EQ(vp9.spatial_idx > 0, vp9.inter_layer_predicted);  // D
2189      EXPECT_EQ(!vp9.inter_pic_predicted,
2190                frames_sent_ % kKeyFrameInterval == 0);
2191
2192      if (IsNewPictureId(vp9)) {
2193        EXPECT_EQ(0, vp9.spatial_idx);
2194        EXPECT_EQ(num_spatial_layers_ - 1, last_vp9_.spatial_idx);
2195      }
2196
2197      VerifyFixedTemporalLayerStructure(vp9,
2198                                        l_field_ ? num_temporal_layers_ : 0);
2199
2200      if (frames_sent_ > kNumFramesToSend)
2201        observation_complete_.Set();
2202    }
2203    const uint8_t num_temporal_layers_;
2204    const uint8_t num_spatial_layers_;
2205    const bool l_field_;
2206  } test(num_temporal_layers, num_spatial_layers);
2207
2208  RunBaseTest(&test);
2209}
2210
2211#if !defined(MEMORY_SANITIZER)
2212// Fails under MemorySanitizer:
2213// See https://code.google.com/p/webrtc/issues/detail?id=5402.
2214TEST_F(VideoSendStreamTest, Vp9FlexModeRefCount) {
2215  class FlexibleMode : public Vp9HeaderObserver {
2216    void ModifyVideoConfigsHook(
2217        VideoSendStream::Config* send_config,
2218        std::vector<VideoReceiveStream::Config>* receive_configs,
2219        VideoEncoderConfig* encoder_config) override {
2220      encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
2221      vp9_settings_.flexibleMode = true;
2222      vp9_settings_.numberOfTemporalLayers = 1;
2223      vp9_settings_.numberOfSpatialLayers = 2;
2224    }
2225
2226    void InspectHeader(const RTPVideoHeaderVP9& vp9_header) override {
2227      EXPECT_TRUE(vp9_header.flexible_mode);
2228      EXPECT_EQ(kNoTl0PicIdx, vp9_header.tl0_pic_idx);
2229      if (vp9_header.inter_pic_predicted) {
2230        EXPECT_GT(vp9_header.num_ref_pics, 0u);
2231        observation_complete_.Set();
2232      }
2233    }
2234  } test;
2235
2236  RunBaseTest(&test);
2237}
2238#endif
2239
2240}  // namespace webrtc
2241