blob: ca2d1a234419647e5def435951aabfa39fb09c80 [file] [log] [blame]
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001/*
kjellander1afca732016-02-07 20:46:45 -08002 * Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003 *
kjellander1afca732016-02-07 20:46:45 -08004 * 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.
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00009 */
10
Jonas Olssona4d87372019-07-05 19:08:33 +020011#include "media/engine/webrtc_video_engine.h"
12
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000013#include <map>
kwiberg686a8ef2016-02-26 03:00:35 -080014#include <memory>
Elad Alon040dc432019-05-22 15:40:02 +020015#include <string>
Steve Antone78bcb92017-10-31 09:53:08 -070016#include <utility>
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000017#include <vector>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000018
Steve Anton2c9ebef2019-01-28 17:27:58 -080019#include "absl/algorithm/container.h"
Niels Möller805a27e2019-01-21 12:21:27 +010020#include "absl/memory/memory.h"
Niels Möller039743e2018-10-23 10:07:25 +020021#include "absl/strings/match.h"
Danil Chapovalov83bbe912019-08-07 12:24:53 +020022#include "api/rtc_event_log/rtc_event_log.h"
Steve Anton10542f22019-01-11 09:11:00 -080023#include "api/rtp_parameters.h"
Danil Chapovalov53d45ba2019-07-03 14:56:33 +020024#include "api/task_queue/default_task_queue_factory.h"
Piotr (Peter) Slatala946b9682019-03-18 10:25:02 -070025#include "api/test/fake_media_transport.h"
Jiawei Ouc2ebe212018-11-08 10:02:56 -080026#include "api/test/mock_video_bitrate_allocator.h"
27#include "api/test/mock_video_bitrate_allocator_factory.h"
Emircan Uysalerdbcac7f2017-10-30 23:10:12 -070028#include "api/test/mock_video_decoder_factory.h"
29#include "api/test/mock_video_encoder_factory.h"
Niels Möller65f17ca2019-09-12 13:59:36 +020030#include "api/transport/media/media_transport_config.h"
Jonas Oreland49ac5952018-09-26 16:04:32 +020031#include "api/units/time_delta.h"
Jiawei Ouc2ebe212018-11-08 10:02:56 -080032#include "api/video/builtin_video_bitrate_allocator_factory.h"
Niels Möller805a27e2019-01-21 12:21:27 +010033#include "api/video/i420_buffer.h"
Åsa Persson23eba222018-10-02 14:47:06 +020034#include "api/video/video_bitrate_allocation.h"
Anders Carlsson5f2bb622018-05-14 09:48:06 +020035#include "api/video_codecs/builtin_video_decoder_factory.h"
36#include "api/video_codecs/builtin_video_encoder_factory.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020037#include "api/video_codecs/sdp_video_format.h"
38#include "api/video_codecs/video_decoder_factory.h"
39#include "api/video_codecs/video_encoder.h"
40#include "api/video_codecs/video_encoder_factory.h"
41#include "call/flexfec_receive_stream.h"
42#include "common_video/h264/profile_level_id.h"
Niels Möller805a27e2019-01-21 12:21:27 +010043#include "media/base/fake_frame_source.h"
Steve Anton10542f22019-01-11 09:11:00 -080044#include "media/base/fake_network_interface.h"
Steve Anton10542f22019-01-11 09:11:00 -080045#include "media/base/fake_video_renderer.h"
46#include "media/base/media_constants.h"
47#include "media/base/rtp_utils.h"
48#include "media/base/test_utils.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020049#include "media/engine/constants.h"
Steve Anton10542f22019-01-11 09:11:00 -080050#include "media/engine/fake_webrtc_call.h"
51#include "media/engine/fake_webrtc_video_engine.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020052#include "media/engine/simulcast.h"
Steve Anton10542f22019-01-11 09:11:00 -080053#include "media/engine/webrtc_voice_engine.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020054#include "rtc_base/arraysize.h"
Steve Anton10542f22019-01-11 09:11:00 -080055#include "rtc_base/fake_clock.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020056#include "rtc_base/gunit.h"
Yves Gerey665174f2018-06-19 15:03:05 +020057#include "rtc_base/numerics/safe_conversions.h"
Steve Antonf3802842019-01-24 19:07:40 -080058#include "rtc_base/time_utils.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020059#include "test/field_trial.h"
Niels Möllerd0f0f682019-01-14 09:09:53 +010060#include "test/frame_generator.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020061#include "test/gmock.h"
Tommi25eb47c2019-08-29 16:39:05 +020062#include "test/rtp_header_parser.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000063
philipeld9cc8c02019-09-16 14:53:40 +020064using ::testing::Contains;
65using ::testing::Eq;
Mirko Bonadei6a489f22019-04-09 15:11:12 +020066using ::testing::Field;
Chen Xing90f3b892019-06-25 10:16:14 +020067using ::testing::IsEmpty;
philipeld9cc8c02019-09-16 14:53:40 +020068using ::testing::Pair;
Chen Xing90f3b892019-06-25 10:16:14 +020069using ::testing::SizeIs;
Sebastian Jansson8f83b422018-02-21 13:07:13 +010070using webrtc::BitrateConstraints;
isheriff6f8d6862016-05-26 11:24:55 -070071using webrtc::RtpExtension;
72
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000073namespace {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000074static const int kDefaultQpMax = 56;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000075
noahricd10a68e2015-07-10 11:27:55 -070076static const uint8_t kRedRtxPayloadType = 125;
77
Niels Möller6557d0c2018-04-11 15:18:34 +020078static const uint32_t kTimeout = 5000U;
79static const uint32_t kDefaultReceiveSsrc = 0;
80static const uint32_t kSsrc = 1234u;
81static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
82static const int kVideoWidth = 640;
83static const int kVideoHeight = 360;
84static const int kFramerate = 30;
85
Peter Boström0c4e06b2015-10-07 12:23:21 +020086static const uint32_t kSsrcs1[] = {1};
87static const uint32_t kSsrcs3[] = {1, 2, 3};
88static const uint32_t kRtxSsrcs1[] = {4};
brandtr468da7c2016-11-22 02:16:47 -080089static const uint32_t kFlexfecSsrc = 5;
Peter Boström0c4e06b2015-10-07 12:23:21 +020090static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
mzanaty8a855d62017-02-17 15:46:43 -080091static const uint32_t kDefaultRecvSsrc = 0;
92
Bjorn A Mellemda4f0932019-07-30 08:34:03 -070093constexpr uint32_t kRtpHeaderSize = 12;
94
pbos@webrtc.org3c107582014-07-20 15:27:35 +000095static const char kUnsupportedExtensionName[] =
96 "urn:ietf:params:rtp-hdrext:unsupported";
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000097
magjed509e4fe2016-11-18 01:34:11 -080098cricket::VideoCodec RemoveFeedbackParams(cricket::VideoCodec&& codec) {
99 codec.feedback_params = cricket::FeedbackParams();
Mirko Bonadei29a8d102018-04-25 23:58:26 +0200100 return std::move(codec);
magjed509e4fe2016-11-18 01:34:11 -0800101}
102
Elad Alonfadb1812019-05-24 13:40:02 +0200103void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec,
104 bool lntf_expected) {
105 EXPECT_EQ(lntf_expected,
106 codec.HasFeedbackParam(cricket::FeedbackParam(
107 cricket::kRtcpFbParamLntf, cricket::kParamValueEmpty)));
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +0000108 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
109 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
110 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
111 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
112 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
113 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
114 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
stefan43edf0f2015-11-20 18:05:48 -0800115 cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty)));
116 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +0000117 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
118}
119
magjed725e4842016-11-16 00:48:13 -0800120// Return true if any codec in |codecs| is an RTX codec with associated payload
121// type |payload_type|.
122bool HasRtxCodec(const std::vector<cricket::VideoCodec>& codecs,
123 int payload_type) {
124 for (const cricket::VideoCodec& codec : codecs) {
125 int associated_payload_type;
Niels Möller039743e2018-10-23 10:07:25 +0200126 if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx") &&
magjed725e4842016-11-16 00:48:13 -0800127 codec.GetParam(cricket::kCodecParamAssociatedPayloadType,
128 &associated_payload_type) &&
129 associated_payload_type == payload_type) {
130 return true;
131 }
132 }
133 return false;
134}
135
nisseca5706d2017-09-11 02:32:16 -0700136// TODO(nisse): Duplicated in call.cc.
137const int* FindKeyByValue(const std::map<int, int>& m, int v) {
138 for (const auto& kv : m) {
139 if (kv.second == v)
140 return &kv.first;
141 }
142 return nullptr;
143}
144
Yves Gerey665174f2018-06-19 15:03:05 +0200145bool HasRtxReceiveAssociation(const webrtc::VideoReceiveStream::Config& config,
146 int payload_type) {
nisseca5706d2017-09-11 02:32:16 -0700147 return FindKeyByValue(config.rtp.rtx_associated_payload_types,
148 payload_type) != nullptr;
149}
150
151// Check that there's an Rtx payload type for each decoder.
152bool VerifyRtxReceiveAssociations(
153 const webrtc::VideoReceiveStream::Config& config) {
154 for (const auto& decoder : config.decoders) {
155 if (!HasRtxReceiveAssociation(config, decoder.payload_type))
156 return false;
157 }
158 return true;
159}
160
brandtrffc61182016-11-28 06:02:22 -0800161rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateBlackFrameBuffer(
nisse64ec8f82016-09-27 00:17:25 -0700162 int width,
163 int height) {
164 rtc::scoped_refptr<webrtc::I420Buffer> buffer =
165 webrtc::I420Buffer::Create(width, height);
nisseaf916892017-01-10 07:44:26 -0800166 webrtc::I420Buffer::SetBlack(buffer);
nisse64ec8f82016-09-27 00:17:25 -0700167 return buffer;
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +0000168}
169
Shao Changbine62202f2015-04-21 20:24:50 +0800170void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
171 const std::map<int, int>& rtx_types) {
172 std::map<int, int>::const_iterator it;
Niels Möller259a4972018-04-05 15:36:51 +0200173 it = rtx_types.find(config.rtp.payload_type);
Shao Changbine62202f2015-04-21 20:24:50 +0800174 EXPECT_TRUE(it != rtx_types.end() &&
175 it->second == config.rtp.rtx.payload_type);
176
brandtrb5f2c3f2016-10-04 23:28:39 -0700177 if (config.rtp.ulpfec.red_rtx_payload_type != -1) {
178 it = rtx_types.find(config.rtp.ulpfec.red_payload_type);
Shao Changbine62202f2015-04-21 20:24:50 +0800179 EXPECT_TRUE(it != rtx_types.end() &&
brandtrb5f2c3f2016-10-04 23:28:39 -0700180 it->second == config.rtp.ulpfec.red_rtx_payload_type);
Shao Changbine62202f2015-04-21 20:24:50 +0800181 }
182}
kthelgason2bc68642017-02-07 07:02:22 -0800183
184cricket::MediaConfig GetMediaConfig() {
185 cricket::MediaConfig media_config;
Niels Möller1d7ecd22018-01-18 15:25:12 +0100186 media_config.video.enable_cpu_adaptation = false;
kthelgason2bc68642017-02-07 07:02:22 -0800187 return media_config;
188}
nisse26e3abb2017-08-25 04:44:25 -0700189
Åsa Perssonbdee46d2018-06-25 11:28:06 +0200190// Values from GetMaxDefaultVideoBitrateKbps in webrtcvideoengine.cc.
191int GetMaxDefaultBitrateBps(size_t width, size_t height) {
192 if (width * height <= 320 * 240) {
193 return 600000;
194 } else if (width * height <= 640 * 480) {
195 return 1700000;
196 } else if (width * height <= 960 * 540) {
197 return 2000000;
198 } else {
199 return 2500000;
200 }
201}
202
Niels Möller731a2c22018-07-30 15:08:07 +0200203class MockVideoSource : public rtc::VideoSourceInterface<webrtc::VideoFrame> {
204 public:
205 MOCK_METHOD2(AddOrUpdateSink,
206 void(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
207 const rtc::VideoSinkWants& wants));
208 MOCK_METHOD1(RemoveSink,
209 void(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink));
210};
211
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000212} // namespace
213
Yves Gerey665174f2018-06-19 15:03:05 +0200214#define EXPECT_FRAME_WAIT(c, w, h, t) \
Niels Möller6557d0c2018-04-11 15:18:34 +0200215 EXPECT_EQ_WAIT((c), renderer_.num_rendered_frames(), (t)); \
Yves Gerey665174f2018-06-19 15:03:05 +0200216 EXPECT_EQ((w), renderer_.width()); \
217 EXPECT_EQ((h), renderer_.height()); \
Niels Möller6557d0c2018-04-11 15:18:34 +0200218 EXPECT_EQ(0, renderer_.errors());
219
Yves Gerey665174f2018-06-19 15:03:05 +0200220#define EXPECT_FRAME_ON_RENDERER_WAIT(r, c, w, h, t) \
Niels Möller6557d0c2018-04-11 15:18:34 +0200221 EXPECT_EQ_WAIT((c), (r).num_rendered_frames(), (t)); \
Yves Gerey665174f2018-06-19 15:03:05 +0200222 EXPECT_EQ((w), (r).width()); \
223 EXPECT_EQ((h), (r).height()); \
Niels Möller6557d0c2018-04-11 15:18:34 +0200224 EXPECT_EQ(0, (r).errors());
225
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000226namespace cricket {
eladalonf1841382017-06-12 01:16:46 -0700227class WebRtcVideoEngineTest : public ::testing::Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000228 public:
eladalonf1841382017-06-12 01:16:46 -0700229 WebRtcVideoEngineTest() : WebRtcVideoEngineTest("") {}
Elad Alon040dc432019-05-22 15:40:02 +0200230 explicit WebRtcVideoEngineTest(const std::string& field_trials)
231 : override_field_trials_(
232 field_trials.empty()
233 ? nullptr
Mirko Bonadei317a1f02019-09-17 17:06:18 +0200234 : std::make_unique<webrtc::test::ScopedFieldTrials>(
Elad Alon040dc432019-05-22 15:40:02 +0200235 field_trials)),
Danil Chapovalov53d45ba2019-07-03 14:56:33 +0200236 task_queue_factory_(webrtc::CreateDefaultTaskQueueFactory()),
237 call_(webrtc::Call::Create([&] {
238 webrtc::Call::Config call_config(&event_log_);
239 call_config.task_queue_factory = task_queue_factory_.get();
240 return call_config;
241 }())),
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200242 encoder_factory_(new cricket::FakeWebRtcVideoEncoderFactory),
243 decoder_factory_(new cricket::FakeWebRtcVideoDecoderFactory),
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200244 video_bitrate_allocator_factory_(
245 webrtc::CreateBuiltinVideoBitrateAllocatorFactory()),
Anders Carlsson67537952018-05-03 11:28:29 +0200246 engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200247 encoder_factory_),
Anders Carlsson67537952018-05-03 11:28:29 +0200248 std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200249 decoder_factory_)) {
Ilya Nikolaevskiy9c38c472018-09-03 16:11:42 +0200250 // Ensure fake clock doesn't return 0, which will cause some initializations
251 // fail inside RTP senders.
Sebastian Jansson40889f32019-04-17 12:11:20 +0200252 fake_clock_.AdvanceTime(webrtc::TimeDelta::us(1));
Ilya Nikolaevskiy9c38c472018-09-03 16:11:42 +0200253 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000254
255 protected:
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200256 void AssignDefaultAptRtxTypes();
257 void AssignDefaultCodec();
258
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100259 // Find the index of the codec in the engine with the given name. The codec
260 // must be present.
Oleh Prypina40f8242017-12-21 13:32:23 +0100261 size_t GetEngineCodecIndex(const std::string& name) const;
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100262
magjed509e4fe2016-11-18 01:34:11 -0800263 // Find the codec in the engine with the given name. The codec must be
264 // present.
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100265 cricket::VideoCodec GetEngineCodec(const std::string& name) const;
magjed509e4fe2016-11-18 01:34:11 -0800266
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200267 VideoMediaChannel* SetSendParamsWithAllSupportedCodecs();
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000268
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200269 VideoMediaChannel* SetRecvParamsWithSupportedCodecs(
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000270 const std::vector<VideoCodec>& codecs);
271
Elad Alon157540a2019-02-08 23:37:52 +0100272 void ExpectRtpCapabilitySupport(const char* uri, bool supported) const;
Peter Boströme4499152016-02-05 11:13:28 +0100273
Ilya Nikolaevskiy9c38c472018-09-03 16:11:42 +0200274 // Has to be the first one, so it is initialized before the call or there is a
275 // race condition in the clock access.
276 rtc::ScopedFakeClock fake_clock_;
Elad Alon040dc432019-05-22 15:40:02 +0200277 std::unique_ptr<webrtc::test::ScopedFieldTrials> override_field_trials_;
Danil Chapovalov83bbe912019-08-07 12:24:53 +0200278 webrtc::RtcEventLogNull event_log_;
Danil Chapovalov53d45ba2019-07-03 14:56:33 +0200279 std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
eladalonf1841382017-06-12 01:16:46 -0700280 // Used in WebRtcVideoEngineVoiceTest, but defined here so it's properly
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000281 // initialized when the constructor is called.
kwiberg686a8ef2016-02-26 03:00:35 -0800282 std::unique_ptr<webrtc::Call> call_;
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200283 cricket::FakeWebRtcVideoEncoderFactory* encoder_factory_;
284 cricket::FakeWebRtcVideoDecoderFactory* decoder_factory_;
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200285 std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
286 video_bitrate_allocator_factory_;
eladalonf1841382017-06-12 01:16:46 -0700287 WebRtcVideoEngine engine_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000288 VideoCodec default_codec_;
Shao Changbine62202f2015-04-21 20:24:50 +0800289 std::map<int, int> default_apt_rtx_types_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000290};
291
eladalonf1841382017-06-12 01:16:46 -0700292TEST_F(WebRtcVideoEngineTest, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200293 encoder_factory_->AddSupportedVideoCodecType("VP8");
294 AssignDefaultCodec();
295
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000296 std::vector<VideoCodec> engine_codecs = engine_.codecs();
297 for (size_t i = 0; i < engine_codecs.size(); ++i) {
298 if (engine_codecs[i].name != kRtxCodecName)
299 continue;
300 int associated_payload_type;
301 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000302 &associated_payload_type));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000303 EXPECT_EQ(default_codec_.id, associated_payload_type);
304 return;
305 }
306 FAIL() << "No RTX codec found among default codecs.";
307}
308
eladalonf1841382017-06-12 01:16:46 -0700309TEST_F(WebRtcVideoEngineTest, SupportsTimestampOffsetHeaderExtension) {
Elad Alon157540a2019-02-08 23:37:52 +0100310 ExpectRtpCapabilitySupport(RtpExtension::kTimestampOffsetUri, true);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000311}
312
eladalonf1841382017-06-12 01:16:46 -0700313TEST_F(WebRtcVideoEngineTest, SupportsAbsoluteSenderTimeHeaderExtension) {
Elad Alon157540a2019-02-08 23:37:52 +0100314 ExpectRtpCapabilitySupport(RtpExtension::kAbsSendTimeUri, true);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000315}
316
eladalonf1841382017-06-12 01:16:46 -0700317TEST_F(WebRtcVideoEngineTest, SupportsTransportSequenceNumberHeaderExtension) {
Elad Alon157540a2019-02-08 23:37:52 +0100318 ExpectRtpCapabilitySupport(RtpExtension::kTransportSequenceNumberUri, true);
stefanc1aeaf02015-10-15 07:26:07 -0700319}
320
eladalonf1841382017-06-12 01:16:46 -0700321TEST_F(WebRtcVideoEngineTest, SupportsVideoRotationHeaderExtension) {
Elad Alon157540a2019-02-08 23:37:52 +0100322 ExpectRtpCapabilitySupport(RtpExtension::kVideoRotationUri, true);
323}
324
325TEST_F(WebRtcVideoEngineTest, SupportsPlayoutDelayHeaderExtension) {
326 ExpectRtpCapabilitySupport(RtpExtension::kPlayoutDelayUri, true);
327}
328
329TEST_F(WebRtcVideoEngineTest, SupportsVideoContentTypeHeaderExtension) {
330 ExpectRtpCapabilitySupport(RtpExtension::kVideoContentTypeUri, true);
331}
332
333TEST_F(WebRtcVideoEngineTest, SupportsVideoTimingHeaderExtension) {
334 ExpectRtpCapabilitySupport(RtpExtension::kVideoTimingUri, true);
335}
336
337TEST_F(WebRtcVideoEngineTest, SupportsFrameMarkingHeaderExtension) {
338 ExpectRtpCapabilitySupport(RtpExtension::kFrameMarkingUri, true);
Johannes Krond0b69a82018-12-03 14:18:53 +0100339}
340
341TEST_F(WebRtcVideoEngineTest, SupportsColorSpaceHeaderExtension) {
Elad Alon157540a2019-02-08 23:37:52 +0100342 ExpectRtpCapabilitySupport(RtpExtension::kColorSpaceUri, true);
343}
344
Elad Alonccb9b752019-02-19 13:01:31 +0100345TEST_F(WebRtcVideoEngineTest, AdvertiseGenericDescriptor00) {
346 ExpectRtpCapabilitySupport(RtpExtension::kGenericFrameDescriptorUri00, false);
347}
348
349TEST_F(WebRtcVideoEngineTest, AdvertiseGenericDescriptor01) {
350 ExpectRtpCapabilitySupport(RtpExtension::kGenericFrameDescriptorUri01, false);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700351}
352
philipel1e054862018-10-08 16:13:53 +0200353class WebRtcVideoEngineTestWithGenericDescriptor
354 : public WebRtcVideoEngineTest {
355 public:
356 WebRtcVideoEngineTestWithGenericDescriptor()
357 : WebRtcVideoEngineTest("WebRTC-GenericDescriptorAdvertised/Enabled/") {}
358};
359
Elad Alonccb9b752019-02-19 13:01:31 +0100360TEST_F(WebRtcVideoEngineTestWithGenericDescriptor,
361 AdvertiseGenericDescriptor00) {
362 ExpectRtpCapabilitySupport(RtpExtension::kGenericFrameDescriptorUri00, true);
363}
364
365TEST_F(WebRtcVideoEngineTestWithGenericDescriptor,
366 AdvertiseGenericDescriptor01) {
367 ExpectRtpCapabilitySupport(RtpExtension::kGenericFrameDescriptorUri01, true);
philipel1e054862018-10-08 16:13:53 +0200368}
369
eladalonf1841382017-06-12 01:16:46 -0700370TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) {
Niels Möller731a2c22018-07-30 15:08:07 +0200371 // Allocate the source first to prevent early destruction before channel's
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700372 // dtor is called.
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200373 ::testing::NiceMock<MockVideoSource> video_source;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700374
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200375 encoder_factory_->AddSupportedVideoCodecType("VP8");
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700376
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200377 std::unique_ptr<VideoMediaChannel> channel(
378 SetSendParamsWithAllSupportedCodecs());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700379 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
380
381 // Add CVO extension.
382 const int id = 1;
magjed509e4fe2016-11-18 01:34:11 -0800383 cricket::VideoSendParameters parameters;
384 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200385 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700386 RtpExtension(RtpExtension::kVideoRotationUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200387 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700388
Niels Möller731a2c22018-07-30 15:08:07 +0200389 EXPECT_CALL(
390 video_source,
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200391 AddOrUpdateSink(::testing::_,
Niels Möller731a2c22018-07-30 15:08:07 +0200392 Field(&rtc::VideoSinkWants::rotation_applied, false)));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700393 // Set capturer.
Niels Möller731a2c22018-07-30 15:08:07 +0200394 EXPECT_TRUE(channel->SetVideoSend(kSsrc, nullptr, &video_source));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700395
396 // Verify capturer has turned off applying rotation.
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200397 ::testing::Mock::VerifyAndClear(&video_source);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700398
399 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200400 parameters.extensions.clear();
Niels Möller731a2c22018-07-30 15:08:07 +0200401 EXPECT_CALL(
402 video_source,
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200403 AddOrUpdateSink(::testing::_,
Niels Möller731a2c22018-07-30 15:08:07 +0200404 Field(&rtc::VideoSinkWants::rotation_applied, true)));
405
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200406 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700407}
408
eladalonf1841382017-06-12 01:16:46 -0700409TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) {
Niels Möller731a2c22018-07-30 15:08:07 +0200410 // Allocate the source first to prevent early destruction before channel's
perkj91e1c152016-03-02 05:34:00 -0800411 // dtor is called.
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200412 ::testing::NiceMock<MockVideoSource> video_source;
perkj91e1c152016-03-02 05:34:00 -0800413
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200414 encoder_factory_->AddSupportedVideoCodecType("VP8");
perkj91e1c152016-03-02 05:34:00 -0800415
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200416 std::unique_ptr<VideoMediaChannel> channel(
417 SetSendParamsWithAllSupportedCodecs());
perkj91e1c152016-03-02 05:34:00 -0800418 // Add CVO extension.
419 const int id = 1;
magjed509e4fe2016-11-18 01:34:11 -0800420 cricket::VideoSendParameters parameters;
421 parameters.codecs.push_back(GetEngineCodec("VP8"));
perkj91e1c152016-03-02 05:34:00 -0800422 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700423 RtpExtension(RtpExtension::kVideoRotationUri, id));
perkj91e1c152016-03-02 05:34:00 -0800424 EXPECT_TRUE(channel->SetSendParameters(parameters));
425 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
426
Niels Möller731a2c22018-07-30 15:08:07 +0200427 // Set source.
428 EXPECT_CALL(
429 video_source,
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200430 AddOrUpdateSink(::testing::_,
Niels Möller731a2c22018-07-30 15:08:07 +0200431 Field(&rtc::VideoSinkWants::rotation_applied, false)));
432 EXPECT_TRUE(channel->SetVideoSend(kSsrc, nullptr, &video_source));
perkj91e1c152016-03-02 05:34:00 -0800433}
434
eladalonf1841382017-06-12 01:16:46 -0700435TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) {
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200436 ::testing::NiceMock<MockVideoSource> video_source;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700437
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200438 encoder_factory_->AddSupportedVideoCodecType("VP8");
439 encoder_factory_->AddSupportedVideoCodecType("VP9");
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700440
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200441 std::unique_ptr<VideoMediaChannel> channel(
442 SetSendParamsWithAllSupportedCodecs());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700443 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
444
445 // Set capturer.
Niels Möller731a2c22018-07-30 15:08:07 +0200446 EXPECT_CALL(
447 video_source,
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200448 AddOrUpdateSink(::testing::_,
Niels Möller731a2c22018-07-30 15:08:07 +0200449 Field(&rtc::VideoSinkWants::rotation_applied, true)));
450 EXPECT_TRUE(channel->SetVideoSend(kSsrc, nullptr, &video_source));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700451
perkjcaafdba2016-03-20 07:34:29 -0700452 // Verify capturer has turned on applying rotation.
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200453 ::testing::Mock::VerifyAndClear(&video_source);
perkjcaafdba2016-03-20 07:34:29 -0700454
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700455 // Add CVO extension.
456 const int id = 1;
magjed509e4fe2016-11-18 01:34:11 -0800457 cricket::VideoSendParameters parameters;
458 parameters.codecs.push_back(GetEngineCodec("VP8"));
459 parameters.codecs.push_back(GetEngineCodec("VP9"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200460 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700461 RtpExtension(RtpExtension::kVideoRotationUri, id));
perkjcaafdba2016-03-20 07:34:29 -0700462 // Also remove the first codec to trigger a codec change as well.
463 parameters.codecs.erase(parameters.codecs.begin());
Niels Möller731a2c22018-07-30 15:08:07 +0200464 EXPECT_CALL(
465 video_source,
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200466 AddOrUpdateSink(::testing::_,
Niels Möller731a2c22018-07-30 15:08:07 +0200467 Field(&rtc::VideoSinkWants::rotation_applied, false)));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200468 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700469
470 // Verify capturer has turned off applying rotation.
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200471 ::testing::Mock::VerifyAndClear(&video_source);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700472
473 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200474 parameters.extensions.clear();
Niels Möller731a2c22018-07-30 15:08:07 +0200475 EXPECT_CALL(
476 video_source,
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200477 AddOrUpdateSink(::testing::_,
Niels Möller731a2c22018-07-30 15:08:07 +0200478 Field(&rtc::VideoSinkWants::rotation_applied, true)));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200479 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700480}
481
eladalonf1841382017-06-12 01:16:46 -0700482TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200483 encoder_factory_->AddSupportedVideoCodecType("VP8");
484
Sebastian Jansson84848f22018-11-16 10:40:36 +0100485 std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200486 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
487 video_bitrate_allocator_factory_.get()));
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000488
489 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
490
491 EXPECT_FALSE(channel->SetSend(true))
492 << "Channel should not start without codecs.";
493 EXPECT_TRUE(channel->SetSend(false))
494 << "Channel should be stoppable even without set codecs.";
495}
496
eladalonf1841382017-06-12 01:16:46 -0700497TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200498 encoder_factory_->AddSupportedVideoCodecType("VP8");
499
Sebastian Jansson84848f22018-11-16 10:40:36 +0100500 std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200501 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
502 video_bitrate_allocator_factory_.get()));
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000503 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
504 VideoMediaInfo info;
505 channel->GetStats(&info);
506}
507
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200508TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200509 encoder_factory_->AddSupportedVideoCodecType("VP8");
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000510
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200511 std::unique_ptr<VideoMediaChannel> channel(
512 SetSendParamsWithAllSupportedCodecs());
Sergey Ulanove2b15012016-11-22 16:08:30 -0800513 channel->OnReadyToSend(true);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000514
515 EXPECT_TRUE(
516 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200517 EXPECT_EQ(0, encoder_factory_->GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000518 EXPECT_TRUE(channel->SetSend(true));
Niels Möllerd0f0f682019-01-14 09:09:53 +0100519 webrtc::test::FrameForwarder frame_forwarder;
520 cricket::FakeFrameSource frame_source(1280, 720,
521 rtc::kNumMicrosecsPerSec / 30);
522 EXPECT_TRUE(channel->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
523 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Per21d45d22016-10-30 21:37:57 +0100524 // Sending one frame will have allocate the encoder.
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200525 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(1));
526 EXPECT_TRUE_WAIT(encoder_factory_->encoders()[0]->GetNumEncodedFrames() > 0,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000527 kTimeout);
528
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200529 int num_created_encoders = encoder_factory_->GetNumCreatedEncoders();
Per21d45d22016-10-30 21:37:57 +0100530 EXPECT_EQ(num_created_encoders, 1);
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000531
532 // Setting codecs of the same type should not reallocate any encoders
533 // (expecting a no-op).
magjed509e4fe2016-11-18 01:34:11 -0800534 cricket::VideoSendParameters parameters;
535 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200536 EXPECT_TRUE(channel->SetSendParameters(parameters));
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200537 EXPECT_EQ(num_created_encoders, encoder_factory_->GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000538
539 // Remove stream previously added to free the external encoder instance.
540 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200541 EXPECT_EQ(0u, encoder_factory_->encoders().size());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000542}
543
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200544// Test that when an encoder factory supports H264, we add an RTX
545// codec for it.
546// TODO(deadbeef): This test should be updated if/when we start
547// adding RTX codecs for unrecognized codec names.
548TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForH264Codec) {
magjed725e4842016-11-16 00:48:13 -0800549 using webrtc::H264::kLevel1;
Jonas Olssona4d87372019-07-05 19:08:33 +0200550 using webrtc::H264::ProfileLevelId;
551 using webrtc::H264::ProfileLevelIdToString;
Anders Carlsson67537952018-05-03 11:28:29 +0200552 webrtc::SdpVideoFormat h264_constrained_baseline("H264");
553 h264_constrained_baseline.parameters[kH264FmtpProfileLevelId] =
magjed725e4842016-11-16 00:48:13 -0800554 *ProfileLevelIdToString(
555 ProfileLevelId(webrtc::H264::kProfileConstrainedBaseline, kLevel1));
Anders Carlsson67537952018-05-03 11:28:29 +0200556 webrtc::SdpVideoFormat h264_constrained_high("H264");
557 h264_constrained_high.parameters[kH264FmtpProfileLevelId] =
magjed725e4842016-11-16 00:48:13 -0800558 *ProfileLevelIdToString(
559 ProfileLevelId(webrtc::H264::kProfileConstrainedHigh, kLevel1));
Anders Carlsson67537952018-05-03 11:28:29 +0200560 webrtc::SdpVideoFormat h264_high("H264");
561 h264_high.parameters[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
magjed725e4842016-11-16 00:48:13 -0800562 ProfileLevelId(webrtc::H264::kProfileHigh, kLevel1));
563
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200564 encoder_factory_->AddSupportedVideoCodec(h264_constrained_baseline);
565 encoder_factory_->AddSupportedVideoCodec(h264_constrained_high);
566 encoder_factory_->AddSupportedVideoCodec(h264_high);
Taylor Brandstetter6c3e7882016-06-29 11:14:19 -0700567
magjed725e4842016-11-16 00:48:13 -0800568 // First figure out what payload types the test codecs got assigned.
569 const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
magjed509e4fe2016-11-18 01:34:11 -0800570 // Now search for RTX codecs for them. Expect that they all have associated
571 // RTX codecs.
magjed725e4842016-11-16 00:48:13 -0800572 EXPECT_TRUE(HasRtxCodec(
Anders Carlsson67537952018-05-03 11:28:29 +0200573 codecs,
574 FindMatchingCodec(codecs, cricket::VideoCodec(h264_constrained_baseline))
575 ->id));
magjed725e4842016-11-16 00:48:13 -0800576 EXPECT_TRUE(HasRtxCodec(
Anders Carlsson67537952018-05-03 11:28:29 +0200577 codecs,
578 FindMatchingCodec(codecs, cricket::VideoCodec(h264_constrained_high))
579 ->id));
magjed509e4fe2016-11-18 01:34:11 -0800580 EXPECT_TRUE(HasRtxCodec(
Anders Carlsson67537952018-05-03 11:28:29 +0200581 codecs, FindMatchingCodec(codecs, cricket::VideoCodec(h264_high))->id));
Taylor Brandstetter6c3e7882016-06-29 11:14:19 -0700582}
583
Mirko Bonadei8ef57932018-11-16 14:38:03 +0100584#if defined(RTC_ENABLE_VP9)
eladalonf1841382017-06-12 01:16:46 -0700585TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200586 encoder_factory_->AddSupportedVideoCodecType("VP9");
Peter Boström53eda3d2015-03-27 15:53:18 +0100587
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200588 std::unique_ptr<VideoMediaChannel> channel(
589 SetSendParamsWithAllSupportedCodecs());
Peter Boström53eda3d2015-03-27 15:53:18 +0100590
591 EXPECT_TRUE(
592 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
593}
Mirko Bonadei8ef57932018-11-16 14:38:03 +0100594#endif // defined(RTC_ENABLE_VP9)
Peter Boström53eda3d2015-03-27 15:53:18 +0100595
eladalonf1841382017-06-12 01:16:46 -0700596TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200597 encoder_factory_->AddSupportedVideoCodecType("VP8");
Sebastian Jansson8f83b422018-02-21 13:07:13 +0100598 FakeCall* fake_call = new FakeCall();
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200599 call_.reset(fake_call);
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200600 std::unique_ptr<VideoMediaChannel> channel(
601 SetSendParamsWithAllSupportedCodecs());
qiangchenc27d89f2015-07-16 10:27:16 -0700602
603 EXPECT_TRUE(
604 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
605
Niels Möllerd0f0f682019-01-14 09:09:53 +0100606 webrtc::test::FrameForwarder frame_forwarder;
607 cricket::FakeFrameSource frame_source(1280, 720,
608 rtc::kNumMicrosecsPerSec / 60);
609 EXPECT_TRUE(channel->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
qiangchenc27d89f2015-07-16 10:27:16 -0700610 channel->SetSend(true);
611
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200612 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
qiangchenc27d89f2015-07-16 10:27:16 -0700613
Niels Möllerd0f0f682019-01-14 09:09:53 +0100614 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
pbos1cb121d2015-09-14 11:38:38 -0700615 int64_t last_timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700616 for (int i = 0; i < 10; i++) {
Niels Möllerd0f0f682019-01-14 09:09:53 +0100617 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
pbos1cb121d2015-09-14 11:38:38 -0700618 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700619 int64_t interval = timestamp - last_timestamp;
620
621 // Precision changes from nanosecond to millisecond.
622 // Allow error to be no more than 1.
623 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(60) / 1E6, interval, 1);
624
625 last_timestamp = timestamp;
626 }
627
Niels Möllerd0f0f682019-01-14 09:09:53 +0100628 frame_forwarder.IncomingCapturedFrame(
629 frame_source.GetFrame(1280, 720, webrtc::VideoRotation::kVideoRotation_0,
630 rtc::kNumMicrosecsPerSec / 30));
qiangchenc27d89f2015-07-16 10:27:16 -0700631 last_timestamp = stream->GetLastTimestamp();
632 for (int i = 0; i < 10; i++) {
Niels Möllerd0f0f682019-01-14 09:09:53 +0100633 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame(
634 1280, 720, webrtc::VideoRotation::kVideoRotation_0,
635 rtc::kNumMicrosecsPerSec / 30));
pbos1cb121d2015-09-14 11:38:38 -0700636 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700637 int64_t interval = timestamp - last_timestamp;
638
639 // Precision changes from nanosecond to millisecond.
640 // Allow error to be no more than 1.
641 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1);
642
643 last_timestamp = timestamp;
644 }
645
646 // Remove stream previously added to free the external encoder instance.
647 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
648}
649
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200650void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
651 std::vector<VideoCodec> engine_codecs = engine_.codecs();
652 RTC_DCHECK(!engine_codecs.empty());
653 for (const cricket::VideoCodec& codec : engine_codecs) {
654 if (codec.name == "rtx") {
655 int associated_payload_type;
656 if (codec.GetParam(kCodecParamAssociatedPayloadType,
657 &associated_payload_type)) {
658 default_apt_rtx_types_[associated_payload_type] = codec.id;
659 }
660 }
661 }
662}
663
664void WebRtcVideoEngineTest::AssignDefaultCodec() {
665 std::vector<VideoCodec> engine_codecs = engine_.codecs();
666 RTC_DCHECK(!engine_codecs.empty());
667 bool codec_set = false;
668 for (const cricket::VideoCodec& codec : engine_codecs) {
669 if (!codec_set && codec.name != "rtx" && codec.name != "red" &&
670 codec.name != "ulpfec") {
671 default_codec_ = codec;
672 codec_set = true;
673 }
674 }
675
676 RTC_DCHECK(codec_set);
677}
678
Oleh Prypina40f8242017-12-21 13:32:23 +0100679size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
680 const std::string& name) const {
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100681 const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
682 for (size_t i = 0; i < codecs.size(); ++i) {
683 const cricket::VideoCodec engine_codec = codecs[i];
Niels Möller039743e2018-10-23 10:07:25 +0200684 if (!absl::EqualsIgnoreCase(name, engine_codec.name))
Magnus Jedvert8deb8182017-10-05 13:13:32 +0200685 continue;
686 // The tests only use H264 Constrained Baseline. Make sure we don't return
687 // an internal H264 codec from the engine with a different H264 profile.
Niels Möller039743e2018-10-23 10:07:25 +0200688 if (absl::EqualsIgnoreCase(name.c_str(), kH264CodecName)) {
Danil Chapovalov00c71832018-06-15 15:58:38 +0200689 const absl::optional<webrtc::H264::ProfileLevelId> profile_level_id =
Magnus Jedvert8deb8182017-10-05 13:13:32 +0200690 webrtc::H264::ParseSdpProfileLevelId(engine_codec.params);
691 if (profile_level_id->profile !=
692 webrtc::H264::kProfileConstrainedBaseline) {
693 continue;
694 }
695 }
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100696 return i;
magjed509e4fe2016-11-18 01:34:11 -0800697 }
698 // This point should never be reached.
699 ADD_FAILURE() << "Unrecognized codec name: " << name;
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100700 return -1;
701}
702
703cricket::VideoCodec WebRtcVideoEngineTest::GetEngineCodec(
704 const std::string& name) const {
705 return engine_.codecs()[GetEngineCodecIndex(name)];
magjed509e4fe2016-11-18 01:34:11 -0800706}
707
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200708VideoMediaChannel*
709WebRtcVideoEngineTest::SetSendParamsWithAllSupportedCodecs() {
Sebastian Jansson84848f22018-11-16 10:40:36 +0100710 VideoMediaChannel* channel = engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200711 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
712 video_bitrate_allocator_factory_.get());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200713 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -0800714 // We need to look up the codec in the engine to get the correct payload type.
Anders Carlsson67537952018-05-03 11:28:29 +0200715 for (const webrtc::SdpVideoFormat& format :
716 encoder_factory_->GetSupportedFormats()) {
717 cricket::VideoCodec engine_codec = GetEngineCodec(format.name);
Steve Anton2c9ebef2019-01-28 17:27:58 -0800718 if (!absl::c_linear_search(parameters.codecs, engine_codec)) {
Anders Carlsson67537952018-05-03 11:28:29 +0200719 parameters.codecs.push_back(engine_codec);
720 }
721 }
magjed509e4fe2016-11-18 01:34:11 -0800722
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200723 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000724
725 return channel;
726}
727
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200728VideoMediaChannel* WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs(
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000729 const std::vector<VideoCodec>& codecs) {
Sebastian Jansson84848f22018-11-16 10:40:36 +0100730 VideoMediaChannel* channel = engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200731 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
732 video_bitrate_allocator_factory_.get());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200733 cricket::VideoRecvParameters parameters;
734 parameters.codecs = codecs;
735 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000736
737 return channel;
738}
739
Elad Alon157540a2019-02-08 23:37:52 +0100740void WebRtcVideoEngineTest::ExpectRtpCapabilitySupport(const char* uri,
741 bool supported) const {
742 const RtpCapabilities capabilities = engine_.GetCapabilities();
743 if (supported) {
744 EXPECT_THAT(capabilities.header_extensions,
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200745 ::testing::Contains(::testing::Field(&RtpExtension::uri, uri)));
Elad Alon157540a2019-02-08 23:37:52 +0100746 } else {
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200747 EXPECT_THAT(capabilities.header_extensions,
748 ::testing::Each(::testing::Field(&RtpExtension::uri,
749 ::testing::StrNe(uri))));
Elad Alon157540a2019-02-08 23:37:52 +0100750 }
751}
752
eladalonf1841382017-06-12 01:16:46 -0700753TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200754 encoder_factory_->AddSupportedVideoCodecType("VP8");
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000755
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200756 std::unique_ptr<VideoMediaChannel> channel(
757 SetSendParamsWithAllSupportedCodecs());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000758
Peter Boström0c4e06b2015-10-07 12:23:21 +0200759 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000760
Yves Gerey665174f2018-06-19 15:03:05 +0200761 EXPECT_TRUE(channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000762 EXPECT_TRUE(channel->SetSend(true));
763
Niels Möller805a27e2019-01-21 12:21:27 +0100764 webrtc::test::FrameForwarder frame_forwarder;
765 cricket::FakeFrameSource frame_source(1280, 720,
766 rtc::kNumMicrosecsPerSec / 60);
767 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), nullptr, &frame_forwarder));
768 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000769
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200770 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(2));
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000771
772 // Verify that encoders are configured for simulcast through adapter
773 // (increasing resolution and only configured to send one stream each).
774 int prev_width = -1;
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200775 for (size_t i = 0; i < encoder_factory_->encoders().size(); ++i) {
776 ASSERT_TRUE(encoder_factory_->encoders()[i]->WaitForInitEncode());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000777 webrtc::VideoCodec codec_settings =
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200778 encoder_factory_->encoders()[i]->GetCodecSettings();
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000779 EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
780 EXPECT_GT(codec_settings.width, prev_width);
781 prev_width = codec_settings.width;
782 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000783
Niels Möllerff40b142018-04-09 08:49:14 +0200784 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), nullptr, nullptr));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000785
786 channel.reset();
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200787 ASSERT_EQ(0u, encoder_factory_->encoders().size());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000788}
789
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200790TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) {
791 encoder_factory_->AddSupportedVideoCodecType("VP8");
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200792 encoder_factory_->AddSupportedVideoCodecType("H264");
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000793
Niels Möllerd0f0f682019-01-14 09:09:53 +0100794 // Frame source.
795 webrtc::test::FrameForwarder frame_forwarder;
796 cricket::FakeFrameSource frame_source(1280, 720,
797 rtc::kNumMicrosecsPerSec / 30);
Niels Möller4db138e2018-04-19 09:04:13 +0200798
Sebastian Jansson84848f22018-11-16 10:40:36 +0100799 std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200800 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
801 video_bitrate_allocator_factory_.get()));
Anders Carlsson67537952018-05-03 11:28:29 +0200802 cricket::VideoSendParameters parameters;
803 parameters.codecs.push_back(GetEngineCodec("H264"));
804 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000805
806 EXPECT_TRUE(
807 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Niels Möllerd0f0f682019-01-14 09:09:53 +0100808 EXPECT_TRUE(channel->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
Niels Möller4db138e2018-04-19 09:04:13 +0200809 // Sending one frame will have allocate the encoder.
Niels Möllerd0f0f682019-01-14 09:09:53 +0100810 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Niels Möller4db138e2018-04-19 09:04:13 +0200811
812 ASSERT_EQ_WAIT(1u, encoder_factory_->encoders().size(), kTimeout);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000813
Anders Carlsson67537952018-05-03 11:28:29 +0200814 cricket::VideoSendParameters new_parameters;
815 new_parameters.codecs.push_back(GetEngineCodec("VP8"));
816 EXPECT_TRUE(channel->SetSendParameters(new_parameters));
Niels Möller4db138e2018-04-19 09:04:13 +0200817
818 // Sending one frame will switch encoder.
Niels Möllerd0f0f682019-01-14 09:09:53 +0100819 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Niels Möller4db138e2018-04-19 09:04:13 +0200820
Anders Carlsson8a150d92018-05-14 12:40:04 +0200821 EXPECT_EQ_WAIT(1u, encoder_factory_->encoders().size(), kTimeout);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000822}
823
eladalonf1841382017-06-12 01:16:46 -0700824TEST_F(WebRtcVideoEngineTest,
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000825 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200826 encoder_factory_->AddSupportedVideoCodecType("VP8");
827 encoder_factory_->AddSupportedVideoCodecType("H264");
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000828
Sebastian Jansson84848f22018-11-16 10:40:36 +0100829 std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200830 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
831 video_bitrate_allocator_factory_.get()));
magjed509e4fe2016-11-18 01:34:11 -0800832 cricket::VideoSendParameters parameters;
833 parameters.codecs.push_back(GetEngineCodec("VP8"));
834 EXPECT_TRUE(channel->SetSendParameters(parameters));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000835
Peter Boström0c4e06b2015-10-07 12:23:21 +0200836 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000837
Yves Gerey665174f2018-06-19 15:03:05 +0200838 EXPECT_TRUE(channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000839 EXPECT_TRUE(channel->SetSend(true));
840
841 // Send a fake frame, or else the media engine will configure the simulcast
842 // encoder adapter at a low-enough size that it'll only create a single
843 // encoder layer.
Niels Möller805a27e2019-01-21 12:21:27 +0100844 webrtc::test::FrameForwarder frame_forwarder;
845 cricket::FakeFrameSource frame_source(1280, 720,
846 rtc::kNumMicrosecsPerSec / 30);
847 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), nullptr, &frame_forwarder));
848 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000849
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200850 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(2));
851 ASSERT_TRUE(encoder_factory_->encoders()[0]->WaitForInitEncode());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000852 EXPECT_EQ(webrtc::kVideoCodecVP8,
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200853 encoder_factory_->encoders()[0]->GetCodecSettings().codecType);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000854
855 channel.reset();
856 // Make sure DestroyVideoEncoder was called on the factory.
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200857 EXPECT_EQ(0u, encoder_factory_->encoders().size());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000858}
859
eladalonf1841382017-06-12 01:16:46 -0700860TEST_F(WebRtcVideoEngineTest,
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000861 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200862 encoder_factory_->AddSupportedVideoCodecType("VP8");
863 encoder_factory_->AddSupportedVideoCodecType("H264");
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000864
Sebastian Jansson84848f22018-11-16 10:40:36 +0100865 std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200866 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
867 video_bitrate_allocator_factory_.get()));
magjed509e4fe2016-11-18 01:34:11 -0800868 cricket::VideoSendParameters parameters;
869 parameters.codecs.push_back(GetEngineCodec("H264"));
870 EXPECT_TRUE(channel->SetSendParameters(parameters));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000871
872 EXPECT_TRUE(
873 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Per21d45d22016-10-30 21:37:57 +0100874
875 // Send a frame of 720p. This should trigger a "real" encoder initialization.
Niels Möller805a27e2019-01-21 12:21:27 +0100876 webrtc::test::FrameForwarder frame_forwarder;
877 cricket::FakeFrameSource frame_source(1280, 720,
878 rtc::kNumMicrosecsPerSec / 30);
879 EXPECT_TRUE(channel->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
880 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Niels Möller4db138e2018-04-19 09:04:13 +0200881 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(1));
882 ASSERT_EQ(1u, encoder_factory_->encoders().size());
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200883 ASSERT_TRUE(encoder_factory_->encoders()[0]->WaitForInitEncode());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000884 EXPECT_EQ(webrtc::kVideoCodecH264,
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200885 encoder_factory_->encoders()[0]->GetCodecSettings().codecType);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000886
887 channel.reset();
888 // Make sure DestroyVideoEncoder was called on the factory.
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200889 ASSERT_EQ(0u, encoder_factory_->encoders().size());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000890}
891
Sergio Garcia Murillo43800f92018-06-21 16:16:38 +0200892TEST_F(WebRtcVideoEngineTest, SimulcastEnabledForH264BehindFieldTrial) {
Elad Alon040dc432019-05-22 15:40:02 +0200893 RTC_DCHECK(!override_field_trials_);
Mirko Bonadei317a1f02019-09-17 17:06:18 +0200894 override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
Sergio Garcia Murillo43800f92018-06-21 16:16:38 +0200895 "WebRTC-H264Simulcast/Enabled/");
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200896 encoder_factory_->AddSupportedVideoCodecType("H264");
noahricfdac5162015-08-27 01:59:29 -0700897
Sebastian Jansson84848f22018-11-16 10:40:36 +0100898 std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +0200899 call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
900 video_bitrate_allocator_factory_.get()));
Anders Carlsson67537952018-05-03 11:28:29 +0200901 cricket::VideoSendParameters parameters;
902 parameters.codecs.push_back(GetEngineCodec("H264"));
903 EXPECT_TRUE(channel->SetSendParameters(parameters));
noahricfdac5162015-08-27 01:59:29 -0700904
Peter Boström0c4e06b2015-10-07 12:23:21 +0200905 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
noahricfdac5162015-08-27 01:59:29 -0700906 EXPECT_TRUE(
907 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
Peter Boströmce23bee2016-02-02 14:14:30 +0100908
909 // Send a frame of 720p. This should trigger a "real" encoder initialization.
Niels Möller805a27e2019-01-21 12:21:27 +0100910 webrtc::test::FrameForwarder frame_forwarder;
911 cricket::FakeFrameSource frame_source(1280, 720,
912 rtc::kNumMicrosecsPerSec / 30);
913 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder));
914 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Peter Boströmce23bee2016-02-02 14:14:30 +0100915
Niels Möller4db138e2018-04-19 09:04:13 +0200916 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(1));
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200917 ASSERT_EQ(1u, encoder_factory_->encoders().size());
918 FakeWebRtcVideoEncoder* encoder = encoder_factory_->encoders()[0];
919 ASSERT_TRUE(encoder_factory_->encoders()[0]->WaitForInitEncode());
noahricfdac5162015-08-27 01:59:29 -0700920 EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
Sergio Garcia Murillo43800f92018-06-21 16:16:38 +0200921 EXPECT_LT(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
Niels Möllerff40b142018-04-09 08:49:14 +0200922 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], nullptr, nullptr));
noahricfdac5162015-08-27 01:59:29 -0700923}
924
brandtrffc61182016-11-28 06:02:22 -0800925// Test that the FlexFEC field trial properly alters the output of
eladalonf1841382017-06-12 01:16:46 -0700926// WebRtcVideoEngine::codecs(), for an existing |engine_| object.
brandtrffc61182016-11-28 06:02:22 -0800927//
928// TODO(brandtr): Remove this test, when the FlexFEC field trial is gone.
eladalonf1841382017-06-12 01:16:46 -0700929TEST_F(WebRtcVideoEngineTest,
brandtrffc61182016-11-28 06:02:22 -0800930 Flexfec03SupportedAsInternalCodecBehindFieldTrial) {
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200931 encoder_factory_->AddSupportedVideoCodecType("VP8");
932
Steve Anton2c9ebef2019-01-28 17:27:58 -0800933 auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
brandtrffc61182016-11-28 06:02:22 -0800934
935 // FlexFEC is not active without field trial.
Steve Anton2c9ebef2019-01-28 17:27:58 -0800936 EXPECT_THAT(engine_.codecs(), Not(Contains(flexfec)));
brandtrffc61182016-11-28 06:02:22 -0800937
938 // FlexFEC is active with field trial.
Elad Alon040dc432019-05-22 15:40:02 +0200939 RTC_DCHECK(!override_field_trials_);
Mirko Bonadei317a1f02019-09-17 17:06:18 +0200940 override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
brandtr340e3fd2017-02-28 15:43:10 -0800941 "WebRTC-FlexFEC-03-Advertised/Enabled/");
Steve Anton2c9ebef2019-01-28 17:27:58 -0800942 EXPECT_THAT(engine_.codecs(), Contains(flexfec));
brandtrffc61182016-11-28 06:02:22 -0800943}
944
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200945// Test that codecs are added in the order they are reported from the factory.
946TEST_F(WebRtcVideoEngineTest, ReportSupportedCodecs) {
947 encoder_factory_->AddSupportedVideoCodecType("VP8");
948 const char* kFakeCodecName = "FakeCodec";
949 encoder_factory_->AddSupportedVideoCodecType(kFakeCodecName);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000950
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200951 // The last reported codec should appear after the first codec in the vector.
Oleh Prypina40f8242017-12-21 13:32:23 +0100952 const size_t vp8_index = GetEngineCodecIndex("VP8");
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200953 const size_t fake_codec_index = GetEngineCodecIndex(kFakeCodecName);
954 EXPECT_LT(vp8_index, fake_codec_index);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000955}
956
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200957// Test that a codec that was added after the engine was initialized
brandtrffc61182016-11-28 06:02:22 -0800958// does show up in the codec list after it was added.
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200959TEST_F(WebRtcVideoEngineTest, ReportSupportedAddedCodec) {
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100960 const char* kFakeExternalCodecName1 = "FakeExternalCodec1";
961 const char* kFakeExternalCodecName2 = "FakeExternalCodec2";
Magnus Jedvert154ee1f2017-11-15 19:27:11 +0100962
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100963 // Set up external encoder factory with first codec, and initialize engine.
964 encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName1);
965
brandtrffc61182016-11-28 06:02:22 -0800966 std::vector<cricket::VideoCodec> codecs_before(engine_.codecs());
brandtrffc61182016-11-28 06:02:22 -0800967
968 // Add second codec.
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100969 encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName2);
brandtrffc61182016-11-28 06:02:22 -0800970 std::vector<cricket::VideoCodec> codecs_after(engine_.codecs());
Sami Kalliomäkie9a18b22018-07-13 10:28:21 +0200971 // The codec itself and RTX should have been added.
972 EXPECT_EQ(codecs_before.size() + 2, codecs_after.size());
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100973
974 // Check that both fake codecs are present and that the second fake codec
975 // appears after the first fake codec.
Oleh Prypina40f8242017-12-21 13:32:23 +0100976 const size_t fake_codec_index1 = GetEngineCodecIndex(kFakeExternalCodecName1);
977 const size_t fake_codec_index2 = GetEngineCodecIndex(kFakeExternalCodecName2);
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100978 EXPECT_LT(fake_codec_index1, fake_codec_index2);
brandtrffc61182016-11-28 06:02:22 -0800979}
980
Sami Kalliomäkie9a18b22018-07-13 10:28:21 +0200981TEST_F(WebRtcVideoEngineTest, ReportRtxForExternalCodec) {
982 const char* kFakeCodecName = "FakeCodec";
983 encoder_factory_->AddSupportedVideoCodecType(kFakeCodecName);
984
985 const size_t fake_codec_index = GetEngineCodecIndex(kFakeCodecName);
986 EXPECT_EQ("rtx", engine_.codecs().at(fake_codec_index + 1).name);
987}
988
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200989TEST_F(WebRtcVideoEngineTest, RegisterDecodersIfSupported) {
990 encoder_factory_->AddSupportedVideoCodecType("VP8");
Anders Carlsson67537952018-05-03 11:28:29 +0200991 decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200992 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -0800993 parameters.codecs.push_back(GetEngineCodec("VP8"));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000994
kwiberg686a8ef2016-02-26 03:00:35 -0800995 std::unique_ptr<VideoMediaChannel> channel(
Anders Carlsson5f2bb622018-05-14 09:48:06 +0200996 SetRecvParamsWithSupportedCodecs(parameters.codecs));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000997
998 EXPECT_TRUE(
999 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001000 ASSERT_EQ(1u, decoder_factory_->decoders().size());
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001001
1002 // Setting codecs of the same type should not reallocate the decoder.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001003 EXPECT_TRUE(channel->SetRecvParameters(parameters));
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001004 EXPECT_EQ(1, decoder_factory_->GetNumCreatedDecoders());
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001005
1006 // Remove stream previously added to free the external decoder instance.
1007 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001008 EXPECT_EQ(0u, decoder_factory_->decoders().size());
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001009}
1010
Anders Carlsson5f2bb622018-05-14 09:48:06 +02001011// Verifies that we can set up decoders.
1012TEST_F(WebRtcVideoEngineTest, RegisterH264DecoderIfSupported) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001013 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
1014 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
1015 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
1016 // codecs.
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001017 encoder_factory_->AddSupportedVideoCodecType("H264");
Steve Anton2dbc6272019-05-31 13:08:58 -07001018 webrtc::SdpVideoFormat supported_h264("H264");
1019 supported_h264.parameters[kH264FmtpPacketizationMode] = "1";
1020 decoder_factory_->AddSupportedVideoCodecType(supported_h264);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001021 std::vector<cricket::VideoCodec> codecs;
magjed509e4fe2016-11-18 01:34:11 -08001022 codecs.push_back(GetEngineCodec("H264"));
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001023
kwiberg686a8ef2016-02-26 03:00:35 -08001024 std::unique_ptr<VideoMediaChannel> channel(
Anders Carlsson5f2bb622018-05-14 09:48:06 +02001025 SetRecvParamsWithSupportedCodecs(codecs));
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001026
1027 EXPECT_TRUE(
1028 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001029 ASSERT_EQ(1u, decoder_factory_->decoders().size());
pbos@webrtc.org96a93252014-11-03 14:46:44 +00001030}
1031
Jonas Oreland49ac5952018-09-26 16:04:32 +02001032// Tests when GetSources is called with non-existing ssrc, it will return an
1033// empty list of RtpSource without crashing.
1034TEST_F(WebRtcVideoEngineTest, GetSourcesWithNonExistingSsrc) {
1035 // Setup an recv stream with |kSsrc|.
1036 encoder_factory_->AddSupportedVideoCodecType("VP8");
1037 decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
1038 cricket::VideoRecvParameters parameters;
1039 parameters.codecs.push_back(GetEngineCodec("VP8"));
1040 std::unique_ptr<VideoMediaChannel> channel(
1041 SetRecvParamsWithSupportedCodecs(parameters.codecs));
1042
1043 EXPECT_TRUE(
1044 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
1045
1046 // Call GetSources with |kSsrc + 1| which doesn't exist.
1047 std::vector<webrtc::RtpSource> sources = channel->GetSources(kSsrc + 1);
1048 EXPECT_EQ(0u, sources.size());
1049}
1050
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001051TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullFactories) {
1052 std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory;
1053 std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory;
1054 WebRtcVideoEngine engine(std::move(encoder_factory),
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001055 std::move(decoder_factory));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001056 EXPECT_EQ(0u, engine.codecs().size());
1057}
1058
1059TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, EmptyFactories) {
1060 // |engine| take ownership of the factories.
Emircan Uysalerdbcac7f2017-10-30 23:10:12 -07001061 webrtc::MockVideoEncoderFactory* encoder_factory =
1062 new webrtc::MockVideoEncoderFactory();
1063 webrtc::MockVideoDecoderFactory* decoder_factory =
1064 new webrtc::MockVideoDecoderFactory();
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001065 WebRtcVideoEngine engine(
1066 (std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001067 (std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001068 EXPECT_CALL(*encoder_factory, GetSupportedFormats());
1069 EXPECT_EQ(0u, engine.codecs().size());
1070 EXPECT_CALL(*encoder_factory, Die());
1071 EXPECT_CALL(*decoder_factory, Die());
1072}
1073
1074// Test full behavior in the video engine when video codec factories of the new
1075// type are injected supporting the single codec Vp8. Check the returned codecs
1076// from the engine and that we will create a Vp8 encoder and decoder using the
1077// new factories.
1078TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
1079 // |engine| take ownership of the factories.
Emircan Uysalerdbcac7f2017-10-30 23:10:12 -07001080 webrtc::MockVideoEncoderFactory* encoder_factory =
1081 new webrtc::MockVideoEncoderFactory();
1082 webrtc::MockVideoDecoderFactory* decoder_factory =
1083 new webrtc::MockVideoDecoderFactory();
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001084 std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory>
1085 rate_allocator_factory =
Mirko Bonadei317a1f02019-09-17 17:06:18 +02001086 std::make_unique<webrtc::MockVideoBitrateAllocatorFactory>();
Jiawei Ouc2ebe212018-11-08 10:02:56 -08001087 EXPECT_CALL(*rate_allocator_factory,
1088 CreateVideoBitrateAllocatorProxy(Field(
1089 &webrtc::VideoCodec::codecType, webrtc::kVideoCodecVP8)))
Mirko Bonadei6a489f22019-04-09 15:11:12 +02001090 .WillOnce(::testing::Return(new webrtc::MockVideoBitrateAllocator()));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001091 WebRtcVideoEngine engine(
1092 (std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001093 (std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001094 const webrtc::SdpVideoFormat vp8_format("VP8");
1095 const std::vector<webrtc::SdpVideoFormat> supported_formats = {vp8_format};
1096 EXPECT_CALL(*encoder_factory, GetSupportedFormats())
Mirko Bonadei6a489f22019-04-09 15:11:12 +02001097 .WillRepeatedly(::testing::Return(supported_formats));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001098
1099 // Verify the codecs from the engine.
1100 const std::vector<VideoCodec> engine_codecs = engine.codecs();
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +01001101 // Verify default codecs has been added correctly.
1102 EXPECT_EQ(5u, engine_codecs.size());
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001103 EXPECT_EQ("VP8", engine_codecs.at(0).name);
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +01001104
1105 // RTX codec for VP8.
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001106 EXPECT_EQ("rtx", engine_codecs.at(1).name);
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +01001107 int vp8_associated_payload;
1108 EXPECT_TRUE(engine_codecs.at(1).GetParam(kCodecParamAssociatedPayloadType,
1109 &vp8_associated_payload));
1110 EXPECT_EQ(vp8_associated_payload, engine_codecs.at(0).id);
1111
1112 EXPECT_EQ(kRedCodecName, engine_codecs.at(2).name);
1113
1114 // RTX codec for RED.
1115 EXPECT_EQ("rtx", engine_codecs.at(3).name);
1116 int red_associated_payload;
1117 EXPECT_TRUE(engine_codecs.at(3).GetParam(kCodecParamAssociatedPayloadType,
1118 &red_associated_payload));
1119 EXPECT_EQ(red_associated_payload, engine_codecs.at(2).id);
1120
1121 EXPECT_EQ(kUlpfecCodecName, engine_codecs.at(4).name);
1122
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001123 int associated_payload_type;
1124 EXPECT_TRUE(engine_codecs.at(1).GetParam(
1125 cricket::kCodecParamAssociatedPayloadType, &associated_payload_type));
1126 EXPECT_EQ(engine_codecs.at(0).id, associated_payload_type);
1127 // Verify default parameters has been added to the VP8 codec.
Elad Alonfadb1812019-05-24 13:40:02 +02001128 VerifyCodecHasDefaultFeedbackParams(engine_codecs.at(0),
1129 /*lntf_expected=*/false);
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001130
1131 // Mock encoder creation. |engine| take ownership of the encoder.
Mirta Dvornicic1ec2a162018-12-10 09:47:34 +00001132 webrtc::VideoEncoderFactory::CodecInfo codec_info;
1133 codec_info.is_hardware_accelerated = false;
1134 codec_info.has_internal_source = false;
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001135 const webrtc::SdpVideoFormat format("VP8");
Mirta Dvornicic1ec2a162018-12-10 09:47:34 +00001136 EXPECT_CALL(*encoder_factory, QueryVideoEncoder(format))
Mirko Bonadei6a489f22019-04-09 15:11:12 +02001137 .WillRepeatedly(::testing::Return(codec_info));
Anders Carlsson67537952018-05-03 11:28:29 +02001138 FakeWebRtcVideoEncoder* const encoder = new FakeWebRtcVideoEncoder(nullptr);
Niels Möllerc572ff32018-11-07 08:43:50 +01001139 rtc::Event encoder_created;
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001140 EXPECT_CALL(*encoder_factory, CreateVideoEncoderProxy(format))
Niels Möller4db138e2018-04-19 09:04:13 +02001141 .WillOnce(
1142 ::testing::DoAll(::testing::InvokeWithoutArgs(
1143 [&encoder_created]() { encoder_created.Set(); }),
1144 ::testing::Return(encoder)));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001145
1146 // Mock decoder creation. |engine| take ownership of the decoder.
Anders Carlsson67537952018-05-03 11:28:29 +02001147 FakeWebRtcVideoDecoder* const decoder = new FakeWebRtcVideoDecoder(nullptr);
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001148 EXPECT_CALL(*decoder_factory, CreateVideoDecoderProxy(format))
Mirko Bonadei6a489f22019-04-09 15:11:12 +02001149 .WillOnce(::testing::Return(decoder));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001150
1151 // Create a call.
Danil Chapovalov83bbe912019-08-07 12:24:53 +02001152 webrtc::RtcEventLogNull event_log;
Danil Chapovalov53d45ba2019-07-03 14:56:33 +02001153 auto task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
1154 webrtc::Call::Config call_config(&event_log);
1155 call_config.task_queue_factory = task_queue_factory.get();
1156 const auto call = absl::WrapUnique(webrtc::Call::Create(call_config));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001157
1158 // Create send channel.
1159 const int send_ssrc = 123;
Sebastian Jansson84848f22018-11-16 10:40:36 +01001160 std::unique_ptr<VideoMediaChannel> send_channel(engine.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001161 call.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
1162 rate_allocator_factory.get()));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001163 cricket::VideoSendParameters send_parameters;
1164 send_parameters.codecs.push_back(engine_codecs.at(0));
1165 EXPECT_TRUE(send_channel->SetSendParameters(send_parameters));
1166 send_channel->OnReadyToSend(true);
1167 EXPECT_TRUE(
1168 send_channel->AddSendStream(StreamParams::CreateLegacy(send_ssrc)));
1169 EXPECT_TRUE(send_channel->SetSend(true));
1170
Niels Möller4db138e2018-04-19 09:04:13 +02001171 // Set capturer.
Niels Möller805a27e2019-01-21 12:21:27 +01001172 webrtc::test::FrameForwarder frame_forwarder;
1173 cricket::FakeFrameSource frame_source(1280, 720,
1174 rtc::kNumMicrosecsPerSec / 30);
1175 EXPECT_TRUE(send_channel->SetVideoSend(send_ssrc, nullptr, &frame_forwarder));
Niels Möller4db138e2018-04-19 09:04:13 +02001176 // Sending one frame will allocate the encoder.
Niels Möller805a27e2019-01-21 12:21:27 +01001177 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Niels Möller4db138e2018-04-19 09:04:13 +02001178 encoder_created.Wait(kTimeout);
1179
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001180 // Create recv channel.
1181 const int recv_ssrc = 321;
Sebastian Jansson84848f22018-11-16 10:40:36 +01001182 std::unique_ptr<VideoMediaChannel> recv_channel(engine.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001183 call.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
1184 rate_allocator_factory.get()));
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001185 cricket::VideoRecvParameters recv_parameters;
1186 recv_parameters.codecs.push_back(engine_codecs.at(0));
1187 EXPECT_TRUE(recv_channel->SetRecvParameters(recv_parameters));
1188 EXPECT_TRUE(recv_channel->AddRecvStream(
1189 cricket::StreamParams::CreateLegacy(recv_ssrc)));
1190
1191 // Remove streams previously added to free the encoder and decoder instance.
1192 EXPECT_CALL(*encoder_factory, Die());
1193 EXPECT_CALL(*decoder_factory, Die());
Jiawei Ouc2ebe212018-11-08 10:02:56 -08001194 EXPECT_CALL(*rate_allocator_factory, Die());
Magnus Jedvertd4b0c052017-09-14 10:24:54 +02001195 EXPECT_TRUE(send_channel->RemoveSendStream(send_ssrc));
1196 EXPECT_TRUE(recv_channel->RemoveRecvStream(recv_ssrc));
1197}
1198
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001199// Test behavior when decoder factory fails to create a decoder (returns null).
1200TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullDecoder) {
1201 // |engine| take ownership of the factories.
1202 webrtc::MockVideoEncoderFactory* encoder_factory =
Jiawei Ouc2ebe212018-11-08 10:02:56 -08001203 new webrtc::MockVideoEncoderFactory();
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001204 webrtc::MockVideoDecoderFactory* decoder_factory =
Jiawei Ouc2ebe212018-11-08 10:02:56 -08001205 new webrtc::MockVideoDecoderFactory();
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001206 std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory>
1207 rate_allocator_factory =
Mirko Bonadei317a1f02019-09-17 17:06:18 +02001208 std::make_unique<webrtc::MockVideoBitrateAllocatorFactory>();
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001209 WebRtcVideoEngine engine(
1210 (std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001211 (std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001212 const webrtc::SdpVideoFormat vp8_format("VP8");
1213 const std::vector<webrtc::SdpVideoFormat> supported_formats = {vp8_format};
1214 EXPECT_CALL(*encoder_factory, GetSupportedFormats())
Mirko Bonadei6a489f22019-04-09 15:11:12 +02001215 .WillRepeatedly(::testing::Return(supported_formats));
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001216
1217 // Decoder creation fails.
Mirko Bonadei6a489f22019-04-09 15:11:12 +02001218 EXPECT_CALL(*decoder_factory, CreateVideoDecoderProxy(::testing::_))
1219 .WillOnce(::testing::Return(nullptr));
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001220
1221 // Create a call.
Danil Chapovalov83bbe912019-08-07 12:24:53 +02001222 webrtc::RtcEventLogNull event_log;
Danil Chapovalov53d45ba2019-07-03 14:56:33 +02001223 auto task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
1224 webrtc::Call::Config call_config(&event_log);
1225 call_config.task_queue_factory = task_queue_factory.get();
1226 const auto call = absl::WrapUnique(webrtc::Call::Create(call_config));
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001227
1228 // Create recv channel.
1229 const int recv_ssrc = 321;
Sebastian Jansson84848f22018-11-16 10:40:36 +01001230 std::unique_ptr<VideoMediaChannel> recv_channel(engine.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001231 call.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
1232 rate_allocator_factory.get()));
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01001233 cricket::VideoRecvParameters recv_parameters;
1234 recv_parameters.codecs.push_back(engine.codecs().front());
1235 EXPECT_TRUE(recv_channel->SetRecvParameters(recv_parameters));
1236 EXPECT_TRUE(recv_channel->AddRecvStream(
1237 cricket::StreamParams::CreateLegacy(recv_ssrc)));
1238
1239 // Remove streams previously added to free the encoder and decoder instance.
1240 EXPECT_TRUE(recv_channel->RemoveRecvStream(recv_ssrc));
1241}
1242
eladalonf1841382017-06-12 01:16:46 -07001243TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001244 encoder_factory_->AddSupportedVideoCodecType("VP8");
Sebastian Jansson8f83b422018-02-21 13:07:13 +01001245 std::unique_ptr<FakeCall> fake_call(new FakeCall());
Anders Carlsson5f2bb622018-05-14 09:48:06 +02001246 std::unique_ptr<VideoMediaChannel> channel(
1247 SetSendParamsWithAllSupportedCodecs());
sprangf24a0642017-02-28 13:23:26 -08001248 ASSERT_TRUE(
1249 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
1250 cricket::VideoCodec codec = GetEngineCodec("VP8");
1251 cricket::VideoSendParameters parameters;
1252 parameters.codecs.push_back(codec);
1253 channel->OnReadyToSend(true);
1254 channel->SetSend(true);
1255 ASSERT_TRUE(channel->SetSendParameters(parameters));
1256
Niels Möller805a27e2019-01-21 12:21:27 +01001257 webrtc::test::FrameForwarder frame_forwarder;
1258 cricket::FakeFrameSource frame_source(1280, 720,
1259 rtc::kNumMicrosecsPerSec / 30);
sprangf24a0642017-02-28 13:23:26 -08001260 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01001261 EXPECT_TRUE(channel->SetVideoSend(kSsrc, &options, &frame_forwarder));
sprangf24a0642017-02-28 13:23:26 -08001262
Niels Möller805a27e2019-01-21 12:21:27 +01001263 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001264 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(1));
Niels Möllere3cf3d02018-06-13 11:52:16 +02001265 EXPECT_EQ(webrtc::VideoCodecMode::kRealtimeVideo,
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001266 encoder_factory_->encoders().back()->GetCodecSettings().mode);
sprangf24a0642017-02-28 13:23:26 -08001267
Niels Möller805a27e2019-01-21 12:21:27 +01001268 EXPECT_TRUE(channel->SetVideoSend(kSsrc, &options, &frame_forwarder));
1269 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
sprangf24a0642017-02-28 13:23:26 -08001270 // No change in content type, keep current encoder.
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001271 EXPECT_EQ(1, encoder_factory_->GetNumCreatedEncoders());
sprangf24a0642017-02-28 13:23:26 -08001272
1273 options.is_screencast.emplace(true);
Niels Möller805a27e2019-01-21 12:21:27 +01001274 EXPECT_TRUE(channel->SetVideoSend(kSsrc, &options, &frame_forwarder));
1275 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
sprangf24a0642017-02-28 13:23:26 -08001276 // Change to screen content, recreate encoder. For the simulcast encoder
1277 // adapter case, this will result in two calls since InitEncode triggers a
1278 // a new instance.
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001279 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(2));
Niels Möllere3cf3d02018-06-13 11:52:16 +02001280 EXPECT_EQ(webrtc::VideoCodecMode::kScreensharing,
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001281 encoder_factory_->encoders().back()->GetCodecSettings().mode);
sprangf24a0642017-02-28 13:23:26 -08001282
Niels Möller805a27e2019-01-21 12:21:27 +01001283 EXPECT_TRUE(channel->SetVideoSend(kSsrc, &options, &frame_forwarder));
1284 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
sprangf24a0642017-02-28 13:23:26 -08001285 // Still screen content, no need to update encoder.
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001286 EXPECT_EQ(2, encoder_factory_->GetNumCreatedEncoders());
sprangf24a0642017-02-28 13:23:26 -08001287
1288 options.is_screencast.emplace(false);
1289 options.video_noise_reduction.emplace(false);
Niels Möller805a27e2019-01-21 12:21:27 +01001290 EXPECT_TRUE(channel->SetVideoSend(kSsrc, &options, &frame_forwarder));
sprangf24a0642017-02-28 13:23:26 -08001291 // Change back to regular video content, update encoder. Also change
1292 // a non |is_screencast| option just to verify it doesn't affect recreation.
Niels Möller805a27e2019-01-21 12:21:27 +01001293 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001294 ASSERT_TRUE(encoder_factory_->WaitForCreatedVideoEncoders(3));
Niels Möllere3cf3d02018-06-13 11:52:16 +02001295 EXPECT_EQ(webrtc::VideoCodecMode::kRealtimeVideo,
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001296 encoder_factory_->encoders().back()->GetCodecSettings().mode);
sprangf24a0642017-02-28 13:23:26 -08001297
1298 // Remove stream previously added to free the external encoder instance.
1299 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
Magnus Jedvert02e7a192017-09-23 17:21:32 +02001300 EXPECT_EQ(0u, encoder_factory_->encoders().size());
sprangf24a0642017-02-28 13:23:26 -08001301}
1302
Mirko Bonadei6a489f22019-04-09 15:11:12 +02001303class WebRtcVideoChannelBaseTest : public ::testing::Test {
Niels Möller6557d0c2018-04-11 15:18:34 +02001304 protected:
1305 WebRtcVideoChannelBaseTest()
Danil Chapovalov53d45ba2019-07-03 14:56:33 +02001306 : task_queue_factory_(webrtc::CreateDefaultTaskQueueFactory()),
1307 video_bitrate_allocator_factory_(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001308 webrtc::CreateBuiltinVideoBitrateAllocatorFactory()),
1309 engine_(webrtc::CreateBuiltinVideoEncoderFactory(),
1310 webrtc::CreateBuiltinVideoDecoderFactory()) {}
Niels Möller6557d0c2018-04-11 15:18:34 +02001311
1312 virtual void SetUp() {
Jonas Oreland49ac5952018-09-26 16:04:32 +02001313 // One testcase calls SetUp in a loop, only create call_ once.
1314 if (!call_) {
Danil Chapovalov53d45ba2019-07-03 14:56:33 +02001315 webrtc::Call::Config call_config(&event_log_);
1316 call_config.task_queue_factory = task_queue_factory_.get();
1317 call_.reset(webrtc::Call::Create(call_config));
Jonas Oreland49ac5952018-09-26 16:04:32 +02001318 }
Niels Möller6557d0c2018-04-11 15:18:34 +02001319 cricket::MediaConfig media_config;
1320 // Disabling cpu overuse detection actually disables quality scaling too; it
1321 // implies DegradationPreference kMaintainResolution. Automatic scaling
1322 // needs to be disabled, otherwise, tests which check the size of received
1323 // frames become flaky.
1324 media_config.video.enable_cpu_adaptation = false;
Sebastian Jansson84848f22018-11-16 10:40:36 +01001325 channel_.reset(
1326 static_cast<cricket::WebRtcVideoChannel*>(engine_.CreateMediaChannel(
1327 call_.get(), media_config, cricket::VideoOptions(),
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001328 webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get())));
Niels Möller6557d0c2018-04-11 15:18:34 +02001329 channel_->OnReadyToSend(true);
1330 EXPECT_TRUE(channel_.get() != NULL);
1331 network_interface_.SetDestination(channel_.get());
Anton Sukhanov4f08faa2019-05-21 11:12:57 -07001332 channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig());
Niels Möller6557d0c2018-04-11 15:18:34 +02001333 cricket::VideoRecvParameters parameters;
1334 parameters.codecs = engine_.codecs();
1335 channel_->SetRecvParameters(parameters);
1336 EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams()));
Mirko Bonadei317a1f02019-09-17 17:06:18 +02001337 frame_forwarder_ = std::make_unique<webrtc::test::FrameForwarder>();
1338 frame_source_ = std::make_unique<cricket::FakeFrameSource>(
Niels Möller805a27e2019-01-21 12:21:27 +01001339 640, 480, rtc::kNumMicrosecsPerSec / kFramerate);
1340 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, frame_forwarder_.get()));
Niels Möller6557d0c2018-04-11 15:18:34 +02001341 }
1342
1343 // Utility method to setup an additional stream to send and receive video.
1344 // Used to test send and recv between two streams.
1345 void SetUpSecondStream() {
1346 SetUpSecondStreamWithNoRecv();
1347 // Setup recv for second stream.
1348 EXPECT_TRUE(channel_->AddRecvStream(
1349 cricket::StreamParams::CreateLegacy(kSsrc + 2)));
1350 // Make the second renderer available for use by a new stream.
1351 EXPECT_TRUE(channel_->SetSink(kSsrc + 2, &renderer2_));
1352 }
1353 // Setup an additional stream just to send video. Defer add recv stream.
1354 // This is required if you want to test unsignalled recv of video rtp packets.
1355 void SetUpSecondStreamWithNoRecv() {
1356 // SetUp() already added kSsrc make sure duplicate SSRCs cant be added.
Yves Gerey665174f2018-06-19 15:03:05 +02001357 EXPECT_TRUE(
1358 channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Niels Möller6557d0c2018-04-11 15:18:34 +02001359 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_));
Yves Gerey665174f2018-06-19 15:03:05 +02001360 EXPECT_FALSE(
1361 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Niels Möller6557d0c2018-04-11 15:18:34 +02001362 EXPECT_TRUE(channel_->AddSendStream(
1363 cricket::StreamParams::CreateLegacy(kSsrc + 2)));
1364 // We dont add recv for the second stream.
1365
1366 // Setup the receive and renderer for second stream after send.
Mirko Bonadei317a1f02019-09-17 17:06:18 +02001367 frame_forwarder_2_ = std::make_unique<webrtc::test::FrameForwarder>();
Yves Gerey665174f2018-06-19 15:03:05 +02001368 EXPECT_TRUE(
Niels Möller805a27e2019-01-21 12:21:27 +01001369 channel_->SetVideoSend(kSsrc + 2, nullptr, frame_forwarder_2_.get()));
Niels Möller6557d0c2018-04-11 15:18:34 +02001370 }
Yves Gerey665174f2018-06-19 15:03:05 +02001371 virtual void TearDown() { channel_.reset(); }
1372 bool SetDefaultCodec() { return SetOneCodec(DefaultCodec()); }
Niels Möller6557d0c2018-04-11 15:18:34 +02001373
1374 bool SetOneCodec(const cricket::VideoCodec& codec) {
Mirko Bonadei317a1f02019-09-17 17:06:18 +02001375 frame_source_ = std::make_unique<cricket::FakeFrameSource>(
Niels Möller805a27e2019-01-21 12:21:27 +01001376 kVideoWidth, kVideoHeight, rtc::kNumMicrosecsPerSec / kFramerate);
Niels Möller6557d0c2018-04-11 15:18:34 +02001377
1378 bool sending = channel_->sending();
1379 bool success = SetSend(false);
1380 if (success) {
1381 cricket::VideoSendParameters parameters;
1382 parameters.codecs.push_back(codec);
1383 success = channel_->SetSendParameters(parameters);
1384 }
1385 if (success) {
1386 success = SetSend(sending);
1387 }
1388 return success;
1389 }
Yves Gerey665174f2018-06-19 15:03:05 +02001390 bool SetSend(bool send) { return channel_->SetSend(send); }
Niels Möller805a27e2019-01-21 12:21:27 +01001391 void SendFrame() {
1392 if (frame_forwarder_2_) {
1393 frame_forwarder_2_->IncomingCapturedFrame(frame_source_->GetFrame());
Niels Möller6557d0c2018-04-11 15:18:34 +02001394 }
Niels Möller805a27e2019-01-21 12:21:27 +01001395 frame_forwarder_->IncomingCapturedFrame(frame_source_->GetFrame());
Niels Möller6557d0c2018-04-11 15:18:34 +02001396 }
1397 bool WaitAndSendFrame(int wait_ms) {
1398 bool ret = rtc::Thread::Current()->ProcessMessages(wait_ms);
Niels Möller805a27e2019-01-21 12:21:27 +01001399 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001400 return ret;
1401 }
Yves Gerey665174f2018-06-19 15:03:05 +02001402 int NumRtpBytes() { return network_interface_.NumRtpBytes(); }
Niels Möller6557d0c2018-04-11 15:18:34 +02001403 int NumRtpBytes(uint32_t ssrc) {
1404 return network_interface_.NumRtpBytes(ssrc);
1405 }
Yves Gerey665174f2018-06-19 15:03:05 +02001406 int NumRtpPackets() { return network_interface_.NumRtpPackets(); }
Niels Möller6557d0c2018-04-11 15:18:34 +02001407 int NumRtpPackets(uint32_t ssrc) {
1408 return network_interface_.NumRtpPackets(ssrc);
1409 }
Yves Gerey665174f2018-06-19 15:03:05 +02001410 int NumSentSsrcs() { return network_interface_.NumSentSsrcs(); }
Niels Möller6557d0c2018-04-11 15:18:34 +02001411 const rtc::CopyOnWriteBuffer* GetRtpPacket(int index) {
1412 return network_interface_.GetRtpPacket(index);
1413 }
1414 static int GetPayloadType(const rtc::CopyOnWriteBuffer* p) {
Åsa Persson23cd45a2018-07-03 10:40:40 +02001415 webrtc::RTPHeader header;
1416 EXPECT_TRUE(ParseRtpPacket(p, &header));
1417 return header.payloadType;
Niels Möller6557d0c2018-04-11 15:18:34 +02001418 }
Åsa Persson23cd45a2018-07-03 10:40:40 +02001419
Niels Möller6557d0c2018-04-11 15:18:34 +02001420 static bool ParseRtpPacket(const rtc::CopyOnWriteBuffer* p,
Åsa Persson23cd45a2018-07-03 10:40:40 +02001421 webrtc::RTPHeader* header) {
1422 std::unique_ptr<webrtc::RtpHeaderParser> parser(
Tommi25eb47c2019-08-29 16:39:05 +02001423 webrtc::RtpHeaderParser::CreateForTest());
Åsa Persson23cd45a2018-07-03 10:40:40 +02001424 return parser->Parse(p->cdata(), p->size(), header);
Niels Möller6557d0c2018-04-11 15:18:34 +02001425 }
1426
1427 // Tests that we can send and receive frames.
1428 void SendAndReceive(const cricket::VideoCodec& codec) {
1429 EXPECT_TRUE(SetOneCodec(codec));
1430 EXPECT_TRUE(SetSend(true));
1431 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
1432 EXPECT_EQ(0, renderer_.num_rendered_frames());
Niels Möller805a27e2019-01-21 12:21:27 +01001433 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001434 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
1435 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0));
1436 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
1437 }
1438
1439 void SendReceiveManyAndGetStats(const cricket::VideoCodec& codec,
Yves Gerey665174f2018-06-19 15:03:05 +02001440 int duration_sec,
1441 int fps) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001442 EXPECT_TRUE(SetOneCodec(codec));
1443 EXPECT_TRUE(SetSend(true));
1444 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
1445 EXPECT_EQ(0, renderer_.num_rendered_frames());
1446 for (int i = 0; i < duration_sec; ++i) {
1447 for (int frame = 1; frame <= fps; ++frame) {
1448 EXPECT_TRUE(WaitAndSendFrame(1000 / fps));
1449 EXPECT_FRAME_WAIT(frame + i * fps, kVideoWidth, kVideoHeight, kTimeout);
1450 }
1451 }
1452 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0));
1453 EXPECT_EQ(codec.id, GetPayloadType(p.get()));
1454 }
1455
Niels Möller6557d0c2018-04-11 15:18:34 +02001456 cricket::VideoSenderInfo GetSenderStats(size_t i) {
1457 cricket::VideoMediaInfo info;
1458 EXPECT_TRUE(channel_->GetStats(&info));
1459 return info.senders[i];
1460 }
1461
1462 cricket::VideoReceiverInfo GetReceiverStats(size_t i) {
1463 cricket::VideoMediaInfo info;
1464 EXPECT_TRUE(channel_->GetStats(&info));
1465 return info.receivers[i];
1466 }
1467
1468 // Two streams one channel tests.
1469
1470 // Tests that we can send and receive frames.
1471 void TwoStreamsSendAndReceive(const cricket::VideoCodec& codec) {
1472 SetUpSecondStream();
1473 // Test sending and receiving on first stream.
1474 SendAndReceive(codec);
1475 // Test sending and receiving on second stream.
1476 EXPECT_EQ_WAIT(1, renderer2_.num_rendered_frames(), kTimeout);
1477 EXPECT_GT(NumRtpPackets(), 0);
1478 EXPECT_EQ(1, renderer2_.num_rendered_frames());
1479 }
1480
1481 cricket::VideoCodec GetEngineCodec(const std::string& name) {
1482 for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
Niels Möller039743e2018-10-23 10:07:25 +02001483 if (absl::EqualsIgnoreCase(name, engine_codec.name))
Niels Möller6557d0c2018-04-11 15:18:34 +02001484 return engine_codec;
1485 }
1486 // This point should never be reached.
1487 ADD_FAILURE() << "Unrecognized codec name: " << name;
1488 return cricket::VideoCodec();
1489 }
1490
1491 cricket::VideoCodec DefaultCodec() { return GetEngineCodec("VP8"); }
1492
1493 cricket::StreamParams DefaultSendStreamParams() {
1494 return cricket::StreamParams::CreateLegacy(kSsrc);
1495 }
1496
Danil Chapovalov83bbe912019-08-07 12:24:53 +02001497 webrtc::RtcEventLogNull event_log_;
Danil Chapovalov53d45ba2019-07-03 14:56:33 +02001498 std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
Jonas Oreland49ac5952018-09-26 16:04:32 +02001499 std::unique_ptr<webrtc::Call> call_;
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02001500 std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
1501 video_bitrate_allocator_factory_;
Niels Möller6557d0c2018-04-11 15:18:34 +02001502 WebRtcVideoEngine engine_;
Niels Möller805a27e2019-01-21 12:21:27 +01001503
1504 std::unique_ptr<cricket::FakeFrameSource> frame_source_;
1505 std::unique_ptr<webrtc::test::FrameForwarder> frame_forwarder_;
1506 std::unique_ptr<webrtc::test::FrameForwarder> frame_forwarder_2_;
1507
Niels Möller6557d0c2018-04-11 15:18:34 +02001508 std::unique_ptr<WebRtcVideoChannel> channel_;
1509 cricket::FakeNetworkInterface network_interface_;
1510 cricket::FakeVideoRenderer renderer_;
1511
1512 // Used by test cases where 2 streams are run on the same channel.
1513 cricket::FakeVideoRenderer renderer2_;
1514};
1515
1516// Test that SetSend works.
srtee0c2eea2017-12-15 17:44:33 +01001517TEST_F(WebRtcVideoChannelBaseTest, SetSend) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001518 EXPECT_FALSE(channel_->sending());
Niels Möller805a27e2019-01-21 12:21:27 +01001519 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, frame_forwarder_.get()));
Niels Möller6557d0c2018-04-11 15:18:34 +02001520 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1521 EXPECT_FALSE(channel_->sending());
1522 EXPECT_TRUE(SetSend(true));
1523 EXPECT_TRUE(channel_->sending());
Niels Möller805a27e2019-01-21 12:21:27 +01001524 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001525 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
1526 EXPECT_TRUE(SetSend(false));
1527 EXPECT_FALSE(channel_->sending());
srtee0c2eea2017-12-15 17:44:33 +01001528}
Niels Möller6557d0c2018-04-11 15:18:34 +02001529
1530// Test that SetSend fails without codecs being set.
srtee0c2eea2017-12-15 17:44:33 +01001531TEST_F(WebRtcVideoChannelBaseTest, SetSendWithoutCodecs) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001532 EXPECT_FALSE(channel_->sending());
1533 EXPECT_FALSE(SetSend(true));
1534 EXPECT_FALSE(channel_->sending());
srtee0c2eea2017-12-15 17:44:33 +01001535}
Niels Möller6557d0c2018-04-11 15:18:34 +02001536
1537// Test that we properly set the send and recv buffer sizes by the time
1538// SetSend is called.
srtee0c2eea2017-12-15 17:44:33 +01001539TEST_F(WebRtcVideoChannelBaseTest, SetSendSetsTransportBufferSizes) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001540 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1541 EXPECT_TRUE(SetSend(true));
1542 EXPECT_EQ(64 * 1024, network_interface_.sendbuf_size());
Johannes Krond38a2b82018-10-23 11:31:19 +02001543 EXPECT_EQ(256 * 1024, network_interface_.recvbuf_size());
Erik Språng820ebd02018-08-20 17:14:25 +02001544}
1545
Johannes Kron5a0665b2019-04-08 10:35:50 +02001546// Test that we properly set the send and recv buffer sizes when overriding
1547// via field trials.
1548TEST_F(WebRtcVideoChannelBaseTest, OverridesRecvBufferSize) {
1549 // Set field trial to override the default recv buffer size, and then re-run
1550 // setup where the interface is created and configured.
1551 const int kCustomRecvBufferSize = 123456;
1552 webrtc::test::ScopedFieldTrials field_trial(
1553 "WebRTC-IncreasedReceivebuffers/123456/");
1554 SetUp();
1555
1556 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1557 EXPECT_TRUE(SetSend(true));
1558 EXPECT_EQ(64 * 1024, network_interface_.sendbuf_size());
1559 EXPECT_EQ(kCustomRecvBufferSize, network_interface_.recvbuf_size());
1560}
1561
1562// Test that we properly set the send and recv buffer sizes when overriding
1563// via field trials with suffix.
1564TEST_F(WebRtcVideoChannelBaseTest, OverridesRecvBufferSizeWithSuffix) {
1565 // Set field trial to override the default recv buffer size, and then re-run
1566 // setup where the interface is created and configured.
1567 const int kCustomRecvBufferSize = 123456;
1568 webrtc::test::ScopedFieldTrials field_trial(
1569 "WebRTC-IncreasedReceivebuffers/123456_Dogfood/");
1570 SetUp();
1571
1572 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1573 EXPECT_TRUE(SetSend(true));
1574 EXPECT_EQ(64 * 1024, network_interface_.sendbuf_size());
1575 EXPECT_EQ(kCustomRecvBufferSize, network_interface_.recvbuf_size());
1576}
1577
1578// Test that we properly set the send and recv buffer sizes when overriding
1579// via field trials that don't make any sense.
1580TEST_F(WebRtcVideoChannelBaseTest, InvalidRecvBufferSize) {
1581 // Set bogus field trial values to override the default recv buffer size, and
1582 // then re-run setup where the interface is created and configured. The
1583 // default value should still be used.
1584
1585 for (std::string group : {" ", "NotANumber", "-1", "0"}) {
1586 std::string field_trial_string = "WebRTC-IncreasedReceivebuffers/";
1587 field_trial_string += group;
1588 field_trial_string += "/";
1589 webrtc::test::ScopedFieldTrials field_trial(field_trial_string);
1590 SetUp();
1591
1592 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1593 EXPECT_TRUE(SetSend(true));
1594 EXPECT_EQ(64 * 1024, network_interface_.sendbuf_size());
1595 EXPECT_EQ(256 * 1024, network_interface_.recvbuf_size());
1596 }
1597}
1598
Niels Möller6557d0c2018-04-11 15:18:34 +02001599// Test that stats work properly for a 1-1 call.
srtee0c2eea2017-12-15 17:44:33 +01001600TEST_F(WebRtcVideoChannelBaseTest, GetStats) {
Bjorn A Mellemda4f0932019-07-30 08:34:03 -07001601 webrtc::test::ScopedFieldTrials field_trials(
1602 "WebRTC-UseStandardBytesStats/Enabled/");
1603 SetUp();
1604
Niels Möller6557d0c2018-04-11 15:18:34 +02001605 const int kDurationSec = 3;
1606 const int kFps = 10;
1607 SendReceiveManyAndGetStats(DefaultCodec(), kDurationSec, kFps);
1608
1609 cricket::VideoMediaInfo info;
1610 EXPECT_TRUE(channel_->GetStats(&info));
1611
1612 ASSERT_EQ(1U, info.senders.size());
1613 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload?
1614 // For webrtc, bytes_sent does not include the RTP header length.
Bjorn A Mellemda4f0932019-07-30 08:34:03 -07001615 EXPECT_EQ(info.senders[0].bytes_sent,
1616 NumRtpBytes() - kRtpHeaderSize * NumRtpPackets());
Niels Möller6557d0c2018-04-11 15:18:34 +02001617 EXPECT_EQ(NumRtpPackets(), info.senders[0].packets_sent);
1618 EXPECT_EQ(0.0, info.senders[0].fraction_lost);
1619 ASSERT_TRUE(info.senders[0].codec_payload_type);
1620 EXPECT_EQ(DefaultCodec().id, *info.senders[0].codec_payload_type);
1621 EXPECT_EQ(0, info.senders[0].firs_rcvd);
1622 EXPECT_EQ(0, info.senders[0].plis_rcvd);
1623 EXPECT_EQ(0, info.senders[0].nacks_rcvd);
1624 EXPECT_EQ(kVideoWidth, info.senders[0].send_frame_width);
1625 EXPECT_EQ(kVideoHeight, info.senders[0].send_frame_height);
1626 EXPECT_GT(info.senders[0].framerate_input, 0);
1627 EXPECT_GT(info.senders[0].framerate_sent, 0);
1628
1629 EXPECT_EQ(1U, info.send_codecs.count(DefaultCodec().id));
1630 EXPECT_EQ(DefaultCodec().ToCodecParameters(),
1631 info.send_codecs[DefaultCodec().id]);
1632
1633 ASSERT_EQ(1U, info.receivers.size());
1634 EXPECT_EQ(1U, info.senders[0].ssrcs().size());
1635 EXPECT_EQ(1U, info.receivers[0].ssrcs().size());
1636 EXPECT_EQ(info.senders[0].ssrcs()[0], info.receivers[0].ssrcs()[0]);
1637 ASSERT_TRUE(info.receivers[0].codec_payload_type);
1638 EXPECT_EQ(DefaultCodec().id, *info.receivers[0].codec_payload_type);
Bjorn A Mellemda4f0932019-07-30 08:34:03 -07001639 EXPECT_EQ(NumRtpBytes() - kRtpHeaderSize * NumRtpPackets(),
1640 info.receivers[0].bytes_rcvd);
Niels Möller6557d0c2018-04-11 15:18:34 +02001641 EXPECT_EQ(NumRtpPackets(), info.receivers[0].packets_rcvd);
Niels Möller6557d0c2018-04-11 15:18:34 +02001642 EXPECT_EQ(0, info.receivers[0].packets_lost);
1643 // TODO(asapersson): Not set for webrtc. Handle missing stats.
1644 // EXPECT_EQ(0, info.receivers[0].packets_concealed);
1645 EXPECT_EQ(0, info.receivers[0].firs_sent);
1646 EXPECT_EQ(0, info.receivers[0].plis_sent);
1647 EXPECT_EQ(0, info.receivers[0].nacks_sent);
1648 EXPECT_EQ(kVideoWidth, info.receivers[0].frame_width);
1649 EXPECT_EQ(kVideoHeight, info.receivers[0].frame_height);
1650 EXPECT_GT(info.receivers[0].framerate_rcvd, 0);
1651 EXPECT_GT(info.receivers[0].framerate_decoded, 0);
1652 EXPECT_GT(info.receivers[0].framerate_output, 0);
1653
1654 EXPECT_EQ(1U, info.receive_codecs.count(DefaultCodec().id));
1655 EXPECT_EQ(DefaultCodec().ToCodecParameters(),
1656 info.receive_codecs[DefaultCodec().id]);
srtee0c2eea2017-12-15 17:44:33 +01001657}
Niels Möller6557d0c2018-04-11 15:18:34 +02001658
1659// Test that stats work properly for a conf call with multiple recv streams.
srtee0c2eea2017-12-15 17:44:33 +01001660TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleRecvStreams) {
Bjorn A Mellemda4f0932019-07-30 08:34:03 -07001661 webrtc::test::ScopedFieldTrials field_trials(
1662 "WebRTC-UseStandardBytesStats/Enabled/");
1663 SetUp();
1664
Niels Möller6557d0c2018-04-11 15:18:34 +02001665 cricket::FakeVideoRenderer renderer1, renderer2;
1666 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1667 cricket::VideoSendParameters parameters;
1668 parameters.codecs.push_back(DefaultCodec());
1669 parameters.conference_mode = true;
1670 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1671 EXPECT_TRUE(SetSend(true));
Yves Gerey665174f2018-06-19 15:03:05 +02001672 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
1673 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
Niels Möller6557d0c2018-04-11 15:18:34 +02001674 EXPECT_TRUE(channel_->SetSink(1, &renderer1));
1675 EXPECT_TRUE(channel_->SetSink(2, &renderer2));
1676 EXPECT_EQ(0, renderer1.num_rendered_frames());
1677 EXPECT_EQ(0, renderer2.num_rendered_frames());
1678 std::vector<uint32_t> ssrcs;
1679 ssrcs.push_back(1);
1680 ssrcs.push_back(2);
1681 network_interface_.SetConferenceMode(true, ssrcs);
Niels Möller805a27e2019-01-21 12:21:27 +01001682 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001683 EXPECT_FRAME_ON_RENDERER_WAIT(renderer1, 1, kVideoWidth, kVideoHeight,
1684 kTimeout);
1685 EXPECT_FRAME_ON_RENDERER_WAIT(renderer2, 1, kVideoWidth, kVideoHeight,
1686 kTimeout);
1687
1688 EXPECT_TRUE(channel_->SetSend(false));
1689
1690 cricket::VideoMediaInfo info;
1691 EXPECT_TRUE(channel_->GetStats(&info));
1692 ASSERT_EQ(1U, info.senders.size());
1693 // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload?
1694 // For webrtc, bytes_sent does not include the RTP header length.
Bjorn A Mellemda4f0932019-07-30 08:34:03 -07001695 EXPECT_EQ_WAIT(NumRtpBytes() - kRtpHeaderSize * NumRtpPackets(),
1696 GetSenderStats(0).bytes_sent, kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02001697 EXPECT_EQ_WAIT(NumRtpPackets(), GetSenderStats(0).packets_sent, kTimeout);
1698 EXPECT_EQ(kVideoWidth, GetSenderStats(0).send_frame_width);
1699 EXPECT_EQ(kVideoHeight, GetSenderStats(0).send_frame_height);
1700
1701 ASSERT_EQ(2U, info.receivers.size());
1702 for (size_t i = 0; i < info.receivers.size(); ++i) {
1703 EXPECT_EQ(1U, GetReceiverStats(i).ssrcs().size());
1704 EXPECT_EQ(i + 1, GetReceiverStats(i).ssrcs()[0]);
Bjorn A Mellemda4f0932019-07-30 08:34:03 -07001705 EXPECT_EQ_WAIT(NumRtpBytes() - kRtpHeaderSize * NumRtpPackets(),
1706 GetReceiverStats(i).bytes_rcvd, kTimeout);
Yves Gerey665174f2018-06-19 15:03:05 +02001707 EXPECT_EQ_WAIT(NumRtpPackets(), GetReceiverStats(i).packets_rcvd, kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02001708 EXPECT_EQ_WAIT(kVideoWidth, GetReceiverStats(i).frame_width, kTimeout);
1709 EXPECT_EQ_WAIT(kVideoHeight, GetReceiverStats(i).frame_height, kTimeout);
1710 }
srtee0c2eea2017-12-15 17:44:33 +01001711}
Niels Möller6557d0c2018-04-11 15:18:34 +02001712
1713// Test that stats work properly for a conf call with multiple send streams.
srtee0c2eea2017-12-15 17:44:33 +01001714TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleSendStreams) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001715 // Normal setup; note that we set the SSRC explicitly to ensure that
1716 // it will come first in the senders map.
1717 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1718 cricket::VideoSendParameters parameters;
1719 parameters.codecs.push_back(DefaultCodec());
1720 parameters.conference_mode = true;
1721 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Yves Gerey665174f2018-06-19 15:03:05 +02001722 EXPECT_TRUE(
1723 channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Niels Möller6557d0c2018-04-11 15:18:34 +02001724 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_));
1725 EXPECT_TRUE(SetSend(true));
Niels Möller805a27e2019-01-21 12:21:27 +01001726 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001727 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
1728 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
1729
1730 // Add an additional capturer, and hook up a renderer to receive it.
1731 cricket::FakeVideoRenderer renderer2;
Niels Möller805a27e2019-01-21 12:21:27 +01001732 webrtc::test::FrameForwarder frame_forwarder;
Niels Möller6557d0c2018-04-11 15:18:34 +02001733 const int kTestWidth = 160;
1734 const int kTestHeight = 120;
Niels Möller805a27e2019-01-21 12:21:27 +01001735 cricket::FakeFrameSource frame_source(kTestWidth, kTestHeight,
1736 rtc::kNumMicrosecsPerSec / 5);
Yves Gerey665174f2018-06-19 15:03:05 +02001737 EXPECT_TRUE(
1738 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(5678)));
Niels Möller805a27e2019-01-21 12:21:27 +01001739 EXPECT_TRUE(channel_->SetVideoSend(5678, nullptr, &frame_forwarder));
Yves Gerey665174f2018-06-19 15:03:05 +02001740 EXPECT_TRUE(
1741 channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(5678)));
Niels Möller6557d0c2018-04-11 15:18:34 +02001742 EXPECT_TRUE(channel_->SetSink(5678, &renderer2));
Niels Möller805a27e2019-01-21 12:21:27 +01001743 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Yves Gerey665174f2018-06-19 15:03:05 +02001744 EXPECT_FRAME_ON_RENDERER_WAIT(renderer2, 1, kTestWidth, kTestHeight,
1745 kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02001746
1747 // Get stats, and make sure they are correct for two senders. We wait until
1748 // the number of expected packets have been sent to avoid races where we
1749 // check stats before it has been updated.
1750 cricket::VideoMediaInfo info;
1751 for (uint32_t i = 0; i < kTimeout; ++i) {
1752 rtc::Thread::Current()->ProcessMessages(1);
1753 EXPECT_TRUE(channel_->GetStats(&info));
1754 ASSERT_EQ(2U, info.senders.size());
1755 if (info.senders[0].packets_sent + info.senders[1].packets_sent ==
1756 NumRtpPackets()) {
1757 // Stats have been updated for both sent frames, expectations can be
1758 // checked now.
1759 break;
1760 }
1761 }
1762 EXPECT_EQ(NumRtpPackets(),
1763 info.senders[0].packets_sent + info.senders[1].packets_sent)
1764 << "Timed out while waiting for packet counts for all sent packets.";
1765 EXPECT_EQ(1U, info.senders[0].ssrcs().size());
1766 EXPECT_EQ(1234U, info.senders[0].ssrcs()[0]);
1767 EXPECT_EQ(kVideoWidth, info.senders[0].send_frame_width);
1768 EXPECT_EQ(kVideoHeight, info.senders[0].send_frame_height);
1769 EXPECT_EQ(1U, info.senders[1].ssrcs().size());
1770 EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]);
1771 EXPECT_EQ(kTestWidth, info.senders[1].send_frame_width);
1772 EXPECT_EQ(kTestHeight, info.senders[1].send_frame_height);
1773 // The capturer must be unregistered here as it runs out of it's scope next.
1774 channel_->SetVideoSend(5678, nullptr, nullptr);
srtee0c2eea2017-12-15 17:44:33 +01001775}
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +00001776
Niels Möller6557d0c2018-04-11 15:18:34 +02001777// Test that we can set the bandwidth.
srtee0c2eea2017-12-15 17:44:33 +01001778TEST_F(WebRtcVideoChannelBaseTest, SetSendBandwidth) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001779 cricket::VideoSendParameters parameters;
1780 parameters.codecs.push_back(DefaultCodec());
1781 parameters.max_bandwidth_bps = -1; // <= 0 means unlimited.
1782 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1783 parameters.max_bandwidth_bps = 128 * 1024;
1784 EXPECT_TRUE(channel_->SetSendParameters(parameters));
srtee0c2eea2017-12-15 17:44:33 +01001785}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001786
Niels Möller6557d0c2018-04-11 15:18:34 +02001787// Test that we can set the SSRC for the default send source.
srtee0c2eea2017-12-15 17:44:33 +01001788TEST_F(WebRtcVideoChannelBaseTest, SetSendSsrc) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001789 EXPECT_TRUE(SetDefaultCodec());
1790 EXPECT_TRUE(SetSend(true));
Niels Möller805a27e2019-01-21 12:21:27 +01001791 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001792 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
Åsa Persson23cd45a2018-07-03 10:40:40 +02001793 webrtc::RTPHeader header;
Niels Möller6557d0c2018-04-11 15:18:34 +02001794 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0));
Åsa Persson23cd45a2018-07-03 10:40:40 +02001795 EXPECT_TRUE(ParseRtpPacket(p.get(), &header));
1796 EXPECT_EQ(kSsrc, header.ssrc);
1797
Niels Möller6557d0c2018-04-11 15:18:34 +02001798 // Packets are being paced out, so these can mismatch between the first and
1799 // second call to NumRtpPackets until pending packets are paced out.
Åsa Persson23cd45a2018-07-03 10:40:40 +02001800 EXPECT_EQ_WAIT(NumRtpPackets(), NumRtpPackets(header.ssrc), kTimeout);
1801 EXPECT_EQ_WAIT(NumRtpBytes(), NumRtpBytes(header.ssrc), kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02001802 EXPECT_EQ(1, NumSentSsrcs());
1803 EXPECT_EQ(0, NumRtpPackets(kSsrc - 1));
1804 EXPECT_EQ(0, NumRtpBytes(kSsrc - 1));
srtee0c2eea2017-12-15 17:44:33 +01001805}
Niels Möller6557d0c2018-04-11 15:18:34 +02001806
1807// Test that we can set the SSRC even after codecs are set.
srtee0c2eea2017-12-15 17:44:33 +01001808TEST_F(WebRtcVideoChannelBaseTest, SetSendSsrcAfterSetCodecs) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001809 // Remove stream added in Setup.
1810 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
1811 EXPECT_TRUE(SetDefaultCodec());
Niels Möller6557d0c2018-04-11 15:18:34 +02001812 EXPECT_TRUE(
Yves Gerey665174f2018-06-19 15:03:05 +02001813 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(999)));
Niels Möller805a27e2019-01-21 12:21:27 +01001814 EXPECT_TRUE(channel_->SetVideoSend(999u, nullptr, frame_forwarder_.get()));
Niels Möller6557d0c2018-04-11 15:18:34 +02001815 EXPECT_TRUE(SetSend(true));
1816 EXPECT_TRUE(WaitAndSendFrame(0));
1817 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
Åsa Persson23cd45a2018-07-03 10:40:40 +02001818 webrtc::RTPHeader header;
Niels Möller6557d0c2018-04-11 15:18:34 +02001819 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0));
Åsa Persson23cd45a2018-07-03 10:40:40 +02001820 EXPECT_TRUE(ParseRtpPacket(p.get(), &header));
1821 EXPECT_EQ(999u, header.ssrc);
Niels Möller6557d0c2018-04-11 15:18:34 +02001822 // Packets are being paced out, so these can mismatch between the first and
1823 // second call to NumRtpPackets until pending packets are paced out.
Åsa Persson23cd45a2018-07-03 10:40:40 +02001824 EXPECT_EQ_WAIT(NumRtpPackets(), NumRtpPackets(header.ssrc), kTimeout);
1825 EXPECT_EQ_WAIT(NumRtpBytes(), NumRtpBytes(header.ssrc), kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02001826 EXPECT_EQ(1, NumSentSsrcs());
1827 EXPECT_EQ(0, NumRtpPackets(kSsrc));
1828 EXPECT_EQ(0, NumRtpBytes(kSsrc));
srtee0c2eea2017-12-15 17:44:33 +01001829}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001830
Niels Möller6557d0c2018-04-11 15:18:34 +02001831// Test that we can set the default video renderer before and after
1832// media is received.
srtee0c2eea2017-12-15 17:44:33 +01001833TEST_F(WebRtcVideoChannelBaseTest, SetSink) {
Yves Gerey665174f2018-06-19 15:03:05 +02001834 uint8_t data1[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
1835 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
Niels Möller6557d0c2018-04-11 15:18:34 +02001836
1837 rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1));
1838 rtc::SetBE32(packet1.data() + 8, kSsrc);
1839 channel_->SetSink(kDefaultReceiveSsrc, NULL);
1840 EXPECT_TRUE(SetDefaultCodec());
1841 EXPECT_TRUE(SetSend(true));
1842 EXPECT_EQ(0, renderer_.num_rendered_frames());
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07001843 channel_->OnPacketReceived(packet1, /* packet_time_us */ -1);
Niels Möller6557d0c2018-04-11 15:18:34 +02001844 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
Niels Möller805a27e2019-01-21 12:21:27 +01001845 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001846 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
srtee0c2eea2017-12-15 17:44:33 +01001847}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001848
Niels Möller6557d0c2018-04-11 15:18:34 +02001849// Tests setting up and configuring a send stream.
srtee0c2eea2017-12-15 17:44:33 +01001850TEST_F(WebRtcVideoChannelBaseTest, AddRemoveSendStreams) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001851 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1852 EXPECT_TRUE(SetSend(true));
1853 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
Niels Möller805a27e2019-01-21 12:21:27 +01001854 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001855 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
1856 EXPECT_GT(NumRtpPackets(), 0);
Åsa Persson23cd45a2018-07-03 10:40:40 +02001857 webrtc::RTPHeader header;
Niels Möller6557d0c2018-04-11 15:18:34 +02001858 size_t last_packet = NumRtpPackets() - 1;
Yves Gerey665174f2018-06-19 15:03:05 +02001859 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(
1860 GetRtpPacket(static_cast<int>(last_packet)));
Åsa Persson23cd45a2018-07-03 10:40:40 +02001861 EXPECT_TRUE(ParseRtpPacket(p.get(), &header));
1862 EXPECT_EQ(kSsrc, header.ssrc);
Niels Möller6557d0c2018-04-11 15:18:34 +02001863
1864 // Remove the send stream that was added during Setup.
1865 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
1866 int rtp_packets = NumRtpPackets();
1867
Niels Möller6557d0c2018-04-11 15:18:34 +02001868 EXPECT_TRUE(
Yves Gerey665174f2018-06-19 15:03:05 +02001869 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(789u)));
Niels Möller805a27e2019-01-21 12:21:27 +01001870 EXPECT_TRUE(channel_->SetVideoSend(789u, nullptr, frame_forwarder_.get()));
Niels Möller6557d0c2018-04-11 15:18:34 +02001871 EXPECT_EQ(rtp_packets, NumRtpPackets());
1872 // Wait 30ms to guarantee the engine does not drop the frame.
1873 EXPECT_TRUE(WaitAndSendFrame(30));
1874 EXPECT_TRUE_WAIT(NumRtpPackets() > rtp_packets, kTimeout);
1875
1876 last_packet = NumRtpPackets() - 1;
1877 p.reset(GetRtpPacket(static_cast<int>(last_packet)));
Åsa Persson23cd45a2018-07-03 10:40:40 +02001878 EXPECT_TRUE(ParseRtpPacket(p.get(), &header));
1879 EXPECT_EQ(789u, header.ssrc);
srtee0c2eea2017-12-15 17:44:33 +01001880}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001881
Niels Möller6557d0c2018-04-11 15:18:34 +02001882// Tests the behavior of incoming streams in a conference scenario.
srtee0c2eea2017-12-15 17:44:33 +01001883TEST_F(WebRtcVideoChannelBaseTest, SimulateConference) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001884 cricket::FakeVideoRenderer renderer1, renderer2;
1885 EXPECT_TRUE(SetDefaultCodec());
1886 cricket::VideoSendParameters parameters;
1887 parameters.codecs.push_back(DefaultCodec());
1888 parameters.conference_mode = true;
1889 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1890 EXPECT_TRUE(SetSend(true));
Yves Gerey665174f2018-06-19 15:03:05 +02001891 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
1892 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
Niels Möller6557d0c2018-04-11 15:18:34 +02001893 EXPECT_TRUE(channel_->SetSink(1, &renderer1));
1894 EXPECT_TRUE(channel_->SetSink(2, &renderer2));
1895 EXPECT_EQ(0, renderer1.num_rendered_frames());
1896 EXPECT_EQ(0, renderer2.num_rendered_frames());
1897 std::vector<uint32_t> ssrcs;
1898 ssrcs.push_back(1);
1899 ssrcs.push_back(2);
1900 network_interface_.SetConferenceMode(true, ssrcs);
Niels Möller805a27e2019-01-21 12:21:27 +01001901 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001902 EXPECT_FRAME_ON_RENDERER_WAIT(renderer1, 1, kVideoWidth, kVideoHeight,
1903 kTimeout);
1904 EXPECT_FRAME_ON_RENDERER_WAIT(renderer2, 1, kVideoWidth, kVideoHeight,
1905 kTimeout);
1906
1907 std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0));
1908 EXPECT_EQ(DefaultCodec().id, GetPayloadType(p.get()));
1909 EXPECT_EQ(kVideoWidth, renderer1.width());
1910 EXPECT_EQ(kVideoHeight, renderer1.height());
1911 EXPECT_EQ(kVideoWidth, renderer2.width());
1912 EXPECT_EQ(kVideoHeight, renderer2.height());
1913 EXPECT_TRUE(channel_->RemoveRecvStream(2));
1914 EXPECT_TRUE(channel_->RemoveRecvStream(1));
srtee0c2eea2017-12-15 17:44:33 +01001915}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001916
Niels Möller6557d0c2018-04-11 15:18:34 +02001917// Tests that we can add and remove capturers and frames are sent out properly
srtee0c2eea2017-12-15 17:44:33 +01001918TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001919 using cricket::FOURCC_I420;
Jonas Olssona4d87372019-07-05 19:08:33 +02001920 using cricket::VideoCodec;
1921 using cricket::VideoFormat;
1922 using cricket::VideoOptions;
Niels Möller6557d0c2018-04-11 15:18:34 +02001923
1924 VideoCodec codec = DefaultCodec();
1925 const int time_between_send_ms = VideoFormat::FpsToInterval(kFramerate);
1926 EXPECT_TRUE(SetOneCodec(codec));
1927 EXPECT_TRUE(SetSend(true));
1928 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
1929 EXPECT_EQ(0, renderer_.num_rendered_frames());
Niels Möller805a27e2019-01-21 12:21:27 +01001930 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001931 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
Niels Möller805a27e2019-01-21 12:21:27 +01001932
1933 webrtc::test::FrameForwarder frame_forwarder;
1934 cricket::FakeFrameSource frame_source(480, 360, rtc::kNumMicrosecsPerSec / 30,
1935 rtc::kNumMicrosecsPerSec / 30);
Niels Möller6557d0c2018-04-11 15:18:34 +02001936
1937 // TODO(nisse): This testcase fails if we don't configure
1938 // screencast. It's unclear why, I see nothing obvious in this
1939 // test which is related to screencast logic.
1940 VideoOptions video_options;
1941 video_options.is_screencast = true;
1942 channel_->SetVideoSend(kSsrc, &video_options, nullptr);
1943
Niels Möller6557d0c2018-04-11 15:18:34 +02001944 int captured_frames = 1;
1945 for (int iterations = 0; iterations < 2; ++iterations) {
Niels Möller805a27e2019-01-21 12:21:27 +01001946 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, &frame_forwarder));
Niels Möller6557d0c2018-04-11 15:18:34 +02001947 rtc::Thread::Current()->ProcessMessages(time_between_send_ms);
Niels Möller805a27e2019-01-21 12:21:27 +01001948 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
1949
Niels Möller6557d0c2018-04-11 15:18:34 +02001950 ++captured_frames;
1951 // Wait until frame of right size is captured.
1952 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
Niels Möller805a27e2019-01-21 12:21:27 +01001953 480 == renderer_.width() &&
1954 360 == renderer_.height() && !renderer_.black_frame(),
Yves Gerey665174f2018-06-19 15:03:05 +02001955 kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02001956 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
Niels Möller805a27e2019-01-21 12:21:27 +01001957 EXPECT_EQ(480, renderer_.width());
1958 EXPECT_EQ(360, renderer_.height());
Niels Möller6557d0c2018-04-11 15:18:34 +02001959 captured_frames = renderer_.num_rendered_frames() + 1;
1960 EXPECT_FALSE(renderer_.black_frame());
1961 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr));
1962 // Make sure a black frame is generated within the specified timeout.
1963 // The black frame should be the resolution of the previous frame to
1964 // prevent expensive encoder reconfigurations.
1965 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
Niels Möller805a27e2019-01-21 12:21:27 +01001966 480 == renderer_.width() &&
1967 360 == renderer_.height() && renderer_.black_frame(),
Yves Gerey665174f2018-06-19 15:03:05 +02001968 kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02001969 EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
Niels Möller805a27e2019-01-21 12:21:27 +01001970 EXPECT_EQ(480, renderer_.width());
1971 EXPECT_EQ(360, renderer_.height());
Niels Möller6557d0c2018-04-11 15:18:34 +02001972 EXPECT_TRUE(renderer_.black_frame());
1973
1974 // The black frame has the same timestamp as the next frame since it's
1975 // timestamp is set to the last frame's timestamp + interval. WebRTC will
1976 // not render a frame with the same timestamp so capture another frame
1977 // with the frame capturer to increment the next frame's timestamp.
Niels Möller805a27e2019-01-21 12:21:27 +01001978 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Niels Möller6557d0c2018-04-11 15:18:34 +02001979 }
srtee0c2eea2017-12-15 17:44:33 +01001980}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001981
Niels Möller6557d0c2018-04-11 15:18:34 +02001982// Tests that if SetVideoSend is called with a NULL capturer after the
1983// capturer was already removed, the application doesn't crash (and no black
1984// frame is sent).
srtee0c2eea2017-12-15 17:44:33 +01001985TEST_F(WebRtcVideoChannelBaseTest, RemoveCapturerWithoutAdd) {
Niels Möller6557d0c2018-04-11 15:18:34 +02001986 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
1987 EXPECT_TRUE(SetSend(true));
1988 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
1989 EXPECT_EQ(0, renderer_.num_rendered_frames());
Niels Möller805a27e2019-01-21 12:21:27 +01001990 SendFrame();
Niels Möller6557d0c2018-04-11 15:18:34 +02001991 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
1992 // Wait for one frame so they don't get dropped because we send frames too
1993 // tightly.
1994 rtc::Thread::Current()->ProcessMessages(30);
1995 // Remove the capturer.
1996 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr));
1997
1998 // No capturer was added, so this SetVideoSend shouldn't do anything.
1999 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr));
2000 rtc::Thread::Current()->ProcessMessages(300);
2001 // Verify no more frames were sent.
2002 EXPECT_EQ(1, renderer_.num_rendered_frames());
srtee0c2eea2017-12-15 17:44:33 +01002003}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002004
Niels Möller6557d0c2018-04-11 15:18:34 +02002005// Tests that we can add and remove capturer as unique sources.
srtee0c2eea2017-12-15 17:44:33 +01002006TEST_F(WebRtcVideoChannelBaseTest, AddRemoveCapturerMultipleSources) {
Niels Möller6557d0c2018-04-11 15:18:34 +02002007 // WebRTC implementation will drop frames if pushed to quickly. Wait the
2008 // interval time to avoid that.
2009 // WebRTC implementation will drop frames if pushed to quickly. Wait the
2010 // interval time to avoid that.
2011 // Set up the stream associated with the engine.
Yves Gerey665174f2018-06-19 15:03:05 +02002012 EXPECT_TRUE(
2013 channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
Niels Möller6557d0c2018-04-11 15:18:34 +02002014 EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_));
2015 cricket::VideoFormat capture_format(
2016 kVideoWidth, kVideoHeight,
2017 cricket::VideoFormat::FpsToInterval(kFramerate), cricket::FOURCC_I420);
2018 // Set up additional stream 1.
2019 cricket::FakeVideoRenderer renderer1;
2020 EXPECT_FALSE(channel_->SetSink(1, &renderer1));
Yves Gerey665174f2018-06-19 15:03:05 +02002021 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
Niels Möller6557d0c2018-04-11 15:18:34 +02002022 EXPECT_TRUE(channel_->SetSink(1, &renderer1));
Yves Gerey665174f2018-06-19 15:03:05 +02002023 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(1)));
Niels Möller805a27e2019-01-21 12:21:27 +01002024
2025 webrtc::test::FrameForwarder frame_forwarder1;
2026 cricket::FakeFrameSource frame_source(kVideoWidth, kVideoHeight,
2027 rtc::kNumMicrosecsPerSec / kFramerate);
2028
Niels Möller6557d0c2018-04-11 15:18:34 +02002029 // Set up additional stream 2.
2030 cricket::FakeVideoRenderer renderer2;
2031 EXPECT_FALSE(channel_->SetSink(2, &renderer2));
Yves Gerey665174f2018-06-19 15:03:05 +02002032 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
Niels Möller6557d0c2018-04-11 15:18:34 +02002033 EXPECT_TRUE(channel_->SetSink(2, &renderer2));
Yves Gerey665174f2018-06-19 15:03:05 +02002034 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
Niels Möller805a27e2019-01-21 12:21:27 +01002035 webrtc::test::FrameForwarder frame_forwarder2;
2036
Niels Möller6557d0c2018-04-11 15:18:34 +02002037 // State for all the streams.
2038 EXPECT_TRUE(SetOneCodec(DefaultCodec()));
2039 // A limitation in the lmi implementation requires that SetVideoSend() is
2040 // called after SetOneCodec().
2041 // TODO(hellner): this seems like an unnecessary constraint, fix it.
Niels Möller805a27e2019-01-21 12:21:27 +01002042 EXPECT_TRUE(channel_->SetVideoSend(1, nullptr, &frame_forwarder1));
2043 EXPECT_TRUE(channel_->SetVideoSend(2, nullptr, &frame_forwarder2));
Niels Möller6557d0c2018-04-11 15:18:34 +02002044 EXPECT_TRUE(SetSend(true));
2045 // Test capturer associated with engine.
2046 const int kTestWidth = 160;
2047 const int kTestHeight = 120;
Niels Möller805a27e2019-01-21 12:21:27 +01002048 frame_forwarder1.IncomingCapturedFrame(frame_source.GetFrame(
2049 kTestWidth, kTestHeight, webrtc::VideoRotation::kVideoRotation_0,
2050 rtc::kNumMicrosecsPerSec / kFramerate));
Yves Gerey665174f2018-06-19 15:03:05 +02002051 EXPECT_FRAME_ON_RENDERER_WAIT(renderer1, 1, kTestWidth, kTestHeight,
2052 kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02002053 // Capture a frame with additional capturer2, frames should be received
Niels Möller805a27e2019-01-21 12:21:27 +01002054 frame_forwarder2.IncomingCapturedFrame(frame_source.GetFrame(
2055 kTestWidth, kTestHeight, webrtc::VideoRotation::kVideoRotation_0,
2056 rtc::kNumMicrosecsPerSec / kFramerate));
Yves Gerey665174f2018-06-19 15:03:05 +02002057 EXPECT_FRAME_ON_RENDERER_WAIT(renderer2, 1, kTestWidth, kTestHeight,
2058 kTimeout);
Niels Möller6557d0c2018-04-11 15:18:34 +02002059 // Successfully remove the capturer.
2060 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr));
2061 // The capturers must be unregistered here as it runs out of it's scope
2062 // next.
2063 EXPECT_TRUE(channel_->SetVideoSend(1, nullptr, nullptr));
2064 EXPECT_TRUE(channel_->SetVideoSend(2, nullptr, nullptr));
srtee0c2eea2017-12-15 17:44:33 +01002065}
Niels Möller6557d0c2018-04-11 15:18:34 +02002066
2067// Tests empty StreamParams is rejected.
srtee0c2eea2017-12-15 17:44:33 +01002068TEST_F(WebRtcVideoChannelBaseTest, RejectEmptyStreamParams) {
Niels Möller6557d0c2018-04-11 15:18:34 +02002069 // Remove the send stream that was added during Setup.
2070 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
2071
2072 cricket::StreamParams empty;
2073 EXPECT_FALSE(channel_->AddSendStream(empty));
Yves Gerey665174f2018-06-19 15:03:05 +02002074 EXPECT_TRUE(
2075 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(789u)));
srtee0c2eea2017-12-15 17:44:33 +01002076}
Niels Möller6557d0c2018-04-11 15:18:34 +02002077
2078// Test that multiple send streams can be created and deleted properly.
srtee0c2eea2017-12-15 17:44:33 +01002079TEST_F(WebRtcVideoChannelBaseTest, MultipleSendStreams) {
Niels Möller6557d0c2018-04-11 15:18:34 +02002080 // Remove stream added in Setup. I.e. remove stream corresponding to default
2081 // channel.
2082 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
Yves Gerey665174f2018-06-19 15:03:05 +02002083 const unsigned int kSsrcsSize = sizeof(kSsrcs4) / sizeof(kSsrcs4[0]);
Niels Möller6557d0c2018-04-11 15:18:34 +02002084 for (unsigned int i = 0; i < kSsrcsSize; ++i) {
2085 EXPECT_TRUE(channel_->AddSendStream(
2086 cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
2087 }
2088 // Delete one of the non default channel streams, let the destructor delete
2089 // the remaining ones.
2090 EXPECT_TRUE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1]));
2091 // Stream should already be deleted.
2092 EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[kSsrcsSize - 1]));
srtee0c2eea2017-12-15 17:44:33 +01002093}
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00002094
eladalonf1841382017-06-12 01:16:46 -07002095TEST_F(WebRtcVideoChannelBaseTest, SendAndReceiveVp8Vga) {
magjed509e4fe2016-11-18 01:34:11 -08002096 SendAndReceive(GetEngineCodec("VP8"));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00002097}
2098
eladalonf1841382017-06-12 01:16:46 -07002099TEST_F(WebRtcVideoChannelBaseTest, SendAndReceiveVp8Qvga) {
magjed509e4fe2016-11-18 01:34:11 -08002100 SendAndReceive(GetEngineCodec("VP8"));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00002101}
2102
eladalonf1841382017-06-12 01:16:46 -07002103TEST_F(WebRtcVideoChannelBaseTest, SendAndReceiveVp8SvcQqvga) {
magjed509e4fe2016-11-18 01:34:11 -08002104 SendAndReceive(GetEngineCodec("VP8"));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00002105}
2106
eladalonf1841382017-06-12 01:16:46 -07002107TEST_F(WebRtcVideoChannelBaseTest, TwoStreamsSendAndReceive) {
Peter Boströmd1f584b2016-04-20 16:31:53 +02002108 // Set a high bitrate to not be downscaled by VP8 due to low initial start
2109 // bitrates. This currently happens at <250k, and two streams sharing 300k
2110 // initially will use QVGA instead of VGA.
2111 // TODO(pbos): Set up the quality scaler so that both senders reliably start
2112 // at QVGA, then verify that instead.
magjed509e4fe2016-11-18 01:34:11 -08002113 cricket::VideoCodec codec = GetEngineCodec("VP8");
Peter Boströmd1f584b2016-04-20 16:31:53 +02002114 codec.params[kCodecParamStartBitrate] = "1000000";
Niels Möller6557d0c2018-04-11 15:18:34 +02002115 TwoStreamsSendAndReceive(codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002116}
2117
philipeld9cc8c02019-09-16 14:53:40 +02002118TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderFallback) {
philipele8ed8302019-07-03 11:53:48 +02002119 cricket::VideoSendParameters parameters;
2120 parameters.codecs.push_back(GetEngineCodec("VP9"));
2121 parameters.codecs.push_back(GetEngineCodec("VP8"));
2122 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2123
2124 VideoCodec codec;
2125 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2126 EXPECT_EQ("VP9", codec.name);
2127
philipeld9cc8c02019-09-16 14:53:40 +02002128 // RequestEncoderFallback will post a task to the worker thread (which is also
philipele8ed8302019-07-03 11:53:48 +02002129 // the current thread), hence the ProcessMessages call.
philipeld9cc8c02019-09-16 14:53:40 +02002130 channel_->RequestEncoderFallback();
philipele8ed8302019-07-03 11:53:48 +02002131 rtc::Thread::Current()->ProcessMessages(30);
2132 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2133 EXPECT_EQ("VP8", codec.name);
2134
2135 // No other codec to fall back to, keep using VP8.
philipeld9cc8c02019-09-16 14:53:40 +02002136 channel_->RequestEncoderFallback();
philipele8ed8302019-07-03 11:53:48 +02002137 rtc::Thread::Current()->ProcessMessages(30);
2138 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2139 EXPECT_EQ("VP8", codec.name);
2140}
2141
philipeld9cc8c02019-09-16 14:53:40 +02002142TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchWithConfig) {
2143 const std::string kParam = "the-param";
2144 const std::string kPing = "ping";
2145 const std::string kPong = "pong";
2146
2147 cricket::VideoSendParameters parameters;
2148 VideoCodec vp9 = GetEngineCodec("VP9");
2149 vp9.params[kParam] = kPong;
2150 parameters.codecs.push_back(vp9);
2151
2152 VideoCodec vp8 = GetEngineCodec("VP8");
2153 vp8.params[kParam] = kPing;
2154 parameters.codecs.push_back(vp8);
2155
2156 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2157
2158 VideoCodec codec;
2159 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2160 EXPECT_THAT(codec.name, Eq("VP9"));
2161
2162 // RequestEncoderSwitch will post a task to the worker thread (which is also
2163 // the current thread), hence the ProcessMessages call.
2164 webrtc::EncoderSwitchRequestCallback::Config conf1{"VP8", kParam, kPing};
2165 channel_->RequestEncoderSwitch(conf1);
2166 rtc::Thread::Current()->ProcessMessages(30);
2167 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2168 EXPECT_THAT(codec.name, Eq("VP8"));
2169 EXPECT_THAT(codec.params, Contains(Pair(kParam, kPing)));
2170
2171 webrtc::EncoderSwitchRequestCallback::Config conf2{"VP9", kParam, kPong};
2172 channel_->RequestEncoderSwitch(conf2);
2173 rtc::Thread::Current()->ProcessMessages(30);
2174 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2175 EXPECT_THAT(codec.name, Eq("VP9"));
2176 EXPECT_THAT(codec.params, Contains(Pair(kParam, kPong)));
2177}
2178
2179TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchIncorrectParam) {
2180 const std::string kParam = "the-param";
2181 const std::string kPing = "ping";
2182 const std::string kPong = "pong";
2183
2184 cricket::VideoSendParameters parameters;
2185 VideoCodec vp9 = GetEngineCodec("VP9");
2186 vp9.params[kParam] = kPong;
2187 parameters.codecs.push_back(vp9);
2188
2189 VideoCodec vp8 = GetEngineCodec("VP8");
2190 vp8.params[kParam] = kPing;
2191 parameters.codecs.push_back(vp8);
2192
2193 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2194
2195 VideoCodec codec;
2196 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2197 EXPECT_THAT(codec.name, Eq("VP9"));
2198
2199 // RequestEncoderSwitch will post a task to the worker thread (which is also
2200 // the current thread), hence the ProcessMessages call.
2201 webrtc::EncoderSwitchRequestCallback::Config conf1{"VP8", kParam, kPing};
2202 channel_->RequestEncoderSwitch(conf1);
2203 rtc::Thread::Current()->ProcessMessages(30);
2204 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2205 EXPECT_THAT(codec.name, Eq("VP8"));
2206 EXPECT_THAT(codec.params, Contains(Pair(kParam, kPing)));
2207
2208 // Incorrect conf2.value, expect no codec switch.
2209 webrtc::EncoderSwitchRequestCallback::Config conf2{"VP9", kParam, kPing};
2210 channel_->RequestEncoderSwitch(conf2);
2211 rtc::Thread::Current()->ProcessMessages(30);
2212 ASSERT_TRUE(channel_->GetSendCodec(&codec));
2213 EXPECT_THAT(codec.name, Eq("VP8"));
2214 EXPECT_THAT(codec.params, Contains(Pair(kParam, kPing)));
2215}
2216
eladalonf1841382017-06-12 01:16:46 -07002217class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002218 public:
eladalonf1841382017-06-12 01:16:46 -07002219 WebRtcVideoChannelTest() : WebRtcVideoChannelTest("") {}
2220 explicit WebRtcVideoChannelTest(const char* field_trials)
Niels Möller805a27e2019-01-21 12:21:27 +01002221 : WebRtcVideoEngineTest(field_trials),
2222 frame_source_(1280, 720, rtc::kNumMicrosecsPerSec / 30),
2223 last_ssrc_(0) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00002224 void SetUp() override {
Anders Carlsson5f2bb622018-05-14 09:48:06 +02002225 encoder_factory_->AddSupportedVideoCodecType("VP8");
2226 encoder_factory_->AddSupportedVideoCodecType("VP9");
2227#if defined(WEBRTC_USE_H264)
2228 encoder_factory_->AddSupportedVideoCodecType("H264");
2229#endif
2230
Sebastian Jansson8f83b422018-02-21 13:07:13 +01002231 fake_call_.reset(new FakeCall());
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02002232 channel_.reset(engine_.CreateMediaChannel(
2233 fake_call_.get(), GetMediaConfig(), VideoOptions(),
2234 webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()));
Sergey Ulanove2b15012016-11-22 16:08:30 -08002235 channel_->OnReadyToSend(true);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002236 last_ssrc_ = 123;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002237 send_parameters_.codecs = engine_.codecs();
2238 recv_parameters_.codecs = engine_.codecs();
2239 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002240 }
2241
2242 protected:
2243 FakeVideoSendStream* AddSendStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002244 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002245 }
2246
2247 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002248 size_t num_streams = fake_call_->GetVideoSendStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002249 EXPECT_TRUE(channel_->AddSendStream(sp));
2250 std::vector<FakeVideoSendStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002251 fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002252 EXPECT_EQ(num_streams + 1, streams.size());
2253 return streams[streams.size() - 1];
2254 }
2255
2256 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002257 return fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002258 }
2259
2260 FakeVideoReceiveStream* AddRecvStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002261 return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002262 }
2263
2264 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002265 size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002266 EXPECT_TRUE(channel_->AddRecvStream(sp));
2267 std::vector<FakeVideoReceiveStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002268 fake_call_->GetVideoReceiveStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002269 EXPECT_EQ(num_streams + 1, streams.size());
2270 return streams[streams.size() - 1];
2271 }
2272
pbos@webrtc.org00873182014-11-25 14:03:34 +00002273 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
2274 int expected_min_bitrate_bps,
2275 const char* start_bitrate_kbps,
2276 int expected_start_bitrate_bps,
2277 const char* max_bitrate_kbps,
2278 int expected_max_bitrate_bps) {
Sebastian Jansson8f83b422018-02-21 13:07:13 +01002279 ExpectSetBitrateParameters(expected_min_bitrate_bps,
2280 expected_start_bitrate_bps,
2281 expected_max_bitrate_bps);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002282 auto& codecs = send_parameters_.codecs;
2283 codecs.clear();
magjed509e4fe2016-11-18 01:34:11 -08002284 codecs.push_back(GetEngineCodec("VP8"));
pbos@webrtc.org00873182014-11-25 14:03:34 +00002285 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
2286 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
2287 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002288 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Sebastian Jansson8f83b422018-02-21 13:07:13 +01002289 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002290
Sebastian Jansson8f83b422018-02-21 13:07:13 +01002291 void ExpectSetBitrateParameters(int min_bitrate_bps,
2292 int start_bitrate_bps,
2293 int max_bitrate_bps) {
2294 EXPECT_CALL(
2295 *fake_call_->GetMockTransportControllerSend(),
2296 SetSdpBitrateParameters(AllOf(
2297 Field(&BitrateConstraints::min_bitrate_bps, min_bitrate_bps),
2298 Field(&BitrateConstraints::start_bitrate_bps, start_bitrate_bps),
2299 Field(&BitrateConstraints::max_bitrate_bps, max_bitrate_bps))));
2300 }
2301
2302 void ExpectSetMaxBitrate(int max_bitrate_bps) {
2303 EXPECT_CALL(*fake_call_->GetMockTransportControllerSend(),
2304 SetSdpBitrateParameters(Field(
2305 &BitrateConstraints::max_bitrate_bps, max_bitrate_bps)));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002306 }
2307
Johannes Kron9190b822018-10-29 11:22:05 +01002308 void TestExtmapAllowMixedCaller(bool extmap_allow_mixed) {
2309 // For a caller, the answer will be applied in set remote description
2310 // where SetSendParameters() is called.
2311 EXPECT_TRUE(
2312 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
2313 send_parameters_.extmap_allow_mixed = extmap_allow_mixed;
2314 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2315 const webrtc::VideoSendStream::Config& config =
2316 fake_call_->GetVideoSendStreams()[0]->GetConfig();
2317 EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed);
2318 }
2319
2320 void TestExtmapAllowMixedCallee(bool extmap_allow_mixed) {
2321 // For a callee, the answer will be applied in set local description
2322 // where SetExtmapAllowMixed() and AddSendStream() are called.
2323 channel_->SetExtmapAllowMixed(extmap_allow_mixed);
2324 EXPECT_TRUE(
2325 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
2326 const webrtc::VideoSendStream::Config& config =
2327 fake_call_->GetVideoSendStreams()[0]->GetConfig();
2328 EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed);
2329 }
2330
isheriff6f8d6862016-05-26 11:24:55 -07002331 void TestSetSendRtpHeaderExtensions(const std::string& ext_uri) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002332 // Enable extension.
2333 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002334 cricket::VideoSendParameters parameters = send_parameters_;
isheriff6f8d6862016-05-26 11:24:55 -07002335 parameters.extensions.push_back(RtpExtension(ext_uri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002336 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002337 FakeVideoSendStream* send_stream =
2338 AddSendStream(cricket::StreamParams::CreateLegacy(123));
2339
2340 // Verify the send extension id.
2341 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
2342 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07002343 EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002344 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002345 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002346 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
2347 // receivers.
2348 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
2349 ->GetConfig()
2350 .rtp.extensions.empty());
2351
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002352 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002353 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02002354 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2355 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002356 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
2357
2358 // Verify that adding receive RTP header extensions adds them for existing
2359 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002360 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02002361 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002362 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
2363 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07002364 EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002365 }
2366
isheriff6f8d6862016-05-26 11:24:55 -07002367 void TestSetRecvRtpHeaderExtensions(const std::string& ext_uri) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002368 // Enable extension.
2369 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002370 cricket::VideoRecvParameters parameters = recv_parameters_;
isheriff6f8d6862016-05-26 11:24:55 -07002371 parameters.extensions.push_back(RtpExtension(ext_uri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002372 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002373
2374 FakeVideoReceiveStream* recv_stream =
2375 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2376
2377 // Verify the recv extension id.
2378 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
2379 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07002380 EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002381 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002382 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002383
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002384 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
2385 // senders.
2386 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
2387 ->GetConfig()
2388 .rtp.extensions.empty());
2389
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002390 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002391 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02002392 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
2393 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002394 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
2395
2396 // Verify that adding receive RTP header extensions adds them for existing
2397 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002398 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02002399 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002400 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
2401 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07002402 EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002403 }
2404
Elad Alonfadb1812019-05-24 13:40:02 +02002405 void TestLossNotificationState(bool expect_lntf_enabled) {
2406 AssignDefaultCodec();
2407 VerifyCodecHasDefaultFeedbackParams(default_codec_, expect_lntf_enabled);
2408
2409 cricket::VideoSendParameters parameters;
2410 parameters.codecs = engine_.codecs();
2411 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2412 EXPECT_TRUE(channel_->SetSend(true));
2413
2414 // Send side.
2415 FakeVideoSendStream* send_stream =
2416 AddSendStream(cricket::StreamParams::CreateLegacy(1));
2417 EXPECT_EQ(send_stream->GetConfig().rtp.lntf.enabled, expect_lntf_enabled);
2418
2419 // Receiver side.
2420 FakeVideoReceiveStream* recv_stream =
2421 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
2422 EXPECT_EQ(recv_stream->GetConfig().rtp.lntf.enabled, expect_lntf_enabled);
2423 }
2424
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002425 void TestExtensionFilter(const std::vector<std::string>& extensions,
2426 const std::string& expected_extension) {
2427 cricket::VideoSendParameters parameters = send_parameters_;
2428 int expected_id = -1;
2429 int id = 1;
2430 for (const std::string& extension : extensions) {
2431 if (extension == expected_extension)
2432 expected_id = id;
isheriff6f8d6862016-05-26 11:24:55 -07002433 parameters.extensions.push_back(RtpExtension(extension, id++));
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002434 }
2435 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2436 FakeVideoSendStream* send_stream =
2437 AddSendStream(cricket::StreamParams::CreateLegacy(123));
2438
2439 // Verify that only one of them has been set, and that it is the one with
2440 // highest priority (transport sequence number).
2441 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
2442 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
2443 EXPECT_EQ(expected_extension,
isheriff6f8d6862016-05-26 11:24:55 -07002444 send_stream->GetConfig().rtp.extensions[0].uri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002445 }
2446
asapersson3c81a1a2017-06-14 05:52:21 -07002447 void TestDegradationPreference(bool resolution_scaling_enabled,
2448 bool fps_scaling_enabled);
2449
Erik Språngefbde372015-04-29 16:21:28 +02002450 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
Peter Boström3548dd22015-05-22 18:48:36 +02002451 void TestReceiverLocalSsrcConfiguration(bool receiver_first);
magjed509e4fe2016-11-18 01:34:11 -08002452 void TestReceiveUnsignaledSsrcPacket(uint8_t payload_type,
2453 bool expect_created_receive_stream);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002454
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002455 FakeVideoSendStream* SetDenoisingOption(
nisse05103312016-03-16 02:22:50 -07002456 uint32_t ssrc,
Niels Möller805a27e2019-01-21 12:21:27 +01002457 webrtc::test::FrameForwarder* frame_forwarder,
nisse0db023a2016-03-01 04:29:59 -08002458 bool enabled) {
nisse05103312016-03-16 02:22:50 -07002459 cricket::VideoOptions options;
Oskar Sundbom78807582017-11-16 11:09:55 +01002460 options.video_noise_reduction = enabled;
Niels Möller805a27e2019-01-21 12:21:27 +01002461 EXPECT_TRUE(channel_->SetVideoSend(ssrc, &options, frame_forwarder));
nisse0db023a2016-03-01 04:29:59 -08002462 // Options only take effect on the next frame.
Niels Möller805a27e2019-01-21 12:21:27 +01002463 frame_forwarder->IncomingCapturedFrame(frame_source_.GetFrame());
nisse0db023a2016-03-01 04:29:59 -08002464
Erik Språng143cec12015-04-28 10:01:41 +02002465 return fake_call_->GetVideoSendStreams().back();
2466 }
2467
Peter Boström2feafdb2015-09-09 14:32:14 +02002468 FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
2469 const int kRtxSsrcOffset = 0xDEADBEEF;
Erik Språng143cec12015-04-28 10:01:41 +02002470 last_ssrc_ += 3;
Peter Boström2feafdb2015-09-09 14:32:14 +02002471 std::vector<uint32_t> ssrcs;
2472 std::vector<uint32_t> rtx_ssrcs;
2473 uint32_t num_streams = enabled ? 3 : 1;
2474 for (uint32_t i = 0; i < num_streams; ++i) {
2475 uint32_t ssrc = last_ssrc_ + i;
2476 ssrcs.push_back(ssrc);
2477 if (with_rtx) {
2478 rtx_ssrcs.push_back(ssrc + kRtxSsrcOffset);
2479 }
Erik Språng143cec12015-04-28 10:01:41 +02002480 }
Peter Boström2feafdb2015-09-09 14:32:14 +02002481 if (with_rtx) {
2482 return AddSendStream(
2483 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
2484 }
2485 return AddSendStream(CreateSimStreamParams("cname", ssrcs));
Erik Språng143cec12015-04-28 10:01:41 +02002486 }
2487
perkjfa10b552016-10-02 23:45:26 -07002488 int GetMaxEncoderBitrate() {
skvladdc1c62c2016-03-16 19:07:43 -07002489 std::vector<FakeVideoSendStream*> streams =
2490 fake_call_->GetVideoSendStreams();
perkjfa10b552016-10-02 23:45:26 -07002491 EXPECT_EQ(1u, streams.size());
skvladdc1c62c2016-03-16 19:07:43 -07002492 FakeVideoSendStream* stream = streams[streams.size() - 1];
Mirko Bonadeif859e552018-05-30 15:31:29 +02002493 EXPECT_EQ(1u, stream->GetEncoderConfig().number_of_streams);
perkjfa10b552016-10-02 23:45:26 -07002494 return stream->GetVideoStreams()[0].max_bitrate_bps;
skvladdc1c62c2016-03-16 19:07:43 -07002495 }
2496
perkjfa10b552016-10-02 23:45:26 -07002497 void SetAndExpectMaxBitrate(int global_max,
skvladdc1c62c2016-03-16 19:07:43 -07002498 int stream_max,
2499 int expected_encoder_bitrate) {
2500 VideoSendParameters limited_send_params = send_parameters_;
2501 limited_send_params.max_bandwidth_bps = global_max;
2502 EXPECT_TRUE(channel_->SetSendParameters(limited_send_params));
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002503 webrtc::RtpParameters parameters =
2504 channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07002505 EXPECT_EQ(1UL, parameters.encodings.size());
Oskar Sundbom78807582017-11-16 11:09:55 +01002506 parameters.encodings[0].max_bitrate_bps = stream_max;
Zach Steinba37b4b2018-01-23 15:02:36 -08002507 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
skvladdc1c62c2016-03-16 19:07:43 -07002508 // Read back the parameteres and verify they have the correct value
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002509 parameters = channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07002510 EXPECT_EQ(1UL, parameters.encodings.size());
Oskar Sundbom78807582017-11-16 11:09:55 +01002511 EXPECT_EQ(stream_max, parameters.encodings[0].max_bitrate_bps);
skvladdc1c62c2016-03-16 19:07:43 -07002512 // Verify that the new value propagated down to the encoder
perkjfa10b552016-10-02 23:45:26 -07002513 EXPECT_EQ(expected_encoder_bitrate, GetMaxEncoderBitrate());
skvladdc1c62c2016-03-16 19:07:43 -07002514 }
2515
Åsa Persson55659812018-06-18 17:51:32 +02002516 // Values from kSimulcastConfigs in simulcast.cc.
2517 const std::vector<webrtc::VideoStream> GetSimulcastBitrates720p() const {
2518 std::vector<webrtc::VideoStream> layers(3);
2519 layers[0].min_bitrate_bps = 30000;
2520 layers[0].target_bitrate_bps = 150000;
2521 layers[0].max_bitrate_bps = 200000;
2522 layers[1].min_bitrate_bps = 150000;
2523 layers[1].target_bitrate_bps = 500000;
2524 layers[1].max_bitrate_bps = 700000;
2525 layers[2].min_bitrate_bps = 600000;
2526 layers[2].target_bitrate_bps = 2500000;
2527 layers[2].max_bitrate_bps = 2500000;
2528 return layers;
2529 }
2530
Niels Möller805a27e2019-01-21 12:21:27 +01002531 cricket::FakeFrameSource frame_source_;
kwiberg686a8ef2016-02-26 03:00:35 -08002532 std::unique_ptr<FakeCall> fake_call_;
2533 std::unique_ptr<VideoMediaChannel> channel_;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002534 cricket::VideoSendParameters send_parameters_;
2535 cricket::VideoRecvParameters recv_parameters_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02002536 uint32_t last_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002537};
2538
eladalonf1841382017-06-12 01:16:46 -07002539TEST_F(WebRtcVideoChannelTest, SetsSyncGroupFromSyncLabel) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02002540 const uint32_t kVideoSsrc = 123;
pbos8fc7fa72015-07-15 08:02:58 -07002541 const std::string kSyncLabel = "AvSyncLabel";
2542
2543 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
Seth Hampson845e8782018-03-02 11:34:10 -08002544 sp.set_stream_ids({kSyncLabel});
pbos8fc7fa72015-07-15 08:02:58 -07002545 EXPECT_TRUE(channel_->AddRecvStream(sp));
2546
Mirko Bonadeif859e552018-05-30 15:31:29 +02002547 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos8fc7fa72015-07-15 08:02:58 -07002548 EXPECT_EQ(kSyncLabel,
2549 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
2550 << "SyncGroup should be set based on sync_label";
2551}
2552
eladalonf1841382017-06-12 01:16:46 -07002553TEST_F(WebRtcVideoChannelTest, RecvStreamWithSimAndRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002554 cricket::VideoSendParameters parameters;
2555 parameters.codecs = engine_.codecs();
2556 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002557 EXPECT_TRUE(channel_->SetSend(true));
nisse4b4dc862016-02-17 05:25:36 -08002558 parameters.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002559 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002560
2561 // Send side.
Peter Boström0c4e06b2015-10-07 12:23:21 +02002562 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2563 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002564 FakeVideoSendStream* send_stream = AddSendStream(
2565 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
2566
2567 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
2568 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
2569 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
2570
2571 // Receiver side.
2572 FakeVideoReceiveStream* recv_stream = AddRecvStream(
2573 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
nisse26e3abb2017-08-25 04:44:25 -07002574 EXPECT_FALSE(
2575 recv_stream->GetConfig().rtp.rtx_associated_payload_types.empty());
nisseca5706d2017-09-11 02:32:16 -07002576 EXPECT_TRUE(VerifyRtxReceiveAssociations(recv_stream->GetConfig()))
Peter Boströmd8b01092016-05-12 16:44:36 +02002577 << "RTX should be mapped for all decoders/payload types.";
nisseca5706d2017-09-11 02:32:16 -07002578 EXPECT_TRUE(HasRtxReceiveAssociation(recv_stream->GetConfig(),
Yves Gerey665174f2018-06-19 15:03:05 +02002579 GetEngineCodec("red").id))
nisseca5706d2017-09-11 02:32:16 -07002580 << "RTX should be mapped for the RED payload type";
2581
brandtr14742122017-01-27 04:53:07 -08002582 EXPECT_EQ(rtx_ssrcs[0], recv_stream->GetConfig().rtp.rtx_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002583}
2584
eladalonf1841382017-06-12 01:16:46 -07002585TEST_F(WebRtcVideoChannelTest, RecvStreamWithRtx) {
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002586 // Setup one channel with an associated RTX stream.
2587 cricket::StreamParams params =
2588 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
2589 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
2590 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
brandtr14742122017-01-27 04:53:07 -08002591 EXPECT_EQ(kRtxSsrcs1[0], recv_stream->GetConfig().rtp.rtx_ssrc);
nisseca5706d2017-09-11 02:32:16 -07002592
2593 EXPECT_TRUE(VerifyRtxReceiveAssociations(recv_stream->GetConfig()))
2594 << "RTX should be mapped for all decoders/payload types.";
2595 EXPECT_TRUE(HasRtxReceiveAssociation(recv_stream->GetConfig(),
Yves Gerey665174f2018-06-19 15:03:05 +02002596 GetEngineCodec("red").id))
nisseca5706d2017-09-11 02:32:16 -07002597 << "RTX should be mapped for the RED payload type";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002598}
2599
eladalonf1841382017-06-12 01:16:46 -07002600TEST_F(WebRtcVideoChannelTest, RecvStreamNoRtx) {
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002601 // Setup one channel without an associated RTX stream.
2602 cricket::StreamParams params =
2603 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
2604 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
brandtr14742122017-01-27 04:53:07 -08002605 ASSERT_EQ(0U, recv_stream->GetConfig().rtp.rtx_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002606}
2607
Johannes Kron9190b822018-10-29 11:22:05 +01002608// Test propagation of extmap allow mixed setting.
2609TEST_F(WebRtcVideoChannelTest, SetExtmapAllowMixedAsCaller) {
2610 TestExtmapAllowMixedCaller(/*extmap_allow_mixed=*/true);
2611}
2612TEST_F(WebRtcVideoChannelTest, SetExtmapAllowMixedDisabledAsCaller) {
2613 TestExtmapAllowMixedCaller(/*extmap_allow_mixed=*/false);
2614}
2615TEST_F(WebRtcVideoChannelTest, SetExtmapAllowMixedAsCallee) {
2616 TestExtmapAllowMixedCallee(/*extmap_allow_mixed=*/true);
2617}
2618TEST_F(WebRtcVideoChannelTest, SetExtmapAllowMixedDisabledAsCallee) {
2619 TestExtmapAllowMixedCallee(/*extmap_allow_mixed=*/false);
2620}
2621
eladalonf1841382017-06-12 01:16:46 -07002622TEST_F(WebRtcVideoChannelTest, NoHeaderExtesionsByDefault) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002623 FakeVideoSendStream* send_stream =
2624 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
2625 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
2626
2627 FakeVideoReceiveStream* recv_stream =
2628 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
2629 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002630}
2631
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002632// Test support for RTP timestamp offset header extension.
eladalonf1841382017-06-12 01:16:46 -07002633TEST_F(WebRtcVideoChannelTest, SendRtpTimestampOffsetHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002634 TestSetSendRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002635}
isheriff6f8d6862016-05-26 11:24:55 -07002636
eladalonf1841382017-06-12 01:16:46 -07002637TEST_F(WebRtcVideoChannelTest, RecvRtpTimestampOffsetHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002638 TestSetRecvRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002639}
2640
2641// Test support for absolute send time header extension.
eladalonf1841382017-06-12 01:16:46 -07002642TEST_F(WebRtcVideoChannelTest, SendAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002643 TestSetSendRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00002644}
isheriff6f8d6862016-05-26 11:24:55 -07002645
eladalonf1841382017-06-12 01:16:46 -07002646TEST_F(WebRtcVideoChannelTest, RecvAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002647 TestSetRecvRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002648}
2649
eladalonf1841382017-06-12 01:16:46 -07002650TEST_F(WebRtcVideoChannelTest, FiltersExtensionsPicksTransportSeqNum) {
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002651 // Enable three redundant extensions.
2652 std::vector<std::string> extensions;
isheriff6f8d6862016-05-26 11:24:55 -07002653 extensions.push_back(RtpExtension::kAbsSendTimeUri);
2654 extensions.push_back(RtpExtension::kTimestampOffsetUri);
2655 extensions.push_back(RtpExtension::kTransportSequenceNumberUri);
2656 TestExtensionFilter(extensions, RtpExtension::kTransportSequenceNumberUri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002657}
2658
eladalonf1841382017-06-12 01:16:46 -07002659TEST_F(WebRtcVideoChannelTest, FiltersExtensionsPicksAbsSendTime) {
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002660 // Enable two redundant extensions.
2661 std::vector<std::string> extensions;
isheriff6f8d6862016-05-26 11:24:55 -07002662 extensions.push_back(RtpExtension::kAbsSendTimeUri);
2663 extensions.push_back(RtpExtension::kTimestampOffsetUri);
2664 TestExtensionFilter(extensions, RtpExtension::kAbsSendTimeUri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002665}
2666
stefanc1aeaf02015-10-15 07:26:07 -07002667// Test support for transport sequence number header extension.
eladalonf1841382017-06-12 01:16:46 -07002668TEST_F(WebRtcVideoChannelTest, SendTransportSequenceNumberHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002669 TestSetSendRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
stefanc1aeaf02015-10-15 07:26:07 -07002670}
eladalonf1841382017-06-12 01:16:46 -07002671TEST_F(WebRtcVideoChannelTest, RecvTransportSequenceNumberHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002672 TestSetRecvRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
stefanc1aeaf02015-10-15 07:26:07 -07002673}
2674
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002675// Test support for video rotation header extension.
eladalonf1841382017-06-12 01:16:46 -07002676TEST_F(WebRtcVideoChannelTest, SendVideoRotationHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002677 TestSetSendRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002678}
eladalonf1841382017-06-12 01:16:46 -07002679TEST_F(WebRtcVideoChannelTest, RecvVideoRotationHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002680 TestSetRecvRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002681}
2682
eladalonf1841382017-06-12 01:16:46 -07002683TEST_F(WebRtcVideoChannelTest, IdenticalSendExtensionsDoesntRecreateStream) {
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002684 const int kAbsSendTimeId = 1;
2685 const int kVideoRotationId = 2;
isheriff6f8d6862016-05-26 11:24:55 -07002686 send_parameters_.extensions.push_back(
2687 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
2688 send_parameters_.extensions.push_back(
2689 RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002690
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002691 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002692 FakeVideoSendStream* send_stream =
2693 AddSendStream(cricket::StreamParams::CreateLegacy(123));
2694
2695 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
Stefan Holmerbbaf3632015-10-29 18:53:23 +01002696 ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002697
2698 // Setting the same extensions (even if in different order) shouldn't
2699 // reallocate the stream.
Steve Anton2c9ebef2019-01-28 17:27:58 -08002700 absl::c_reverse(send_parameters_.extensions);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002701 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002702
2703 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
2704
2705 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002706 send_parameters_.extensions.resize(1);
2707 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002708
2709 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
2710}
2711
eladalonf1841382017-06-12 01:16:46 -07002712TEST_F(WebRtcVideoChannelTest, IdenticalRecvExtensionsDoesntRecreateStream) {
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002713 const int kTOffsetId = 1;
2714 const int kAbsSendTimeId = 2;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002715 const int kVideoRotationId = 3;
isheriff6f8d6862016-05-26 11:24:55 -07002716 recv_parameters_.extensions.push_back(
2717 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
2718 recv_parameters_.extensions.push_back(
2719 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
2720 recv_parameters_.extensions.push_back(
2721 RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002722
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002723 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Peter Boström54be3e02015-05-25 15:04:24 +02002724 FakeVideoReceiveStream* recv_stream =
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002725 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2726
2727 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
Peter Boström54be3e02015-05-25 15:04:24 +02002728 ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002729
2730 // Setting the same extensions (even if in different order) shouldn't
2731 // reallocate the stream.
Steve Anton2c9ebef2019-01-28 17:27:58 -08002732 absl::c_reverse(recv_parameters_.extensions);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002733 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002734
2735 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2736
2737 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002738 recv_parameters_.extensions.resize(1);
2739 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00002740
2741 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
2742}
2743
eladalonf1841382017-06-12 01:16:46 -07002744TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002745 SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002746 const int kUnsupportedId = 1;
2747 const int kTOffsetId = 2;
2748
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002749 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002750 RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002751 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002752 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002753 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002754 FakeVideoSendStream* send_stream =
2755 AddSendStream(cricket::StreamParams::CreateLegacy(123));
2756
2757 // Only timestamp offset extension is set to send stream,
2758 // unsupported rtp extension is ignored.
2759 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -07002760 EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
2761 send_stream->GetConfig().rtp.extensions[0].uri.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002762}
2763
eladalonf1841382017-06-12 01:16:46 -07002764TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002765 SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002766 const int kUnsupportedId = 1;
2767 const int kTOffsetId = 2;
2768
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002769 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002770 RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002771 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002772 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002773 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002774 FakeVideoReceiveStream* recv_stream =
2775 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2776
2777 // Only timestamp offset extension is set to receive stream,
2778 // unsupported rtp extension is ignored.
2779 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -07002780 EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
2781 recv_stream->GetConfig().rtp.extensions[0].uri.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002782}
2783
eladalonf1841382017-06-12 01:16:46 -07002784TEST_F(WebRtcVideoChannelTest, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02002785 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002786 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
isheriff6f8d6862016-05-26 11:24:55 -07002787 send_parameters_.extensions.push_back(
2788 RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002789 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002790 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
2791 }
2792}
2793
eladalonf1841382017-06-12 01:16:46 -07002794TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02002795 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002796 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
isheriff6f8d6862016-05-26 11:24:55 -07002797 recv_parameters_.extensions.push_back(
2798 RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002799 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002800 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
2801 }
2802}
2803
eladalonf1841382017-06-12 01:16:46 -07002804TEST_F(WebRtcVideoChannelTest, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002805 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002806 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002807 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002808 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002809 RtpExtension(RtpExtension::kAbsSendTimeUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002810 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002811
2812 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002813 send_parameters_.extensions.clear();
2814 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002815 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002816 send_parameters_.extensions.push_back(send_parameters_.extensions.back());
2817 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002818}
2819
eladalonf1841382017-06-12 01:16:46 -07002820TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002821 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002822 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002823 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002824 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002825 RtpExtension(RtpExtension::kAbsSendTimeUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002826 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002827
2828 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002829 recv_parameters_.extensions.clear();
2830 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002831 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002832 recv_parameters_.extensions.push_back(recv_parameters_.extensions.back());
2833 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00002834}
2835
eladalonf1841382017-06-12 01:16:46 -07002836TEST_F(WebRtcVideoChannelTest, AddRecvStreamOnlyUsesOneReceiveStream) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002837 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002838 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002839}
2840
eladalonf1841382017-06-12 01:16:46 -07002841TEST_F(WebRtcVideoChannelTest, RtcpIsCompoundByDefault) {
Peter Boströmd7da1202015-06-05 14:09:38 +02002842 FakeVideoReceiveStream* stream = AddRecvStream();
pbosda903ea2015-10-02 02:36:56 -07002843 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
Peter Boströmd7da1202015-06-05 14:09:38 +02002844}
2845
eladalonf1841382017-06-12 01:16:46 -07002846TEST_F(WebRtcVideoChannelTest, TransportCcIsEnabledByDefault) {
stefan43edf0f2015-11-20 18:05:48 -08002847 FakeVideoReceiveStream* stream = AddRecvStream();
2848 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
2849}
2850
eladalonf1841382017-06-12 01:16:46 -07002851TEST_F(WebRtcVideoChannelTest, TransportCcCanBeEnabledAndDisabled) {
stefan43edf0f2015-11-20 18:05:48 -08002852 FakeVideoReceiveStream* stream = AddRecvStream();
2853 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
2854
2855 // Verify that transport cc feedback is turned off when send(!) codecs without
2856 // transport cc feedback are set.
2857 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08002858 parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
stefan43edf0f2015-11-20 18:05:48 -08002859 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
2860 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2861 stream = fake_call_->GetVideoReceiveStreams()[0];
2862 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc);
2863
2864 // Verify that transport cc feedback is turned on when setting default codecs
2865 // since the default codecs have transport cc feedback enabled.
2866 parameters.codecs = engine_.codecs();
2867 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2868 stream = fake_call_->GetVideoReceiveStreams()[0];
2869 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
2870}
2871
Elad Alonfadb1812019-05-24 13:40:02 +02002872TEST_F(WebRtcVideoChannelTest, LossNotificationIsDisabledByDefault) {
2873 TestLossNotificationState(false);
2874}
2875
2876TEST_F(WebRtcVideoChannelTest, LossNotificationIsEnabledByFieldTrial) {
2877 RTC_DCHECK(!override_field_trials_);
Mirko Bonadei317a1f02019-09-17 17:06:18 +02002878 override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
Elad Alonfadb1812019-05-24 13:40:02 +02002879 "WebRTC-RtcpLossNotification/Enabled/");
2880 SetUp();
2881 TestLossNotificationState(true);
2882}
2883
2884TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) {
2885 RTC_DCHECK(!override_field_trials_);
Mirko Bonadei317a1f02019-09-17 17:06:18 +02002886 override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
Elad Alonfadb1812019-05-24 13:40:02 +02002887 "WebRTC-RtcpLossNotification/Enabled/");
2888 SetUp();
2889
2890 AssignDefaultCodec();
2891 VerifyCodecHasDefaultFeedbackParams(default_codec_, true);
2892
2893 {
2894 cricket::VideoSendParameters parameters;
2895 parameters.codecs = engine_.codecs();
2896 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2897 EXPECT_TRUE(channel_->SetSend(true));
2898 }
2899
2900 // Start with LNTF enabled.
2901 FakeVideoSendStream* send_stream =
2902 AddSendStream(cricket::StreamParams::CreateLegacy(1));
2903 ASSERT_TRUE(send_stream->GetConfig().rtp.lntf.enabled);
2904 FakeVideoReceiveStream* recv_stream =
2905 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
2906 ASSERT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled);
2907
2908 // Verify that LNTF is turned off when send(!) codecs without LNTF are set.
2909 cricket::VideoSendParameters parameters;
2910 parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
2911 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
2912 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2913 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2914 EXPECT_FALSE(recv_stream->GetConfig().rtp.lntf.enabled);
2915 send_stream = fake_call_->GetVideoSendStreams()[0];
2916 EXPECT_FALSE(send_stream->GetConfig().rtp.lntf.enabled);
2917
2918 // Setting the default codecs again, including VP8, turns LNTF back on.
2919 parameters.codecs = engine_.codecs();
2920 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2921 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2922 EXPECT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled);
2923 send_stream = fake_call_->GetVideoSendStreams()[0];
2924 EXPECT_TRUE(send_stream->GetConfig().rtp.lntf.enabled);
2925}
2926
eladalonf1841382017-06-12 01:16:46 -07002927TEST_F(WebRtcVideoChannelTest, NackIsEnabledByDefault) {
Anders Carlsson5f2bb622018-05-14 09:48:06 +02002928 AssignDefaultCodec();
Elad Alonfadb1812019-05-24 13:40:02 +02002929 VerifyCodecHasDefaultFeedbackParams(default_codec_, false);
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00002930
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002931 cricket::VideoSendParameters parameters;
2932 parameters.codecs = engine_.codecs();
2933 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org19864742014-05-30 07:35:47 +00002934 EXPECT_TRUE(channel_->SetSend(true));
2935
2936 // Send side.
2937 FakeVideoSendStream* send_stream =
2938 AddSendStream(cricket::StreamParams::CreateLegacy(1));
2939 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
2940
2941 // Receiver side.
2942 FakeVideoReceiveStream* recv_stream =
2943 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
2944 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
2945
2946 // Nack history size should match between sender and receiver.
2947 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
2948 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002949}
2950
eladalonf1841382017-06-12 01:16:46 -07002951TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) {
Peter Boström67c9df72015-05-11 14:34:58 +02002952 FakeVideoSendStream* send_stream = AddSendStream();
Peter Boström3548dd22015-05-22 18:48:36 +02002953 FakeVideoReceiveStream* recv_stream = AddRecvStream();
Peter Boström67c9df72015-05-11 14:34:58 +02002954
2955 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
2956 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
2957
2958 // Verify that NACK is turned off when send(!) codecs without NACK are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002959 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08002960 parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002961 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
2962 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02002963 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2964 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
2965 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00002966 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
2967
Peter Boström67c9df72015-05-11 14:34:58 +02002968 // Verify that NACK is turned on when setting default codecs since the
2969 // default codecs have NACK enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002970 parameters.codecs = engine_.codecs();
2971 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02002972 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2973 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
2974 send_stream = fake_call_->GetVideoSendStreams()[0];
2975 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00002976}
2977
Peter Boströme7ba0862016-03-12 00:02:28 +01002978// This test verifies that new frame sizes reconfigures encoders even though not
2979// (yet) sending. The purpose of this is to permit encoding as quickly as
2980// possible once we start sending. Likely the frames being input are from the
2981// same source that will be sent later, which just means that we're ready
2982// earlier.
eladalonf1841382017-06-12 01:16:46 -07002983TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) {
Peter Boströme7ba0862016-03-12 00:02:28 +01002984 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08002985 parameters.codecs.push_back(GetEngineCodec("VP8"));
Peter Boströme7ba0862016-03-12 00:02:28 +01002986 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2987 channel_->SetSend(false);
2988
2989 FakeVideoSendStream* stream = AddSendStream();
2990
perkjfa10b552016-10-02 23:45:26 -07002991 // No frames entered.
Peter Boströme7ba0862016-03-12 00:02:28 +01002992 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
Danil Chapovalov350531e2018-06-08 11:04:04 +00002993 EXPECT_EQ(0u, streams[0].width);
2994 EXPECT_EQ(0u, streams[0].height);
Peter Boströme7ba0862016-03-12 00:02:28 +01002995
Niels Möller805a27e2019-01-21 12:21:27 +01002996 webrtc::test::FrameForwarder frame_forwarder;
2997 cricket::FakeFrameSource frame_source(1280, 720,
2998 rtc::kNumMicrosecsPerSec / 30);
2999
3000 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
3001 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
Peter Boströme7ba0862016-03-12 00:02:28 +01003002
3003 // Frame entered, should be reconfigured to new dimensions.
3004 streams = stream->GetVideoStreams();
Niels Möller805a27e2019-01-21 12:21:27 +01003005 EXPECT_EQ(rtc::checked_cast<size_t>(1280), streams[0].width);
3006 EXPECT_EQ(rtc::checked_cast<size_t>(720), streams[0].height);
Peter Boströme7ba0862016-03-12 00:02:28 +01003007
Niels Möllerff40b142018-04-09 08:49:14 +02003008 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
Peter Boströme7ba0862016-03-12 00:02:28 +01003009}
3010
eladalonf1841382017-06-12 01:16:46 -07003011TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003012 static const int kScreenshareMinBitrateKbps = 800;
magjed509e4fe2016-11-18 01:34:11 -08003013 cricket::VideoCodec codec = GetEngineCodec("VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003014 cricket::VideoSendParameters parameters;
3015 parameters.codecs.push_back(codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003016 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003017 AddSendStream();
3018
Niels Möller805a27e2019-01-21 12:21:27 +01003019 webrtc::test::FrameForwarder frame_forwarder;
3020 cricket::FakeFrameSource frame_source(1280, 720,
3021 rtc::kNumMicrosecsPerSec / 30);
nisse05103312016-03-16 02:22:50 -07003022 VideoOptions min_bitrate_options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003023 min_bitrate_options.screencast_min_bitrate_kbps = kScreenshareMinBitrateKbps;
Niels Möller805a27e2019-01-21 12:21:27 +01003024 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &min_bitrate_options,
3025 &frame_forwarder));
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003026
3027 EXPECT_TRUE(channel_->SetSend(true));
3028
Niels Möller805a27e2019-01-21 12:21:27 +01003029 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003030 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
3031 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
3032
3033 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
3034
3035 // Verify non-screencast settings.
perkj26091b12016-09-01 01:17:40 -07003036 webrtc::VideoEncoderConfig encoder_config =
3037 send_stream->GetEncoderConfig().Copy();
Erik Språng143cec12015-04-28 10:01:41 +02003038 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003039 encoder_config.content_type);
perkjfa10b552016-10-02 23:45:26 -07003040 std::vector<webrtc::VideoStream> streams = send_stream->GetVideoStreams();
Niels Möller805a27e2019-01-21 12:21:27 +01003041 EXPECT_EQ(rtc::checked_cast<size_t>(1280), streams.front().width);
3042 EXPECT_EQ(rtc::checked_cast<size_t>(720), streams.front().height);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003043 EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
3044 << "Non-screenshare shouldn't use min-transmit bitrate.";
3045
Niels Möllerff40b142018-04-09 08:49:14 +02003046 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
perkjd533aec2017-01-13 05:57:25 -08003047 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
nisse05103312016-03-16 02:22:50 -07003048 VideoOptions screencast_options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003049 screencast_options.is_screencast = true;
Niels Möller805a27e2019-01-21 12:21:27 +01003050 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &screencast_options,
3051 &frame_forwarder));
3052 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
sprangf24a0642017-02-28 13:23:26 -08003053 // Send stream recreated after option change.
3054 ASSERT_EQ(2, fake_call_->GetNumCreatedSendStreams());
3055 send_stream = fake_call_->GetVideoSendStreams().front();
3056 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003057
3058 // Verify screencast settings.
perkj26091b12016-09-01 01:17:40 -07003059 encoder_config = send_stream->GetEncoderConfig().Copy();
Erik Språng143cec12015-04-28 10:01:41 +02003060 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003061 encoder_config.content_type);
3062 EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
3063 encoder_config.min_transmit_bitrate_bps);
3064
perkjfa10b552016-10-02 23:45:26 -07003065 streams = send_stream->GetVideoStreams();
Niels Möller805a27e2019-01-21 12:21:27 +01003066 EXPECT_EQ(rtc::checked_cast<size_t>(1280), streams.front().width);
3067 EXPECT_EQ(rtc::checked_cast<size_t>(720), streams.front().height);
Sergey Silkina796a7e2018-03-01 15:11:29 +01003068 EXPECT_FALSE(streams[0].num_temporal_layers.has_value());
Niels Möllerff40b142018-04-09 08:49:14 +02003069 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003070}
3071
eladalonf1841382017-06-12 01:16:46 -07003072TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003073 ConferenceModeScreencastConfiguresTemporalLayer) {
Rasmus Brandt195d1d72018-05-09 11:28:01 +02003074 static const int kConferenceScreencastTemporalBitrateBps = 200 * 1000;
nisse4b4dc862016-02-17 05:25:36 -08003075 send_parameters_.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003076 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003077
3078 AddSendStream();
nisse05103312016-03-16 02:22:50 -07003079 VideoOptions options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003080 options.is_screencast = true;
Niels Möller805a27e2019-01-21 12:21:27 +01003081 webrtc::test::FrameForwarder frame_forwarder;
3082 cricket::FakeFrameSource frame_source(1280, 720,
3083 rtc::kNumMicrosecsPerSec / 30);
3084 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003085 EXPECT_TRUE(channel_->SetSend(true));
3086
Niels Möller805a27e2019-01-21 12:21:27 +01003087 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003088 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
3089 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
3090
perkj26091b12016-09-01 01:17:40 -07003091 webrtc::VideoEncoderConfig encoder_config =
3092 send_stream->GetEncoderConfig().Copy();
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003093
3094 // Verify screencast settings.
perkj26091b12016-09-01 01:17:40 -07003095 encoder_config = send_stream->GetEncoderConfig().Copy();
Erik Språng143cec12015-04-28 10:01:41 +02003096 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003097 encoder_config.content_type);
perkjfa10b552016-10-02 23:45:26 -07003098
3099 std::vector<webrtc::VideoStream> streams = send_stream->GetVideoStreams();
3100 ASSERT_EQ(1u, streams.size());
Sergey Silkina796a7e2018-03-01 15:11:29 +01003101 ASSERT_EQ(2u, streams[0].num_temporal_layers);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00003102 EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
Sergey Silkina796a7e2018-03-01 15:11:29 +01003103 streams[0].target_bitrate_bps);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00003104
Niels Möllerff40b142018-04-09 08:49:14 +02003105 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003106}
3107
eladalonf1841382017-06-12 01:16:46 -07003108TEST_F(WebRtcVideoChannelTest, SuspendBelowMinBitrateDisabledByDefault) {
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00003109 FakeVideoSendStream* stream = AddSendStream();
3110 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
3111}
3112
eladalonf1841382017-06-12 01:16:46 -07003113TEST_F(WebRtcVideoChannelTest, SetMediaConfigSuspendBelowMinBitrate) {
kthelgason2bc68642017-02-07 07:02:22 -08003114 MediaConfig media_config = GetMediaConfig();
nisse0db023a2016-03-01 04:29:59 -08003115 media_config.video.suspend_below_min_bitrate = true;
3116
Sebastian Jansson84848f22018-11-16 10:40:36 +01003117 channel_.reset(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02003118 fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(),
3119 video_bitrate_allocator_factory_.get()));
Sergey Ulanove2b15012016-11-22 16:08:30 -08003120 channel_->OnReadyToSend(true);
nisse0db023a2016-03-01 04:29:59 -08003121
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003122 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00003123
3124 FakeVideoSendStream* stream = AddSendStream();
3125 EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
3126
nisse0db023a2016-03-01 04:29:59 -08003127 media_config.video.suspend_below_min_bitrate = false;
Sebastian Jansson84848f22018-11-16 10:40:36 +01003128 channel_.reset(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02003129 fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(),
3130 video_bitrate_allocator_factory_.get()));
Sergey Ulanove2b15012016-11-22 16:08:30 -08003131 channel_->OnReadyToSend(true);
nisse0db023a2016-03-01 04:29:59 -08003132
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003133 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00003134
nisse0db023a2016-03-01 04:29:59 -08003135 stream = AddSendStream();
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00003136 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
3137}
3138
eladalonf1841382017-06-12 01:16:46 -07003139TEST_F(WebRtcVideoChannelTest, Vp8DenoisingEnabledByDefault) {
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00003140 FakeVideoSendStream* stream = AddSendStream();
3141 webrtc::VideoCodecVP8 vp8_settings;
3142 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
3143 EXPECT_TRUE(vp8_settings.denoisingOn);
3144}
3145
eladalonf1841382017-06-12 01:16:46 -07003146TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003147 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08003148 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003149 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00003150
Peter Boström2feafdb2015-09-09 14:32:14 +02003151 // Single-stream settings should apply with RTX as well (verifies that we
3152 // check number of regular SSRCs and not StreamParams::ssrcs which contains
3153 // both RTX and regular SSRCs).
3154 FakeVideoSendStream* stream = SetUpSimulcast(false, true);
Erik Språng143cec12015-04-28 10:01:41 +02003155
Niels Möller805a27e2019-01-21 12:21:27 +01003156 webrtc::test::FrameForwarder frame_forwarder;
3157 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
Erik Språng143cec12015-04-28 10:01:41 +02003158 channel_->SetSend(true);
3159
Niels Möller805a27e2019-01-21 12:21:27 +01003160 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Erik Språng143cec12015-04-28 10:01:41 +02003161
pbos4cba4eb2015-10-26 11:18:18 -07003162 webrtc::VideoCodecVP8 vp8_settings;
3163 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
3164 EXPECT_TRUE(vp8_settings.denoisingOn)
3165 << "VP8 denoising should be on by default.";
3166
Niels Möller805a27e2019-01-21 12:21:27 +01003167 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false);
Erik Språng143cec12015-04-28 10:01:41 +02003168
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00003169 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
3170 EXPECT_FALSE(vp8_settings.denoisingOn);
Erik Språng143cec12015-04-28 10:01:41 +02003171 EXPECT_TRUE(vp8_settings.automaticResizeOn);
3172 EXPECT_TRUE(vp8_settings.frameDroppingOn);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00003173
Niels Möller805a27e2019-01-21 12:21:27 +01003174 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, true);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00003175
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00003176 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
3177 EXPECT_TRUE(vp8_settings.denoisingOn);
Erik Språng143cec12015-04-28 10:01:41 +02003178 EXPECT_TRUE(vp8_settings.automaticResizeOn);
3179 EXPECT_TRUE(vp8_settings.frameDroppingOn);
3180
Niels Möllerff40b142018-04-09 08:49:14 +02003181 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
Peter Boström2feafdb2015-09-09 14:32:14 +02003182 stream = SetUpSimulcast(true, false);
Niels Möller805a27e2019-01-21 12:21:27 +01003183 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
Erik Språng143cec12015-04-28 10:01:41 +02003184 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01003185 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Erik Språng143cec12015-04-28 10:01:41 +02003186
Mirko Bonadeif859e552018-05-30 15:31:29 +02003187 EXPECT_EQ(3u, stream->GetVideoStreams().size());
Erik Språng143cec12015-04-28 10:01:41 +02003188 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
3189 // Autmatic resize off when using simulcast.
3190 EXPECT_FALSE(vp8_settings.automaticResizeOn);
3191 EXPECT_TRUE(vp8_settings.frameDroppingOn);
3192
Florent Castelli66b38602019-07-10 16:57:57 +02003193 // In screen-share mode, denoising is forced off.
nisse05103312016-03-16 02:22:50 -07003194 VideoOptions options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003195 options.is_screencast = true;
Niels Möller805a27e2019-01-21 12:21:27 +01003196 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Niels Möller60653ba2016-03-02 11:41:36 +01003197
Niels Möller805a27e2019-01-21 12:21:27 +01003198 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false);
Erik Språng143cec12015-04-28 10:01:41 +02003199
Florent Castelli66b38602019-07-10 16:57:57 +02003200 EXPECT_EQ(3u, stream->GetVideoStreams().size());
Erik Språng143cec12015-04-28 10:01:41 +02003201 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
3202 EXPECT_FALSE(vp8_settings.denoisingOn);
3203 // Resizing and frame dropping always off for screen sharing.
3204 EXPECT_FALSE(vp8_settings.automaticResizeOn);
3205 EXPECT_FALSE(vp8_settings.frameDroppingOn);
3206
Niels Möller805a27e2019-01-21 12:21:27 +01003207 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, true);
Erik Språng143cec12015-04-28 10:01:41 +02003208
3209 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
3210 EXPECT_FALSE(vp8_settings.denoisingOn);
3211 EXPECT_FALSE(vp8_settings.automaticResizeOn);
3212 EXPECT_FALSE(vp8_settings.frameDroppingOn);
3213
Niels Möllerff40b142018-04-09 08:49:14 +02003214 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
Erik Språng143cec12015-04-28 10:01:41 +02003215}
3216
deadbeef119760a2016-04-04 11:43:27 -07003217// Test that setting the same options doesn't result in the encoder being
3218// reconfigured.
eladalonf1841382017-06-12 01:16:46 -07003219TEST_F(WebRtcVideoChannelTest, SetIdenticalOptionsDoesntReconfigureEncoder) {
deadbeef119760a2016-04-04 11:43:27 -07003220 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01003221 webrtc::test::FrameForwarder frame_forwarder;
deadbeef119760a2016-04-04 11:43:27 -07003222
perkjfa10b552016-10-02 23:45:26 -07003223 AddSendStream();
perkjfa10b552016-10-02 23:45:26 -07003224 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08003225 parameters.codecs.push_back(GetEngineCodec("VP8"));
perkjfa10b552016-10-02 23:45:26 -07003226 ASSERT_TRUE(channel_->SetSendParameters(parameters));
3227 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
3228
Niels Möller805a27e2019-01-21 12:21:27 +01003229 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
3230 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
3231 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
perkjfa10b552016-10-02 23:45:26 -07003232 // Expect 1 reconfigurations at this point from the initial configuration.
3233 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations());
deadbeef119760a2016-04-04 11:43:27 -07003234
3235 // Set the options one more time and expect no additional reconfigurations.
Niels Möller805a27e2019-01-21 12:21:27 +01003236 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
perkjfa10b552016-10-02 23:45:26 -07003237 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations());
3238
3239 // Change |options| and expect 2 reconfigurations.
Oskar Sundbom78807582017-11-16 11:09:55 +01003240 options.video_noise_reduction = true;
Niels Möller805a27e2019-01-21 12:21:27 +01003241 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
deadbeef119760a2016-04-04 11:43:27 -07003242 EXPECT_EQ(2, send_stream->num_encoder_reconfigurations());
3243
Niels Möllerff40b142018-04-09 08:49:14 +02003244 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
deadbeef119760a2016-04-04 11:43:27 -07003245}
3246
eladalonf1841382017-06-12 01:16:46 -07003247class Vp9SettingsTest : public WebRtcVideoChannelTest {
Erik Språng143cec12015-04-28 10:01:41 +02003248 public:
asaperssonc5dabdd2016-03-21 04:15:50 -07003249 Vp9SettingsTest() : Vp9SettingsTest("") {}
3250 explicit Vp9SettingsTest(const char* field_trials)
eladalonf1841382017-06-12 01:16:46 -07003251 : WebRtcVideoChannelTest(field_trials) {
Magnus Jedvert02e7a192017-09-23 17:21:32 +02003252 encoder_factory_->AddSupportedVideoCodecType("VP9");
Erik Språng143cec12015-04-28 10:01:41 +02003253 }
3254 virtual ~Vp9SettingsTest() {}
3255
3256 protected:
Erik Språng143cec12015-04-28 10:01:41 +02003257 void TearDown() override {
3258 // Remove references to encoder_factory_ since this will be destroyed
3259 // before channel_ and engine_.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003260 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
Erik Språng143cec12015-04-28 10:01:41 +02003261 }
Erik Språng143cec12015-04-28 10:01:41 +02003262};
3263
3264TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003265 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08003266 parameters.codecs.push_back(GetEngineCodec("VP9"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003267 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Erik Språng143cec12015-04-28 10:01:41 +02003268
Peter Boström2feafdb2015-09-09 14:32:14 +02003269 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
Erik Språng143cec12015-04-28 10:01:41 +02003270
Niels Möller805a27e2019-01-21 12:21:27 +01003271 webrtc::test::FrameForwarder frame_forwarder;
3272 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
Erik Språng143cec12015-04-28 10:01:41 +02003273 channel_->SetSend(true);
3274
Niels Möller805a27e2019-01-21 12:21:27 +01003275 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Erik Språng143cec12015-04-28 10:01:41 +02003276
pbos4cba4eb2015-10-26 11:18:18 -07003277 webrtc::VideoCodecVP9 vp9_settings;
3278 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
jianja5e8aa62017-03-27 10:09:00 -07003279 EXPECT_TRUE(vp9_settings.denoisingOn)
3280 << "VP9 denoising should be on by default.";
pbos4cba4eb2015-10-26 11:18:18 -07003281
Niels Möller805a27e2019-01-21 12:21:27 +01003282 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false);
Erik Språng143cec12015-04-28 10:01:41 +02003283
Erik Språng143cec12015-04-28 10:01:41 +02003284 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
3285 EXPECT_FALSE(vp9_settings.denoisingOn);
3286 // Frame dropping always on for real time video.
3287 EXPECT_TRUE(vp9_settings.frameDroppingOn);
3288
Niels Möller805a27e2019-01-21 12:21:27 +01003289 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, true);
Erik Språng143cec12015-04-28 10:01:41 +02003290
3291 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
3292 EXPECT_TRUE(vp9_settings.denoisingOn);
3293 EXPECT_TRUE(vp9_settings.frameDroppingOn);
3294
3295 // In screen-share mode, denoising is forced off.
nisse05103312016-03-16 02:22:50 -07003296 VideoOptions options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003297 options.is_screencast = true;
Niels Möller805a27e2019-01-21 12:21:27 +01003298 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
perkj2d5f0912016-02-29 00:04:41 -08003299
Niels Möller805a27e2019-01-21 12:21:27 +01003300 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false);
Erik Språng143cec12015-04-28 10:01:41 +02003301
3302 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
3303 EXPECT_FALSE(vp9_settings.denoisingOn);
Sergey Silkinbe71a1e2018-05-17 16:46:43 +02003304 // Frame dropping always on for screen sharing.
3305 EXPECT_TRUE(vp9_settings.frameDroppingOn);
Erik Språng143cec12015-04-28 10:01:41 +02003306
Niels Möller805a27e2019-01-21 12:21:27 +01003307 stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false);
Erik Språng143cec12015-04-28 10:01:41 +02003308
3309 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
3310 EXPECT_FALSE(vp9_settings.denoisingOn);
Sergey Silkinbe71a1e2018-05-17 16:46:43 +02003311 EXPECT_TRUE(vp9_settings.frameDroppingOn);
Erik Språng143cec12015-04-28 10:01:41 +02003312
Niels Möllerff40b142018-04-09 08:49:14 +02003313 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003314}
3315
Sergey Silkinf18072e2018-03-14 10:35:35 +01003316TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) {
3317 cricket::VideoSendParameters parameters;
3318 parameters.codecs.push_back(GetEngineCodec("VP9"));
3319 ASSERT_TRUE(channel_->SetSendParameters(parameters));
3320
3321 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
3322
3323 FakeVideoSendStream* stream =
3324 AddSendStream(CreateSimStreamParams("cname", ssrcs));
3325
3326 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
Sergey Silkinf18072e2018-03-14 10:35:35 +01003327
Niels Möller805a27e2019-01-21 12:21:27 +01003328 webrtc::test::FrameForwarder frame_forwarder;
3329 EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder));
Sergey Silkinf18072e2018-03-14 10:35:35 +01003330 channel_->SetSend(true);
3331
Niels Möller805a27e2019-01-21 12:21:27 +01003332 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Sergey Silkinf18072e2018-03-14 10:35:35 +01003333
3334 webrtc::VideoCodecVP9 vp9_settings;
3335 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
3336
3337 const size_t kNumSpatialLayers = ssrcs.size();
3338 const size_t kNumTemporalLayers = 3;
3339 EXPECT_EQ(vp9_settings.numberOfSpatialLayers, kNumSpatialLayers);
3340 EXPECT_EQ(vp9_settings.numberOfTemporalLayers, kNumTemporalLayers);
3341
Niels Möllerff40b142018-04-09 08:49:14 +02003342 EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, nullptr));
Sergey Silkinf18072e2018-03-14 10:35:35 +01003343}
3344
Ilya Nikolaevskiy33d2a912019-04-02 11:05:03 +02003345TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) {
3346 cricket::VideoSendParameters parameters;
3347 parameters.codecs.push_back(GetEngineCodec("VP9"));
3348 ASSERT_TRUE(channel_->SetSendParameters(parameters));
3349
3350 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
3351
3352 FakeVideoSendStream* stream =
3353 AddSendStream(CreateSimStreamParams("cname", ssrcs));
3354
3355 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3356
3357 // Despite 3 ssrcs provided, single layer is used.
3358 EXPECT_EQ(1u, config.rtp.ssrcs.size());
3359
3360 webrtc::test::FrameForwarder frame_forwarder;
3361 EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder));
3362 channel_->SetSend(true);
3363
3364 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
3365
3366 webrtc::VideoCodecVP9 vp9_settings;
3367 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
3368
3369 const size_t kNumSpatialLayers = ssrcs.size();
3370 EXPECT_EQ(vp9_settings.numberOfSpatialLayers, kNumSpatialLayers);
3371
3372 EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, nullptr));
3373}
3374
Sergey Silkin8b9b5f92018-12-10 09:28:53 +01003375TEST_F(Vp9SettingsTest, AllEncodingParametersCopied) {
3376 cricket::VideoSendParameters send_parameters;
3377 send_parameters.codecs.push_back(GetEngineCodec("VP9"));
3378 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
3379
3380 const size_t kNumSpatialLayers = 3;
3381 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
3382
3383 FakeVideoSendStream* stream =
3384 AddSendStream(CreateSimStreamParams("cname", ssrcs));
3385
3386 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrcs[0]);
3387 ASSERT_EQ(kNumSpatialLayers, parameters.encodings.size());
3388 ASSERT_TRUE(parameters.encodings[0].active);
3389 ASSERT_TRUE(parameters.encodings[1].active);
3390 ASSERT_TRUE(parameters.encodings[2].active);
3391 // Invert value to verify copying.
3392 parameters.encodings[1].active = false;
3393 EXPECT_TRUE(channel_->SetRtpSendParameters(ssrcs[0], parameters).ok());
3394
3395 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
3396
3397 // number_of_streams should be 1 since all spatial layers are sent on the
3398 // same SSRC. But encoding parameters of all layers is supposed to be copied
3399 // and stored in simulcast_layers[].
3400 EXPECT_EQ(1u, encoder_config.number_of_streams);
3401 EXPECT_EQ(encoder_config.simulcast_layers.size(), kNumSpatialLayers);
3402 EXPECT_TRUE(encoder_config.simulcast_layers[0].active);
3403 EXPECT_FALSE(encoder_config.simulcast_layers[1].active);
3404 EXPECT_TRUE(encoder_config.simulcast_layers[2].active);
3405}
3406
Sergey Silkincf267052019-04-09 11:40:09 +02003407class Vp9SettingsTestWithFieldTrial
3408 : public Vp9SettingsTest,
3409 public ::testing::WithParamInterface<
3410 ::testing::tuple<const char*, int, int, webrtc::InterLayerPredMode>> {
asaperssonc5dabdd2016-03-21 04:15:50 -07003411 protected:
Sergey Silkincf267052019-04-09 11:40:09 +02003412 Vp9SettingsTestWithFieldTrial()
3413 : Vp9SettingsTest(::testing::get<0>(GetParam())),
3414 num_spatial_layers_(::testing::get<1>(GetParam())),
3415 num_temporal_layers_(::testing::get<2>(GetParam())),
Sergey Silkin19da5ce2019-05-20 17:57:17 +02003416 inter_layer_pred_mode_(::testing::get<3>(GetParam())) {}
Sergey Silkincf267052019-04-09 11:40:09 +02003417
3418 void VerifySettings(int num_spatial_layers,
3419 int num_temporal_layers,
3420 webrtc::InterLayerPredMode interLayerPred) {
asaperssonc5dabdd2016-03-21 04:15:50 -07003421 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08003422 parameters.codecs.push_back(GetEngineCodec("VP9"));
asaperssonc5dabdd2016-03-21 04:15:50 -07003423 ASSERT_TRUE(channel_->SetSendParameters(parameters));
3424
3425 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
3426
Niels Möller805a27e2019-01-21 12:21:27 +01003427 webrtc::test::FrameForwarder frame_forwarder;
3428 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
asaperssonc5dabdd2016-03-21 04:15:50 -07003429 channel_->SetSend(true);
3430
Niels Möller805a27e2019-01-21 12:21:27 +01003431 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
asaperssonc5dabdd2016-03-21 04:15:50 -07003432
3433 webrtc::VideoCodecVP9 vp9_settings;
3434 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
3435 EXPECT_EQ(num_spatial_layers, vp9_settings.numberOfSpatialLayers);
3436 EXPECT_EQ(num_temporal_layers, vp9_settings.numberOfTemporalLayers);
Sergey Silkin19da5ce2019-05-20 17:57:17 +02003437 EXPECT_EQ(inter_layer_pred_mode_, vp9_settings.interLayerPred);
asaperssonc5dabdd2016-03-21 04:15:50 -07003438
Niels Möllerff40b142018-04-09 08:49:14 +02003439 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
asaperssonc5dabdd2016-03-21 04:15:50 -07003440 }
Sergey Silkincf267052019-04-09 11:40:09 +02003441
3442 const uint8_t num_spatial_layers_;
3443 const uint8_t num_temporal_layers_;
Sergey Silkin19da5ce2019-05-20 17:57:17 +02003444 const webrtc::InterLayerPredMode inter_layer_pred_mode_;
asaperssonc5dabdd2016-03-21 04:15:50 -07003445};
3446
Sergey Silkincf267052019-04-09 11:40:09 +02003447TEST_P(Vp9SettingsTestWithFieldTrial, VerifyCodecSettings) {
Sergey Silkin19da5ce2019-05-20 17:57:17 +02003448 VerifySettings(num_spatial_layers_, num_temporal_layers_,
3449 inter_layer_pred_mode_);
asaperssonc5dabdd2016-03-21 04:15:50 -07003450}
3451
Sergey Silkincf267052019-04-09 11:40:09 +02003452INSTANTIATE_TEST_SUITE_P(
Mirko Bonadei09f11952019-09-29 10:19:42 +02003453 All,
Sergey Silkincf267052019-04-09 11:40:09 +02003454 Vp9SettingsTestWithFieldTrial,
3455 ::testing::Values(
3456 std::make_tuple("", 1, 1, webrtc::InterLayerPredMode::kOnKeyPic),
3457 std::make_tuple("WebRTC-SupportVP9SVC/Default/",
3458 1,
3459 1,
3460 webrtc::InterLayerPredMode::kOnKeyPic),
3461 std::make_tuple("WebRTC-SupportVP9SVC/EnabledByFlag_2SL3TL/",
3462 2,
3463 3,
3464 webrtc::InterLayerPredMode::kOnKeyPic),
Sergey Silkin19da5ce2019-05-20 17:57:17 +02003465 std::make_tuple("WebRTC-Vp9InterLayerPred/Default/",
Sergey Silkincf267052019-04-09 11:40:09 +02003466 1,
3467 1,
Sergey Silkin19da5ce2019-05-20 17:57:17 +02003468 webrtc::InterLayerPredMode::kOnKeyPic),
3469 std::make_tuple("WebRTC-Vp9InterLayerPred/Disabled/",
Sergey Silkincf267052019-04-09 11:40:09 +02003470 1,
3471 1,
Sergey Silkin19da5ce2019-05-20 17:57:17 +02003472 webrtc::InterLayerPredMode::kOnKeyPic),
3473 std::make_tuple(
3474 "WebRTC-Vp9InterLayerPred/Enabled,inter_layer_pred_mode:off/",
3475 1,
3476 1,
3477 webrtc::InterLayerPredMode::kOff),
3478 std::make_tuple(
3479 "WebRTC-Vp9InterLayerPred/Enabled,inter_layer_pred_mode:on/",
3480 1,
3481 1,
3482 webrtc::InterLayerPredMode::kOn),
3483 std::make_tuple(
3484 "WebRTC-Vp9InterLayerPred/Enabled,inter_layer_pred_mode:onkeypic/",
3485 1,
3486 1,
3487 webrtc::InterLayerPredMode::kOnKeyPic)));
asaperssonc5dabdd2016-03-21 04:15:50 -07003488
Åsa Persson45bbc8a2017-11-13 10:16:47 +01003489TEST_F(WebRtcVideoChannelTest, VerifyMinBitrate) {
3490 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
3491 ASSERT_EQ(1u, streams.size());
3492 EXPECT_EQ(cricket::kMinVideoBitrateBps, streams[0].min_bitrate_bps);
3493}
3494
3495TEST_F(WebRtcVideoChannelTest, VerifyMinBitrateWithForcedFallbackFieldTrial) {
Elad Alon040dc432019-05-22 15:40:02 +02003496 RTC_DCHECK(!override_field_trials_);
Mirko Bonadei317a1f02019-09-17 17:06:18 +02003497 override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
Åsa Persson45bbc8a2017-11-13 10:16:47 +01003498 "WebRTC-VP8-Forced-Fallback-Encoder-v2/Enabled-1,2,34567/");
3499 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
3500 ASSERT_EQ(1u, streams.size());
3501 EXPECT_EQ(34567, streams[0].min_bitrate_bps);
3502}
3503
asapersson3c81a1a2017-06-14 05:52:21 -07003504TEST_F(WebRtcVideoChannelTest,
3505 BalancedDegradationPreferenceNotSupportedWithoutFieldtrial) {
Elad Alon040dc432019-05-22 15:40:02 +02003506 RTC_DCHECK(!override_field_trials_);
Mirko Bonadei317a1f02019-09-17 17:06:18 +02003507 override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
asapersson3c81a1a2017-06-14 05:52:21 -07003508 "WebRTC-Video-BalancedDegradation/Disabled/");
3509 const bool kResolutionScalingEnabled = true;
3510 const bool kFpsScalingEnabled = false;
3511 TestDegradationPreference(kResolutionScalingEnabled, kFpsScalingEnabled);
3512}
3513
3514TEST_F(WebRtcVideoChannelTest,
3515 BalancedDegradationPreferenceSupportedBehindFieldtrial) {
Elad Alon040dc432019-05-22 15:40:02 +02003516 RTC_DCHECK(!override_field_trials_);
Mirko Bonadei317a1f02019-09-17 17:06:18 +02003517 override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
asapersson3c81a1a2017-06-14 05:52:21 -07003518 "WebRTC-Video-BalancedDegradation/Enabled/");
3519 const bool kResolutionScalingEnabled = true;
3520 const bool kFpsScalingEnabled = true;
3521 TestDegradationPreference(kResolutionScalingEnabled, kFpsScalingEnabled);
3522}
3523
eladalonf1841382017-06-12 01:16:46 -07003524TEST_F(WebRtcVideoChannelTest, AdaptsOnOveruse) {
Erik Språngefbde372015-04-29 16:21:28 +02003525 TestCpuAdaptation(true, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003526}
3527
eladalonf1841382017-06-12 01:16:46 -07003528TEST_F(WebRtcVideoChannelTest, DoesNotAdaptOnOveruseWhenDisabled) {
Erik Språngefbde372015-04-29 16:21:28 +02003529 TestCpuAdaptation(false, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003530}
3531
Niels Möller3de32e62019-01-18 08:42:18 +01003532TEST_F(WebRtcVideoChannelTest, DoesNotAdaptWhenScreeensharing) {
3533 TestCpuAdaptation(false, true);
3534}
3535
eladalonf1841382017-06-12 01:16:46 -07003536TEST_F(WebRtcVideoChannelTest, DoesNotAdaptOnOveruseWhenScreensharing) {
Erik Språngefbde372015-04-29 16:21:28 +02003537 TestCpuAdaptation(true, true);
3538}
3539
eladalonf1841382017-06-12 01:16:46 -07003540TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
magjed509e4fe2016-11-18 01:34:11 -08003541 cricket::VideoCodec codec = GetEngineCodec("VP8");
Per766ad3b2016-04-05 15:23:49 +02003542 cricket::VideoSendParameters parameters;
3543 parameters.codecs.push_back(codec);
3544
kthelgason2bc68642017-02-07 07:02:22 -08003545 MediaConfig media_config = GetMediaConfig();
Niels Möller1d7ecd22018-01-18 15:25:12 +01003546 media_config.video.enable_cpu_adaptation = true;
Sebastian Jansson84848f22018-11-16 10:40:36 +01003547 channel_.reset(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02003548 fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(),
3549 video_bitrate_allocator_factory_.get()));
Sergey Ulanove2b15012016-11-22 16:08:30 -08003550 channel_->OnReadyToSend(true);
Per766ad3b2016-04-05 15:23:49 +02003551 ASSERT_TRUE(channel_->SetSendParameters(parameters));
3552
3553 AddSendStream();
Niels Möller805a27e2019-01-21 12:21:27 +01003554 webrtc::test::FrameForwarder frame_forwarder;
Per766ad3b2016-04-05 15:23:49 +02003555
Per766ad3b2016-04-05 15:23:49 +02003556 ASSERT_TRUE(channel_->SetSend(true));
3557 cricket::VideoOptions camera_options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003558 camera_options.is_screencast = false;
Niels Möller805a27e2019-01-21 12:21:27 +01003559 channel_->SetVideoSend(last_ssrc_, &camera_options, &frame_forwarder);
Per766ad3b2016-04-05 15:23:49 +02003560
3561 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
3562 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
Per766ad3b2016-04-05 15:23:49 +02003563
Niels Möllerdcc70292019-01-15 16:32:38 +01003564 EXPECT_TRUE(send_stream->resolution_scaling_enabled());
3565 // Dont' expect anything on framerate_scaling_enabled, since the default is
3566 // transitioning from MAINTAIN_FRAMERATE to BALANCED.
Per766ad3b2016-04-05 15:23:49 +02003567
Niels Möllerdcc70292019-01-15 16:32:38 +01003568 // Switch to screen share. Expect no resolution scaling.
Per766ad3b2016-04-05 15:23:49 +02003569 cricket::VideoOptions screenshare_options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003570 screenshare_options.is_screencast = true;
Niels Möller805a27e2019-01-21 12:21:27 +01003571 channel_->SetVideoSend(last_ssrc_, &screenshare_options, &frame_forwarder);
sprangf24a0642017-02-28 13:23:26 -08003572 ASSERT_EQ(2, fake_call_->GetNumCreatedSendStreams());
3573 send_stream = fake_call_->GetVideoSendStreams().front();
Niels Möllerdcc70292019-01-15 16:32:38 +01003574 EXPECT_FALSE(send_stream->resolution_scaling_enabled());
Per766ad3b2016-04-05 15:23:49 +02003575
Niels Möllerdcc70292019-01-15 16:32:38 +01003576 // Switch back to the normal capturer. Expect resolution scaling to be
3577 // reenabled.
Niels Möller805a27e2019-01-21 12:21:27 +01003578 channel_->SetVideoSend(last_ssrc_, &camera_options, &frame_forwarder);
3579 send_stream = fake_call_->GetVideoSendStreams().front();
sprangf24a0642017-02-28 13:23:26 -08003580 ASSERT_EQ(3, fake_call_->GetNumCreatedSendStreams());
3581 send_stream = fake_call_->GetVideoSendStreams().front();
Niels Möllerdcc70292019-01-15 16:32:38 +01003582 EXPECT_TRUE(send_stream->resolution_scaling_enabled());
Per766ad3b2016-04-05 15:23:49 +02003583
Niels Möllerff40b142018-04-09 08:49:14 +02003584 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
Per766ad3b2016-04-05 15:23:49 +02003585}
3586
asapersson3c81a1a2017-06-14 05:52:21 -07003587// TODO(asapersson): Remove this test when the balanced field trial is removed.
3588void WebRtcVideoChannelTest::TestDegradationPreference(
3589 bool resolution_scaling_enabled,
3590 bool fps_scaling_enabled) {
3591 cricket::VideoCodec codec = GetEngineCodec("VP8");
3592 cricket::VideoSendParameters parameters;
3593 parameters.codecs.push_back(codec);
3594
3595 MediaConfig media_config = GetMediaConfig();
Niels Möller1d7ecd22018-01-18 15:25:12 +01003596 media_config.video.enable_cpu_adaptation = true;
Sebastian Jansson84848f22018-11-16 10:40:36 +01003597 channel_.reset(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02003598 fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(),
3599 video_bitrate_allocator_factory_.get()));
asapersson3c81a1a2017-06-14 05:52:21 -07003600 channel_->OnReadyToSend(true);
3601
3602 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3603
3604 AddSendStream();
3605
Niels Möller805a27e2019-01-21 12:21:27 +01003606 webrtc::test::FrameForwarder frame_forwarder;
asapersson3c81a1a2017-06-14 05:52:21 -07003607 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01003608 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
asapersson3c81a1a2017-06-14 05:52:21 -07003609
3610 EXPECT_TRUE(channel_->SetSend(true));
3611
3612 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
3613 EXPECT_EQ(resolution_scaling_enabled,
3614 send_stream->resolution_scaling_enabled());
3615 EXPECT_EQ(fps_scaling_enabled, send_stream->framerate_scaling_enabled());
3616
Niels Möllerff40b142018-04-09 08:49:14 +02003617 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
asapersson3c81a1a2017-06-14 05:52:21 -07003618}
3619
eladalonf1841382017-06-12 01:16:46 -07003620void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse,
3621 bool is_screenshare) {
magjed509e4fe2016-11-18 01:34:11 -08003622 cricket::VideoCodec codec = GetEngineCodec("VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003623 cricket::VideoSendParameters parameters;
3624 parameters.codecs.push_back(codec);
nisse51542be2016-02-12 02:27:06 -08003625
kthelgason2bc68642017-02-07 07:02:22 -08003626 MediaConfig media_config = GetMediaConfig();
3627 if (enable_overuse) {
Niels Möller1d7ecd22018-01-18 15:25:12 +01003628 media_config.video.enable_cpu_adaptation = true;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00003629 }
Sebastian Jansson84848f22018-11-16 10:40:36 +01003630 channel_.reset(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02003631 fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(),
3632 video_bitrate_allocator_factory_.get()));
Sergey Ulanove2b15012016-11-22 16:08:30 -08003633 channel_->OnReadyToSend(true);
nisse51542be2016-02-12 02:27:06 -08003634
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003635 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00003636
3637 AddSendStream();
3638
Niels Möller805a27e2019-01-21 12:21:27 +01003639 webrtc::test::FrameForwarder frame_forwarder;
nisse05103312016-03-16 02:22:50 -07003640 VideoOptions options;
Oskar Sundbom78807582017-11-16 11:09:55 +01003641 options.is_screencast = is_screenshare;
Niels Möller805a27e2019-01-21 12:21:27 +01003642 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00003643
3644 EXPECT_TRUE(channel_->SetSend(true));
3645
solenberge5269742015-09-08 05:13:22 -07003646 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
perkj2d5f0912016-02-29 00:04:41 -08003647
sprangc5d62e22017-04-02 23:53:04 -07003648 if (!enable_overuse) {
perkj803d97f2016-11-01 11:45:46 -07003649 EXPECT_FALSE(send_stream->resolution_scaling_enabled());
sprangc5d62e22017-04-02 23:53:04 -07003650 EXPECT_FALSE(send_stream->framerate_scaling_enabled());
Niels Möller805a27e2019-01-21 12:21:27 +01003651 } else if (is_screenshare) {
sprangc5d62e22017-04-02 23:53:04 -07003652 EXPECT_FALSE(send_stream->resolution_scaling_enabled());
3653 EXPECT_TRUE(send_stream->framerate_scaling_enabled());
3654 } else {
3655 EXPECT_TRUE(send_stream->resolution_scaling_enabled());
3656 EXPECT_FALSE(send_stream->framerate_scaling_enabled());
3657 }
Niels Möllerff40b142018-04-09 08:49:14 +02003658 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003659}
3660
eladalonf1841382017-06-12 01:16:46 -07003661TEST_F(WebRtcVideoChannelTest, EstimatesNtpStartTimeCorrectly) {
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003662 // Start at last timestamp to verify that wraparounds are estimated correctly.
3663 static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
3664 static const int64_t kInitialNtpTimeMs = 1247891230;
3665 static const int kFrameOffsetMs = 20;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003666 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003667
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003668 FakeVideoReceiveStream* stream = AddRecvStream();
3669 cricket::FakeVideoRenderer renderer;
nisse08582ff2016-02-04 01:24:52 -08003670 EXPECT_TRUE(channel_->SetSink(last_ssrc_, &renderer));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003671
Artem Titov1ebfb6a2019-01-03 23:49:37 +01003672 webrtc::VideoFrame video_frame =
3673 webrtc::VideoFrame::Builder()
3674 .set_video_frame_buffer(CreateBlackFrameBuffer(4, 4))
3675 .set_timestamp_rtp(kInitialTimestamp)
3676 .set_timestamp_us(0)
3677 .set_rotation(webrtc::kVideoRotation_0)
3678 .build();
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003679 // Initial NTP time is not available on the first frame, but should still be
3680 // able to be estimated.
nisseeb83a1a2016-03-21 01:27:56 -07003681 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003682
3683 EXPECT_EQ(1, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003684
3685 // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which
3686 // triggers a constant-overflow warning, hence we're calculating it explicitly
3687 // here.
Sebastian Jansson40889f32019-04-17 12:11:20 +02003688 fake_clock_.AdvanceTime(webrtc::TimeDelta::ms(kFrameOffsetMs));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003689 video_frame.set_timestamp(kFrameOffsetMs * 90 - 1);
3690 video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs);
nisseeb83a1a2016-03-21 01:27:56 -07003691 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003692
3693 EXPECT_EQ(2, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003694
3695 // Verify that NTP time has been correctly deduced.
3696 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003697 ASSERT_TRUE(channel_->GetStats(&info));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00003698 ASSERT_EQ(1u, info.receivers.size());
3699 EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003700}
3701
eladalonf1841382017-06-12 01:16:46 -07003702TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) {
Anders Carlsson5f2bb622018-05-14 09:48:06 +02003703 AssignDefaultAptRtxTypes();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003704 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003705
3706 VideoCodec codec;
3707 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00003708 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003709
3710 // Using a RTX setup to verify that the default RTX payload type is good.
Peter Boström0c4e06b2015-10-07 12:23:21 +02003711 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3712 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003713 FakeVideoSendStream* stream = AddSendStream(
3714 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
perkj26091b12016-09-01 01:17:40 -07003715 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003716
3717 // Make sure NACK and FEC are enabled on the correct payload types.
3718 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
magjed509e4fe2016-11-18 01:34:11 -08003719 EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
3720 EXPECT_EQ(GetEngineCodec("red").id, config.rtp.ulpfec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00003721
3722 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
3723 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
Shao Changbine62202f2015-04-21 20:24:50 +08003724 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003725 // TODO(juberti): Check RTCP, PLI, TMMBR.
3726}
3727
Mirta Dvornicic479a3c02019-06-04 15:38:50 +02003728TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutPacketization) {
3729 cricket::VideoSendParameters parameters;
3730 parameters.codecs.push_back(GetEngineCodec("VP8"));
3731 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3732
3733 FakeVideoSendStream* stream = AddSendStream();
3734 const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3735 EXPECT_FALSE(config.rtp.raw_payload);
3736}
3737
3738TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithPacketization) {
3739 cricket::VideoSendParameters parameters;
3740 parameters.codecs.push_back(GetEngineCodec("VP8"));
3741 parameters.codecs.back().packetization = kPacketizationParamRaw;
3742 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3743
3744 FakeVideoSendStream* stream = AddSendStream();
3745 const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3746 EXPECT_TRUE(config.rtp.raw_payload);
3747}
3748
brandtr31bd2242017-05-19 05:47:46 -07003749// The following four tests ensures that FlexFEC is not activated by default
3750// when the field trials are not enabled.
3751// TODO(brandtr): Remove or update these tests when FlexFEC _is_ enabled by
3752// default.
Yves Gerey665174f2018-06-19 15:03:05 +02003753TEST_F(WebRtcVideoChannelTest, FlexfecSendCodecWithoutSsrcNotExposedByDefault) {
brandtr468da7c2016-11-22 02:16:47 -08003754 FakeVideoSendStream* stream = AddSendStream();
3755 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3756
brandtr3d200bd2017-01-16 06:59:19 -08003757 EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
brandtr31bd2242017-05-19 05:47:46 -07003758 EXPECT_EQ(0U, config.rtp.flexfec.ssrc);
3759 EXPECT_TRUE(config.rtp.flexfec.protected_media_ssrcs.empty());
brandtr468da7c2016-11-22 02:16:47 -08003760}
3761
eladalonf1841382017-06-12 01:16:46 -07003762TEST_F(WebRtcVideoChannelTest, FlexfecSendCodecWithSsrcNotExposedByDefault) {
brandtr468da7c2016-11-22 02:16:47 -08003763 FakeVideoSendStream* stream = AddSendStream(
3764 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
3765 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3766
brandtr3d200bd2017-01-16 06:59:19 -08003767 EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
brandtr31bd2242017-05-19 05:47:46 -07003768 EXPECT_EQ(0U, config.rtp.flexfec.ssrc);
3769 EXPECT_TRUE(config.rtp.flexfec.protected_media_ssrcs.empty());
3770}
3771
Yves Gerey665174f2018-06-19 15:03:05 +02003772TEST_F(WebRtcVideoChannelTest, FlexfecRecvCodecWithoutSsrcNotExposedByDefault) {
brandtr31bd2242017-05-19 05:47:46 -07003773 AddRecvStream();
3774
3775 const std::vector<FakeFlexfecReceiveStream*>& streams =
3776 fake_call_->GetFlexfecReceiveStreams();
3777 EXPECT_TRUE(streams.empty());
3778}
3779
eladalonf1841382017-06-12 01:16:46 -07003780TEST_F(WebRtcVideoChannelTest, FlexfecRecvCodecWithSsrcNotExposedByDefault) {
brandtr31bd2242017-05-19 05:47:46 -07003781 AddRecvStream(
3782 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
3783
3784 const std::vector<FakeFlexfecReceiveStream*>& streams =
3785 fake_call_->GetFlexfecReceiveStreams();
3786 EXPECT_TRUE(streams.empty());
brandtr468da7c2016-11-22 02:16:47 -08003787}
3788
3789// TODO(brandtr): When FlexFEC is no longer behind a field trial, merge all
3790// tests that use this test fixture into the corresponding "non-field trial"
3791// tests.
eladalonf1841382017-06-12 01:16:46 -07003792class WebRtcVideoChannelFlexfecRecvTest : public WebRtcVideoChannelTest {
brandtr468da7c2016-11-22 02:16:47 -08003793 public:
eladalonf1841382017-06-12 01:16:46 -07003794 WebRtcVideoChannelFlexfecRecvTest()
3795 : WebRtcVideoChannelTest("WebRTC-FlexFEC-03-Advertised/Enabled/") {}
brandtr468da7c2016-11-22 02:16:47 -08003796};
3797
eladalonf1841382017-06-12 01:16:46 -07003798TEST_F(WebRtcVideoChannelFlexfecRecvTest,
brandtr36e7d702017-01-13 07:15:54 -08003799 DefaultFlexfecCodecHasTransportCcAndRembFeedbackParam) {
3800 EXPECT_TRUE(cricket::HasTransportCc(GetEngineCodec("flexfec-03")));
3801 EXPECT_TRUE(cricket::HasRemb(GetEngineCodec("flexfec-03")));
3802}
3803
eladalonf1841382017-06-12 01:16:46 -07003804TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithoutSsrc) {
brandtr31bd2242017-05-19 05:47:46 -07003805 AddRecvStream();
3806
3807 const std::vector<FakeFlexfecReceiveStream*>& streams =
3808 fake_call_->GetFlexfecReceiveStreams();
3809 EXPECT_TRUE(streams.empty());
Rasmus Brandt60bb6fe2018-02-05 09:51:47 +01003810
3811 const std::vector<FakeVideoReceiveStream*>& video_streams =
3812 fake_call_->GetVideoReceiveStreams();
3813 ASSERT_EQ(1U, video_streams.size());
3814 const FakeVideoReceiveStream& video_stream = *video_streams.front();
3815 EXPECT_EQ(0, video_stream.GetNumAddedSecondarySinks());
3816 EXPECT_EQ(0, video_stream.GetNumRemovedSecondarySinks());
brandtr31bd2242017-05-19 05:47:46 -07003817}
3818
eladalonf1841382017-06-12 01:16:46 -07003819TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithSsrc) {
brandtr31bd2242017-05-19 05:47:46 -07003820 AddRecvStream(
3821 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
3822
3823 const std::vector<FakeFlexfecReceiveStream*>& streams =
3824 fake_call_->GetFlexfecReceiveStreams();
3825 ASSERT_EQ(1U, streams.size());
3826 const FakeFlexfecReceiveStream* stream = streams.front();
3827 const webrtc::FlexfecReceiveStream::Config& config = stream->GetConfig();
3828 EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.payload_type);
3829 EXPECT_EQ(kFlexfecSsrc, config.remote_ssrc);
3830 ASSERT_EQ(1U, config.protected_media_ssrcs.size());
3831 EXPECT_EQ(kSsrcs1[0], config.protected_media_ssrcs[0]);
brandtr7cd28b92017-09-22 00:26:25 -07003832
3833 const std::vector<FakeVideoReceiveStream*>& video_streams =
3834 fake_call_->GetVideoReceiveStreams();
3835 ASSERT_EQ(1U, video_streams.size());
Rasmus Brandt60bb6fe2018-02-05 09:51:47 +01003836 const FakeVideoReceiveStream& video_stream = *video_streams.front();
3837 EXPECT_EQ(1, video_stream.GetNumAddedSecondarySinks());
brandtr7cd28b92017-09-22 00:26:25 -07003838 const webrtc::VideoReceiveStream::Config& video_config =
Rasmus Brandt60bb6fe2018-02-05 09:51:47 +01003839 video_stream.GetConfig();
brandtr7cd28b92017-09-22 00:26:25 -07003840 EXPECT_TRUE(video_config.rtp.protected_by_flexfec);
brandtr31bd2242017-05-19 05:47:46 -07003841}
3842
eladalonf1841382017-06-12 01:16:46 -07003843TEST_F(WebRtcVideoChannelFlexfecRecvTest,
brandtr11fb4722017-05-30 01:31:37 -07003844 EnablingFlexfecDoesNotRecreateVideoReceiveStream) {
3845 cricket::VideoRecvParameters recv_parameters;
3846 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
3847 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
3848
3849 AddRecvStream(
3850 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
3851 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
Rasmus Brandt60bb6fe2018-02-05 09:51:47 +01003852 const std::vector<FakeVideoReceiveStream*>& video_streams =
3853 fake_call_->GetVideoReceiveStreams();
3854 ASSERT_EQ(1U, video_streams.size());
3855 const FakeVideoReceiveStream& video_stream = *video_streams.front();
3856 EXPECT_EQ(0, video_stream.GetNumAddedSecondarySinks());
3857 EXPECT_EQ(0, video_stream.GetNumRemovedSecondarySinks());
brandtr11fb4722017-05-30 01:31:37 -07003858
3859 // Enable FlexFEC.
3860 recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
3861 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
3862 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams())
3863 << "Enabling FlexFEC should create FlexfecReceiveStream.";
3864 EXPECT_EQ(1U, fake_call_->GetVideoReceiveStreams().size())
3865 << "Enabling FlexFEC should not create VideoReceiveStream.";
3866 EXPECT_EQ(1U, fake_call_->GetFlexfecReceiveStreams().size())
3867 << "Enabling FlexFEC should create a single FlexfecReceiveStream.";
Rasmus Brandt60bb6fe2018-02-05 09:51:47 +01003868 EXPECT_EQ(1, video_stream.GetNumAddedSecondarySinks());
3869 EXPECT_EQ(0, video_stream.GetNumRemovedSecondarySinks());
brandtr11fb4722017-05-30 01:31:37 -07003870}
3871
eladalonf1841382017-06-12 01:16:46 -07003872TEST_F(WebRtcVideoChannelFlexfecRecvTest,
brandtr11fb4722017-05-30 01:31:37 -07003873 DisablingFlexfecDoesNotRecreateVideoReceiveStream) {
3874 cricket::VideoRecvParameters recv_parameters;
3875 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
3876 recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
3877 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
3878
3879 AddRecvStream(
3880 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
3881 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
brandtr11fb4722017-05-30 01:31:37 -07003882 EXPECT_EQ(1U, fake_call_->GetFlexfecReceiveStreams().size());
Rasmus Brandt60bb6fe2018-02-05 09:51:47 +01003883 const std::vector<FakeVideoReceiveStream*>& video_streams =
3884 fake_call_->GetVideoReceiveStreams();
3885 ASSERT_EQ(1U, video_streams.size());
3886 const FakeVideoReceiveStream& video_stream = *video_streams.front();
3887 EXPECT_EQ(1, video_stream.GetNumAddedSecondarySinks());
3888 EXPECT_EQ(0, video_stream.GetNumRemovedSecondarySinks());
brandtr11fb4722017-05-30 01:31:37 -07003889
3890 // Disable FlexFEC.
3891 recv_parameters.codecs.clear();
3892 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
3893 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
3894 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams())
3895 << "Disabling FlexFEC should not recreate VideoReceiveStream.";
3896 EXPECT_EQ(1U, fake_call_->GetVideoReceiveStreams().size())
3897 << "Disabling FlexFEC should not destroy VideoReceiveStream.";
3898 EXPECT_TRUE(fake_call_->GetFlexfecReceiveStreams().empty())
3899 << "Disabling FlexFEC should destroy FlexfecReceiveStream.";
Rasmus Brandt60bb6fe2018-02-05 09:51:47 +01003900 EXPECT_EQ(1, video_stream.GetNumAddedSecondarySinks());
3901 EXPECT_EQ(1, video_stream.GetNumRemovedSecondarySinks());
brandtr11fb4722017-05-30 01:31:37 -07003902}
3903
Steve Anton2d2bbb12019-08-07 09:57:59 -07003904TEST_F(WebRtcVideoChannelFlexfecRecvTest, DuplicateFlexfecCodecIsDropped) {
3905 constexpr int kUnusedPayloadType1 = 127;
3906
3907 cricket::VideoRecvParameters recv_parameters;
3908 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
3909 recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
3910 cricket::VideoCodec duplicate = GetEngineCodec("flexfec-03");
3911 duplicate.id = kUnusedPayloadType1;
3912 recv_parameters.codecs.push_back(duplicate);
3913 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
3914
3915 AddRecvStream(
3916 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
3917
3918 const std::vector<FakeFlexfecReceiveStream*>& streams =
3919 fake_call_->GetFlexfecReceiveStreams();
3920 ASSERT_EQ(1U, streams.size());
3921 const FakeFlexfecReceiveStream* stream = streams.front();
3922 const webrtc::FlexfecReceiveStream::Config& config = stream->GetConfig();
3923 EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.payload_type);
3924}
3925
brandtr31bd2242017-05-19 05:47:46 -07003926// TODO(brandtr): When FlexFEC is no longer behind a field trial, merge all
3927// tests that use this test fixture into the corresponding "non-field trial"
3928// tests.
eladalonf1841382017-06-12 01:16:46 -07003929class WebRtcVideoChannelFlexfecSendRecvTest : public WebRtcVideoChannelTest {
brandtr31bd2242017-05-19 05:47:46 -07003930 public:
eladalonf1841382017-06-12 01:16:46 -07003931 WebRtcVideoChannelFlexfecSendRecvTest()
3932 : WebRtcVideoChannelTest(
brandtr31bd2242017-05-19 05:47:46 -07003933 "WebRTC-FlexFEC-03-Advertised/Enabled/WebRTC-FlexFEC-03/Enabled/") {
3934 }
3935};
3936
Yves Gerey665174f2018-06-19 15:03:05 +02003937TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetDefaultSendCodecsWithoutSsrc) {
brandtr468da7c2016-11-22 02:16:47 -08003938 FakeVideoSendStream* stream = AddSendStream();
3939 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3940
brandtr3d200bd2017-01-16 06:59:19 -08003941 EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.rtp.flexfec.payload_type);
3942 EXPECT_EQ(0U, config.rtp.flexfec.ssrc);
3943 EXPECT_TRUE(config.rtp.flexfec.protected_media_ssrcs.empty());
brandtr468da7c2016-11-22 02:16:47 -08003944}
3945
eladalonf1841382017-06-12 01:16:46 -07003946TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetDefaultSendCodecsWithSsrc) {
brandtr468da7c2016-11-22 02:16:47 -08003947 FakeVideoSendStream* stream = AddSendStream(
3948 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
3949 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3950
brandtr3d200bd2017-01-16 06:59:19 -08003951 EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.rtp.flexfec.payload_type);
3952 EXPECT_EQ(kFlexfecSsrc, config.rtp.flexfec.ssrc);
3953 ASSERT_EQ(1U, config.rtp.flexfec.protected_media_ssrcs.size());
3954 EXPECT_EQ(kSsrcs1[0], config.rtp.flexfec.protected_media_ssrcs[0]);
brandtr468da7c2016-11-22 02:16:47 -08003955}
3956
eladalonf1841382017-06-12 01:16:46 -07003957TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003958 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08003959 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003960 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003961
3962 FakeVideoSendStream* stream = AddSendStream();
perkj26091b12016-09-01 01:17:40 -07003963 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003964
brandtrb5f2c3f2016-10-04 23:28:39 -07003965 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type);
3966 EXPECT_EQ(-1, config.rtp.ulpfec.red_payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003967}
3968
eladalonf1841382017-06-12 01:16:46 -07003969TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetSendCodecsWithoutFec) {
brandtr468da7c2016-11-22 02:16:47 -08003970 cricket::VideoSendParameters parameters;
3971 parameters.codecs.push_back(GetEngineCodec("VP8"));
3972 ASSERT_TRUE(channel_->SetSendParameters(parameters));
3973
3974 FakeVideoSendStream* stream = AddSendStream();
3975 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
3976
brandtr3d200bd2017-01-16 06:59:19 -08003977 EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
brandtr468da7c2016-11-22 02:16:47 -08003978}
3979
eladalonf1841382017-06-12 01:16:46 -07003980TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) {
brandtr9c3d4c42017-01-23 06:59:13 -08003981 AddRecvStream(
3982 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
brandtr9c3d4c42017-01-23 06:59:13 -08003983
3984 cricket::VideoRecvParameters recv_parameters;
3985 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
3986 recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
3987 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
brandtr9d58d942017-02-03 04:43:41 -08003988
3989 const std::vector<FakeFlexfecReceiveStream*>& flexfec_streams =
3990 fake_call_->GetFlexfecReceiveStreams();
3991 ASSERT_EQ(1U, flexfec_streams.size());
3992 const FakeFlexfecReceiveStream* flexfec_stream = flexfec_streams.front();
3993 const webrtc::FlexfecReceiveStream::Config& flexfec_stream_config =
3994 flexfec_stream->GetConfig();
brandtr9c3d4c42017-01-23 06:59:13 -08003995 EXPECT_EQ(GetEngineCodec("flexfec-03").id,
brandtr9d58d942017-02-03 04:43:41 -08003996 flexfec_stream_config.payload_type);
3997 EXPECT_EQ(kFlexfecSsrc, flexfec_stream_config.remote_ssrc);
3998 ASSERT_EQ(1U, flexfec_stream_config.protected_media_ssrcs.size());
3999 EXPECT_EQ(kSsrcs1[0], flexfec_stream_config.protected_media_ssrcs[0]);
4000 const std::vector<FakeVideoReceiveStream*>& video_streams =
4001 fake_call_->GetVideoReceiveStreams();
4002 const FakeVideoReceiveStream* video_stream = video_streams.front();
4003 const webrtc::VideoReceiveStream::Config& video_stream_config =
4004 video_stream->GetConfig();
4005 EXPECT_EQ(video_stream_config.rtp.local_ssrc,
4006 flexfec_stream_config.local_ssrc);
4007 EXPECT_EQ(video_stream_config.rtp.rtcp_mode, flexfec_stream_config.rtcp_mode);
4008 EXPECT_EQ(video_stream_config.rtcp_send_transport,
4009 flexfec_stream_config.rtcp_send_transport);
4010 // TODO(brandtr): Update this EXPECT when we set |transport_cc| in a
4011 // spec-compliant way.
4012 EXPECT_EQ(video_stream_config.rtp.transport_cc,
4013 flexfec_stream_config.transport_cc);
4014 EXPECT_EQ(video_stream_config.rtp.rtcp_mode, flexfec_stream_config.rtcp_mode);
4015 EXPECT_EQ(video_stream_config.rtp.extensions,
4016 flexfec_stream_config.rtp_header_extensions);
brandtr9c3d4c42017-01-23 06:59:13 -08004017}
4018
brandtr31bd2242017-05-19 05:47:46 -07004019// We should not send FlexFEC, even if we advertise it, unless the right
4020// field trial is set.
4021// TODO(brandtr): Remove when FlexFEC is enabled by default.
eladalonf1841382017-06-12 01:16:46 -07004022TEST_F(WebRtcVideoChannelFlexfecRecvTest,
brandtr31bd2242017-05-19 05:47:46 -07004023 SetSendCodecsWithoutSsrcWithFecDoesNotEnableFec) {
4024 cricket::VideoSendParameters parameters;
4025 parameters.codecs.push_back(GetEngineCodec("VP8"));
4026 parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
4027 ASSERT_TRUE(channel_->SetSendParameters(parameters));
4028
4029 FakeVideoSendStream* stream = AddSendStream();
4030 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
4031
4032 EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
Mirko Bonadeif859e552018-05-30 15:31:29 +02004033 EXPECT_EQ(0u, config.rtp.flexfec.ssrc);
brandtr31bd2242017-05-19 05:47:46 -07004034 EXPECT_TRUE(config.rtp.flexfec.protected_media_ssrcs.empty());
4035}
4036
eladalonf1841382017-06-12 01:16:46 -07004037TEST_F(WebRtcVideoChannelFlexfecRecvTest,
brandtr31bd2242017-05-19 05:47:46 -07004038 SetSendCodecsWithSsrcWithFecDoesNotEnableFec) {
4039 cricket::VideoSendParameters parameters;
4040 parameters.codecs.push_back(GetEngineCodec("VP8"));
4041 parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
4042 ASSERT_TRUE(channel_->SetSendParameters(parameters));
4043
4044 FakeVideoSendStream* stream = AddSendStream(
4045 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
4046 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
4047
4048 EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
Mirko Bonadeif859e552018-05-30 15:31:29 +02004049 EXPECT_EQ(0u, config.rtp.flexfec.ssrc);
brandtr31bd2242017-05-19 05:47:46 -07004050 EXPECT_TRUE(config.rtp.flexfec.protected_media_ssrcs.empty());
4051}
4052
eladalonf1841382017-06-12 01:16:46 -07004053TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00004054 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
magjed509e4fe2016-11-18 01:34:11 -08004055 const int kUnusedPayloadType = 127;
4056 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType));
4057
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004058 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004059 cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx");
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004060 parameters.codecs.push_back(rtx_codec);
4061 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00004062 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004063}
4064
eladalonf1841382017-06-12 01:16:46 -07004065TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00004066 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
magjed509e4fe2016-11-18 01:34:11 -08004067 const int kUnusedPayloadType1 = 126;
4068 const int kUnusedPayloadType2 = 127;
4069 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
4070 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
4071 {
4072 cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
4073 kUnusedPayloadType1, GetEngineCodec("VP8").id);
4074 cricket::VideoSendParameters parameters;
4075 parameters.codecs.push_back(GetEngineCodec("VP8"));
4076 parameters.codecs.push_back(rtx_codec);
4077 ASSERT_TRUE(channel_->SetSendParameters(parameters));
4078 }
4079 {
4080 cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
4081 kUnusedPayloadType1, kUnusedPayloadType2);
4082 cricket::VideoSendParameters parameters;
4083 parameters.codecs.push_back(GetEngineCodec("VP8"));
4084 parameters.codecs.push_back(rtx_codec);
4085 EXPECT_FALSE(channel_->SetSendParameters(parameters))
4086 << "RTX without matching video codec should be rejected.";
4087 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004088}
4089
eladalonf1841382017-06-12 01:16:46 -07004090TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) {
brandtr14742122017-01-27 04:53:07 -08004091 const int kUnusedPayloadType1 = 126;
4092 const int kUnusedPayloadType2 = 127;
4093 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
4094 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
4095
4096 // SSRCs for RTX.
4097 cricket::StreamParams params =
4098 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
4099 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
4100 AddSendStream(params);
4101
4102 // Original payload type for RTX.
4103 cricket::VideoSendParameters parameters;
4104 parameters.codecs.push_back(GetEngineCodec("VP8"));
4105 cricket::VideoCodec rtx_codec(kUnusedPayloadType1, "rtx");
4106 rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
4107 parameters.codecs.push_back(rtx_codec);
4108 EXPECT_TRUE(channel_->SetSendParameters(parameters));
4109 ASSERT_EQ(1U, fake_call_->GetVideoSendStreams().size());
4110 const webrtc::VideoSendStream::Config& config_before =
4111 fake_call_->GetVideoSendStreams()[0]->GetConfig();
4112 EXPECT_EQ(kUnusedPayloadType1, config_before.rtp.rtx.payload_type);
4113 ASSERT_EQ(1U, config_before.rtp.rtx.ssrcs.size());
4114 EXPECT_EQ(kRtxSsrcs1[0], config_before.rtp.rtx.ssrcs[0]);
4115
4116 // Change payload type for RTX.
4117 parameters.codecs[1].id = kUnusedPayloadType2;
4118 EXPECT_TRUE(channel_->SetSendParameters(parameters));
4119 ASSERT_EQ(1U, fake_call_->GetVideoSendStreams().size());
4120 const webrtc::VideoSendStream::Config& config_after =
4121 fake_call_->GetVideoSendStreams()[0]->GetConfig();
4122 EXPECT_EQ(kUnusedPayloadType2, config_after.rtp.rtx.payload_type);
4123 ASSERT_EQ(1U, config_after.rtp.rtx.ssrcs.size());
4124 EXPECT_EQ(kRtxSsrcs1[0], config_after.rtp.rtx.ssrcs[0]);
4125}
4126
eladalonf1841382017-06-12 01:16:46 -07004127TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004128 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004129 parameters.codecs.push_back(GetEngineCodec("VP8"));
4130 parameters.codecs.push_back(GetEngineCodec("ulpfec"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004131 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00004132
4133 FakeVideoSendStream* stream = AddSendStream();
perkj26091b12016-09-01 01:17:40 -07004134 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
pbos@webrtc.org269605c2014-06-26 08:49:03 +00004135
magjed509e4fe2016-11-18 01:34:11 -08004136 EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00004137
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004138 parameters.codecs.pop_back();
4139 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00004140 stream = fake_call_->GetVideoSendStreams()[0];
brandtr468da7c2016-11-22 02:16:47 -08004141 ASSERT_TRUE(stream != nullptr);
perkj26091b12016-09-01 01:17:40 -07004142 config = stream->GetConfig().Copy();
brandtrb5f2c3f2016-10-04 23:28:39 -07004143 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type)
brandtr468da7c2016-11-22 02:16:47 -08004144 << "SetSendCodec without ULPFEC should disable current ULPFEC.";
4145}
4146
eladalonf1841382017-06-12 01:16:46 -07004147TEST_F(WebRtcVideoChannelFlexfecSendRecvTest,
brandtr31bd2242017-05-19 05:47:46 -07004148 SetSendCodecsWithoutFecDisablesFec) {
brandtr468da7c2016-11-22 02:16:47 -08004149 cricket::VideoSendParameters parameters;
4150 parameters.codecs.push_back(GetEngineCodec("VP8"));
4151 parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
4152 ASSERT_TRUE(channel_->SetSendParameters(parameters));
4153
4154 FakeVideoSendStream* stream = AddSendStream(
4155 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
4156 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
4157
brandtr3d200bd2017-01-16 06:59:19 -08004158 EXPECT_EQ(GetEngineCodec("flexfec-03").id, config.rtp.flexfec.payload_type);
4159 EXPECT_EQ(kFlexfecSsrc, config.rtp.flexfec.ssrc);
brandtr468da7c2016-11-22 02:16:47 -08004160 ASSERT_EQ(1U, config.rtp.flexfec.protected_media_ssrcs.size());
4161 EXPECT_EQ(kSsrcs1[0], config.rtp.flexfec.protected_media_ssrcs[0]);
4162
4163 parameters.codecs.pop_back();
4164 ASSERT_TRUE(channel_->SetSendParameters(parameters));
4165 stream = fake_call_->GetVideoSendStreams()[0];
4166 ASSERT_TRUE(stream != nullptr);
4167 config = stream->GetConfig().Copy();
brandtr3d200bd2017-01-16 06:59:19 -08004168 EXPECT_EQ(-1, config.rtp.flexfec.payload_type)
brandtr468da7c2016-11-22 02:16:47 -08004169 << "SetSendCodec without FlexFEC should disable current FlexFEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004170}
4171
eladalonf1841382017-06-12 01:16:46 -07004172TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004173 cricket::VideoSendParameters parameters;
perkj26752742016-10-24 01:21:16 -07004174 cricket::VideoCodec codec(100, "VP8");
4175 codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax);
4176 parameters.codecs.push_back(codec);
perkjfa10b552016-10-02 23:45:26 -07004177
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004178 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00004179 channel_->SetSend(true);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00004180
pbos@webrtc.org86196c42015-02-16 21:02:00 +00004181 FakeVideoSendStream* stream = AddSendStream();
Niels Möller805a27e2019-01-21 12:21:27 +01004182 webrtc::test::FrameForwarder frame_forwarder;
4183 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00004184
4185 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
perkjfa10b552016-10-02 23:45:26 -07004186 EXPECT_EQ(kDefaultQpMax, streams[0].max_qp);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00004187
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004188 parameters.codecs.clear();
perkj26752742016-10-24 01:21:16 -07004189 codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax + 1);
4190 parameters.codecs.push_back(codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004191 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00004192 streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
perkjfa10b552016-10-02 23:45:26 -07004193 EXPECT_EQ(kDefaultQpMax + 1, streams[0].max_qp);
Niels Möllerff40b142018-04-09 08:49:14 +02004194 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004195}
4196
eladalonf1841382017-06-12 01:16:46 -07004197TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithBitrates) {
pbos@webrtc.org00873182014-11-25 14:03:34 +00004198 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
4199 200000);
4200}
4201
eladalonf1841382017-06-12 01:16:46 -07004202TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithHighMaxBitrate) {
pbos@webrtc.orga5f6fb52015-03-23 22:29:39 +00004203 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
4204 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
4205 ASSERT_EQ(1u, streams.size());
4206 EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
4207}
4208
eladalonf1841382017-06-12 01:16:46 -07004209TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.org00873182014-11-25 14:03:34 +00004210 SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004211 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "", -1);
pbos@webrtc.org00873182014-11-25 14:03:34 +00004212}
4213
eladalonf1841382017-06-12 01:16:46 -07004214TEST_F(WebRtcVideoChannelTest, SetSendCodecsCapsMinAndStartBitrate) {
pbos@webrtc.org00873182014-11-25 14:03:34 +00004215 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004216}
4217
eladalonf1841382017-06-12 01:16:46 -07004218TEST_F(WebRtcVideoChannelTest, SetSendCodecsRejectsMaxLessThanMinBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004219 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300";
4220 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200";
4221 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004222}
4223
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004224// Test that when both the codec-specific bitrate params and max_bandwidth_bps
4225// are present in the same send parameters, the settings are combined correctly.
eladalonf1841382017-06-12 01:16:46 -07004226TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithBitratesAndMaxSendBandwidth) {
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004227 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "100";
4228 send_parameters_.codecs[0].params[kCodecParamStartBitrate] = "200";
4229 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "300";
4230 send_parameters_.max_bandwidth_bps = 400000;
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004231 // We expect max_bandwidth_bps to take priority, if set.
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004232 ExpectSetBitrateParameters(100000, 200000, 400000);
4233 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
4234 // Since the codec isn't changing, start_bitrate_bps should be -1.
4235 ExpectSetBitrateParameters(100000, -1, 350000);
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004236
4237 // Decrease max_bandwidth_bps.
4238 send_parameters_.max_bandwidth_bps = 350000;
4239 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004240
4241 // Now try again with the values flipped around.
4242 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "400";
4243 send_parameters_.max_bandwidth_bps = 300000;
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004244 ExpectSetBitrateParameters(100000, 200000, 300000);
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004245 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004246
4247 // If we change the codec max, max_bandwidth_bps should still apply.
4248 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "350";
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004249 ExpectSetBitrateParameters(100000, 200000, 300000);
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004250 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07004251}
4252
Piotr (Peter) Slatala946b9682019-03-18 10:25:02 -07004253// Test that when both the codec-specific bitrate params and max_bandwidth_bps
4254// are present in the same send parameters, the settings are combined correctly.
4255TEST_F(WebRtcVideoChannelTest,
4256 SetSendCodecsWithBitratesAndMaxSendBandwidthForMediaTransport) {
4257 // Same as SetSendCodecsWithBitratesAndMaxSendBandwidth but with Media
4258 // Transport.
4259 webrtc::MediaTransportSettings settings;
4260 settings.is_caller = true;
4261 webrtc::FakeMediaTransport fake_media_transport(settings);
4262 std::unique_ptr<cricket::FakeNetworkInterface> network_interface(
4263 new cricket::FakeNetworkInterface);
Anton Sukhanov4f08faa2019-05-21 11:12:57 -07004264 channel_->SetInterface(network_interface.get(),
4265 webrtc::MediaTransportConfig(&fake_media_transport));
Piotr (Peter) Slatala946b9682019-03-18 10:25:02 -07004266
4267 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "100";
4268 send_parameters_.codecs[0].params[kCodecParamStartBitrate] = "200";
4269 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "300";
4270 send_parameters_.max_bandwidth_bps = 400000;
4271 {
4272 // We expect max_bandwidth_bps to take priority, if set.
4273 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4274 ASSERT_EQ(1u,
4275 fake_media_transport.target_rate_constraints_in_order().size());
4276 const webrtc::MediaTransportTargetRateConstraints& constraint =
4277 fake_media_transport.target_rate_constraints_in_order()[0];
4278 ASSERT_EQ(webrtc::DataRate::bps(100000), constraint.min_bitrate);
4279 ASSERT_EQ(webrtc::DataRate::bps(200000), constraint.starting_bitrate);
4280 ASSERT_EQ(webrtc::DataRate::bps(400000), constraint.max_bitrate);
4281 }
4282
4283 {
4284 // Decrease max_bandwidth_bps.
4285 send_parameters_.max_bandwidth_bps = 350000;
4286 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4287 ASSERT_EQ(2u,
4288 fake_media_transport.target_rate_constraints_in_order().size());
4289 const webrtc::MediaTransportTargetRateConstraints& constraint =
4290 fake_media_transport.target_rate_constraints_in_order()[1];
4291
4292 // Since the codec isn't changing, start_bitrate_bps should be 0.
4293 ASSERT_EQ(webrtc::DataRate::bps(100000), constraint.min_bitrate);
4294 ASSERT_EQ(absl::nullopt, constraint.starting_bitrate);
4295 ASSERT_EQ(webrtc::DataRate::bps(350000), constraint.max_bitrate);
4296 }
4297
4298 {
4299 // Now try again with the values flipped around.
4300 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "400";
4301 send_parameters_.max_bandwidth_bps = 300000;
4302 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4303 ASSERT_EQ(3u,
4304 fake_media_transport.target_rate_constraints_in_order().size());
4305 const webrtc::MediaTransportTargetRateConstraints& constraint =
4306 fake_media_transport.target_rate_constraints_in_order()[2];
4307
4308 ASSERT_EQ(webrtc::DataRate::bps(100000), constraint.min_bitrate);
4309 ASSERT_EQ(webrtc::DataRate::bps(200000), constraint.starting_bitrate);
4310 ASSERT_EQ(webrtc::DataRate::bps(300000), constraint.max_bitrate);
4311 }
4312
4313 {
4314 // Now try again with the values flipped around.
4315 // If we change the codec max, max_bandwidth_bps should still apply.
4316 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "350";
4317 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4318 ASSERT_EQ(4u,
4319 fake_media_transport.target_rate_constraints_in_order().size());
4320 const webrtc::MediaTransportTargetRateConstraints& constraint =
4321 fake_media_transport.target_rate_constraints_in_order()[3];
4322
4323 ASSERT_EQ(webrtc::DataRate::bps(100000), constraint.min_bitrate);
4324 ASSERT_EQ(webrtc::DataRate::bps(200000), constraint.starting_bitrate);
4325 ASSERT_EQ(webrtc::DataRate::bps(300000), constraint.max_bitrate);
4326 }
4327}
4328
Yves Gerey665174f2018-06-19 15:03:05 +02004329TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthShouldPreserveOtherBitrates) {
pbos@webrtc.org00873182014-11-25 14:03:34 +00004330 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
4331 200000);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004332 send_parameters_.max_bandwidth_bps = 300000;
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004333 // Setting max bitrate should keep previous min bitrate.
4334 // Setting max bitrate should not reset start bitrate.
4335 ExpectSetBitrateParameters(100000, -1, 300000);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004336 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org00873182014-11-25 14:03:34 +00004337}
4338
eladalonf1841382017-06-12 01:16:46 -07004339TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthShouldBeRemovable) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004340 send_parameters_.max_bandwidth_bps = 300000;
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004341 ExpectSetMaxBitrate(300000);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004342 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos5c7760a2017-03-10 11:23:12 -08004343 // -1 means to disable max bitrate (set infinite).
4344 send_parameters_.max_bandwidth_bps = -1;
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004345 ExpectSetMaxBitrate(-1);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004346 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004347}
4348
eladalonf1841382017-06-12 01:16:46 -07004349TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthAndAddSendStream) {
perkjfa10b552016-10-02 23:45:26 -07004350 send_parameters_.max_bandwidth_bps = 99999;
4351 FakeVideoSendStream* stream = AddSendStream();
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004352 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
perkjfa10b552016-10-02 23:45:26 -07004353 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
perkjfa10b552016-10-02 23:45:26 -07004354 ASSERT_EQ(1u, stream->GetVideoStreams().size());
4355 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
4356 stream->GetVideoStreams()[0].max_bitrate_bps);
4357
4358 send_parameters_.max_bandwidth_bps = 77777;
Sebastian Jansson8f83b422018-02-21 13:07:13 +01004359 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
perkjfa10b552016-10-02 23:45:26 -07004360 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4361 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
perkjfa10b552016-10-02 23:45:26 -07004362 stream->GetVideoStreams()[0].max_bitrate_bps);
4363}
4364
Seth Hampsonfeec91e2018-07-13 10:41:10 -07004365// Tests that when the codec specific max bitrate and VideoSendParameters
4366// max_bandwidth_bps are used, that it sets the VideoStream's max bitrate
4367// appropriately.
4368TEST_F(WebRtcVideoChannelTest,
4369 MaxBitratePrioritizesVideoSendParametersOverCodecMaxBitrate) {
4370 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "100";
4371 send_parameters_.codecs[0].params[kCodecParamStartBitrate] = "200";
4372 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "300";
4373 send_parameters_.max_bandwidth_bps = -1;
4374 AddSendStream();
4375 ExpectSetMaxBitrate(300000);
4376 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4377
4378 std::vector<FakeVideoSendStream*> video_send_streams = GetFakeSendStreams();
4379 ASSERT_EQ(1u, video_send_streams.size());
4380 FakeVideoSendStream* video_send_stream = video_send_streams[0];
4381 ASSERT_EQ(1u, video_send_streams[0]->GetVideoStreams().size());
4382 // First the max bitrate is set based upon the codec param.
4383 EXPECT_EQ(300000,
4384 video_send_streams[0]->GetVideoStreams()[0].max_bitrate_bps);
4385
4386 // The VideoSendParameters max bitrate overrides the codec's.
4387 send_parameters_.max_bandwidth_bps = 500000;
4388 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
4389 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4390 ASSERT_EQ(1u, video_send_stream->GetVideoStreams().size());
4391 EXPECT_EQ(500000, video_send_stream->GetVideoStreams()[0].max_bitrate_bps);
4392}
4393
4394// Tests that when the codec specific max bitrate and RtpParameters
4395// max_bitrate_bps are used, that it sets the VideoStream's max bitrate
4396// appropriately.
4397TEST_F(WebRtcVideoChannelTest,
4398 MaxBitratePrioritizesRtpParametersOverCodecMaxBitrate) {
4399 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "100";
4400 send_parameters_.codecs[0].params[kCodecParamStartBitrate] = "200";
4401 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "300";
4402 send_parameters_.max_bandwidth_bps = -1;
4403 AddSendStream();
4404 ExpectSetMaxBitrate(300000);
4405 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4406
4407 std::vector<FakeVideoSendStream*> video_send_streams = GetFakeSendStreams();
4408 ASSERT_EQ(1u, video_send_streams.size());
4409 FakeVideoSendStream* video_send_stream = video_send_streams[0];
4410 ASSERT_EQ(1u, video_send_stream->GetVideoStreams().size());
4411 // First the max bitrate is set based upon the codec param.
4412 EXPECT_EQ(300000, video_send_stream->GetVideoStreams()[0].max_bitrate_bps);
4413
4414 // The RtpParameter max bitrate overrides the codec's.
4415 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
4416 ASSERT_EQ(1u, parameters.encodings.size());
4417 parameters.encodings[0].max_bitrate_bps = 500000;
4418 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
4419 ASSERT_EQ(1u, video_send_stream->GetVideoStreams().size());
4420 EXPECT_EQ(parameters.encodings[0].max_bitrate_bps,
4421 video_send_stream->GetVideoStreams()[0].max_bitrate_bps);
4422}
4423
Åsa Persson55659812018-06-18 17:51:32 +02004424TEST_F(WebRtcVideoChannelTest,
4425 MaxBitrateIsMinimumOfMaxSendBandwidthAndMaxEncodingBitrate) {
4426 send_parameters_.max_bandwidth_bps = 99999;
4427 FakeVideoSendStream* stream = AddSendStream();
4428 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
4429 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
4430 ASSERT_EQ(1u, stream->GetVideoStreams().size());
4431 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
4432 stream->GetVideoStreams()[0].max_bitrate_bps);
4433
4434 // Get and set the rtp encoding parameters.
4435 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
4436 EXPECT_EQ(1u, parameters.encodings.size());
4437
4438 parameters.encodings[0].max_bitrate_bps = 99999 - 1;
4439 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
4440 EXPECT_EQ(parameters.encodings[0].max_bitrate_bps,
4441 stream->GetVideoStreams()[0].max_bitrate_bps);
4442
4443 parameters.encodings[0].max_bitrate_bps = 99999 + 1;
4444 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
4445 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
4446 stream->GetVideoStreams()[0].max_bitrate_bps);
4447}
4448
eladalonf1841382017-06-12 01:16:46 -07004449TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004450 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004451 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004452 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004453 channel_->SetSend(true);
4454
4455 FakeVideoSendStream* stream = AddSendStream();
4456
Niels Möller805a27e2019-01-21 12:21:27 +01004457 webrtc::test::FrameForwarder frame_forwarder;
4458 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
Peter Boström3afc8c42016-01-27 16:45:21 +01004459
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004460 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
4461 int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
4462 EXPECT_GT(initial_max_bitrate_bps, 0);
4463
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004464 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
4465 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01004466 // Insert a frame to update the encoder config.
Niels Möller805a27e2019-01-21 12:21:27 +01004467 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004468 streams = stream->GetVideoStreams();
4469 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
Niels Möllerff40b142018-04-09 08:49:14 +02004470 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004471}
4472
eladalonf1841382017-06-12 01:16:46 -07004473TEST_F(WebRtcVideoChannelTest,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004474 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004475 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004476 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004477 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004478 channel_->SetSend(true);
4479
4480 FakeVideoSendStream* stream = AddSendStream(
4481 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
4482
4483 // Send a frame to make sure this scales up to >1 stream (simulcast).
Niels Möller805a27e2019-01-21 12:21:27 +01004484 webrtc::test::FrameForwarder frame_forwarder;
4485 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], nullptr, &frame_forwarder));
4486 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004487
4488 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
4489 ASSERT_GT(streams.size(), 1u)
4490 << "Without simulcast this test doesn't make sense.";
pbosbe16f792015-10-16 12:49:39 -07004491 int initial_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004492 EXPECT_GT(initial_max_bitrate_bps, 0);
4493
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004494 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
4495 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01004496 // Insert a frame to update the encoder config.
Niels Möller805a27e2019-01-21 12:21:27 +01004497 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004498 streams = stream->GetVideoStreams();
pbosbe16f792015-10-16 12:49:39 -07004499 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004500 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
4501
Niels Möllerff40b142018-04-09 08:49:14 +02004502 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], nullptr, nullptr));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01004503}
4504
eladalonf1841382017-06-12 01:16:46 -07004505TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithMaxQuantization) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004506 static const char* kMaxQuantization = "21";
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004507 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004508 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004509 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
4510 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Mirko Bonadeif859e552018-05-30 15:31:29 +02004511 EXPECT_EQ(atoi(kMaxQuantization),
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00004512 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004513
4514 VideoCodec codec;
4515 EXPECT_TRUE(channel_->GetSendCodec(&codec));
4516 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
4517}
4518
eladalonf1841382017-06-12 01:16:46 -07004519TEST_F(WebRtcVideoChannelTest, SetSendCodecsRejectBadPayloadTypes) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004520 // TODO(pbos): Should we only allow the dynamic range?
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00004521 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004522 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004523 parameters.codecs.push_back(GetEngineCodec("VP8"));
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00004524 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004525 parameters.codecs[0].id = kIncorrectPayloads[i];
4526 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00004527 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004528 }
4529}
4530
eladalonf1841382017-06-12 01:16:46 -07004531TEST_F(WebRtcVideoChannelTest, SetSendCodecsAcceptAllValidPayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004532 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004533 parameters.codecs.push_back(GetEngineCodec("VP8"));
magjedf823ede2016-11-12 09:53:04 -08004534 for (int payload_type = 96; payload_type <= 127; ++payload_type) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004535 parameters.codecs[0].id = payload_type;
4536 EXPECT_TRUE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004537 << "Payload type '" << payload_type << "' rejected.";
4538 }
4539}
4540
deadbeef67cf2c12016-04-13 10:07:16 -07004541// Test that setting the a different set of codecs but with an identical front
4542// codec doesn't result in the stream being recreated.
4543// This may happen when a subsequent negotiation includes fewer codecs, as a
4544// result of one of the codecs being rejected.
eladalonf1841382017-06-12 01:16:46 -07004545TEST_F(WebRtcVideoChannelTest,
deadbeef67cf2c12016-04-13 10:07:16 -07004546 SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) {
4547 cricket::VideoSendParameters parameters1;
magjed509e4fe2016-11-18 01:34:11 -08004548 parameters1.codecs.push_back(GetEngineCodec("VP8"));
4549 parameters1.codecs.push_back(GetEngineCodec("VP9"));
deadbeef67cf2c12016-04-13 10:07:16 -07004550 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
4551
4552 AddSendStream();
4553 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
4554
4555 cricket::VideoSendParameters parameters2;
magjed509e4fe2016-11-18 01:34:11 -08004556 parameters2.codecs.push_back(GetEngineCodec("VP8"));
deadbeef67cf2c12016-04-13 10:07:16 -07004557 EXPECT_TRUE(channel_->SetSendParameters(parameters2));
4558 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
4559}
4560
eladalonf1841382017-06-12 01:16:46 -07004561TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithOnlyVp8) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004562 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004563 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004564 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004565}
4566
pbos@webrtc.orge322a172014-06-13 11:47:28 +00004567// Test that we set our inbound RTX codecs properly.
eladalonf1841382017-06-12 01:16:46 -07004568TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) {
magjed509e4fe2016-11-18 01:34:11 -08004569 const int kUnusedPayloadType1 = 126;
4570 const int kUnusedPayloadType2 = 127;
4571 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
4572 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
4573
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004574 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004575 parameters.codecs.push_back(GetEngineCodec("VP8"));
4576 cricket::VideoCodec rtx_codec(kUnusedPayloadType1, "rtx");
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004577 parameters.codecs.push_back(rtx_codec);
4578 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00004579 << "RTX codec without associated payload should be rejected.";
4580
magjed509e4fe2016-11-18 01:34:11 -08004581 parameters.codecs[1].SetParam("apt", kUnusedPayloadType2);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004582 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00004583 << "RTX codec with invalid associated payload type should be rejected.";
4584
magjed509e4fe2016-11-18 01:34:11 -08004585 parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004586 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orge322a172014-06-13 11:47:28 +00004587
magjed509e4fe2016-11-18 01:34:11 -08004588 cricket::VideoCodec rtx_codec2(kUnusedPayloadType2, "rtx");
pbos@webrtc.orge322a172014-06-13 11:47:28 +00004589 rtx_codec2.SetParam("apt", rtx_codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004590 parameters.codecs.push_back(rtx_codec2);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00004591
Yves Gerey665174f2018-06-19 15:03:05 +02004592 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
4593 << "RTX codec with another RTX as associated payload type should be "
4594 "rejected.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00004595}
4596
Mirta Dvornicic479a3c02019-06-04 15:38:50 +02004597TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) {
4598 cricket::VideoCodec vp8_codec = GetEngineCodec("VP8");
4599 vp8_codec.packetization = kPacketizationParamRaw;
4600
4601 cricket::VideoRecvParameters parameters;
4602 parameters.codecs = {vp8_codec, GetEngineCodec("VP9")};
4603 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
4604
4605 const cricket::StreamParams params =
4606 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
4607 AddRecvStream(params);
4608 ASSERT_THAT(fake_call_->GetVideoReceiveStreams(), testing::SizeIs(1));
4609
4610 const webrtc::VideoReceiveStream::Config& config =
4611 fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
4612 ASSERT_THAT(config.rtp.raw_payload_types, testing::SizeIs(1));
4613 EXPECT_EQ(config.rtp.raw_payload_types.count(vp8_codec.id), 1U);
4614}
4615
4616TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketizationRecreatesStream) {
4617 cricket::VideoRecvParameters parameters;
4618 parameters.codecs = {GetEngineCodec("VP8"), GetEngineCodec("VP9")};
4619 parameters.codecs.back().packetization = kPacketizationParamRaw;
4620 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
4621
4622 const cricket::StreamParams params =
4623 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
4624 AddRecvStream(params);
4625 ASSERT_THAT(fake_call_->GetVideoReceiveStreams(), testing::SizeIs(1));
4626 EXPECT_EQ(fake_call_->GetNumCreatedReceiveStreams(), 1);
4627
4628 parameters.codecs.back().packetization.reset();
4629 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
4630 EXPECT_EQ(fake_call_->GetNumCreatedReceiveStreams(), 2);
4631}
4632
Steve Anton2d2bbb12019-08-07 09:57:59 -07004633TEST_F(WebRtcVideoChannelTest, DuplicateUlpfecCodecIsDropped) {
4634 constexpr int kFirstUlpfecPayloadType = 126;
4635 constexpr int kSecondUlpfecPayloadType = 127;
4636
4637 cricket::VideoRecvParameters parameters;
4638 parameters.codecs.push_back(GetEngineCodec("VP8"));
4639 parameters.codecs.push_back(
4640 cricket::VideoCodec(kFirstUlpfecPayloadType, cricket::kUlpfecCodecName));
4641 parameters.codecs.push_back(
4642 cricket::VideoCodec(kSecondUlpfecPayloadType, cricket::kUlpfecCodecName));
4643 ASSERT_TRUE(channel_->SetRecvParameters(parameters));
4644
4645 FakeVideoReceiveStream* recv_stream = AddRecvStream();
4646 EXPECT_EQ(kFirstUlpfecPayloadType,
4647 recv_stream->GetConfig().rtp.ulpfec_payload_type);
4648}
4649
4650TEST_F(WebRtcVideoChannelTest, DuplicateRedCodecIsDropped) {
4651 constexpr int kFirstRedPayloadType = 126;
4652 constexpr int kSecondRedPayloadType = 127;
4653
4654 cricket::VideoRecvParameters parameters;
4655 parameters.codecs.push_back(GetEngineCodec("VP8"));
4656 parameters.codecs.push_back(
4657 cricket::VideoCodec(kFirstRedPayloadType, cricket::kRedCodecName));
4658 parameters.codecs.push_back(
4659 cricket::VideoCodec(kSecondRedPayloadType, cricket::kRedCodecName));
4660 ASSERT_TRUE(channel_->SetRecvParameters(parameters));
4661
4662 FakeVideoReceiveStream* recv_stream = AddRecvStream();
4663 EXPECT_EQ(kFirstRedPayloadType,
4664 recv_stream->GetConfig().rtp.red_payload_type);
4665}
4666
eladalonf1841382017-06-12 01:16:46 -07004667TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
brandtr14742122017-01-27 04:53:07 -08004668 const int kUnusedPayloadType1 = 126;
4669 const int kUnusedPayloadType2 = 127;
4670 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
4671 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
4672
4673 // SSRCs for RTX.
4674 cricket::StreamParams params =
4675 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
4676 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
4677 AddRecvStream(params);
4678
4679 // Original payload type for RTX.
4680 cricket::VideoRecvParameters parameters;
4681 parameters.codecs.push_back(GetEngineCodec("VP8"));
4682 cricket::VideoCodec rtx_codec(kUnusedPayloadType1, "rtx");
4683 rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
4684 parameters.codecs.push_back(rtx_codec);
4685 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
4686 ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
4687 const webrtc::VideoReceiveStream::Config& config_before =
4688 fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
nisse26e3abb2017-08-25 04:44:25 -07004689 EXPECT_EQ(1U, config_before.rtp.rtx_associated_payload_types.size());
4690 const int* payload_type_before = FindKeyByValue(
4691 config_before.rtp.rtx_associated_payload_types, GetEngineCodec("VP8").id);
4692 ASSERT_NE(payload_type_before, nullptr);
4693 EXPECT_EQ(kUnusedPayloadType1, *payload_type_before);
brandtr14742122017-01-27 04:53:07 -08004694 EXPECT_EQ(kRtxSsrcs1[0], config_before.rtp.rtx_ssrc);
4695
4696 // Change payload type for RTX.
4697 parameters.codecs[1].id = kUnusedPayloadType2;
4698 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
4699 ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
4700 const webrtc::VideoReceiveStream::Config& config_after =
4701 fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
nisse26e3abb2017-08-25 04:44:25 -07004702 EXPECT_EQ(1U, config_after.rtp.rtx_associated_payload_types.size());
4703 const int* payload_type_after = FindKeyByValue(
4704 config_after.rtp.rtx_associated_payload_types, GetEngineCodec("VP8").id);
4705 ASSERT_NE(payload_type_after, nullptr);
4706 EXPECT_EQ(kUnusedPayloadType2, *payload_type_after);
brandtr14742122017-01-27 04:53:07 -08004707 EXPECT_EQ(kRtxSsrcs1[0], config_after.rtp.rtx_ssrc);
4708}
4709
eladalonf1841382017-06-12 01:16:46 -07004710TEST_F(WebRtcVideoChannelTest, SetRecvCodecsDifferentPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004711 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004712 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004713 parameters.codecs[0].id = 99;
4714 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004715}
4716
eladalonf1841382017-06-12 01:16:46 -07004717TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004718 cricket::VideoRecvParameters parameters;
4719 parameters.codecs = engine_.codecs();
4720 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00004721
4722 FakeVideoReceiveStream* stream = AddRecvStream();
Tommi733b5472016-06-10 17:58:01 +02004723 const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
Niels Möllercb7e1d22018-09-11 15:56:04 +02004724 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].video_format.name);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00004725 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004726}
4727
eladalonf1841382017-06-12 01:16:46 -07004728TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004729 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004730 parameters.codecs.push_back(GetEngineCodec("VP8"));
perkj26752742016-10-24 01:21:16 -07004731 parameters.codecs.push_back(VideoCodec(101, "WTF3"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004732 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004733}
4734
eladalonf1841382017-06-12 01:16:46 -07004735TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptsMultipleVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004736 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004737 parameters.codecs.push_back(GetEngineCodec("VP8"));
4738 parameters.codecs.push_back(GetEngineCodec("VP9"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004739 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004740}
4741
eladalonf1841382017-06-12 01:16:46 -07004742TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004743 cricket::VideoSendParameters send_parameters;
magjed509e4fe2016-11-18 01:34:11 -08004744 send_parameters.codecs.push_back(GetEngineCodec("VP8"));
4745 send_parameters.codecs.push_back(GetEngineCodec("red"));
4746 send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004747 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00004748
4749 FakeVideoReceiveStream* stream = AddRecvStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00004750
magjed509e4fe2016-11-18 01:34:11 -08004751 EXPECT_EQ(GetEngineCodec("ulpfec").id,
nisse3b3622f2017-09-26 02:49:21 -07004752 stream->GetConfig().rtp.ulpfec_payload_type);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00004753
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004754 cricket::VideoRecvParameters recv_parameters;
magjed509e4fe2016-11-18 01:34:11 -08004755 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004756 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00004757 stream = fake_call_->GetVideoReceiveStreams()[0];
brandtr468da7c2016-11-22 02:16:47 -08004758 ASSERT_TRUE(stream != nullptr);
nisse3b3622f2017-09-26 02:49:21 -07004759 EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec_payload_type)
brandtr468da7c2016-11-22 02:16:47 -08004760 << "SetSendCodec without ULPFEC should disable current ULPFEC.";
4761}
4762
eladalonf1841382017-06-12 01:16:46 -07004763TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvParamsWithoutFecDisablesFec) {
brandtr468da7c2016-11-22 02:16:47 -08004764 AddRecvStream(
4765 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
brandtr9c3d4c42017-01-23 06:59:13 -08004766 const std::vector<FakeFlexfecReceiveStream*>& streams =
brandtr468da7c2016-11-22 02:16:47 -08004767 fake_call_->GetFlexfecReceiveStreams();
4768
4769 ASSERT_EQ(1U, streams.size());
brandtr9c3d4c42017-01-23 06:59:13 -08004770 const FakeFlexfecReceiveStream* stream = streams.front();
4771 EXPECT_EQ(GetEngineCodec("flexfec-03").id, stream->GetConfig().payload_type);
4772 EXPECT_EQ(kFlexfecSsrc, stream->GetConfig().remote_ssrc);
4773 ASSERT_EQ(1U, stream->GetConfig().protected_media_ssrcs.size());
4774 EXPECT_EQ(kSsrcs1[0], stream->GetConfig().protected_media_ssrcs[0]);
brandtr468da7c2016-11-22 02:16:47 -08004775
4776 cricket::VideoRecvParameters recv_parameters;
4777 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
4778 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
4779 EXPECT_TRUE(streams.empty())
4780 << "SetSendCodec without FlexFEC should disable current FlexFEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00004781}
4782
eladalonf1841382017-06-12 01:16:46 -07004783TEST_F(WebRtcVideoChannelTest, SetSendParamsWithFecEnablesFec) {
Stefan Holmer2b1f6512016-05-17 16:33:30 +02004784 FakeVideoReceiveStream* stream = AddRecvStream();
magjed509e4fe2016-11-18 01:34:11 -08004785 EXPECT_EQ(GetEngineCodec("ulpfec").id,
nisse3b3622f2017-09-26 02:49:21 -07004786 stream->GetConfig().rtp.ulpfec_payload_type);
Stefan Holmer2b1f6512016-05-17 16:33:30 +02004787
4788 cricket::VideoRecvParameters recv_parameters;
magjed509e4fe2016-11-18 01:34:11 -08004789 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
4790 recv_parameters.codecs.push_back(GetEngineCodec("red"));
4791 recv_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
Stefan Holmer2b1f6512016-05-17 16:33:30 +02004792 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
4793 stream = fake_call_->GetVideoReceiveStreams()[0];
brandtr468da7c2016-11-22 02:16:47 -08004794 ASSERT_TRUE(stream != nullptr);
magjed509e4fe2016-11-18 01:34:11 -08004795 EXPECT_EQ(GetEngineCodec("ulpfec").id,
nisse3b3622f2017-09-26 02:49:21 -07004796 stream->GetConfig().rtp.ulpfec_payload_type)
brandtr468da7c2016-11-22 02:16:47 -08004797 << "ULPFEC should be enabled on the receive stream.";
Stefan Holmer2b1f6512016-05-17 16:33:30 +02004798
4799 cricket::VideoSendParameters send_parameters;
magjed509e4fe2016-11-18 01:34:11 -08004800 send_parameters.codecs.push_back(GetEngineCodec("VP8"));
4801 send_parameters.codecs.push_back(GetEngineCodec("red"));
4802 send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
Stefan Holmer2b1f6512016-05-17 16:33:30 +02004803 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
4804 stream = fake_call_->GetVideoReceiveStreams()[0];
magjed509e4fe2016-11-18 01:34:11 -08004805 EXPECT_EQ(GetEngineCodec("ulpfec").id,
nisse3b3622f2017-09-26 02:49:21 -07004806 stream->GetConfig().rtp.ulpfec_payload_type)
brandtr468da7c2016-11-22 02:16:47 -08004807 << "ULPFEC should be enabled on the receive stream.";
4808}
4809
eladalonf1841382017-06-12 01:16:46 -07004810TEST_F(WebRtcVideoChannelFlexfecSendRecvTest,
brandtr31bd2242017-05-19 05:47:46 -07004811 SetSendRecvParamsWithFecEnablesFec) {
brandtr468da7c2016-11-22 02:16:47 -08004812 AddRecvStream(
4813 CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
brandtr9c3d4c42017-01-23 06:59:13 -08004814 const std::vector<FakeFlexfecReceiveStream*>& streams =
brandtr468da7c2016-11-22 02:16:47 -08004815 fake_call_->GetFlexfecReceiveStreams();
4816
4817 cricket::VideoRecvParameters recv_parameters;
4818 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
4819 recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
4820 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
4821 ASSERT_EQ(1U, streams.size());
brandtr9c3d4c42017-01-23 06:59:13 -08004822 const FakeFlexfecReceiveStream* stream_with_recv_params = streams.front();
brandtr468da7c2016-11-22 02:16:47 -08004823 EXPECT_EQ(GetEngineCodec("flexfec-03").id,
brandtr9c3d4c42017-01-23 06:59:13 -08004824 stream_with_recv_params->GetConfig().payload_type);
4825 EXPECT_EQ(kFlexfecSsrc, stream_with_recv_params->GetConfig().remote_ssrc);
brandtr468da7c2016-11-22 02:16:47 -08004826 EXPECT_EQ(1U,
brandtr9c3d4c42017-01-23 06:59:13 -08004827 stream_with_recv_params->GetConfig().protected_media_ssrcs.size());
brandtr468da7c2016-11-22 02:16:47 -08004828 EXPECT_EQ(kSsrcs1[0],
brandtr9c3d4c42017-01-23 06:59:13 -08004829 stream_with_recv_params->GetConfig().protected_media_ssrcs[0]);
brandtr468da7c2016-11-22 02:16:47 -08004830
4831 cricket::VideoSendParameters send_parameters;
4832 send_parameters.codecs.push_back(GetEngineCodec("VP8"));
4833 send_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
4834 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
4835 ASSERT_EQ(1U, streams.size());
brandtr9c3d4c42017-01-23 06:59:13 -08004836 const FakeFlexfecReceiveStream* stream_with_send_params = streams.front();
brandtr468da7c2016-11-22 02:16:47 -08004837 EXPECT_EQ(GetEngineCodec("flexfec-03").id,
brandtr9c3d4c42017-01-23 06:59:13 -08004838 stream_with_send_params->GetConfig().payload_type);
4839 EXPECT_EQ(kFlexfecSsrc, stream_with_send_params->GetConfig().remote_ssrc);
brandtr468da7c2016-11-22 02:16:47 -08004840 EXPECT_EQ(1U,
brandtr9c3d4c42017-01-23 06:59:13 -08004841 stream_with_send_params->GetConfig().protected_media_ssrcs.size());
brandtr468da7c2016-11-22 02:16:47 -08004842 EXPECT_EQ(kSsrcs1[0],
brandtr9c3d4c42017-01-23 06:59:13 -08004843 stream_with_send_params->GetConfig().protected_media_ssrcs[0]);
Stefan Holmer2b1f6512016-05-17 16:33:30 +02004844}
4845
eladalonf1841382017-06-12 01:16:46 -07004846TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateFecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004847 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004848 parameters.codecs.push_back(GetEngineCodec("VP8"));
4849 parameters.codecs.push_back(GetEngineCodec("red"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004850 parameters.codecs[1].id = parameters.codecs[0].id;
4851 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004852}
4853
eladalonf1841382017-06-12 01:16:46 -07004854TEST_F(WebRtcVideoChannelFlexfecRecvTest,
brandtr31bd2242017-05-19 05:47:46 -07004855 SetRecvCodecsRejectDuplicateFecPayloads) {
brandtr468da7c2016-11-22 02:16:47 -08004856 cricket::VideoRecvParameters parameters;
4857 parameters.codecs.push_back(GetEngineCodec("VP8"));
4858 parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
4859 parameters.codecs[1].id = parameters.codecs[0].id;
4860 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
4861}
4862
eladalonf1841382017-06-12 01:16:46 -07004863TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateCodecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004864 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004865 parameters.codecs.push_back(GetEngineCodec("VP8"));
4866 parameters.codecs.push_back(GetEngineCodec("VP9"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004867 parameters.codecs[1].id = parameters.codecs[0].id;
4868 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004869}
4870
eladalonf1841382017-06-12 01:16:46 -07004871TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004872 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004873 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08004874 parameters.codecs.push_back(GetEngineCodec("VP8"));
4875 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004876 parameters.codecs[1].id += 1;
4877 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004878}
4879
deadbeef67cf2c12016-04-13 10:07:16 -07004880// Test that setting the same codecs but with a different order
deadbeef874ca3a2015-08-20 17:19:20 -07004881// doesn't result in the stream being recreated.
eladalonf1841382017-06-12 01:16:46 -07004882TEST_F(WebRtcVideoChannelTest,
deadbeef67cf2c12016-04-13 10:07:16 -07004883 SetRecvCodecsDifferentOrderDoesntRecreateStream) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004884 cricket::VideoRecvParameters parameters1;
magjed509e4fe2016-11-18 01:34:11 -08004885 parameters1.codecs.push_back(GetEngineCodec("VP8"));
4886 parameters1.codecs.push_back(GetEngineCodec("red"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004887 EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
deadbeef874ca3a2015-08-20 17:19:20 -07004888
4889 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
4890 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
4891
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004892 cricket::VideoRecvParameters parameters2;
magjed509e4fe2016-11-18 01:34:11 -08004893 parameters2.codecs.push_back(GetEngineCodec("red"));
4894 parameters2.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02004895 EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
deadbeef874ca3a2015-08-20 17:19:20 -07004896 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
4897}
4898
eladalonf1841382017-06-12 01:16:46 -07004899TEST_F(WebRtcVideoChannelTest, SendStreamNotSendingByDefault) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004900 EXPECT_FALSE(AddSendStream()->IsSending());
4901}
4902
eladalonf1841382017-06-12 01:16:46 -07004903TEST_F(WebRtcVideoChannelTest, ReceiveStreamReceivingByDefault) {
pbos@webrtc.org85f42942014-07-22 09:14:58 +00004904 EXPECT_TRUE(AddRecvStream()->IsReceiving());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004905}
4906
eladalonf1841382017-06-12 01:16:46 -07004907TEST_F(WebRtcVideoChannelTest, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00004908 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004909 EXPECT_FALSE(stream->IsSending());
4910
4911 // false->true
4912 EXPECT_TRUE(channel_->SetSend(true));
4913 EXPECT_TRUE(stream->IsSending());
4914 // true->true
4915 EXPECT_TRUE(channel_->SetSend(true));
4916 EXPECT_TRUE(stream->IsSending());
4917 // true->false
4918 EXPECT_TRUE(channel_->SetSend(false));
4919 EXPECT_FALSE(stream->IsSending());
4920 // false->false
4921 EXPECT_TRUE(channel_->SetSend(false));
4922 EXPECT_FALSE(stream->IsSending());
4923
4924 EXPECT_TRUE(channel_->SetSend(true));
4925 FakeVideoSendStream* new_stream = AddSendStream();
4926 EXPECT_TRUE(new_stream->IsSending())
4927 << "Send stream created after SetSend(true) not sending initially.";
4928}
4929
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00004930// This test verifies DSCP settings are properly applied on video media channel.
eladalonf1841382017-06-12 01:16:46 -07004931TEST_F(WebRtcVideoChannelTest, TestSetDscpOptions) {
kwiberg686a8ef2016-02-26 03:00:35 -08004932 std::unique_ptr<cricket::FakeNetworkInterface> network_interface(
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00004933 new cricket::FakeNetworkInterface);
nisse51542be2016-02-12 02:27:06 -08004934 MediaConfig config;
Tim Haloun6ca98362018-09-17 17:06:08 -07004935 std::unique_ptr<cricket::WebRtcVideoChannel> channel;
Tim Haloun648d28a2018-10-18 16:52:22 -07004936 webrtc::RtpParameters parameters;
nisse51542be2016-02-12 02:27:06 -08004937
Sebastian Jansson84848f22018-11-16 10:40:36 +01004938 channel.reset(
4939 static_cast<cricket::WebRtcVideoChannel*>(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02004940 call_.get(), config, VideoOptions(), webrtc::CryptoOptions(),
4941 video_bitrate_allocator_factory_.get())));
Anton Sukhanov4f08faa2019-05-21 11:12:57 -07004942 channel->SetInterface(network_interface.get(),
4943 webrtc::MediaTransportConfig());
nisse51542be2016-02-12 02:27:06 -08004944 // Default value when DSCP is disabled should be DSCP_DEFAULT.
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00004945 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
nisse51542be2016-02-12 02:27:06 -08004946
Tim Haloun648d28a2018-10-18 16:52:22 -07004947 // Default value when DSCP is enabled is also DSCP_DEFAULT, until it is set
4948 // through rtp parameters.
nisse51542be2016-02-12 02:27:06 -08004949 config.enable_dscp = true;
Sebastian Jansson84848f22018-11-16 10:40:36 +01004950 channel.reset(
4951 static_cast<cricket::WebRtcVideoChannel*>(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02004952 call_.get(), config, VideoOptions(), webrtc::CryptoOptions(),
4953 video_bitrate_allocator_factory_.get())));
Anton Sukhanov4f08faa2019-05-21 11:12:57 -07004954 channel->SetInterface(network_interface.get(),
4955 webrtc::MediaTransportConfig());
Tim Haloun648d28a2018-10-18 16:52:22 -07004956 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
4957
4958 // Create a send stream to configure
4959 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
4960 parameters = channel->GetRtpSendParameters(kSsrc);
4961 ASSERT_FALSE(parameters.encodings.empty());
4962
4963 // Various priorities map to various dscp values.
4964 parameters.encodings[0].network_priority = 4.0;
4965 ASSERT_TRUE(channel->SetRtpSendParameters(kSsrc, parameters).ok());
nisse51542be2016-02-12 02:27:06 -08004966 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
Tim Haloun648d28a2018-10-18 16:52:22 -07004967 parameters.encodings[0].network_priority = 0.5;
4968 ASSERT_TRUE(channel->SetRtpSendParameters(kSsrc, parameters).ok());
4969 EXPECT_EQ(rtc::DSCP_CS1, network_interface->dscp());
4970
4971 // A bad priority does not change the dscp value.
4972 parameters.encodings[0].network_priority = 0.0;
4973 ASSERT_FALSE(channel->SetRtpSendParameters(kSsrc, parameters).ok());
4974 EXPECT_EQ(rtc::DSCP_CS1, network_interface->dscp());
nisse51542be2016-02-12 02:27:06 -08004975
Tim Haloun6ca98362018-09-17 17:06:08 -07004976 // Packets should also self-identify their dscp in PacketOptions.
4977 const uint8_t kData[10] = {0};
4978 EXPECT_TRUE(static_cast<webrtc::Transport*>(channel.get())
4979 ->SendRtcp(kData, sizeof(kData)));
Tim Haloun648d28a2018-10-18 16:52:22 -07004980 EXPECT_EQ(rtc::DSCP_CS1, network_interface->options().dscp);
Tim Haloun6ca98362018-09-17 17:06:08 -07004981
nisse51542be2016-02-12 02:27:06 -08004982 // Verify that setting the option to false resets the
4983 // DiffServCodePoint.
4984 config.enable_dscp = false;
Sebastian Jansson84848f22018-11-16 10:40:36 +01004985 channel.reset(
4986 static_cast<cricket::WebRtcVideoChannel*>(engine_.CreateMediaChannel(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02004987 call_.get(), config, VideoOptions(), webrtc::CryptoOptions(),
4988 video_bitrate_allocator_factory_.get())));
Anton Sukhanov4f08faa2019-05-21 11:12:57 -07004989 channel->SetInterface(network_interface.get(),
4990 webrtc::MediaTransportConfig());
nisse51542be2016-02-12 02:27:06 -08004991 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00004992}
4993
deadbeef13871492015-12-09 12:37:51 -08004994// This test verifies that the RTCP reduced size mode is properly applied to
4995// send video streams.
eladalonf1841382017-06-12 01:16:46 -07004996TEST_F(WebRtcVideoChannelTest, TestSetSendRtcpReducedSize) {
deadbeef13871492015-12-09 12:37:51 -08004997 // Create stream, expecting that default mode is "compound".
4998 FakeVideoSendStream* stream1 = AddSendStream();
4999 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
Florent Castellidacec712018-05-24 16:24:21 +02005000 webrtc::RtpParameters rtp_parameters =
5001 channel_->GetRtpSendParameters(last_ssrc_);
5002 EXPECT_FALSE(rtp_parameters.rtcp.reduced_size);
deadbeef13871492015-12-09 12:37:51 -08005003
5004 // Now enable reduced size mode.
5005 send_parameters_.rtcp.reduced_size = true;
5006 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
5007 stream1 = fake_call_->GetVideoSendStreams()[0];
5008 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
Florent Castellidacec712018-05-24 16:24:21 +02005009 rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
5010 EXPECT_TRUE(rtp_parameters.rtcp.reduced_size);
deadbeef13871492015-12-09 12:37:51 -08005011
5012 // Create a new stream and ensure it picks up the reduced size mode.
5013 FakeVideoSendStream* stream2 = AddSendStream();
5014 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
5015}
5016
5017// This test verifies that the RTCP reduced size mode is properly applied to
5018// receive video streams.
eladalonf1841382017-06-12 01:16:46 -07005019TEST_F(WebRtcVideoChannelTest, TestSetRecvRtcpReducedSize) {
deadbeef13871492015-12-09 12:37:51 -08005020 // Create stream, expecting that default mode is "compound".
5021 FakeVideoReceiveStream* stream1 = AddRecvStream();
5022 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
5023
5024 // Now enable reduced size mode.
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07005025 // TODO(deadbeef): Once "recv_parameters" becomes "receiver_parameters",
5026 // the reduced_size flag should come from that.
5027 send_parameters_.rtcp.reduced_size = true;
5028 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
deadbeef13871492015-12-09 12:37:51 -08005029 stream1 = fake_call_->GetVideoReceiveStreams()[0];
5030 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
5031
5032 // Create a new stream and ensure it picks up the reduced size mode.
5033 FakeVideoReceiveStream* stream2 = AddRecvStream();
5034 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
5035}
5036
eladalonf1841382017-06-12 01:16:46 -07005037TEST_F(WebRtcVideoChannelTest, OnReadyToSendSignalsNetworkState) {
skvlad7a43d252016-03-22 15:32:27 -07005038 EXPECT_EQ(webrtc::kNetworkUp,
5039 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
5040 EXPECT_EQ(webrtc::kNetworkUp,
5041 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00005042
5043 channel_->OnReadyToSend(false);
skvlad7a43d252016-03-22 15:32:27 -07005044 EXPECT_EQ(webrtc::kNetworkDown,
5045 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
5046 EXPECT_EQ(webrtc::kNetworkUp,
5047 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00005048
5049 channel_->OnReadyToSend(true);
skvlad7a43d252016-03-22 15:32:27 -07005050 EXPECT_EQ(webrtc::kNetworkUp,
5051 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
5052 EXPECT_EQ(webrtc::kNetworkUp,
5053 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00005054}
5055
eladalonf1841382017-06-12 01:16:46 -07005056TEST_F(WebRtcVideoChannelTest, GetStatsReportsSentCodecName) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005057 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08005058 parameters.codecs.push_back(GetEngineCodec("VP8"));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005059 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström74d9ed72015-03-26 16:28:31 +01005060
5061 AddSendStream();
5062
5063 cricket::VideoMediaInfo info;
5064 ASSERT_TRUE(channel_->GetStats(&info));
magjed509e4fe2016-11-18 01:34:11 -08005065 EXPECT_EQ("VP8", info.senders[0].codec_name);
Peter Boström74d9ed72015-03-26 16:28:31 +01005066}
5067
eladalonf1841382017-06-12 01:16:46 -07005068TEST_F(WebRtcVideoChannelTest, GetStatsReportsEncoderImplementationName) {
Peter Boströmb7d9a972015-12-18 16:01:11 +01005069 FakeVideoSendStream* stream = AddSendStream();
5070 webrtc::VideoSendStream::Stats stats;
5071 stats.encoder_implementation_name = "encoder_implementation_name";
5072 stream->SetStats(stats);
5073
5074 cricket::VideoMediaInfo info;
5075 ASSERT_TRUE(channel_->GetStats(&info));
5076 EXPECT_EQ(stats.encoder_implementation_name,
5077 info.senders[0].encoder_implementation_name);
5078}
5079
eladalonf1841382017-06-12 01:16:46 -07005080TEST_F(WebRtcVideoChannelTest, GetStatsReportsCpuOveruseMetrics) {
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00005081 FakeVideoSendStream* stream = AddSendStream();
5082 webrtc::VideoSendStream::Stats stats;
5083 stats.avg_encode_time_ms = 13;
5084 stats.encode_usage_percent = 42;
5085 stream->SetStats(stats);
5086
5087 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005088 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00005089 EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms);
5090 EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent);
5091}
5092
eladalonf1841382017-06-12 01:16:46 -07005093TEST_F(WebRtcVideoChannelTest, GetStatsReportsFramesEncoded) {
sakal43536c32016-10-24 01:46:43 -07005094 FakeVideoSendStream* stream = AddSendStream();
5095 webrtc::VideoSendStream::Stats stats;
5096 stats.frames_encoded = 13;
5097 stream->SetStats(stats);
5098
5099 cricket::VideoMediaInfo info;
5100 ASSERT_TRUE(channel_->GetStats(&info));
5101 EXPECT_EQ(stats.frames_encoded, info.senders[0].frames_encoded);
5102}
5103
Rasmus Brandt2efae772019-06-27 14:29:34 +02005104TEST_F(WebRtcVideoChannelTest, GetStatsReportsKeyFramesEncoded) {
5105 FakeVideoSendStream* stream = AddSendStream();
5106 webrtc::VideoSendStream::Stats stats;
5107 stats.substreams[123].frame_counts.key_frames = 10;
5108 stats.substreams[456].frame_counts.key_frames = 87;
5109 stream->SetStats(stats);
5110
5111 cricket::VideoMediaInfo info;
5112 ASSERT_TRUE(channel_->GetStats(&info));
5113 // TODO(bugs.webrtc.org/9547): Populate individual outbound-rtp stats objects
5114 // for each simulcast stream, instead of accumulating all keyframes encoded
5115 // over all simulcast streams in the same outbound-rtp stats object.
5116 EXPECT_EQ(97u, info.senders[0].key_frames_encoded);
5117}
5118
eladalonf1841382017-06-12 01:16:46 -07005119TEST_F(WebRtcVideoChannelTest, GetStatsReportsQpSum) {
sakal87da4042016-10-31 06:53:47 -07005120 FakeVideoSendStream* stream = AddSendStream();
5121 webrtc::VideoSendStream::Stats stats;
Oskar Sundbom78807582017-11-16 11:09:55 +01005122 stats.qp_sum = 13;
sakal87da4042016-10-31 06:53:47 -07005123 stream->SetStats(stats);
5124
5125 cricket::VideoMediaInfo info;
5126 ASSERT_TRUE(channel_->GetStats(&info));
5127 EXPECT_EQ(stats.qp_sum, info.senders[0].qp_sum);
5128}
5129
eladalonf1841382017-06-12 01:16:46 -07005130TEST_F(WebRtcVideoChannelTest, GetStatsReportsUpperResolution) {
pbos@webrtc.org273a4142014-12-01 15:23:21 +00005131 FakeVideoSendStream* stream = AddSendStream();
5132 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005133 stats.substreams[17].width = 123;
5134 stats.substreams[17].height = 40;
5135 stats.substreams[42].width = 80;
5136 stats.substreams[42].height = 31;
5137 stats.substreams[11].width = 20;
5138 stats.substreams[11].height = 90;
pbos@webrtc.org273a4142014-12-01 15:23:21 +00005139 stream->SetStats(stats);
5140
5141 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005142 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org273a4142014-12-01 15:23:21 +00005143 ASSERT_EQ(1u, info.senders.size());
5144 EXPECT_EQ(123, info.senders[0].send_frame_width);
5145 EXPECT_EQ(90, info.senders[0].send_frame_height);
5146}
5147
eladalonf1841382017-06-12 01:16:46 -07005148TEST_F(WebRtcVideoChannelTest, GetStatsReportsCpuAdaptationStats) {
perkj803d97f2016-11-01 11:45:46 -07005149 FakeVideoSendStream* stream = AddSendStream();
5150 webrtc::VideoSendStream::Stats stats;
5151 stats.number_of_cpu_adapt_changes = 2;
5152 stats.cpu_limited_resolution = true;
5153 stream->SetStats(stats);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00005154
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00005155 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005156 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00005157 ASSERT_EQ(1U, info.senders.size());
eladalonf1841382017-06-12 01:16:46 -07005158 EXPECT_EQ(WebRtcVideoChannel::ADAPTREASON_CPU, info.senders[0].adapt_reason);
perkj803d97f2016-11-01 11:45:46 -07005159 EXPECT_EQ(stats.number_of_cpu_adapt_changes, info.senders[0].adapt_changes);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00005160}
5161
eladalonf1841382017-06-12 01:16:46 -07005162TEST_F(WebRtcVideoChannelTest, GetStatsReportsAdaptationAndBandwidthStats) {
perkj803d97f2016-11-01 11:45:46 -07005163 FakeVideoSendStream* stream = AddSendStream();
asapersson17821db2015-12-14 02:08:12 -08005164 webrtc::VideoSendStream::Stats stats;
perkj803d97f2016-11-01 11:45:46 -07005165 stats.number_of_cpu_adapt_changes = 2;
5166 stats.cpu_limited_resolution = true;
asapersson17821db2015-12-14 02:08:12 -08005167 stats.bw_limited_resolution = true;
perkj803d97f2016-11-01 11:45:46 -07005168 stream->SetStats(stats);
5169
5170 cricket::VideoMediaInfo info;
asapersson17821db2015-12-14 02:08:12 -08005171 EXPECT_TRUE(channel_->GetStats(&info));
5172 ASSERT_EQ(1U, info.senders.size());
eladalonf1841382017-06-12 01:16:46 -07005173 EXPECT_EQ(WebRtcVideoChannel::ADAPTREASON_CPU |
5174 WebRtcVideoChannel::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08005175 info.senders[0].adapt_reason);
perkj803d97f2016-11-01 11:45:46 -07005176 EXPECT_EQ(stats.number_of_cpu_adapt_changes, info.senders[0].adapt_changes);
asapersson17821db2015-12-14 02:08:12 -08005177}
5178
eladalonf1841382017-06-12 01:16:46 -07005179TEST_F(WebRtcVideoChannelTest,
asapersson17821db2015-12-14 02:08:12 -08005180 GetStatsTranslatesBandwidthLimitedResolutionCorrectly) {
5181 FakeVideoSendStream* stream = AddSendStream();
5182 webrtc::VideoSendStream::Stats stats;
5183 stats.bw_limited_resolution = true;
5184 stream->SetStats(stats);
5185
5186 cricket::VideoMediaInfo info;
5187 EXPECT_TRUE(channel_->GetStats(&info));
5188 ASSERT_EQ(1U, info.senders.size());
eladalonf1841382017-06-12 01:16:46 -07005189 EXPECT_EQ(WebRtcVideoChannel::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08005190 info.senders[0].adapt_reason);
5191}
5192
Yves Gerey665174f2018-06-19 15:03:05 +02005193TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00005194 FakeVideoSendStream* stream = AddSendStream();
5195 webrtc::VideoSendStream::Stats stats;
5196 stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
5197 stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
5198 stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
5199
5200 stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5;
5201 stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7;
5202 stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9;
5203
5204 stream->SetStats(stats);
5205
5206 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005207 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00005208 EXPECT_EQ(7, info.senders[0].firs_rcvd);
5209 EXPECT_EQ(10, info.senders[0].nacks_rcvd);
5210 EXPECT_EQ(13, info.senders[0].plis_rcvd);
5211}
5212
eladalonf1841382017-06-12 01:16:46 -07005213TEST_F(WebRtcVideoChannelTest,
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00005214 GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
5215 FakeVideoReceiveStream* stream = AddRecvStream();
5216 webrtc::VideoReceiveStream::Stats stats;
5217 stats.rtcp_packet_type_counts.fir_packets = 2;
5218 stats.rtcp_packet_type_counts.nack_packets = 3;
5219 stats.rtcp_packet_type_counts.pli_packets = 4;
5220 stream->SetStats(stats);
5221
5222 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005223 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00005224 EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
Mirko Bonadeif859e552018-05-30 15:31:29 +02005225 rtc::checked_cast<unsigned int>(info.receivers[0].firs_sent));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00005226 EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
Mirko Bonadeif859e552018-05-30 15:31:29 +02005227 rtc::checked_cast<unsigned int>(info.receivers[0].nacks_sent));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00005228 EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
Mirko Bonadeif859e552018-05-30 15:31:29 +02005229 rtc::checked_cast<unsigned int>(info.receivers[0].plis_sent));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00005230}
5231
eladalonf1841382017-06-12 01:16:46 -07005232TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005233 FakeVideoReceiveStream* stream = AddRecvStream();
5234 webrtc::VideoReceiveStream::Stats stats;
Peter Boströmb7d9a972015-12-18 16:01:11 +01005235 stats.decoder_implementation_name = "decoder_implementation_name";
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005236 stats.decode_ms = 2;
5237 stats.max_decode_ms = 3;
5238 stats.current_delay_ms = 4;
5239 stats.target_delay_ms = 5;
5240 stats.jitter_buffer_ms = 6;
Guido Urdaneta67378412019-05-28 17:38:08 +02005241 stats.jitter_buffer_delay_seconds = 60;
5242 stats.jitter_buffer_emitted_count = 6;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005243 stats.min_playout_delay_ms = 7;
5244 stats.render_delay_ms = 8;
asapersson26dd92b2016-08-30 00:45:45 -07005245 stats.width = 9;
5246 stats.height = 10;
hbos42f6d2f2017-01-20 03:56:50 -08005247 stats.frame_counts.key_frames = 11;
5248 stats.frame_counts.delta_frames = 12;
hbos50cfe1f2017-01-23 07:21:55 -08005249 stats.frames_rendered = 13;
5250 stats.frames_decoded = 14;
Oskar Sundbom78807582017-11-16 11:09:55 +01005251 stats.qp_sum = 15;
Johannes Kronbfd343b2019-07-01 10:07:50 +02005252 stats.total_decode_time_ms = 16;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005253 stream->SetStats(stats);
5254
5255 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005256 ASSERT_TRUE(channel_->GetStats(&info));
Peter Boströmb7d9a972015-12-18 16:01:11 +01005257 EXPECT_EQ(stats.decoder_implementation_name,
5258 info.receivers[0].decoder_implementation_name);
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005259 EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms);
5260 EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms);
5261 EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms);
5262 EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms);
5263 EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms);
Guido Urdaneta67378412019-05-28 17:38:08 +02005264 EXPECT_EQ(stats.jitter_buffer_delay_seconds,
5265 info.receivers[0].jitter_buffer_delay_seconds);
5266 EXPECT_EQ(stats.jitter_buffer_emitted_count,
5267 info.receivers[0].jitter_buffer_emitted_count);
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005268 EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms);
5269 EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
asapersson26dd92b2016-08-30 00:45:45 -07005270 EXPECT_EQ(stats.width, info.receivers[0].frame_width);
5271 EXPECT_EQ(stats.height, info.receivers[0].frame_height);
Mirko Bonadeif859e552018-05-30 15:31:29 +02005272 EXPECT_EQ(rtc::checked_cast<unsigned int>(stats.frame_counts.key_frames +
5273 stats.frame_counts.delta_frames),
hbos42f6d2f2017-01-20 03:56:50 -08005274 info.receivers[0].frames_received);
hbos50cfe1f2017-01-23 07:21:55 -08005275 EXPECT_EQ(stats.frames_rendered, info.receivers[0].frames_rendered);
sakale5ba44e2016-10-26 07:09:24 -07005276 EXPECT_EQ(stats.frames_decoded, info.receivers[0].frames_decoded);
Rasmus Brandt2efae772019-06-27 14:29:34 +02005277 EXPECT_EQ(rtc::checked_cast<unsigned int>(stats.frame_counts.key_frames),
5278 info.receivers[0].key_frames_decoded);
sakalcc452e12017-02-09 04:53:45 -08005279 EXPECT_EQ(stats.qp_sum, info.receivers[0].qp_sum);
Johannes Kronbfd343b2019-07-01 10:07:50 +02005280 EXPECT_EQ(stats.total_decode_time_ms, info.receivers[0].total_decode_time_ms);
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00005281}
5282
eladalonf1841382017-06-12 01:16:46 -07005283TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesReceivePacketStatsCorrectly) {
Bjorn A Mellemda4f0932019-07-30 08:34:03 -07005284 webrtc::test::ScopedFieldTrials field_trials(
5285 "WebRTC-UseStandardBytesStats/Enabled/");
5286
Peter Boström393347f2015-04-22 14:52:45 +02005287 FakeVideoReceiveStream* stream = AddRecvStream();
5288 webrtc::VideoReceiveStream::Stats stats;
Niels Möllerd77cc242019-08-22 09:40:25 +02005289 stats.rtp_stats.packet_counter.payload_bytes = 2;
5290 stats.rtp_stats.packet_counter.header_bytes = 3;
5291 stats.rtp_stats.packet_counter.padding_bytes = 4;
5292 stats.rtp_stats.packet_counter.packets = 5;
5293 stats.rtp_stats.packets_lost = 6;
Peter Boström393347f2015-04-22 14:52:45 +02005294 stream->SetStats(stats);
5295
5296 cricket::VideoMediaInfo info;
5297 ASSERT_TRUE(channel_->GetStats(&info));
Niels Möllerd77cc242019-08-22 09:40:25 +02005298 EXPECT_EQ(stats.rtp_stats.packet_counter.payload_bytes,
Mirko Bonadeif859e552018-05-30 15:31:29 +02005299 rtc::checked_cast<size_t>(info.receivers[0].bytes_rcvd));
Niels Möllerd77cc242019-08-22 09:40:25 +02005300 EXPECT_EQ(stats.rtp_stats.packet_counter.packets,
Mirko Bonadeif859e552018-05-30 15:31:29 +02005301 rtc::checked_cast<unsigned int>(info.receivers[0].packets_rcvd));
Niels Möllerd77cc242019-08-22 09:40:25 +02005302 EXPECT_EQ(stats.rtp_stats.packets_lost, info.receivers[0].packets_lost);
Peter Boström393347f2015-04-22 14:52:45 +02005303}
5304
eladalonf1841382017-06-12 01:16:46 -07005305TEST_F(WebRtcVideoChannelTest, TranslatesCallStatsCorrectly) {
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00005306 AddSendStream();
5307 AddSendStream();
5308 webrtc::Call::Stats stats;
5309 stats.rtt_ms = 123;
5310 fake_call_->SetStats(stats);
5311
5312 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005313 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00005314 ASSERT_EQ(2u, info.senders.size());
5315 EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms);
5316 EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms);
5317}
5318
eladalonf1841382017-06-12 01:16:46 -07005319TEST_F(WebRtcVideoChannelTest, TranslatesSenderBitrateStatsCorrectly) {
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005320 FakeVideoSendStream* stream = AddSendStream();
5321 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00005322 stats.target_media_bitrate_bps = 156;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005323 stats.media_bitrate_bps = 123;
5324 stats.substreams[17].total_bitrate_bps = 1;
5325 stats.substreams[17].retransmit_bitrate_bps = 2;
5326 stats.substreams[42].total_bitrate_bps = 3;
5327 stats.substreams[42].retransmit_bitrate_bps = 4;
5328 stream->SetStats(stats);
5329
5330 FakeVideoSendStream* stream2 = AddSendStream();
5331 webrtc::VideoSendStream::Stats stats2;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00005332 stats2.target_media_bitrate_bps = 200;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005333 stats2.media_bitrate_bps = 321;
5334 stats2.substreams[13].total_bitrate_bps = 5;
5335 stats2.substreams[13].retransmit_bitrate_bps = 6;
5336 stats2.substreams[21].total_bitrate_bps = 7;
5337 stats2.substreams[21].retransmit_bitrate_bps = 8;
5338 stream2->SetStats(stats2);
5339
5340 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00005341 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005342 ASSERT_EQ(2u, info.senders.size());
stefanf79ade12017-06-02 06:44:03 -07005343 BandwidthEstimationInfo bwe_info;
5344 channel_->FillBitrateInfo(&bwe_info);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005345 // Assuming stream and stream2 corresponds to senders[0] and [1] respectively
5346 // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
5347 EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
5348 EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
pbos@webrtc.org891d4832015-02-26 13:15:22 +00005349 EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
stefanf79ade12017-06-02 06:44:03 -07005350 bwe_info.target_enc_bitrate);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005351 EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
stefanf79ade12017-06-02 06:44:03 -07005352 bwe_info.actual_enc_bitrate);
5353 EXPECT_EQ(1 + 3 + 5 + 7, bwe_info.transmit_bitrate)
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005354 << "Bandwidth stats should take all streams into account.";
stefanf79ade12017-06-02 06:44:03 -07005355 EXPECT_EQ(2 + 4 + 6 + 8, bwe_info.retransmit_bitrate)
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00005356 << "Bandwidth stats should take all streams into account.";
5357}
5358
eladalonf1841382017-06-12 01:16:46 -07005359TEST_F(WebRtcVideoChannelTest, DefaultReceiveStreamReconfiguresToUseRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005360 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00005361
Peter Boström0c4e06b2015-10-07 12:23:21 +02005362 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
5363 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00005364
5365 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
5366 const size_t kDataLength = 12;
5367 uint8_t data[kDataLength];
5368 memset(data, 0, sizeof(data));
5369 rtc::SetBE32(&data[8], ssrcs[0]);
jbaucheec21bd2016-03-20 06:15:43 -07005370 rtc::CopyOnWriteBuffer packet(data, kDataLength);
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005371 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00005372
5373 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
5374 << "No default receive stream created.";
5375 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
brandtr14742122017-01-27 04:53:07 -08005376 EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx_ssrc)
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00005377 << "Default receive stream should not have configured RTX";
5378
5379 EXPECT_TRUE(channel_->AddRecvStream(
5380 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
5381 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
brandtr14742122017-01-27 04:53:07 -08005382 << "AddRecvStream should have reconfigured, not added a new receiver.";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00005383 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
nisse26e3abb2017-08-25 04:44:25 -07005384 EXPECT_FALSE(
5385 recv_stream->GetConfig().rtp.rtx_associated_payload_types.empty());
nisseca5706d2017-09-11 02:32:16 -07005386 EXPECT_TRUE(VerifyRtxReceiveAssociations(recv_stream->GetConfig()))
Peter Boströmd8b01092016-05-12 16:44:36 +02005387 << "RTX should be mapped for all decoders/payload types.";
nisseca5706d2017-09-11 02:32:16 -07005388 EXPECT_TRUE(HasRtxReceiveAssociation(recv_stream->GetConfig(),
Yves Gerey665174f2018-06-19 15:03:05 +02005389 GetEngineCodec("red").id))
nisseca5706d2017-09-11 02:32:16 -07005390 << "RTX should be mapped also for the RED payload type";
brandtr14742122017-01-27 04:53:07 -08005391 EXPECT_EQ(rtx_ssrcs[0], recv_stream->GetConfig().rtp.rtx_ssrc);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00005392}
5393
eladalonf1841382017-06-12 01:16:46 -07005394TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithMissingSsrcsForRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005395 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd4362cd2015-03-25 14:17:23 +01005396
Peter Boström0c4e06b2015-10-07 12:23:21 +02005397 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
5398 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd4362cd2015-03-25 14:17:23 +01005399
5400 StreamParams sp =
5401 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
5402 sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
5403
5404 EXPECT_FALSE(channel_->AddSendStream(sp));
5405 EXPECT_FALSE(channel_->AddRecvStream(sp));
5406}
5407
eladalonf1841382017-06-12 01:16:46 -07005408TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005409 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01005410
Peter Boström0c4e06b2015-10-07 12:23:21 +02005411 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
5412 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd6f4c252015-03-26 16:23:04 +01005413
5414 StreamParams sp =
5415 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
5416
5417 EXPECT_TRUE(channel_->AddSendStream(sp));
5418 EXPECT_TRUE(channel_->AddRecvStream(sp));
5419
5420 // The RTX SSRC is already used in previous streams, using it should fail.
5421 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
5422 EXPECT_FALSE(channel_->AddSendStream(sp));
5423 EXPECT_FALSE(channel_->AddRecvStream(sp));
5424
5425 // After removing the original stream this should be fine to add (makes sure
5426 // that RTX ssrcs are not forever taken).
5427 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
5428 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
5429 EXPECT_TRUE(channel_->AddSendStream(sp));
5430 EXPECT_TRUE(channel_->AddRecvStream(sp));
5431}
5432
eladalonf1841382017-06-12 01:16:46 -07005433TEST_F(WebRtcVideoChannelTest,
Peter Boströmd6f4c252015-03-26 16:23:04 +01005434 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02005435 static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3};
5436 static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005437 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01005438
Peter Boströmd6f4c252015-03-26 16:23:04 +01005439 StreamParams sp =
5440 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
5441
5442 EXPECT_TRUE(channel_->AddSendStream(sp));
5443 EXPECT_TRUE(channel_->AddRecvStream(sp));
5444
5445 // One of the SSRCs is already used in previous streams, using it should fail.
5446 sp = cricket::CreateSimStreamParams("cname",
5447 MAKE_VECTOR(kOverlappingStreamSsrcs));
5448 EXPECT_FALSE(channel_->AddSendStream(sp));
5449 EXPECT_FALSE(channel_->AddRecvStream(sp));
5450
5451 // After removing the original stream this should be fine to add (makes sure
5452 // that RTX ssrcs are not forever taken).
Peter Boström3548dd22015-05-22 18:48:36 +02005453 EXPECT_TRUE(channel_->RemoveSendStream(kFirstStreamSsrcs[0]));
5454 EXPECT_TRUE(channel_->RemoveRecvStream(kFirstStreamSsrcs[0]));
Peter Boströmd6f4c252015-03-26 16:23:04 +01005455 EXPECT_TRUE(channel_->AddSendStream(sp));
5456 EXPECT_TRUE(channel_->AddRecvStream(sp));
5457}
5458
eladalonf1841382017-06-12 01:16:46 -07005459TEST_F(WebRtcVideoChannelTest, ReportsSsrcGroupsInStats) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005460 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström259bd202015-05-28 13:39:50 +02005461
5462 static const uint32_t kSenderSsrcs[] = {4, 7, 10};
5463 static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11};
5464
5465 StreamParams sender_sp = cricket::CreateSimWithRtxStreamParams(
5466 "cname", MAKE_VECTOR(kSenderSsrcs), MAKE_VECTOR(kSenderRtxSsrcs));
5467
5468 EXPECT_TRUE(channel_->AddSendStream(sender_sp));
5469
5470 static const uint32_t kReceiverSsrcs[] = {3};
5471 static const uint32_t kReceiverRtxSsrcs[] = {2};
5472
5473 StreamParams receiver_sp = cricket::CreateSimWithRtxStreamParams(
5474 "cname", MAKE_VECTOR(kReceiverSsrcs), MAKE_VECTOR(kReceiverRtxSsrcs));
5475 EXPECT_TRUE(channel_->AddRecvStream(receiver_sp));
5476
5477 cricket::VideoMediaInfo info;
5478 ASSERT_TRUE(channel_->GetStats(&info));
5479
5480 ASSERT_EQ(1u, info.senders.size());
5481 ASSERT_EQ(1u, info.receivers.size());
5482
5483 EXPECT_NE(sender_sp.ssrc_groups, receiver_sp.ssrc_groups);
5484 EXPECT_EQ(sender_sp.ssrc_groups, info.senders[0].ssrc_groups);
5485 EXPECT_EQ(receiver_sp.ssrc_groups, info.receivers[0].ssrc_groups);
5486}
5487
eladalonf1841382017-06-12 01:16:46 -07005488TEST_F(WebRtcVideoChannelTest, MapsReceivedPayloadTypeToCodecName) {
pbosf42376c2015-08-28 07:35:32 -07005489 FakeVideoReceiveStream* stream = AddRecvStream();
5490 webrtc::VideoReceiveStream::Stats stats;
5491 cricket::VideoMediaInfo info;
5492
5493 // Report no codec name before receiving.
5494 stream->SetStats(stats);
5495 ASSERT_TRUE(channel_->GetStats(&info));
5496 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
5497
5498 // Report VP8 if we're receiving it.
magjed509e4fe2016-11-18 01:34:11 -08005499 stats.current_payload_type = GetEngineCodec("VP8").id;
pbosf42376c2015-08-28 07:35:32 -07005500 stream->SetStats(stats);
5501 ASSERT_TRUE(channel_->GetStats(&info));
5502 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str());
5503
5504 // Report no codec name for unknown playload types.
5505 stats.current_payload_type = 3;
5506 stream->SetStats(stats);
5507 ASSERT_TRUE(channel_->GetStats(&info));
5508 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
5509}
5510
Seth Hampson5897a6e2018-04-03 11:16:33 -07005511// Tests that when we add a stream without SSRCs, but contains a stream_id
5512// that it is stored and its stream id is later used when the first packet
5513// arrives to properly create a receive stream with a sync label.
5514TEST_F(WebRtcVideoChannelTest, RecvUnsignaledSsrcWithSignaledStreamId) {
5515 const char kSyncLabel[] = "sync_label";
5516 cricket::StreamParams unsignaled_stream;
5517 unsignaled_stream.set_stream_ids({kSyncLabel});
5518 ASSERT_TRUE(channel_->AddRecvStream(unsignaled_stream));
5519 // The stream shouldn't have been created at this point because it doesn't
5520 // have any SSRCs.
Mirko Bonadeif859e552018-05-30 15:31:29 +02005521 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
Seth Hampson5897a6e2018-04-03 11:16:33 -07005522
5523 // Create and deliver packet.
5524 const size_t kDataLength = 12;
5525 uint8_t data[kDataLength];
5526 memset(data, 0, sizeof(data));
5527 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
5528 rtc::CopyOnWriteBuffer packet(data, kDataLength);
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005529 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
Seth Hampson5897a6e2018-04-03 11:16:33 -07005530
5531 // The stream should now be created with the appropriate sync label.
5532 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
5533 EXPECT_EQ(kSyncLabel,
5534 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group);
5535
5536 // Removing the unsignaled stream should clear the cache. This time when
5537 // a default video receive stream is created it won't have a sync_group.
5538 ASSERT_TRUE(channel_->RemoveRecvStream(0));
5539 ASSERT_TRUE(channel_->RemoveRecvStream(kIncomingUnsignalledSsrc));
5540 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
5541
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005542 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
Seth Hampson5897a6e2018-04-03 11:16:33 -07005543 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
5544 EXPECT_TRUE(
5545 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group.empty());
5546}
5547
Ruslan Burakov493a6502019-02-27 15:32:48 +01005548// Test BaseMinimumPlayoutDelayMs on receive streams.
5549TEST_F(WebRtcVideoChannelTest, BaseMinimumPlayoutDelayMs) {
5550 // Test that set won't work for non-existing receive streams.
5551 EXPECT_FALSE(channel_->SetBaseMinimumPlayoutDelayMs(kSsrc + 2, 200));
5552 // Test that get won't work for non-existing receive streams.
5553 EXPECT_FALSE(channel_->GetBaseMinimumPlayoutDelayMs(kSsrc + 2));
5554
5555 EXPECT_TRUE(AddRecvStream());
5556 // Test that set works for the existing receive stream.
5557 EXPECT_TRUE(channel_->SetBaseMinimumPlayoutDelayMs(last_ssrc_, 200));
5558 auto* recv_stream = fake_call_->GetVideoReceiveStream(last_ssrc_);
5559 EXPECT_TRUE(recv_stream);
5560 EXPECT_EQ(recv_stream->base_mininum_playout_delay_ms(), 200);
5561 EXPECT_EQ(channel_->GetBaseMinimumPlayoutDelayMs(last_ssrc_).value_or(0),
5562 200);
5563}
5564
5565// Test BaseMinimumPlayoutDelayMs on unsignaled receive streams.
5566TEST_F(WebRtcVideoChannelTest, BaseMinimumPlayoutDelayMsUnsignaledRecvStream) {
5567 absl::optional<int> delay_ms;
5568 const FakeVideoReceiveStream* recv_stream;
5569
5570 // Set default stream with SSRC 0
5571 EXPECT_TRUE(channel_->SetBaseMinimumPlayoutDelayMs(0, 200));
5572 EXPECT_EQ(200, channel_->GetBaseMinimumPlayoutDelayMs(0).value_or(0));
5573
5574 // Spawn an unsignaled stream by sending a packet, it should inherit
5575 // default delay 200.
5576 const size_t kDataLength = 12;
5577 uint8_t data[kDataLength];
5578 memset(data, 0, sizeof(data));
5579 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
5580 rtc::CopyOnWriteBuffer packet(data, kDataLength);
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005581 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
Ruslan Burakov493a6502019-02-27 15:32:48 +01005582
5583 recv_stream = fake_call_->GetVideoReceiveStream(kIncomingUnsignalledSsrc);
5584 EXPECT_EQ(recv_stream->base_mininum_playout_delay_ms(), 200);
5585 delay_ms = channel_->GetBaseMinimumPlayoutDelayMs(kIncomingUnsignalledSsrc);
5586 EXPECT_EQ(200, delay_ms.value_or(0));
5587
5588 // Check that now if we change delay for SSRC 0 it will change delay for the
5589 // default receiving stream as well.
5590 EXPECT_TRUE(channel_->SetBaseMinimumPlayoutDelayMs(0, 300));
5591 EXPECT_EQ(300, channel_->GetBaseMinimumPlayoutDelayMs(0).value_or(0));
5592 delay_ms = channel_->GetBaseMinimumPlayoutDelayMs(kIncomingUnsignalledSsrc);
5593 EXPECT_EQ(300, delay_ms.value_or(0));
5594 recv_stream = fake_call_->GetVideoReceiveStream(kIncomingUnsignalledSsrc);
5595 EXPECT_EQ(recv_stream->base_mininum_playout_delay_ms(), 300);
5596}
5597
eladalonf1841382017-06-12 01:16:46 -07005598void WebRtcVideoChannelTest::TestReceiveUnsignaledSsrcPacket(
noahricd10a68e2015-07-10 11:27:55 -07005599 uint8_t payload_type,
5600 bool expect_created_receive_stream) {
magjed509e4fe2016-11-18 01:34:11 -08005601 // kRedRtxPayloadType must currently be unused.
5602 EXPECT_FALSE(FindCodecById(engine_.codecs(), kRedRtxPayloadType));
5603
noahricd10a68e2015-07-10 11:27:55 -07005604 // Add a RED RTX codec.
5605 VideoCodec red_rtx_codec =
magjed509e4fe2016-11-18 01:34:11 -08005606 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, GetEngineCodec("red").id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02005607 recv_parameters_.codecs.push_back(red_rtx_codec);
5608 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
noahricd10a68e2015-07-10 11:27:55 -07005609
5610 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
5611 const size_t kDataLength = 12;
5612 uint8_t data[kDataLength];
5613 memset(data, 0, sizeof(data));
5614
5615 rtc::Set8(data, 1, payload_type);
5616 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
jbaucheec21bd2016-03-20 06:15:43 -07005617 rtc::CopyOnWriteBuffer packet(data, kDataLength);
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005618 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
noahricd10a68e2015-07-10 11:27:55 -07005619
5620 if (expect_created_receive_stream) {
5621 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
5622 << "Should have created a receive stream for payload type: "
5623 << payload_type;
5624 } else {
5625 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size())
5626 << "Shouldn't have created a receive stream for payload type: "
5627 << payload_type;
5628 }
5629}
5630
Åsa Persson2c7149b2018-10-15 09:36:10 +02005631class WebRtcVideoChannelDiscardUnknownSsrcTest : public WebRtcVideoChannelTest {
5632 public:
5633 WebRtcVideoChannelDiscardUnknownSsrcTest()
5634 : WebRtcVideoChannelTest(
5635 "WebRTC-Video-DiscardPacketsWithUnknownSsrc/Enabled/") {}
5636};
5637
5638TEST_F(WebRtcVideoChannelDiscardUnknownSsrcTest, NoUnsignalledStreamCreated) {
5639 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP8").id,
5640 false /* expect_created_receive_stream */);
5641}
5642
eladalonf1841382017-06-12 01:16:46 -07005643TEST_F(WebRtcVideoChannelTest, Vp8PacketCreatesUnsignalledStream) {
magjed509e4fe2016-11-18 01:34:11 -08005644 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP8").id,
5645 true /* expect_created_receive_stream */);
noahricd10a68e2015-07-10 11:27:55 -07005646}
5647
eladalonf1841382017-06-12 01:16:46 -07005648TEST_F(WebRtcVideoChannelTest, Vp9PacketCreatesUnsignalledStream) {
magjed509e4fe2016-11-18 01:34:11 -08005649 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP9").id,
5650 true /* expect_created_receive_stream */);
noahricd10a68e2015-07-10 11:27:55 -07005651}
5652
eladalonf1841382017-06-12 01:16:46 -07005653TEST_F(WebRtcVideoChannelTest, RtxPacketDoesntCreateUnsignalledStream) {
Anders Carlsson5f2bb622018-05-14 09:48:06 +02005654 AssignDefaultAptRtxTypes();
magjed509e4fe2016-11-18 01:34:11 -08005655 const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
5656 const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
5657 TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
5658 false /* expect_created_receive_stream */);
noahricd10a68e2015-07-10 11:27:55 -07005659}
5660
eladalonf1841382017-06-12 01:16:46 -07005661TEST_F(WebRtcVideoChannelTest, UlpfecPacketDoesntCreateUnsignalledStream) {
magjed509e4fe2016-11-18 01:34:11 -08005662 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("ulpfec").id,
5663 false /* expect_created_receive_stream */);
noahricd10a68e2015-07-10 11:27:55 -07005664}
5665
eladalonf1841382017-06-12 01:16:46 -07005666TEST_F(WebRtcVideoChannelFlexfecRecvTest,
brandtr468da7c2016-11-22 02:16:47 -08005667 FlexfecPacketDoesntCreateUnsignalledStream) {
5668 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("flexfec-03").id,
5669 false /* expect_created_receive_stream */);
5670}
5671
eladalonf1841382017-06-12 01:16:46 -07005672TEST_F(WebRtcVideoChannelTest, RedRtxPacketDoesntCreateUnsignalledStream) {
magjed509e4fe2016-11-18 01:34:11 -08005673 TestReceiveUnsignaledSsrcPacket(kRedRtxPayloadType,
5674 false /* expect_created_receive_stream */);
noahricd10a68e2015-07-10 11:27:55 -07005675}
5676
mzanaty8a855d62017-02-17 15:46:43 -08005677// Test that receiving any unsignalled SSRC works even if it changes.
5678// The first unsignalled SSRC received will create a default receive stream.
5679// Any different unsignalled SSRC received will replace the default.
eladalonf1841382017-06-12 01:16:46 -07005680TEST_F(WebRtcVideoChannelTest, ReceiveDifferentUnsignaledSsrc) {
mzanaty8a855d62017-02-17 15:46:43 -08005681 // Allow receiving VP8, VP9, H264 (if enabled).
5682 cricket::VideoRecvParameters parameters;
5683 parameters.codecs.push_back(GetEngineCodec("VP8"));
5684 parameters.codecs.push_back(GetEngineCodec("VP9"));
5685
5686#if defined(WEBRTC_USE_H264)
5687 cricket::VideoCodec H264codec(126, "H264");
5688 parameters.codecs.push_back(H264codec);
5689#endif
5690
5691 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
5692 // No receive streams yet.
5693 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
5694 cricket::FakeVideoRenderer renderer;
5695 EXPECT_TRUE(channel_->SetSink(kDefaultRecvSsrc, &renderer));
5696
5697 // Receive VP8 packet on first SSRC.
5698 uint8_t data[kMinRtpPacketLen];
5699 cricket::RtpHeader rtpHeader;
5700 rtpHeader.payload_type = GetEngineCodec("VP8").id;
5701 rtpHeader.seq_num = rtpHeader.timestamp = 0;
Yves Gerey665174f2018-06-19 15:03:05 +02005702 rtpHeader.ssrc = kIncomingUnsignalledSsrc + 1;
mzanaty8a855d62017-02-17 15:46:43 -08005703 cricket::SetRtpHeader(data, sizeof(data), rtpHeader);
5704 rtc::CopyOnWriteBuffer packet(data, sizeof(data));
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005705 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
mzanaty8a855d62017-02-17 15:46:43 -08005706 // VP8 packet should create default receive stream.
5707 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
Yves Gerey665174f2018-06-19 15:03:05 +02005708 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
mzanaty8a855d62017-02-17 15:46:43 -08005709 EXPECT_EQ(rtpHeader.ssrc, recv_stream->GetConfig().rtp.remote_ssrc);
5710 // Verify that the receive stream sinks to a renderer.
Artem Titov1ebfb6a2019-01-03 23:49:37 +01005711 webrtc::VideoFrame video_frame =
5712 webrtc::VideoFrame::Builder()
5713 .set_video_frame_buffer(CreateBlackFrameBuffer(4, 4))
5714 .set_timestamp_rtp(100)
5715 .set_timestamp_us(0)
5716 .set_rotation(webrtc::kVideoRotation_0)
5717 .build();
mzanaty8a855d62017-02-17 15:46:43 -08005718 recv_stream->InjectFrame(video_frame);
5719 EXPECT_EQ(1, renderer.num_rendered_frames());
5720
5721 // Receive VP9 packet on second SSRC.
5722 rtpHeader.payload_type = GetEngineCodec("VP9").id;
Yves Gerey665174f2018-06-19 15:03:05 +02005723 rtpHeader.ssrc = kIncomingUnsignalledSsrc + 2;
mzanaty8a855d62017-02-17 15:46:43 -08005724 cricket::SetRtpHeader(data, sizeof(data), rtpHeader);
5725 rtc::CopyOnWriteBuffer packet2(data, sizeof(data));
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005726 channel_->OnPacketReceived(packet2, /* packet_time_us */ -1);
mzanaty8a855d62017-02-17 15:46:43 -08005727 // VP9 packet should replace the default receive SSRC.
5728 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
5729 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
5730 EXPECT_EQ(rtpHeader.ssrc, recv_stream->GetConfig().rtp.remote_ssrc);
5731 // Verify that the receive stream sinks to a renderer.
Artem Titov1ebfb6a2019-01-03 23:49:37 +01005732 webrtc::VideoFrame video_frame2 =
5733 webrtc::VideoFrame::Builder()
5734 .set_video_frame_buffer(CreateBlackFrameBuffer(4, 4))
5735 .set_timestamp_rtp(200)
5736 .set_timestamp_us(0)
5737 .set_rotation(webrtc::kVideoRotation_0)
5738 .build();
mzanaty8a855d62017-02-17 15:46:43 -08005739 recv_stream->InjectFrame(video_frame2);
5740 EXPECT_EQ(2, renderer.num_rendered_frames());
5741
5742#if defined(WEBRTC_USE_H264)
5743 // Receive H264 packet on third SSRC.
5744 rtpHeader.payload_type = 126;
Yves Gerey665174f2018-06-19 15:03:05 +02005745 rtpHeader.ssrc = kIncomingUnsignalledSsrc + 3;
mzanaty8a855d62017-02-17 15:46:43 -08005746 cricket::SetRtpHeader(data, sizeof(data), rtpHeader);
5747 rtc::CopyOnWriteBuffer packet3(data, sizeof(data));
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005748 channel_->OnPacketReceived(packet3, /* packet_time_us */ -1);
mzanaty8a855d62017-02-17 15:46:43 -08005749 // H264 packet should replace the default receive SSRC.
5750 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
5751 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
5752 EXPECT_EQ(rtpHeader.ssrc, recv_stream->GetConfig().rtp.remote_ssrc);
5753 // Verify that the receive stream sinks to a renderer.
Artem Titov1ebfb6a2019-01-03 23:49:37 +01005754 webrtc::VideoFrame video_frame3 =
5755 webrtc::VideoFrame::Builder()
5756 .set_video_frame_buffer(CreateBlackFrameBuffer(4, 4))
5757 .set_timestamp_rtp(300)
5758 .set_timestamp_us(0)
5759 .set_rotation(webrtc::kVideoRotation_0)
5760 .build();
mzanaty8a855d62017-02-17 15:46:43 -08005761 recv_stream->InjectFrame(video_frame3);
5762 EXPECT_EQ(3, renderer.num_rendered_frames());
5763#endif
5764}
5765
brandtr0dc57ea2017-05-29 23:33:31 -07005766// This test verifies that when a new default stream is created for a new
5767// unsignaled SSRC, the new stream does not overwrite any old stream that had
5768// been the default receive stream before being properly signaled.
eladalonf1841382017-06-12 01:16:46 -07005769TEST_F(WebRtcVideoChannelTest,
brandtr0dc57ea2017-05-29 23:33:31 -07005770 NewUnsignaledStreamDoesNotDestroyPreviouslyUnsignaledStream) {
5771 cricket::VideoRecvParameters parameters;
5772 parameters.codecs.push_back(GetEngineCodec("VP8"));
5773 ASSERT_TRUE(channel_->SetRecvParameters(parameters));
5774
5775 // No streams signaled and no packets received, so we should not have any
5776 // stream objects created yet.
5777 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
5778
5779 // Receive packet on an unsignaled SSRC.
5780 uint8_t data[kMinRtpPacketLen];
5781 cricket::RtpHeader rtp_header;
5782 rtp_header.payload_type = GetEngineCodec("VP8").id;
5783 rtp_header.seq_num = rtp_header.timestamp = 0;
5784 rtp_header.ssrc = kSsrcs3[0];
5785 cricket::SetRtpHeader(data, sizeof(data), rtp_header);
5786 rtc::CopyOnWriteBuffer packet(data, sizeof(data));
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005787 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
brandtr0dc57ea2017-05-29 23:33:31 -07005788 // Default receive stream should be created.
5789 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
5790 FakeVideoReceiveStream* recv_stream0 =
5791 fake_call_->GetVideoReceiveStreams()[0];
5792 EXPECT_EQ(kSsrcs3[0], recv_stream0->GetConfig().rtp.remote_ssrc);
5793
5794 // Signal the SSRC.
5795 EXPECT_TRUE(
5796 channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs3[0])));
5797 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
5798 recv_stream0 = fake_call_->GetVideoReceiveStreams()[0];
5799 EXPECT_EQ(kSsrcs3[0], recv_stream0->GetConfig().rtp.remote_ssrc);
5800
5801 // Receive packet on a different unsignaled SSRC.
5802 rtp_header.ssrc = kSsrcs3[1];
5803 cricket::SetRtpHeader(data, sizeof(data), rtp_header);
5804 packet.SetData(data, sizeof(data));
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07005805 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
brandtr0dc57ea2017-05-29 23:33:31 -07005806 // New default receive stream should be created, but old stream should remain.
5807 ASSERT_EQ(2u, fake_call_->GetVideoReceiveStreams().size());
5808 EXPECT_EQ(recv_stream0, fake_call_->GetVideoReceiveStreams()[0]);
5809 FakeVideoReceiveStream* recv_stream1 =
5810 fake_call_->GetVideoReceiveStreams()[1];
5811 EXPECT_EQ(kSsrcs3[1], recv_stream1->GetConfig().rtp.remote_ssrc);
5812}
5813
Seth Hampson7c682e02018-05-04 16:28:15 -07005814TEST_F(WebRtcVideoChannelTest, CanSetMaxBitrateForExistingStream) {
skvladdc1c62c2016-03-16 19:07:43 -07005815 AddSendStream();
5816
Niels Möller805a27e2019-01-21 12:21:27 +01005817 webrtc::test::FrameForwarder frame_forwarder;
5818 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
skvladdc1c62c2016-03-16 19:07:43 -07005819 EXPECT_TRUE(channel_->SetSend(true));
Niels Möller805a27e2019-01-21 12:21:27 +01005820 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
skvladdc1c62c2016-03-16 19:07:43 -07005821
perkjfa10b552016-10-02 23:45:26 -07005822 int default_encoder_bitrate = GetMaxEncoderBitrate();
brandtr468da7c2016-11-22 02:16:47 -08005823 EXPECT_GT(default_encoder_bitrate, 1000);
skvladdc1c62c2016-03-16 19:07:43 -07005824
5825 // TODO(skvlad): Resolve the inconsistency between the interpretation
5826 // of the global bitrate limit for audio and video:
5827 // - Audio: max_bandwidth_bps = 0 - fail the operation,
5828 // max_bandwidth_bps = -1 - remove the bandwidth limit
5829 // - Video: max_bandwidth_bps = 0 - remove the bandwidth limit,
pbos5c7760a2017-03-10 11:23:12 -08005830 // max_bandwidth_bps = -1 - remove the bandwidth limit
skvladdc1c62c2016-03-16 19:07:43 -07005831
perkjfa10b552016-10-02 23:45:26 -07005832 SetAndExpectMaxBitrate(1000, 0, 1000);
5833 SetAndExpectMaxBitrate(1000, 800, 800);
5834 SetAndExpectMaxBitrate(600, 800, 600);
5835 SetAndExpectMaxBitrate(0, 800, 800);
5836 SetAndExpectMaxBitrate(0, 0, default_encoder_bitrate);
skvladdc1c62c2016-03-16 19:07:43 -07005837
Niels Möllerff40b142018-04-09 08:49:14 +02005838 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
skvladdc1c62c2016-03-16 19:07:43 -07005839}
5840
eladalonf1841382017-06-12 01:16:46 -07005841TEST_F(WebRtcVideoChannelTest, CannotSetMaxBitrateForNonexistentStream) {
skvladdc1c62c2016-03-16 19:07:43 -07005842 webrtc::RtpParameters nonexistent_parameters =
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07005843 channel_->GetRtpSendParameters(last_ssrc_);
Mirko Bonadeif859e552018-05-30 15:31:29 +02005844 EXPECT_EQ(0u, nonexistent_parameters.encodings.size());
skvladdc1c62c2016-03-16 19:07:43 -07005845
5846 nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07005847 EXPECT_FALSE(
Zach Steinba37b4b2018-01-23 15:02:36 -08005848 channel_->SetRtpSendParameters(last_ssrc_, nonexistent_parameters).ok());
skvladdc1c62c2016-03-16 19:07:43 -07005849}
5850
eladalonf1841382017-06-12 01:16:46 -07005851TEST_F(WebRtcVideoChannelTest,
Seth Hampson7c682e02018-05-04 16:28:15 -07005852 SetLowMaxBitrateOverwritesVideoStreamMinBitrate) {
Åsa Perssonbdee46d2018-06-25 11:28:06 +02005853 FakeVideoSendStream* stream = AddSendStream();
5854
Seth Hampson7c682e02018-05-04 16:28:15 -07005855 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
5856 EXPECT_EQ(1UL, parameters.encodings.size());
5857 EXPECT_FALSE(parameters.encodings[0].max_bitrate_bps.has_value());
5858 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5859
5860 // Note that this is testing the behavior of the FakeVideoSendStream, which
5861 // also calls to CreateEncoderStreams to get the VideoStreams, so essentially
5862 // we are just testing the behavior of
5863 // EncoderStreamFactory::CreateEncoderStreams.
Åsa Perssonbdee46d2018-06-25 11:28:06 +02005864 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5865 EXPECT_EQ(kMinVideoBitrateBps, stream->GetVideoStreams()[0].min_bitrate_bps);
Seth Hampson7c682e02018-05-04 16:28:15 -07005866
5867 // Set a low max bitrate & check that VideoStream.min_bitrate_bps is limited
5868 // by this amount.
5869 parameters = channel_->GetRtpSendParameters(last_ssrc_);
5870 int low_max_bitrate_bps = kMinVideoBitrateBps - 1000;
5871 parameters.encodings[0].max_bitrate_bps = low_max_bitrate_bps;
5872 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5873
Åsa Perssonbdee46d2018-06-25 11:28:06 +02005874 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5875 EXPECT_EQ(low_max_bitrate_bps, stream->GetVideoStreams()[0].min_bitrate_bps);
5876 EXPECT_EQ(low_max_bitrate_bps, stream->GetVideoStreams()[0].max_bitrate_bps);
5877}
5878
5879TEST_F(WebRtcVideoChannelTest,
5880 SetHighMinBitrateOverwritesVideoStreamMaxBitrate) {
5881 FakeVideoSendStream* stream = AddSendStream();
5882
5883 // Note that this is testing the behavior of the FakeVideoSendStream, which
5884 // also calls to CreateEncoderStreams to get the VideoStreams, so essentially
5885 // we are just testing the behavior of
5886 // EncoderStreamFactory::CreateEncoderStreams.
5887 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5888 int high_min_bitrate_bps = stream->GetVideoStreams()[0].max_bitrate_bps + 1;
5889
5890 // Set a high min bitrate and check that max_bitrate_bps is adjusted up.
5891 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
5892 EXPECT_EQ(1UL, parameters.encodings.size());
5893 parameters.encodings[0].min_bitrate_bps = high_min_bitrate_bps;
5894 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5895
5896 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5897 EXPECT_EQ(high_min_bitrate_bps, stream->GetVideoStreams()[0].min_bitrate_bps);
5898 EXPECT_EQ(high_min_bitrate_bps, stream->GetVideoStreams()[0].max_bitrate_bps);
5899}
5900
5901TEST_F(WebRtcVideoChannelTest,
5902 SetMinBitrateAboveMaxBitrateLimitAdjustsMinBitrateDown) {
5903 send_parameters_.max_bandwidth_bps = 99999;
5904 FakeVideoSendStream* stream = AddSendStream();
5905 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
5906 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
5907 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5908 EXPECT_EQ(kMinVideoBitrateBps, stream->GetVideoStreams()[0].min_bitrate_bps);
5909 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
5910 stream->GetVideoStreams()[0].max_bitrate_bps);
5911
5912 // Set min bitrate above global max bitrate and check that min_bitrate_bps is
5913 // adjusted down.
5914 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
5915 EXPECT_EQ(1UL, parameters.encodings.size());
5916 parameters.encodings[0].min_bitrate_bps = 99999 + 1;
5917 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5918 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5919 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
5920 stream->GetVideoStreams()[0].min_bitrate_bps);
5921 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
5922 stream->GetVideoStreams()[0].max_bitrate_bps);
Seth Hampson7c682e02018-05-04 16:28:15 -07005923}
5924
Åsa Persson8c1bf952018-09-13 10:42:19 +02005925TEST_F(WebRtcVideoChannelTest, SetMaxFramerateOneStream) {
5926 FakeVideoSendStream* stream = AddSendStream();
5927
5928 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
5929 EXPECT_EQ(1UL, parameters.encodings.size());
5930 EXPECT_FALSE(parameters.encodings[0].max_framerate.has_value());
5931 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5932
5933 // Note that this is testing the behavior of the FakeVideoSendStream, which
5934 // also calls to CreateEncoderStreams to get the VideoStreams, so essentially
5935 // we are just testing the behavior of
5936 // EncoderStreamFactory::CreateEncoderStreams.
5937 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5938 EXPECT_EQ(kDefaultVideoMaxFramerate,
5939 stream->GetVideoStreams()[0].max_framerate);
5940
5941 // Set max framerate and check that VideoStream.max_framerate is set.
5942 const int kNewMaxFramerate = kDefaultVideoMaxFramerate - 1;
5943 parameters = channel_->GetRtpSendParameters(last_ssrc_);
5944 parameters.encodings[0].max_framerate = kNewMaxFramerate;
5945 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5946
5947 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5948 EXPECT_EQ(kNewMaxFramerate, stream->GetVideoStreams()[0].max_framerate);
5949}
5950
Åsa Persson23eba222018-10-02 14:47:06 +02005951TEST_F(WebRtcVideoChannelTest, SetNumTemporalLayersForSingleStream) {
5952 FakeVideoSendStream* stream = AddSendStream();
5953
5954 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
5955 EXPECT_EQ(1UL, parameters.encodings.size());
5956 EXPECT_FALSE(parameters.encodings[0].num_temporal_layers.has_value());
5957 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5958
5959 // Note that this is testing the behavior of the FakeVideoSendStream, which
5960 // also calls to CreateEncoderStreams to get the VideoStreams, so essentially
5961 // we are just testing the behavior of
5962 // EncoderStreamFactory::CreateEncoderStreams.
5963 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5964 EXPECT_FALSE(stream->GetVideoStreams()[0].num_temporal_layers.has_value());
5965
5966 // Set temporal layers and check that VideoStream.num_temporal_layers is set.
5967 parameters = channel_->GetRtpSendParameters(last_ssrc_);
5968 parameters.encodings[0].num_temporal_layers = 2;
5969 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
5970
5971 ASSERT_EQ(1UL, stream->GetVideoStreams().size());
5972 EXPECT_EQ(2UL, stream->GetVideoStreams()[0].num_temporal_layers);
5973}
5974
Seth Hampson7c682e02018-05-04 16:28:15 -07005975TEST_F(WebRtcVideoChannelTest,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07005976 CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) {
skvladdc1c62c2016-03-16 19:07:43 -07005977 AddSendStream();
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07005978 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07005979 // Two or more encodings should result in failure.
5980 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Zach Steinba37b4b2018-01-23 15:02:36 -08005981 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
deadbeeffb2aced2017-01-06 23:05:37 -08005982 // Zero encodings should also fail.
5983 parameters.encodings.clear();
Zach Steinba37b4b2018-01-23 15:02:36 -08005984 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
deadbeeffb2aced2017-01-06 23:05:37 -08005985}
5986
Zach Stein3ca452b2018-01-18 10:01:24 -08005987TEST_F(WebRtcVideoChannelTest,
5988 CannotSetSimulcastRtpSendParametersWithIncorrectNumberOfEncodings) {
5989 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
5990 StreamParams sp = CreateSimStreamParams("cname", ssrcs);
5991 AddSendStream(sp);
5992
5993 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
5994
5995 // Additional encodings should result in failure.
5996 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Zach Steinba37b4b2018-01-23 15:02:36 -08005997 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
Zach Stein3ca452b2018-01-18 10:01:24 -08005998 // Zero encodings should also fail.
5999 parameters.encodings.clear();
Zach Steinba37b4b2018-01-23 15:02:36 -08006000 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
Zach Stein3ca452b2018-01-18 10:01:24 -08006001}
6002
deadbeeffb2aced2017-01-06 23:05:37 -08006003// Changing the SSRC through RtpParameters is not allowed.
eladalonf1841382017-06-12 01:16:46 -07006004TEST_F(WebRtcVideoChannelTest, CannotSetSsrcInRtpSendParameters) {
deadbeeffb2aced2017-01-06 23:05:37 -08006005 AddSendStream();
6006 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
Oskar Sundbom78807582017-11-16 11:09:55 +01006007 parameters.encodings[0].ssrc = 0xdeadbeef;
Zach Steinba37b4b2018-01-23 15:02:36 -08006008 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
skvladdc1c62c2016-03-16 19:07:43 -07006009}
6010
Seth Hampson24722b32017-12-22 09:36:42 -08006011// Tests that when RTCRtpEncodingParameters.bitrate_priority gets set to
6012// a value <= 0, setting the parameters returns false.
6013TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersInvalidBitratePriority) {
6014 AddSendStream();
6015 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6016 EXPECT_EQ(1UL, parameters.encodings.size());
6017 EXPECT_EQ(webrtc::kDefaultBitratePriority,
6018 parameters.encodings[0].bitrate_priority);
6019
6020 parameters.encodings[0].bitrate_priority = 0;
Zach Steinba37b4b2018-01-23 15:02:36 -08006021 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
Seth Hampson24722b32017-12-22 09:36:42 -08006022 parameters.encodings[0].bitrate_priority = -2;
Zach Steinba37b4b2018-01-23 15:02:36 -08006023 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
Seth Hampson24722b32017-12-22 09:36:42 -08006024}
6025
6026// Tests when the the RTCRtpEncodingParameters.bitrate_priority gets set
6027// properly on the VideoChannel and propogates down to the video encoder.
6028TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersPriorityOneStream) {
6029 AddSendStream();
6030 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6031 EXPECT_EQ(1UL, parameters.encodings.size());
6032 EXPECT_EQ(webrtc::kDefaultBitratePriority,
6033 parameters.encodings[0].bitrate_priority);
6034
6035 // Change the value and set it on the VideoChannel.
6036 double new_bitrate_priority = 2.0;
6037 parameters.encodings[0].bitrate_priority = new_bitrate_priority;
Zach Steinba37b4b2018-01-23 15:02:36 -08006038 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
Seth Hampson24722b32017-12-22 09:36:42 -08006039
6040 // Verify that the encoding parameters bitrate_priority is set for the
6041 // VideoChannel.
6042 parameters = channel_->GetRtpSendParameters(last_ssrc_);
6043 EXPECT_EQ(1UL, parameters.encodings.size());
6044 EXPECT_EQ(new_bitrate_priority, parameters.encodings[0].bitrate_priority);
6045
6046 // Verify that the new value propagated down to the encoder.
6047 std::vector<FakeVideoSendStream*> video_send_streams =
6048 fake_call_->GetVideoSendStreams();
6049 EXPECT_EQ(1UL, video_send_streams.size());
6050 FakeVideoSendStream* video_send_stream = video_send_streams.front();
6051 // Check that the WebRtcVideoSendStream updated the VideoEncoderConfig
6052 // appropriately.
6053 EXPECT_EQ(new_bitrate_priority,
6054 video_send_stream->GetEncoderConfig().bitrate_priority);
6055 // Check that the vector of VideoStreams also was propagated correctly. Note
6056 // that this is testing the behavior of the FakeVideoSendStream, which mimics
6057 // the calls to CreateEncoderStreams to get the VideoStreams.
Danil Chapovalov00c71832018-06-15 15:58:38 +02006058 EXPECT_EQ(absl::optional<double>(new_bitrate_priority),
Seth Hampson24722b32017-12-22 09:36:42 -08006059 video_send_stream->GetVideoStreams()[0].bitrate_priority);
6060}
6061
6062// Tests that the RTCRtpEncodingParameters.bitrate_priority is set for the
6063// VideoChannel and the value propogates to the video encoder with all simulcast
6064// streams.
6065TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersPrioritySimulcastStreams) {
6066 // Create the stream params with multiple ssrcs for simulcast.
Åsa Persson31cb8f92018-06-27 10:44:56 +02006067 const size_t kNumSimulcastStreams = 3;
Seth Hampson24722b32017-12-22 09:36:42 -08006068 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
6069 StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
6070 AddSendStream(stream_params);
6071 uint32_t primary_ssrc = stream_params.first_ssrc();
6072
Niels Möller805a27e2019-01-21 12:21:27 +01006073 // Using the FrameForwarder, we manually send a full size
Tommi85959932018-02-07 19:26:06 +01006074 // frame. This creates multiple VideoStreams for all simulcast layers when
6075 // reconfiguring, and allows us to test this behavior.
Niels Möller805a27e2019-01-21 12:21:27 +01006076 webrtc::test::FrameForwarder frame_forwarder;
Seth Hampson24722b32017-12-22 09:36:42 -08006077 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006078 EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder));
Seth Hampson24722b32017-12-22 09:36:42 -08006079 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006080 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame(
6081 1920, 1080, webrtc::VideoRotation::kVideoRotation_0,
6082 rtc::kNumMicrosecsPerSec / 30));
6083
Seth Hampson24722b32017-12-22 09:36:42 -08006084 // Get and set the rtp encoding parameters.
6085 webrtc::RtpParameters parameters =
6086 channel_->GetRtpSendParameters(primary_ssrc);
Åsa Persson31cb8f92018-06-27 10:44:56 +02006087 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
Seth Hampson24722b32017-12-22 09:36:42 -08006088 EXPECT_EQ(webrtc::kDefaultBitratePriority,
6089 parameters.encodings[0].bitrate_priority);
6090 // Change the value and set it on the VideoChannel.
6091 double new_bitrate_priority = 2.0;
6092 parameters.encodings[0].bitrate_priority = new_bitrate_priority;
Zach Steinba37b4b2018-01-23 15:02:36 -08006093 EXPECT_TRUE(channel_->SetRtpSendParameters(primary_ssrc, parameters).ok());
Seth Hampson24722b32017-12-22 09:36:42 -08006094
6095 // Verify that the encoding parameters priority is set on the VideoChannel.
6096 parameters = channel_->GetRtpSendParameters(primary_ssrc);
Åsa Persson31cb8f92018-06-27 10:44:56 +02006097 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
Seth Hampson24722b32017-12-22 09:36:42 -08006098 EXPECT_EQ(new_bitrate_priority, parameters.encodings[0].bitrate_priority);
6099
6100 // Verify that the new value propagated down to the encoder.
6101 std::vector<FakeVideoSendStream*> video_send_streams =
6102 fake_call_->GetVideoSendStreams();
6103 EXPECT_EQ(1UL, video_send_streams.size());
6104 FakeVideoSendStream* video_send_stream = video_send_streams.front();
6105 // Check that the WebRtcVideoSendStream updated the VideoEncoderConfig
6106 // appropriately.
Åsa Persson31cb8f92018-06-27 10:44:56 +02006107 EXPECT_EQ(kNumSimulcastStreams,
Seth Hampson24722b32017-12-22 09:36:42 -08006108 video_send_stream->GetEncoderConfig().number_of_streams);
6109 EXPECT_EQ(new_bitrate_priority,
6110 video_send_stream->GetEncoderConfig().bitrate_priority);
6111 // Check that the vector of VideoStreams also propagated correctly. The
6112 // FakeVideoSendStream calls CreateEncoderStreams, and we are testing that
6113 // these are created appropriately for the simulcast case.
Åsa Persson31cb8f92018-06-27 10:44:56 +02006114 EXPECT_EQ(kNumSimulcastStreams, video_send_stream->GetVideoStreams().size());
Danil Chapovalov00c71832018-06-15 15:58:38 +02006115 EXPECT_EQ(absl::optional<double>(new_bitrate_priority),
Seth Hampson24722b32017-12-22 09:36:42 -08006116 video_send_stream->GetVideoStreams()[0].bitrate_priority);
6117 // Since we are only setting bitrate priority per-sender, the other
6118 // VideoStreams should have a bitrate priority of 0.
Danil Chapovalov00c71832018-06-15 15:58:38 +02006119 EXPECT_EQ(absl::nullopt,
Seth Hampson24722b32017-12-22 09:36:42 -08006120 video_send_stream->GetVideoStreams()[1].bitrate_priority);
Danil Chapovalov00c71832018-06-15 15:58:38 +02006121 EXPECT_EQ(absl::nullopt,
Seth Hampson24722b32017-12-22 09:36:42 -08006122 video_send_stream->GetVideoStreams()[2].bitrate_priority);
Niels Möllerff40b142018-04-09 08:49:14 +02006123 EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, nullptr, nullptr));
Seth Hampson24722b32017-12-22 09:36:42 -08006124}
6125
Tim Haloun648d28a2018-10-18 16:52:22 -07006126// RTCRtpEncodingParameters.network_priority must be one of a few values
6127// derived from the default priority, corresponding to very-low, low, medium,
6128// or high.
6129TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersInvalidNetworkPriority) {
6130 AddSendStream();
6131 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6132 EXPECT_EQ(1UL, parameters.encodings.size());
6133 EXPECT_EQ(webrtc::kDefaultBitratePriority,
6134 parameters.encodings[0].network_priority);
6135
6136 double good_values[] = {0.5, 1.0, 2.0, 4.0};
6137 double bad_values[] = {-1.0, 0.0, 0.49, 0.51, 1.1, 3.99, 4.1, 5.0};
6138 for (auto it : good_values) {
6139 parameters.encodings[0].network_priority = it;
6140 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6141 }
6142 for (auto it : bad_values) {
6143 parameters.encodings[0].network_priority = it;
6144 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6145 }
6146}
6147
Florent Castellic1a0bcb2019-01-29 14:26:48 +01006148TEST_F(WebRtcVideoChannelTest,
6149 GetAndSetRtpSendParametersScaleResolutionDownByVP8) {
Rasmus Brandt9387b522019-02-05 14:23:26 +01006150 VideoSendParameters parameters;
6151 parameters.codecs.push_back(VideoCodec(kVp8CodecName));
Florent Castellic1a0bcb2019-01-29 14:26:48 +01006152 ASSERT_TRUE(channel_->SetSendParameters(parameters));
6153 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6154
6155 webrtc::test::FrameForwarder frame_forwarder;
Rasmus Brandt9387b522019-02-05 14:23:26 +01006156 FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30);
Florent Castellic1a0bcb2019-01-29 14:26:48 +01006157
6158 VideoOptions options;
6159 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
6160 channel_->SetSend(true);
6161
6162 // Try layers in natural order (smallest to largest).
6163 {
6164 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6165 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6166 rtp_parameters.encodings[0].scale_resolution_down_by = 4.0;
6167 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6168 rtp_parameters.encodings[2].scale_resolution_down_by = 1.0;
6169 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6170 ASSERT_TRUE(result.ok());
6171
6172 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6173
6174 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6175 ASSERT_EQ(3u, video_streams.size());
6176 EXPECT_EQ(320u, video_streams[0].width);
6177 EXPECT_EQ(180u, video_streams[0].height);
6178 EXPECT_EQ(640u, video_streams[1].width);
6179 EXPECT_EQ(360u, video_streams[1].height);
6180 EXPECT_EQ(1280u, video_streams[2].width);
6181 EXPECT_EQ(720u, video_streams[2].height);
6182 }
6183
6184 // Try layers in reverse natural order (largest to smallest).
6185 {
6186 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6187 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6188 rtp_parameters.encodings[0].scale_resolution_down_by = 1.0;
6189 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6190 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6191 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6192 ASSERT_TRUE(result.ok());
6193
6194 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6195
6196 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6197 ASSERT_EQ(3u, video_streams.size());
6198 EXPECT_EQ(1280u, video_streams[0].width);
6199 EXPECT_EQ(720u, video_streams[0].height);
6200 EXPECT_EQ(640u, video_streams[1].width);
6201 EXPECT_EQ(360u, video_streams[1].height);
6202 EXPECT_EQ(320u, video_streams[2].width);
6203 EXPECT_EQ(180u, video_streams[2].height);
6204 }
6205
6206 // Try layers in mixed order.
6207 {
6208 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6209 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6210 rtp_parameters.encodings[0].scale_resolution_down_by = 10.0;
6211 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6212 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6213 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6214 ASSERT_TRUE(result.ok());
6215
6216 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6217
6218 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6219 ASSERT_EQ(3u, video_streams.size());
6220 EXPECT_EQ(128u, video_streams[0].width);
6221 EXPECT_EQ(72u, video_streams[0].height);
6222 EXPECT_EQ(640u, video_streams[1].width);
6223 EXPECT_EQ(360u, video_streams[1].height);
6224 EXPECT_EQ(320u, video_streams[2].width);
6225 EXPECT_EQ(180u, video_streams[2].height);
6226 }
6227
6228 // Try with a missing scale setting, defaults to 1.0 if any other is set.
6229 {
6230 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6231 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6232 rtp_parameters.encodings[0].scale_resolution_down_by = 1.0;
6233 rtp_parameters.encodings[1].scale_resolution_down_by.reset();
6234 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6235 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6236 ASSERT_TRUE(result.ok());
6237
6238 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6239
6240 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6241 ASSERT_EQ(3u, video_streams.size());
6242 EXPECT_EQ(1280u, video_streams[0].width);
6243 EXPECT_EQ(720u, video_streams[0].height);
6244 EXPECT_EQ(1280u, video_streams[1].width);
6245 EXPECT_EQ(720u, video_streams[1].height);
6246 EXPECT_EQ(320u, video_streams[2].width);
6247 EXPECT_EQ(180u, video_streams[2].height);
6248 }
6249
6250 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6251}
6252
6253TEST_F(WebRtcVideoChannelTest,
Rasmus Brandt9387b522019-02-05 14:23:26 +01006254 GetAndSetRtpSendParametersScaleResolutionDownByVP8WithOddResolution) {
6255 // Ensure that the top layer has width and height divisible by 2^3,
6256 // so that the bottom layer has width and height divisible by 2.
6257 // TODO(bugs.webrtc.org/8785): Remove this field trial when we fully trust
6258 // the number of simulcast layers set by the app.
6259 webrtc::test::ScopedFieldTrials field_trial(
6260 "WebRTC-NormalizeSimulcastResolution/Enabled-3/");
6261
6262 // Set up WebRtcVideoChannel for 3-layer VP8 simulcast.
6263 VideoSendParameters parameters;
6264 parameters.codecs.push_back(VideoCodec(kVp8CodecName));
6265 ASSERT_TRUE(channel_->SetSendParameters(parameters));
6266 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6267 webrtc::test::FrameForwarder frame_forwarder;
6268 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr,
6269 &frame_forwarder));
6270 channel_->SetSend(true);
6271
6272 // Set |scale_resolution_down_by|'s.
6273 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6274 ASSERT_EQ(rtp_parameters.encodings.size(), 3u);
6275 rtp_parameters.encodings[0].scale_resolution_down_by = 1.0;
6276 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6277 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6278 const auto result =
6279 channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6280 ASSERT_TRUE(result.ok());
6281
6282 // Use a capture resolution whose width and height are not divisible by 2^3.
6283 // (See field trial set at the top of the test.)
6284 FakeFrameSource frame_source(2007, 1207, rtc::kNumMicrosecsPerSec / 30);
6285 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6286
6287 // Ensure the scaling is correct.
6288 const auto video_streams = stream->GetVideoStreams();
6289 ASSERT_EQ(video_streams.size(), 3u);
6290 // Ensure that we round the capture resolution down for the top layer...
6291 EXPECT_EQ(video_streams[0].width, 2000u);
6292 EXPECT_EQ(video_streams[0].height, 1200u);
6293 EXPECT_EQ(video_streams[1].width, 1000u);
6294 EXPECT_EQ(video_streams[1].height, 600u);
6295 // ...and that the bottom layer has a width/height divisible by 2.
6296 EXPECT_EQ(video_streams[2].width, 500u);
6297 EXPECT_EQ(video_streams[2].height, 300u);
6298
6299 // Tear down.
6300 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6301}
6302
6303TEST_F(WebRtcVideoChannelTest,
Florent Castellic1a0bcb2019-01-29 14:26:48 +01006304 GetAndSetRtpSendParametersScaleResolutionDownByH264) {
Rasmus Brandt9387b522019-02-05 14:23:26 +01006305 encoder_factory_->AddSupportedVideoCodecType(kH264CodecName);
6306 VideoSendParameters parameters;
6307 parameters.codecs.push_back(VideoCodec(kH264CodecName));
Florent Castellic1a0bcb2019-01-29 14:26:48 +01006308 ASSERT_TRUE(channel_->SetSendParameters(parameters));
6309 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6310
6311 webrtc::test::FrameForwarder frame_forwarder;
Rasmus Brandt9387b522019-02-05 14:23:26 +01006312 FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30);
Florent Castellic1a0bcb2019-01-29 14:26:48 +01006313
6314 VideoOptions options;
6315 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
6316 channel_->SetSend(true);
6317
6318 // Try layers in natural order (smallest to largest).
6319 {
6320 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6321 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6322 rtp_parameters.encodings[0].scale_resolution_down_by = 4.0;
6323 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6324 rtp_parameters.encodings[2].scale_resolution_down_by = 1.0;
6325 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6326 ASSERT_TRUE(result.ok());
6327
6328 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6329
6330 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6331 ASSERT_EQ(3u, video_streams.size());
6332 EXPECT_EQ(320u, video_streams[0].width);
6333 EXPECT_EQ(180u, video_streams[0].height);
6334 EXPECT_EQ(640u, video_streams[1].width);
6335 EXPECT_EQ(360u, video_streams[1].height);
6336 EXPECT_EQ(1280u, video_streams[2].width);
6337 EXPECT_EQ(720u, video_streams[2].height);
6338 }
6339
6340 // Try layers in reverse natural order (largest to smallest).
6341 {
6342 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6343 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6344 rtp_parameters.encodings[0].scale_resolution_down_by = 1.0;
6345 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6346 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6347 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6348 ASSERT_TRUE(result.ok());
6349
6350 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6351
6352 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6353 ASSERT_EQ(3u, video_streams.size());
6354 EXPECT_EQ(1280u, video_streams[0].width);
6355 EXPECT_EQ(720u, video_streams[0].height);
6356 EXPECT_EQ(640u, video_streams[1].width);
6357 EXPECT_EQ(360u, video_streams[1].height);
6358 EXPECT_EQ(320u, video_streams[2].width);
6359 EXPECT_EQ(180u, video_streams[2].height);
6360 }
6361
6362 // Try layers in mixed order.
6363 {
6364 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6365 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6366 rtp_parameters.encodings[0].scale_resolution_down_by = 10.0;
6367 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6368 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6369 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6370 ASSERT_TRUE(result.ok());
6371
6372 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6373
6374 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6375 ASSERT_EQ(3u, video_streams.size());
6376 EXPECT_EQ(128u, video_streams[0].width);
6377 EXPECT_EQ(72u, video_streams[0].height);
6378 EXPECT_EQ(640u, video_streams[1].width);
6379 EXPECT_EQ(360u, video_streams[1].height);
6380 EXPECT_EQ(320u, video_streams[2].width);
6381 EXPECT_EQ(180u, video_streams[2].height);
6382 }
6383
6384 // Try with a missing scale setting, defaults to 1.0 if any other is set.
6385 {
6386 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6387 ASSERT_EQ(3u, rtp_parameters.encodings.size());
6388 rtp_parameters.encodings[0].scale_resolution_down_by = 1.0;
6389 rtp_parameters.encodings[1].scale_resolution_down_by.reset();
6390 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6391 auto result = channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6392 ASSERT_TRUE(result.ok());
6393
6394 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6395
6396 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
6397 ASSERT_EQ(3u, video_streams.size());
6398 EXPECT_EQ(1280u, video_streams[0].width);
6399 EXPECT_EQ(720u, video_streams[0].height);
6400 EXPECT_EQ(1280u, video_streams[1].width);
6401 EXPECT_EQ(720u, video_streams[1].height);
6402 EXPECT_EQ(320u, video_streams[2].width);
6403 EXPECT_EQ(180u, video_streams[2].height);
6404 }
6405 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6406}
6407
Rasmus Brandt9387b522019-02-05 14:23:26 +01006408TEST_F(WebRtcVideoChannelTest,
6409 GetAndSetRtpSendParametersScaleResolutionDownByH264WithOddResolution) {
6410 // Ensure that the top layer has width and height divisible by 2^3,
6411 // so that the bottom layer has width and height divisible by 2.
6412 // TODO(bugs.webrtc.org/8785): Remove this field trial when we fully trust
6413 // the number of simulcast layers set by the app.
6414 webrtc::test::ScopedFieldTrials field_trial(
6415 "WebRTC-NormalizeSimulcastResolution/Enabled-3/");
6416
6417 // Set up WebRtcVideoChannel for 3-layer H264 simulcast.
6418 encoder_factory_->AddSupportedVideoCodecType(kH264CodecName);
6419 VideoSendParameters parameters;
6420 parameters.codecs.push_back(VideoCodec(kH264CodecName));
6421 ASSERT_TRUE(channel_->SetSendParameters(parameters));
6422 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6423 webrtc::test::FrameForwarder frame_forwarder;
6424 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr,
6425 &frame_forwarder));
6426 channel_->SetSend(true);
6427
6428 // Set |scale_resolution_down_by|'s.
6429 auto rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_);
6430 ASSERT_EQ(rtp_parameters.encodings.size(), 3u);
6431 rtp_parameters.encodings[0].scale_resolution_down_by = 1.0;
6432 rtp_parameters.encodings[1].scale_resolution_down_by = 2.0;
6433 rtp_parameters.encodings[2].scale_resolution_down_by = 4.0;
6434 const auto result =
6435 channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
6436 ASSERT_TRUE(result.ok());
6437
6438 // Use a capture resolution whose width and height are not divisible by 2^3.
6439 // (See field trial set at the top of the test.)
6440 FakeFrameSource frame_source(2007, 1207, rtc::kNumMicrosecsPerSec / 30);
6441 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
6442
6443 // Ensure the scaling is correct.
6444 const auto video_streams = stream->GetVideoStreams();
6445 ASSERT_EQ(video_streams.size(), 3u);
6446 // Ensure that we round the capture resolution down for the top layer...
6447 EXPECT_EQ(video_streams[0].width, 2000u);
6448 EXPECT_EQ(video_streams[0].height, 1200u);
6449 EXPECT_EQ(video_streams[1].width, 1000u);
6450 EXPECT_EQ(video_streams[1].height, 600u);
6451 // ...and that the bottom layer has a width/height divisible by 2.
6452 EXPECT_EQ(video_streams[2].width, 500u);
6453 EXPECT_EQ(video_streams[2].height, 300u);
6454
6455 // Tear down.
6456 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6457}
6458
Åsa Persson8c1bf952018-09-13 10:42:19 +02006459TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersMaxFramerate) {
6460 const size_t kNumSimulcastStreams = 3;
6461 SetUpSimulcast(true, false);
6462
6463 // Get and set the rtp encoding parameters.
6464 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6465 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6466 for (const auto& encoding : parameters.encodings) {
6467 EXPECT_FALSE(encoding.max_framerate);
6468 }
6469
6470 // Change the value and set it on the VideoChannel.
6471 parameters.encodings[0].max_framerate = 10;
6472 parameters.encodings[1].max_framerate = 20;
6473 parameters.encodings[2].max_framerate = 25;
6474 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6475
6476 // Verify that the bitrates are set on the VideoChannel.
6477 parameters = channel_->GetRtpSendParameters(last_ssrc_);
6478 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6479 EXPECT_EQ(10, parameters.encodings[0].max_framerate);
6480 EXPECT_EQ(20, parameters.encodings[1].max_framerate);
6481 EXPECT_EQ(25, parameters.encodings[2].max_framerate);
6482}
6483
Åsa Persson23eba222018-10-02 14:47:06 +02006484TEST_F(WebRtcVideoChannelTest,
6485 SetRtpSendParametersNumTemporalLayersFailsForInvalidRange) {
6486 const size_t kNumSimulcastStreams = 3;
6487 SetUpSimulcast(true, false);
6488
6489 // Get and set the rtp encoding parameters.
6490 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6491 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6492
6493 // Num temporal layers should be in the range [1, kMaxTemporalStreams].
6494 parameters.encodings[0].num_temporal_layers = 0;
6495 EXPECT_EQ(webrtc::RTCErrorType::INVALID_RANGE,
6496 channel_->SetRtpSendParameters(last_ssrc_, parameters).type());
6497 parameters.encodings[0].num_temporal_layers = webrtc::kMaxTemporalStreams + 1;
6498 EXPECT_EQ(webrtc::RTCErrorType::INVALID_RANGE,
6499 channel_->SetRtpSendParameters(last_ssrc_, parameters).type());
6500}
6501
6502TEST_F(WebRtcVideoChannelTest,
6503 SetRtpSendParametersNumTemporalLayersFailsForInvalidModification) {
6504 const size_t kNumSimulcastStreams = 3;
6505 SetUpSimulcast(true, false);
6506
6507 // Get and set the rtp encoding parameters.
6508 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6509 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6510
6511 // No/all layers should be set.
6512 parameters.encodings[0].num_temporal_layers = 1;
6513 EXPECT_EQ(webrtc::RTCErrorType::INVALID_MODIFICATION,
6514 channel_->SetRtpSendParameters(last_ssrc_, parameters).type());
6515
6516 // Different values not supported.
6517 parameters.encodings[0].num_temporal_layers = 1;
6518 parameters.encodings[1].num_temporal_layers = 2;
6519 parameters.encodings[2].num_temporal_layers = 2;
6520 EXPECT_EQ(webrtc::RTCErrorType::INVALID_MODIFICATION,
6521 channel_->SetRtpSendParameters(last_ssrc_, parameters).type());
6522}
6523
6524TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersNumTemporalLayers) {
6525 const size_t kNumSimulcastStreams = 3;
6526 SetUpSimulcast(true, false);
6527
6528 // Get and set the rtp encoding parameters.
6529 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6530 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6531 for (const auto& encoding : parameters.encodings)
6532 EXPECT_FALSE(encoding.num_temporal_layers);
6533
6534 // Change the value and set it on the VideoChannel.
6535 parameters.encodings[0].num_temporal_layers = 3;
6536 parameters.encodings[1].num_temporal_layers = 3;
6537 parameters.encodings[2].num_temporal_layers = 3;
6538 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6539
6540 // Verify that the number of temporal layers are set on the VideoChannel.
6541 parameters = channel_->GetRtpSendParameters(last_ssrc_);
6542 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6543 EXPECT_EQ(3, parameters.encodings[0].num_temporal_layers);
6544 EXPECT_EQ(3, parameters.encodings[1].num_temporal_layers);
6545 EXPECT_EQ(3, parameters.encodings[2].num_temporal_layers);
6546}
6547
6548TEST_F(WebRtcVideoChannelTest, NumTemporalLayersPropagatedToEncoder) {
6549 const size_t kNumSimulcastStreams = 3;
6550 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6551
6552 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006553 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson23eba222018-10-02 14:47:06 +02006554 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006555 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson23eba222018-10-02 14:47:06 +02006556 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006557 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson23eba222018-10-02 14:47:06 +02006558
6559 // Get and set the rtp encoding parameters.
6560 // Change the value and set it on the VideoChannel.
6561 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6562 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6563 parameters.encodings[0].num_temporal_layers = 2;
6564 parameters.encodings[1].num_temporal_layers = 2;
6565 parameters.encodings[2].num_temporal_layers = 2;
6566 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6567
6568 // Verify that the new value is propagated down to the encoder.
6569 // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly.
6570 EXPECT_EQ(2, stream->num_encoder_reconfigurations());
6571 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
6572 EXPECT_EQ(kNumSimulcastStreams, encoder_config.number_of_streams);
6573 EXPECT_EQ(kNumSimulcastStreams, encoder_config.simulcast_layers.size());
6574 EXPECT_EQ(2UL, encoder_config.simulcast_layers[0].num_temporal_layers);
6575 EXPECT_EQ(2UL, encoder_config.simulcast_layers[1].num_temporal_layers);
6576 EXPECT_EQ(2UL, encoder_config.simulcast_layers[2].num_temporal_layers);
6577
6578 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
6579 // VideoStreams are created appropriately for the simulcast case.
6580 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6581 EXPECT_EQ(2UL, stream->GetVideoStreams()[0].num_temporal_layers);
6582 EXPECT_EQ(2UL, stream->GetVideoStreams()[1].num_temporal_layers);
6583 EXPECT_EQ(2UL, stream->GetVideoStreams()[2].num_temporal_layers);
6584
6585 // No parameter changed, encoder should not be reconfigured.
6586 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6587 EXPECT_EQ(2, stream->num_encoder_reconfigurations());
6588
6589 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6590}
6591
6592TEST_F(WebRtcVideoChannelTest,
6593 DefaultValuePropagatedToEncoderForUnsetNumTemporalLayers) {
6594 const size_t kDefaultNumTemporalLayers = 3;
6595 const size_t kNumSimulcastStreams = 3;
6596 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6597
6598 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006599 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson23eba222018-10-02 14:47:06 +02006600 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006601 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson23eba222018-10-02 14:47:06 +02006602 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006603 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson23eba222018-10-02 14:47:06 +02006604
6605 // Change rtp encoding parameters, num_temporal_layers not changed.
6606 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6607 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6608 parameters.encodings[0].min_bitrate_bps = 33000;
6609 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6610
6611 // Verify that no value is propagated down to the encoder.
6612 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
6613 EXPECT_EQ(kNumSimulcastStreams, encoder_config.number_of_streams);
6614 EXPECT_EQ(kNumSimulcastStreams, encoder_config.simulcast_layers.size());
6615 EXPECT_FALSE(encoder_config.simulcast_layers[0].num_temporal_layers);
6616 EXPECT_FALSE(encoder_config.simulcast_layers[1].num_temporal_layers);
6617 EXPECT_FALSE(encoder_config.simulcast_layers[2].num_temporal_layers);
6618
6619 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
6620 // VideoStreams are created appropriately for the simulcast case.
6621 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6622 EXPECT_EQ(kDefaultNumTemporalLayers,
6623 stream->GetVideoStreams()[0].num_temporal_layers);
6624 EXPECT_EQ(kDefaultNumTemporalLayers,
6625 stream->GetVideoStreams()[1].num_temporal_layers);
6626 EXPECT_EQ(kDefaultNumTemporalLayers,
6627 stream->GetVideoStreams()[2].num_temporal_layers);
6628
6629 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6630}
6631
Åsa Persson8c1bf952018-09-13 10:42:19 +02006632TEST_F(WebRtcVideoChannelTest, MaxSimulcastFrameratePropagatedToEncoder) {
6633 const size_t kNumSimulcastStreams = 3;
6634 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6635
6636 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006637 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson8c1bf952018-09-13 10:42:19 +02006638 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006639 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson8c1bf952018-09-13 10:42:19 +02006640 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006641 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson8c1bf952018-09-13 10:42:19 +02006642
6643 // Get and set the rtp encoding parameters.
6644 // Change the value and set it on the VideoChannel.
6645 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6646 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6647 parameters.encodings[0].max_framerate = 15;
6648 parameters.encodings[1].max_framerate = 25;
6649 parameters.encodings[2].max_framerate = 20;
6650 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6651
6652 // Verify that the new value propagated down to the encoder.
6653 // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly.
6654 EXPECT_EQ(2, stream->num_encoder_reconfigurations());
6655 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
6656 EXPECT_EQ(kNumSimulcastStreams, encoder_config.number_of_streams);
6657 EXPECT_EQ(kNumSimulcastStreams, encoder_config.simulcast_layers.size());
6658 EXPECT_EQ(15, encoder_config.simulcast_layers[0].max_framerate);
6659 EXPECT_EQ(25, encoder_config.simulcast_layers[1].max_framerate);
6660 EXPECT_EQ(20, encoder_config.simulcast_layers[2].max_framerate);
6661
6662 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
6663 // VideoStreams are created appropriately for the simulcast case.
6664 // Currently the maximum |max_framerate| is used.
6665 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6666 EXPECT_EQ(25, stream->GetVideoStreams()[0].max_framerate);
6667 EXPECT_EQ(25, stream->GetVideoStreams()[1].max_framerate);
6668 EXPECT_EQ(25, stream->GetVideoStreams()[2].max_framerate);
6669
6670 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6671}
6672
6673TEST_F(WebRtcVideoChannelTest,
6674 DefaultValuePropagatedToEncoderForUnsetFramerate) {
6675 const size_t kNumSimulcastStreams = 3;
6676 const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
6677 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6678
6679 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006680 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson8c1bf952018-09-13 10:42:19 +02006681 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006682 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson8c1bf952018-09-13 10:42:19 +02006683 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006684 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson8c1bf952018-09-13 10:42:19 +02006685
6686 // Get and set the rtp encoding parameters.
6687 // Change the value and set it on the VideoChannel.
6688 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6689 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6690 parameters.encodings[0].max_framerate = 15;
6691 parameters.encodings[2].max_framerate = 20;
6692 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6693
6694 // Verify that the new value propagated down to the encoder.
6695 // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly.
6696 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
6697 EXPECT_EQ(kNumSimulcastStreams, encoder_config.number_of_streams);
6698 EXPECT_EQ(kNumSimulcastStreams, encoder_config.simulcast_layers.size());
6699 EXPECT_EQ(15, encoder_config.simulcast_layers[0].max_framerate);
6700 EXPECT_EQ(-1, encoder_config.simulcast_layers[1].max_framerate);
6701 EXPECT_EQ(20, encoder_config.simulcast_layers[2].max_framerate);
6702
6703 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
6704 // VideoStreams are created appropriately for the simulcast case.
6705 // The maximum |max_framerate| is used, kDefaultVideoMaxFramerate: 60.
6706 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6707 EXPECT_EQ(kDefaultVideoMaxFramerate,
6708 stream->GetVideoStreams()[0].max_framerate);
6709 EXPECT_EQ(kDefaultVideoMaxFramerate,
6710 stream->GetVideoStreams()[1].max_framerate);
6711 EXPECT_EQ(kDefaultVideoMaxFramerate,
6712 stream->GetVideoStreams()[2].max_framerate);
6713
6714 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6715}
6716
Åsa Persson55659812018-06-18 17:51:32 +02006717TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersMinAndMaxBitrate) {
6718 const size_t kNumSimulcastStreams = 3;
6719 SetUpSimulcast(true, false);
6720
6721 // Get and set the rtp encoding parameters.
6722 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6723 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6724 for (const auto& encoding : parameters.encodings) {
6725 EXPECT_FALSE(encoding.min_bitrate_bps);
6726 EXPECT_FALSE(encoding.max_bitrate_bps);
6727 }
6728
6729 // Change the value and set it on the VideoChannel.
6730 parameters.encodings[0].min_bitrate_bps = 100000;
6731 parameters.encodings[0].max_bitrate_bps = 200000;
6732 parameters.encodings[1].min_bitrate_bps = 300000;
6733 parameters.encodings[1].max_bitrate_bps = 400000;
6734 parameters.encodings[2].min_bitrate_bps = 500000;
6735 parameters.encodings[2].max_bitrate_bps = 600000;
6736 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6737
6738 // Verify that the bitrates are set on the VideoChannel.
6739 parameters = channel_->GetRtpSendParameters(last_ssrc_);
6740 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6741 EXPECT_EQ(100000, parameters.encodings[0].min_bitrate_bps);
6742 EXPECT_EQ(200000, parameters.encodings[0].max_bitrate_bps);
6743 EXPECT_EQ(300000, parameters.encodings[1].min_bitrate_bps);
6744 EXPECT_EQ(400000, parameters.encodings[1].max_bitrate_bps);
6745 EXPECT_EQ(500000, parameters.encodings[2].min_bitrate_bps);
6746 EXPECT_EQ(600000, parameters.encodings[2].max_bitrate_bps);
6747}
6748
6749TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersFailsWithIncorrectBitrate) {
6750 const size_t kNumSimulcastStreams = 3;
6751 SetUpSimulcast(true, false);
6752
6753 // Get and set the rtp encoding parameters.
6754 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6755 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6756
6757 // Max bitrate lower than min bitrate should fail.
6758 parameters.encodings[2].min_bitrate_bps = 100000;
6759 parameters.encodings[2].max_bitrate_bps = 100000 - 1;
6760 EXPECT_EQ(webrtc::RTCErrorType::INVALID_RANGE,
6761 channel_->SetRtpSendParameters(last_ssrc_, parameters).type());
6762}
6763
6764// Test that min and max bitrate values set via RtpParameters are correctly
6765// propagated to the underlying encoder, and that the target is set to 3/4 of
6766// the maximum (3/4 was chosen because it's similar to the simulcast defaults
6767// that are used if no min/max are specified).
6768TEST_F(WebRtcVideoChannelTest, MinAndMaxSimulcastBitratePropagatedToEncoder) {
6769 const size_t kNumSimulcastStreams = 3;
6770 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6771
6772 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006773 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson55659812018-06-18 17:51:32 +02006774 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006775 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson55659812018-06-18 17:51:32 +02006776 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006777 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson55659812018-06-18 17:51:32 +02006778
6779 // Get and set the rtp encoding parameters.
6780 // Change the value and set it on the VideoChannel.
6781 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6782 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6783 parameters.encodings[0].min_bitrate_bps = 100000;
6784 parameters.encodings[0].max_bitrate_bps = 200000;
6785 parameters.encodings[1].min_bitrate_bps = 300000;
6786 parameters.encodings[1].max_bitrate_bps = 400000;
6787 parameters.encodings[2].min_bitrate_bps = 500000;
6788 parameters.encodings[2].max_bitrate_bps = 600000;
6789 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6790
6791 // Verify that the new value propagated down to the encoder.
6792 // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly.
6793 EXPECT_EQ(2, stream->num_encoder_reconfigurations());
6794 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
6795 EXPECT_EQ(kNumSimulcastStreams, encoder_config.number_of_streams);
6796 EXPECT_EQ(kNumSimulcastStreams, encoder_config.simulcast_layers.size());
6797 EXPECT_EQ(100000, encoder_config.simulcast_layers[0].min_bitrate_bps);
6798 EXPECT_EQ(200000, encoder_config.simulcast_layers[0].max_bitrate_bps);
6799 EXPECT_EQ(300000, encoder_config.simulcast_layers[1].min_bitrate_bps);
6800 EXPECT_EQ(400000, encoder_config.simulcast_layers[1].max_bitrate_bps);
6801 EXPECT_EQ(500000, encoder_config.simulcast_layers[2].min_bitrate_bps);
6802 EXPECT_EQ(600000, encoder_config.simulcast_layers[2].max_bitrate_bps);
6803
6804 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
6805 // VideoStreams are created appropriately for the simulcast case.
6806 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6807 // Target bitrate: 200000 * 3 / 4 = 150000.
6808 EXPECT_EQ(100000, stream->GetVideoStreams()[0].min_bitrate_bps);
6809 EXPECT_EQ(150000, stream->GetVideoStreams()[0].target_bitrate_bps);
6810 EXPECT_EQ(200000, stream->GetVideoStreams()[0].max_bitrate_bps);
6811 // Target bitrate: 400000 * 3 / 4 = 300000.
6812 EXPECT_EQ(300000, stream->GetVideoStreams()[1].min_bitrate_bps);
6813 EXPECT_EQ(300000, stream->GetVideoStreams()[1].target_bitrate_bps);
6814 EXPECT_EQ(400000, stream->GetVideoStreams()[1].max_bitrate_bps);
6815 // Target bitrate: 600000 * 3 / 4 = 450000, less than min -> max.
6816 EXPECT_EQ(500000, stream->GetVideoStreams()[2].min_bitrate_bps);
6817 EXPECT_EQ(600000, stream->GetVideoStreams()[2].target_bitrate_bps);
6818 EXPECT_EQ(600000, stream->GetVideoStreams()[2].max_bitrate_bps);
6819
6820 // No parameter changed, encoder should not be reconfigured.
6821 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6822 EXPECT_EQ(2, stream->num_encoder_reconfigurations());
6823
6824 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6825}
6826
6827// Test to only specify the min or max bitrate value for a layer via
6828// RtpParameters. The unspecified min/max and target value should be set to the
6829// simulcast default that is used if no min/max are specified.
6830TEST_F(WebRtcVideoChannelTest, MinOrMaxSimulcastBitratePropagatedToEncoder) {
6831 const size_t kNumSimulcastStreams = 3;
6832 const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
6833 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6834
6835 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006836 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson55659812018-06-18 17:51:32 +02006837 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006838 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson55659812018-06-18 17:51:32 +02006839 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006840 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson55659812018-06-18 17:51:32 +02006841
6842 // Get and set the rtp encoding parameters.
6843 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6844 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6845
6846 // Change the value and set it on the VideoChannel.
6847 // Layer 0: only configure min bitrate.
6848 const int kMinBpsLayer0 = kDefault[0].min_bitrate_bps + 1;
6849 parameters.encodings[0].min_bitrate_bps = kMinBpsLayer0;
6850 // Layer 1: only configure max bitrate.
6851 const int kMaxBpsLayer1 = kDefault[1].max_bitrate_bps - 1;
6852 parameters.encodings[1].max_bitrate_bps = kMaxBpsLayer1;
6853 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6854
6855 // Verify that the new value propagated down to the encoder.
6856 // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly.
6857 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
6858 EXPECT_EQ(kNumSimulcastStreams, encoder_config.number_of_streams);
6859 EXPECT_EQ(kNumSimulcastStreams, encoder_config.simulcast_layers.size());
6860 EXPECT_EQ(kMinBpsLayer0, encoder_config.simulcast_layers[0].min_bitrate_bps);
6861 EXPECT_EQ(-1, encoder_config.simulcast_layers[0].max_bitrate_bps);
6862 EXPECT_EQ(-1, encoder_config.simulcast_layers[1].min_bitrate_bps);
6863 EXPECT_EQ(kMaxBpsLayer1, encoder_config.simulcast_layers[1].max_bitrate_bps);
6864 EXPECT_EQ(-1, encoder_config.simulcast_layers[2].min_bitrate_bps);
6865 EXPECT_EQ(-1, encoder_config.simulcast_layers[2].max_bitrate_bps);
6866
6867 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
6868 // VideoStreams are created appropriately for the simulcast case.
6869 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6870 // Layer 0: min configured bitrate should overwrite min default.
6871 EXPECT_EQ(kMinBpsLayer0, stream->GetVideoStreams()[0].min_bitrate_bps);
6872 EXPECT_EQ(kDefault[0].target_bitrate_bps,
6873 stream->GetVideoStreams()[0].target_bitrate_bps);
6874 EXPECT_EQ(kDefault[0].max_bitrate_bps,
6875 stream->GetVideoStreams()[0].max_bitrate_bps);
6876 // Layer 1: max configured bitrate should overwrite max default.
6877 EXPECT_EQ(kDefault[1].min_bitrate_bps,
6878 stream->GetVideoStreams()[1].min_bitrate_bps);
6879 EXPECT_EQ(kDefault[1].target_bitrate_bps,
6880 stream->GetVideoStreams()[1].target_bitrate_bps);
6881 EXPECT_EQ(kMaxBpsLayer1, stream->GetVideoStreams()[1].max_bitrate_bps);
6882 // Layer 2: min and max bitrate not configured, default expected.
6883 EXPECT_EQ(kDefault[2].min_bitrate_bps,
6884 stream->GetVideoStreams()[2].min_bitrate_bps);
6885 EXPECT_EQ(kDefault[2].target_bitrate_bps,
6886 stream->GetVideoStreams()[2].target_bitrate_bps);
6887 EXPECT_EQ(kDefault[2].max_bitrate_bps,
6888 stream->GetVideoStreams()[2].max_bitrate_bps);
6889
6890 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6891}
6892
6893// Test that specifying the min (or max) bitrate value for a layer via
6894// RtpParameters above (or below) the simulcast default max (or min) adjusts the
6895// unspecified values accordingly.
6896TEST_F(WebRtcVideoChannelTest, SetMinAndMaxSimulcastBitrateAboveBelowDefault) {
6897 const size_t kNumSimulcastStreams = 3;
6898 const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
6899 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6900
6901 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006902 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson55659812018-06-18 17:51:32 +02006903 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006904 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson55659812018-06-18 17:51:32 +02006905 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006906 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson55659812018-06-18 17:51:32 +02006907
6908 // Get and set the rtp encoding parameters.
6909 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6910 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6911
6912 // Change the value and set it on the VideoChannel.
6913 // For layer 0, set the min bitrate above the default max.
6914 const int kMinBpsLayer0 = kDefault[0].max_bitrate_bps + 1;
6915 parameters.encodings[0].min_bitrate_bps = kMinBpsLayer0;
6916 // For layer 1, set the max bitrate below the default min.
6917 const int kMaxBpsLayer1 = kDefault[1].min_bitrate_bps - 1;
6918 parameters.encodings[1].max_bitrate_bps = kMaxBpsLayer1;
6919 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6920
6921 // Verify that the new value propagated down to the encoder.
6922 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
6923 // VideoStreams are created appropriately for the simulcast case.
6924 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6925 // Layer 0: Min bitrate above default max (target/max should be adjusted).
6926 EXPECT_EQ(kMinBpsLayer0, stream->GetVideoStreams()[0].min_bitrate_bps);
6927 EXPECT_EQ(kMinBpsLayer0, stream->GetVideoStreams()[0].target_bitrate_bps);
6928 EXPECT_EQ(kMinBpsLayer0, stream->GetVideoStreams()[0].max_bitrate_bps);
6929 // Layer 1: Max bitrate below default min (min/target should be adjusted).
6930 EXPECT_EQ(kMaxBpsLayer1, stream->GetVideoStreams()[1].min_bitrate_bps);
6931 EXPECT_EQ(kMaxBpsLayer1, stream->GetVideoStreams()[1].target_bitrate_bps);
6932 EXPECT_EQ(kMaxBpsLayer1, stream->GetVideoStreams()[1].max_bitrate_bps);
6933 // Layer 2: min and max bitrate not configured, default expected.
6934 EXPECT_EQ(kDefault[2].min_bitrate_bps,
6935 stream->GetVideoStreams()[2].min_bitrate_bps);
6936 EXPECT_EQ(kDefault[2].target_bitrate_bps,
6937 stream->GetVideoStreams()[2].target_bitrate_bps);
6938 EXPECT_EQ(kDefault[2].max_bitrate_bps,
6939 stream->GetVideoStreams()[2].max_bitrate_bps);
6940
6941 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6942}
6943
6944TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) {
6945 const size_t kNumSimulcastStreams = 3;
6946 const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
6947 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6948
6949 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006950 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson55659812018-06-18 17:51:32 +02006951 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01006952 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson55659812018-06-18 17:51:32 +02006953 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01006954 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson55659812018-06-18 17:51:32 +02006955
6956 // Set max bitrate for all but the highest layer.
6957 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
6958 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
6959 parameters.encodings[0].max_bitrate_bps = kDefault[0].max_bitrate_bps;
6960 parameters.encodings[1].max_bitrate_bps = kDefault[1].max_bitrate_bps;
6961 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
6962
6963 // Set max bandwidth equal to total max bitrate.
6964 send_parameters_.max_bandwidth_bps =
6965 GetTotalMaxBitrateBps(stream->GetVideoStreams());
6966 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
6967 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
6968
6969 // No bitrate above the total max to give to the highest layer.
6970 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6971 EXPECT_EQ(kDefault[2].max_bitrate_bps,
6972 stream->GetVideoStreams()[2].max_bitrate_bps);
6973
6974 // Set max bandwidth above the total max bitrate.
6975 send_parameters_.max_bandwidth_bps =
6976 GetTotalMaxBitrateBps(stream->GetVideoStreams()) + 1;
6977 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
6978 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
6979
6980 // The highest layer has no max bitrate set -> the bitrate above the total
6981 // max should be given to the highest layer.
6982 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
6983 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
6984 GetTotalMaxBitrateBps(stream->GetVideoStreams()));
6985 EXPECT_EQ(kDefault[2].max_bitrate_bps + 1,
6986 stream->GetVideoStreams()[2].max_bitrate_bps);
6987
6988 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
6989}
6990
6991TEST_F(WebRtcVideoChannelTest,
6992 BandwidthAboveTotalMaxBitrateNotGivenToMaxLayerIfMaxBitrateSet) {
6993 const size_t kNumSimulcastStreams = 3;
6994 const std::vector<webrtc::VideoStream> kDefault = GetSimulcastBitrates720p();
6995 EXPECT_EQ(kNumSimulcastStreams, kDefault.size());
6996 FakeVideoSendStream* stream = SetUpSimulcast(true, false);
6997
6998 // Send a full size frame so all simulcast layers are used when reconfiguring.
Niels Möller805a27e2019-01-21 12:21:27 +01006999 webrtc::test::FrameForwarder frame_forwarder;
Åsa Persson55659812018-06-18 17:51:32 +02007000 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01007001 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder));
Åsa Persson55659812018-06-18 17:51:32 +02007002 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01007003 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame());
Åsa Persson55659812018-06-18 17:51:32 +02007004
7005 // Set max bitrate for the highest layer.
7006 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
7007 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
7008 parameters.encodings[2].max_bitrate_bps = kDefault[2].max_bitrate_bps;
7009 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
7010
7011 // Set max bandwidth above the total max bitrate.
7012 send_parameters_.max_bandwidth_bps =
7013 GetTotalMaxBitrateBps(stream->GetVideoStreams()) + 1;
7014 ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps);
7015 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
7016
7017 // The highest layer has the max bitrate set -> the bitrate above the total
7018 // max should not be given to the highest layer.
7019 EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size());
7020 EXPECT_EQ(*parameters.encodings[2].max_bitrate_bps,
7021 stream->GetVideoStreams()[2].max_bitrate_bps);
7022
7023 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
7024}
7025
Åsa Perssonbdee46d2018-06-25 11:28:06 +02007026// Test that min and max bitrate values set via RtpParameters are correctly
7027// propagated to the underlying encoder for a single stream.
7028TEST_F(WebRtcVideoChannelTest, MinAndMaxBitratePropagatedToEncoder) {
7029 FakeVideoSendStream* stream = AddSendStream();
7030 EXPECT_TRUE(channel_->SetSend(true));
7031 EXPECT_TRUE(stream->IsSending());
7032
7033 // Set min and max bitrate.
7034 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
7035 EXPECT_EQ(1u, parameters.encodings.size());
7036 parameters.encodings[0].min_bitrate_bps = 80000;
7037 parameters.encodings[0].max_bitrate_bps = 150000;
7038 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
7039
7040 // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly.
7041 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
7042 EXPECT_EQ(1u, encoder_config.number_of_streams);
7043 EXPECT_EQ(1u, encoder_config.simulcast_layers.size());
7044 EXPECT_EQ(80000, encoder_config.simulcast_layers[0].min_bitrate_bps);
7045 EXPECT_EQ(150000, encoder_config.simulcast_layers[0].max_bitrate_bps);
7046
7047 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
7048 // VideoStreams are created appropriately.
7049 EXPECT_EQ(1u, stream->GetVideoStreams().size());
7050 EXPECT_EQ(80000, stream->GetVideoStreams()[0].min_bitrate_bps);
7051 EXPECT_EQ(150000, stream->GetVideoStreams()[0].target_bitrate_bps);
7052 EXPECT_EQ(150000, stream->GetVideoStreams()[0].max_bitrate_bps);
7053}
7054
7055// Test the default min and max bitrate value are correctly propagated to the
7056// underlying encoder for a single stream (when the values are not set via
7057// RtpParameters).
7058TEST_F(WebRtcVideoChannelTest, DefaultMinAndMaxBitratePropagatedToEncoder) {
7059 FakeVideoSendStream* stream = AddSendStream();
7060 EXPECT_TRUE(channel_->SetSend(true));
7061 EXPECT_TRUE(stream->IsSending());
7062
7063 // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly.
7064 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
7065 EXPECT_EQ(1u, encoder_config.number_of_streams);
7066 EXPECT_EQ(1u, encoder_config.simulcast_layers.size());
7067 EXPECT_EQ(-1, encoder_config.simulcast_layers[0].min_bitrate_bps);
7068 EXPECT_EQ(-1, encoder_config.simulcast_layers[0].max_bitrate_bps);
7069
7070 // FakeVideoSendStream calls CreateEncoderStreams, test that the vector of
7071 // VideoStreams are created appropriately.
7072 EXPECT_EQ(1u, stream->GetVideoStreams().size());
7073 EXPECT_EQ(cricket::kMinVideoBitrateBps,
7074 stream->GetVideoStreams()[0].min_bitrate_bps);
7075 EXPECT_GT(stream->GetVideoStreams()[0].max_bitrate_bps,
7076 stream->GetVideoStreams()[0].min_bitrate_bps);
7077 EXPECT_EQ(stream->GetVideoStreams()[0].max_bitrate_bps,
7078 stream->GetVideoStreams()[0].target_bitrate_bps);
7079}
7080
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07007081// Test that a stream will not be sending if its encoding is made inactive
7082// through SetRtpSendParameters.
Seth Hampson8234ead2018-02-02 15:16:24 -08007083TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersOneEncodingActive) {
deadbeefdbe2b872016-03-22 15:42:00 -07007084 FakeVideoSendStream* stream = AddSendStream();
7085 EXPECT_TRUE(channel_->SetSend(true));
7086 EXPECT_TRUE(stream->IsSending());
7087
7088 // Get current parameters and change "active" to false.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007089 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
deadbeefdbe2b872016-03-22 15:42:00 -07007090 ASSERT_EQ(1u, parameters.encodings.size());
7091 ASSERT_TRUE(parameters.encodings[0].active);
7092 parameters.encodings[0].active = false;
Zach Steinba37b4b2018-01-23 15:02:36 -08007093 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
deadbeefdbe2b872016-03-22 15:42:00 -07007094 EXPECT_FALSE(stream->IsSending());
7095
7096 // Now change it back to active and verify we resume sending.
7097 parameters.encodings[0].active = true;
Zach Steinba37b4b2018-01-23 15:02:36 -08007098 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
deadbeefdbe2b872016-03-22 15:42:00 -07007099 EXPECT_TRUE(stream->IsSending());
7100}
7101
Seth Hampson8234ead2018-02-02 15:16:24 -08007102// Tests that when active is updated for any simulcast layer then the send
7103// stream's sending state will be updated and it will be reconfigured with the
7104// new appropriate active simulcast streams.
7105TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersMultipleEncodingsActive) {
7106 // Create the stream params with multiple ssrcs for simulcast.
Åsa Persson31cb8f92018-06-27 10:44:56 +02007107 const size_t kNumSimulcastStreams = 3;
Seth Hampson8234ead2018-02-02 15:16:24 -08007108 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
7109 StreamParams stream_params = CreateSimStreamParams("cname", ssrcs);
7110 FakeVideoSendStream* fake_video_send_stream = AddSendStream(stream_params);
7111 uint32_t primary_ssrc = stream_params.first_ssrc();
7112
Niels Möller805a27e2019-01-21 12:21:27 +01007113 // Using the FrameForwarder, we manually send a full size
Tommi85959932018-02-07 19:26:06 +01007114 // frame. This allows us to test that ReconfigureEncoder is called
7115 // appropriately.
Niels Möller805a27e2019-01-21 12:21:27 +01007116 webrtc::test::FrameForwarder frame_forwarder;
Seth Hampson8234ead2018-02-02 15:16:24 -08007117 VideoOptions options;
Niels Möller805a27e2019-01-21 12:21:27 +01007118 EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder));
Seth Hampson8234ead2018-02-02 15:16:24 -08007119 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01007120 frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame(
7121 1920, 1080, webrtc::VideoRotation::kVideoRotation_0,
7122 rtc::kNumMicrosecsPerSec / 30));
Seth Hampson8234ead2018-02-02 15:16:24 -08007123
7124 // Check that all encodings are initially active.
7125 webrtc::RtpParameters parameters =
7126 channel_->GetRtpSendParameters(primary_ssrc);
Åsa Persson31cb8f92018-06-27 10:44:56 +02007127 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
Seth Hampson8234ead2018-02-02 15:16:24 -08007128 EXPECT_TRUE(parameters.encodings[0].active);
7129 EXPECT_TRUE(parameters.encodings[1].active);
7130 EXPECT_TRUE(parameters.encodings[2].active);
7131 EXPECT_TRUE(fake_video_send_stream->IsSending());
7132
7133 // Only turn on only the middle stream.
7134 parameters.encodings[0].active = false;
7135 parameters.encodings[1].active = true;
7136 parameters.encodings[2].active = false;
7137 EXPECT_TRUE(channel_->SetRtpSendParameters(primary_ssrc, parameters).ok());
7138 // Verify that the active fields are set on the VideoChannel.
7139 parameters = channel_->GetRtpSendParameters(primary_ssrc);
Åsa Persson31cb8f92018-06-27 10:44:56 +02007140 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
Seth Hampson8234ead2018-02-02 15:16:24 -08007141 EXPECT_FALSE(parameters.encodings[0].active);
7142 EXPECT_TRUE(parameters.encodings[1].active);
7143 EXPECT_FALSE(parameters.encodings[2].active);
7144 // Check that the VideoSendStream is updated appropriately. This means its
7145 // send state was updated and it was reconfigured.
7146 EXPECT_TRUE(fake_video_send_stream->IsSending());
7147 std::vector<webrtc::VideoStream> simulcast_streams =
7148 fake_video_send_stream->GetVideoStreams();
Åsa Persson31cb8f92018-06-27 10:44:56 +02007149 EXPECT_EQ(kNumSimulcastStreams, simulcast_streams.size());
Seth Hampson8234ead2018-02-02 15:16:24 -08007150 EXPECT_FALSE(simulcast_streams[0].active);
7151 EXPECT_TRUE(simulcast_streams[1].active);
7152 EXPECT_FALSE(simulcast_streams[2].active);
7153
7154 // Turn off all streams.
7155 parameters.encodings[0].active = false;
7156 parameters.encodings[1].active = false;
7157 parameters.encodings[2].active = false;
7158 EXPECT_TRUE(channel_->SetRtpSendParameters(primary_ssrc, parameters).ok());
7159 // Verify that the active fields are set on the VideoChannel.
7160 parameters = channel_->GetRtpSendParameters(primary_ssrc);
Åsa Persson31cb8f92018-06-27 10:44:56 +02007161 EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
Seth Hampson8234ead2018-02-02 15:16:24 -08007162 EXPECT_FALSE(parameters.encodings[0].active);
7163 EXPECT_FALSE(parameters.encodings[1].active);
7164 EXPECT_FALSE(parameters.encodings[2].active);
7165 // Check that the VideoSendStream is off.
7166 EXPECT_FALSE(fake_video_send_stream->IsSending());
7167 simulcast_streams = fake_video_send_stream->GetVideoStreams();
Åsa Persson31cb8f92018-06-27 10:44:56 +02007168 EXPECT_EQ(kNumSimulcastStreams, simulcast_streams.size());
Seth Hampson8234ead2018-02-02 15:16:24 -08007169 EXPECT_FALSE(simulcast_streams[0].active);
7170 EXPECT_FALSE(simulcast_streams[1].active);
7171 EXPECT_FALSE(simulcast_streams[2].active);
7172
Niels Möllerff40b142018-04-09 08:49:14 +02007173 EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, nullptr, nullptr));
Seth Hampson8234ead2018-02-02 15:16:24 -08007174}
7175
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07007176// Test that if a stream is reconfigured (due to a codec change or other
7177// change) while its encoding is still inactive, it doesn't start sending.
eladalonf1841382017-06-12 01:16:46 -07007178TEST_F(WebRtcVideoChannelTest,
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07007179 InactiveStreamDoesntStartSendingWhenReconfigured) {
7180 // Set an initial codec list, which will be modified later.
7181 cricket::VideoSendParameters parameters1;
magjed509e4fe2016-11-18 01:34:11 -08007182 parameters1.codecs.push_back(GetEngineCodec("VP8"));
7183 parameters1.codecs.push_back(GetEngineCodec("VP9"));
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07007184 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
7185
7186 FakeVideoSendStream* stream = AddSendStream();
7187 EXPECT_TRUE(channel_->SetSend(true));
7188 EXPECT_TRUE(stream->IsSending());
7189
7190 // Get current parameters and change "active" to false.
7191 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
7192 ASSERT_EQ(1u, parameters.encodings.size());
7193 ASSERT_TRUE(parameters.encodings[0].active);
7194 parameters.encodings[0].active = false;
7195 EXPECT_EQ(1u, GetFakeSendStreams().size());
7196 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
Zach Steinba37b4b2018-01-23 15:02:36 -08007197 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters).ok());
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07007198 EXPECT_FALSE(stream->IsSending());
7199
7200 // Reorder the codec list, causing the stream to be reconfigured.
7201 cricket::VideoSendParameters parameters2;
magjed509e4fe2016-11-18 01:34:11 -08007202 parameters2.codecs.push_back(GetEngineCodec("VP9"));
7203 parameters2.codecs.push_back(GetEngineCodec("VP8"));
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07007204 EXPECT_TRUE(channel_->SetSendParameters(parameters2));
7205 auto new_streams = GetFakeSendStreams();
7206 // Assert that a new underlying stream was created due to the codec change.
7207 // Otherwise, this test isn't testing what it set out to test.
7208 EXPECT_EQ(1u, GetFakeSendStreams().size());
7209 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
7210
7211 // Verify that we still are not sending anything, due to the inactive
7212 // encoding.
7213 EXPECT_FALSE(new_streams[0]->IsSending());
7214}
7215
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007216// Test that GetRtpSendParameters returns the currently configured codecs.
eladalonf1841382017-06-12 01:16:46 -07007217TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersCodecs) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007218 AddSendStream();
7219 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08007220 parameters.codecs.push_back(GetEngineCodec("VP8"));
7221 parameters.codecs.push_back(GetEngineCodec("VP9"));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007222 EXPECT_TRUE(channel_->SetSendParameters(parameters));
7223
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007224 webrtc::RtpParameters rtp_parameters =
7225 channel_->GetRtpSendParameters(last_ssrc_);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007226 ASSERT_EQ(2u, rtp_parameters.codecs.size());
magjed509e4fe2016-11-18 01:34:11 -08007227 EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(),
7228 rtp_parameters.codecs[0]);
7229 EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(),
7230 rtp_parameters.codecs[1]);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007231}
7232
Florent Castellidacec712018-05-24 16:24:21 +02007233// Test that GetRtpSendParameters returns the currently configured RTCP CNAME.
7234TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersRtcpCname) {
7235 StreamParams params = StreamParams::CreateLegacy(kSsrc);
7236 params.cname = "rtcpcname";
7237 AddSendStream(params);
7238
7239 webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc);
7240 EXPECT_STREQ("rtcpcname", rtp_parameters.rtcp.cname.c_str());
7241}
7242
deadbeeffb2aced2017-01-06 23:05:37 -08007243// Test that RtpParameters for send stream has one encoding and it has
7244// the correct SSRC.
eladalonf1841382017-06-12 01:16:46 -07007245TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersSsrc) {
deadbeeffb2aced2017-01-06 23:05:37 -08007246 AddSendStream();
7247
7248 webrtc::RtpParameters rtp_parameters =
7249 channel_->GetRtpSendParameters(last_ssrc_);
7250 ASSERT_EQ(1u, rtp_parameters.encodings.size());
Oskar Sundbom78807582017-11-16 11:09:55 +01007251 EXPECT_EQ(last_ssrc_, rtp_parameters.encodings[0].ssrc);
deadbeeffb2aced2017-01-06 23:05:37 -08007252}
7253
Florent Castelliabe301f2018-06-12 18:33:49 +02007254TEST_F(WebRtcVideoChannelTest, DetectRtpSendParameterHeaderExtensionsChange) {
7255 AddSendStream();
7256
7257 webrtc::RtpParameters rtp_parameters =
7258 channel_->GetRtpSendParameters(last_ssrc_);
7259 rtp_parameters.header_extensions.emplace_back();
7260
7261 EXPECT_NE(0u, rtp_parameters.header_extensions.size());
7262
7263 webrtc::RTCError result =
7264 channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters);
7265 EXPECT_EQ(webrtc::RTCErrorType::INVALID_MODIFICATION, result.type());
7266}
7267
Florent Castelli87b3c512018-07-18 16:00:28 +02007268TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersDegradationPreference) {
7269 AddSendStream();
7270
Niels Möller805a27e2019-01-21 12:21:27 +01007271 webrtc::test::FrameForwarder frame_forwarder;
7272 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder));
Florent Castelli87b3c512018-07-18 16:00:28 +02007273
7274 webrtc::RtpParameters rtp_parameters =
7275 channel_->GetRtpSendParameters(last_ssrc_);
7276 EXPECT_EQ(rtp_parameters.degradation_preference,
7277 webrtc::DegradationPreference::BALANCED);
7278 rtp_parameters.degradation_preference =
7279 webrtc::DegradationPreference::MAINTAIN_FRAMERATE;
7280
7281 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, rtp_parameters).ok());
7282
7283 webrtc::RtpParameters updated_rtp_parameters =
7284 channel_->GetRtpSendParameters(last_ssrc_);
7285 EXPECT_EQ(updated_rtp_parameters.degradation_preference,
7286 webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
7287
7288 // Remove the source since it will be destroyed before the channel
7289 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
7290}
7291
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007292// Test that if we set/get parameters multiple times, we get the same results.
eladalonf1841382017-06-12 01:16:46 -07007293TEST_F(WebRtcVideoChannelTest, SetAndGetRtpSendParameters) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007294 AddSendStream();
7295 cricket::VideoSendParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08007296 parameters.codecs.push_back(GetEngineCodec("VP8"));
7297 parameters.codecs.push_back(GetEngineCodec("VP9"));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007298 EXPECT_TRUE(channel_->SetSendParameters(parameters));
7299
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007300 webrtc::RtpParameters initial_params =
7301 channel_->GetRtpSendParameters(last_ssrc_);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007302
7303 // We should be able to set the params we just got.
Zach Steinba37b4b2018-01-23 15:02:36 -08007304 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, initial_params).ok());
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007305
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007306 // ... And this shouldn't change the params returned by GetRtpSendParameters.
7307 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(last_ssrc_));
7308}
7309
7310// Test that GetRtpReceiveParameters returns the currently configured codecs.
eladalonf1841382017-06-12 01:16:46 -07007311TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersCodecs) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007312 AddRecvStream();
7313 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08007314 parameters.codecs.push_back(GetEngineCodec("VP8"));
7315 parameters.codecs.push_back(GetEngineCodec("VP9"));
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007316 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
7317
7318 webrtc::RtpParameters rtp_parameters =
7319 channel_->GetRtpReceiveParameters(last_ssrc_);
7320 ASSERT_EQ(2u, rtp_parameters.codecs.size());
magjed509e4fe2016-11-18 01:34:11 -08007321 EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(),
7322 rtp_parameters.codecs[0]);
7323 EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(),
7324 rtp_parameters.codecs[1]);
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007325}
7326
johan073ece42016-08-26 02:59:47 -07007327#if defined(WEBRTC_USE_H264)
eladalonf1841382017-06-12 01:16:46 -07007328TEST_F(WebRtcVideoChannelTest, GetRtpReceiveFmtpSprop) {
johan073ece42016-08-26 02:59:47 -07007329#else
eladalonf1841382017-06-12 01:16:46 -07007330TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) {
johan073ece42016-08-26 02:59:47 -07007331#endif
johan3859c892016-08-05 09:19:25 -07007332 cricket::VideoRecvParameters parameters;
perkj26752742016-10-24 01:21:16 -07007333 cricket::VideoCodec kH264sprop1(101, "H264");
magjed5dfac562016-11-25 03:56:37 -08007334 kH264sprop1.SetParam(kH264FmtpSpropParameterSets, "uvw");
johan3859c892016-08-05 09:19:25 -07007335 parameters.codecs.push_back(kH264sprop1);
perkj26752742016-10-24 01:21:16 -07007336 cricket::VideoCodec kH264sprop2(102, "H264");
magjed5dfac562016-11-25 03:56:37 -08007337 kH264sprop2.SetParam(kH264FmtpSpropParameterSets, "xyz");
johan3859c892016-08-05 09:19:25 -07007338 parameters.codecs.push_back(kH264sprop2);
7339 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
7340
7341 FakeVideoReceiveStream* recv_stream = AddRecvStream();
7342 const webrtc::VideoReceiveStream::Config& cfg = recv_stream->GetConfig();
7343 webrtc::RtpParameters rtp_parameters =
7344 channel_->GetRtpReceiveParameters(last_ssrc_);
7345 ASSERT_EQ(2u, rtp_parameters.codecs.size());
7346 EXPECT_EQ(kH264sprop1.ToCodecParameters(), rtp_parameters.codecs[0]);
7347 ASSERT_EQ(2u, cfg.decoders.size());
7348 EXPECT_EQ(101, cfg.decoders[0].payload_type);
Niels Möllercb7e1d22018-09-11 15:56:04 +02007349 EXPECT_EQ("H264", cfg.decoders[0].video_format.name);
magjed5dfac562016-11-25 03:56:37 -08007350 const auto it0 =
Niels Möllercb7e1d22018-09-11 15:56:04 +02007351 cfg.decoders[0].video_format.parameters.find(kH264FmtpSpropParameterSets);
7352 ASSERT_TRUE(it0 != cfg.decoders[0].video_format.parameters.end());
magjed5dfac562016-11-25 03:56:37 -08007353 EXPECT_EQ("uvw", it0->second);
johan3859c892016-08-05 09:19:25 -07007354
7355 EXPECT_EQ(102, cfg.decoders[1].payload_type);
Niels Möllercb7e1d22018-09-11 15:56:04 +02007356 EXPECT_EQ("H264", cfg.decoders[1].video_format.name);
magjed5dfac562016-11-25 03:56:37 -08007357 const auto it1 =
Niels Möllercb7e1d22018-09-11 15:56:04 +02007358 cfg.decoders[1].video_format.parameters.find(kH264FmtpSpropParameterSets);
7359 ASSERT_TRUE(it1 != cfg.decoders[1].video_format.parameters.end());
magjed5dfac562016-11-25 03:56:37 -08007360 EXPECT_EQ("xyz", it1->second);
johan3859c892016-08-05 09:19:25 -07007361}
7362
sakal1fd95952016-06-22 00:46:15 -07007363// Test that RtpParameters for receive stream has one encoding and it has
7364// the correct SSRC.
eladalonf1841382017-06-12 01:16:46 -07007365TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersSsrc) {
sakal1fd95952016-06-22 00:46:15 -07007366 AddRecvStream();
7367
7368 webrtc::RtpParameters rtp_parameters =
7369 channel_->GetRtpReceiveParameters(last_ssrc_);
7370 ASSERT_EQ(1u, rtp_parameters.encodings.size());
Oskar Sundbom78807582017-11-16 11:09:55 +01007371 EXPECT_EQ(last_ssrc_, rtp_parameters.encodings[0].ssrc);
sakal1fd95952016-06-22 00:46:15 -07007372}
7373
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007374// Test that if we set/get parameters multiple times, we get the same results.
eladalonf1841382017-06-12 01:16:46 -07007375TEST_F(WebRtcVideoChannelTest, SetAndGetRtpReceiveParameters) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007376 AddRecvStream();
7377 cricket::VideoRecvParameters parameters;
magjed509e4fe2016-11-18 01:34:11 -08007378 parameters.codecs.push_back(GetEngineCodec("VP8"));
7379 parameters.codecs.push_back(GetEngineCodec("VP9"));
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07007380 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
7381
7382 webrtc::RtpParameters initial_params =
7383 channel_->GetRtpReceiveParameters(last_ssrc_);
7384
7385 // We should be able to set the params we just got.
7386 EXPECT_TRUE(channel_->SetRtpReceiveParameters(last_ssrc_, initial_params));
7387
7388 // ... And this shouldn't change the params returned by
7389 // GetRtpReceiveParameters.
7390 EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(last_ssrc_));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07007391}
7392
deadbeef3bc15102017-04-20 19:25:07 -07007393// Test that GetRtpReceiveParameters returns parameters correctly when SSRCs
7394// aren't signaled. It should always return an empty "RtpEncodingParameters",
7395// even after a packet is received and the unsignaled SSRC is known.
eladalonf1841382017-06-12 01:16:46 -07007396TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersWithUnsignaledSsrc) {
deadbeef3bc15102017-04-20 19:25:07 -07007397 // Call necessary methods to configure receiving a default stream as
7398 // soon as it arrives.
7399 cricket::VideoRecvParameters parameters;
7400 parameters.codecs.push_back(GetEngineCodec("VP8"));
7401 parameters.codecs.push_back(GetEngineCodec("VP9"));
7402 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
7403
7404 // Call GetRtpReceiveParameters before configured to receive an unsignaled
7405 // stream. Should return nothing.
7406 EXPECT_EQ(webrtc::RtpParameters(), channel_->GetRtpReceiveParameters(0));
7407
7408 // Set a sink for an unsignaled stream.
7409 cricket::FakeVideoRenderer renderer;
7410 // Value of "0" means "unsignaled stream".
7411 EXPECT_TRUE(channel_->SetSink(0, &renderer));
7412
7413 // Call GetRtpReceiveParameters before the SSRC is known. Value of "0"
7414 // in this method means "unsignaled stream".
7415 webrtc::RtpParameters rtp_parameters = channel_->GetRtpReceiveParameters(0);
7416 ASSERT_EQ(1u, rtp_parameters.encodings.size());
7417 EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
7418
7419 // Receive VP8 packet.
7420 uint8_t data[kMinRtpPacketLen];
7421 cricket::RtpHeader rtpHeader;
7422 rtpHeader.payload_type = GetEngineCodec("VP8").id;
7423 rtpHeader.seq_num = rtpHeader.timestamp = 0;
7424 rtpHeader.ssrc = kIncomingUnsignalledSsrc;
7425 cricket::SetRtpHeader(data, sizeof(data), rtpHeader);
7426 rtc::CopyOnWriteBuffer packet(data, sizeof(data));
Amit Hilbuche7a5f7b2019-03-12 11:10:27 -07007427 channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
deadbeef3bc15102017-04-20 19:25:07 -07007428
7429 // The |ssrc| member should still be unset.
7430 rtp_parameters = channel_->GetRtpReceiveParameters(0);
7431 ASSERT_EQ(1u, rtp_parameters.encodings.size());
7432 EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
7433}
7434
eladalonf1841382017-06-12 01:16:46 -07007435void WebRtcVideoChannelTest::TestReceiverLocalSsrcConfiguration(
Peter Boström3548dd22015-05-22 18:48:36 +02007436 bool receiver_first) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02007437 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström3548dd22015-05-22 18:48:36 +02007438
7439 const uint32_t kSenderSsrc = 0xC0FFEE;
Peter Boströmdfa28152015-10-21 17:21:10 +02007440 const uint32_t kSecondSenderSsrc = 0xBADCAFE;
Peter Boström3548dd22015-05-22 18:48:36 +02007441 const uint32_t kReceiverSsrc = 0x4711;
Peter Boströmdfa28152015-10-21 17:21:10 +02007442 const uint32_t kExpectedDefaultReceiverSsrc = 1;
Peter Boström3548dd22015-05-22 18:48:36 +02007443
7444 if (receiver_first) {
7445 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
7446 std::vector<FakeVideoReceiveStream*> receive_streams =
7447 fake_call_->GetVideoReceiveStreams();
7448 ASSERT_EQ(1u, receive_streams.size());
Peter Boströmdfa28152015-10-21 17:21:10 +02007449 // Default local SSRC when we have no sender.
7450 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
7451 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02007452 }
7453 AddSendStream(StreamParams::CreateLegacy(kSenderSsrc));
7454 if (!receiver_first)
7455 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
7456 std::vector<FakeVideoReceiveStream*> receive_streams =
7457 fake_call_->GetVideoReceiveStreams();
7458 ASSERT_EQ(1u, receive_streams.size());
7459 EXPECT_EQ(kSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boströmdfa28152015-10-21 17:21:10 +02007460
7461 // Removing first sender should fall back to another (in this case the second)
7462 // local send stream's SSRC.
7463 AddSendStream(StreamParams::CreateLegacy(kSecondSenderSsrc));
7464 ASSERT_TRUE(channel_->RemoveSendStream(kSenderSsrc));
Yves Gerey665174f2018-06-19 15:03:05 +02007465 receive_streams = fake_call_->GetVideoReceiveStreams();
Peter Boströmdfa28152015-10-21 17:21:10 +02007466 ASSERT_EQ(1u, receive_streams.size());
7467 EXPECT_EQ(kSecondSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
7468
7469 // Removing the last sender should fall back to default local SSRC.
7470 ASSERT_TRUE(channel_->RemoveSendStream(kSecondSenderSsrc));
Yves Gerey665174f2018-06-19 15:03:05 +02007471 receive_streams = fake_call_->GetVideoReceiveStreams();
Peter Boströmdfa28152015-10-21 17:21:10 +02007472 ASSERT_EQ(1u, receive_streams.size());
7473 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
7474 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02007475}
7476
eladalonf1841382017-06-12 01:16:46 -07007477TEST_F(WebRtcVideoChannelTest, ConfiguresLocalSsrc) {
Peter Boström3548dd22015-05-22 18:48:36 +02007478 TestReceiverLocalSsrcConfiguration(false);
7479}
7480
eladalonf1841382017-06-12 01:16:46 -07007481TEST_F(WebRtcVideoChannelTest, ConfiguresLocalSsrcOnExistingReceivers) {
Peter Boström3548dd22015-05-22 18:48:36 +02007482 TestReceiverLocalSsrcConfiguration(true);
7483}
7484
Mirko Bonadei6a489f22019-04-09 15:11:12 +02007485class WebRtcVideoChannelSimulcastTest : public ::testing::Test {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007486 public:
eladalonf1841382017-06-12 01:16:46 -07007487 WebRtcVideoChannelSimulcastTest()
Sebastian Jansson8f83b422018-02-21 13:07:13 +01007488 : fake_call_(),
Magnus Jedvert02e7a192017-09-23 17:21:32 +02007489 encoder_factory_(new cricket::FakeWebRtcVideoEncoderFactory),
7490 decoder_factory_(new cricket::FakeWebRtcVideoDecoderFactory),
Jiawei Ouc2ebe212018-11-08 10:02:56 -08007491 mock_rate_allocator_factory_(
Mirko Bonadei317a1f02019-09-17 17:06:18 +02007492 std::make_unique<webrtc::MockVideoBitrateAllocatorFactory>()),
Anders Carlsson67537952018-05-03 11:28:29 +02007493 engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
Magnus Jedvert02e7a192017-09-23 17:21:32 +02007494 encoder_factory_),
Anders Carlsson67537952018-05-03 11:28:29 +02007495 std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02007496 decoder_factory_)),
magjed2475ae22017-09-12 04:42:15 -07007497 last_ssrc_(0) {}
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007498
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00007499 void SetUp() override {
Anders Carlsson5f2bb622018-05-14 09:48:06 +02007500 encoder_factory_->AddSupportedVideoCodecType("VP8");
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02007501 channel_.reset(engine_.CreateMediaChannel(
7502 &fake_call_, GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
7503 mock_rate_allocator_factory_.get()));
Sergey Ulanove2b15012016-11-22 16:08:30 -08007504 channel_->OnReadyToSend(true);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007505 last_ssrc_ = 123;
7506 }
7507
7508 protected:
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007509 void VerifySimulcastSettings(const VideoCodec& codec,
perkj26752742016-10-24 01:21:16 -07007510 int capture_width,
7511 int capture_height,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007512 size_t num_configured_streams,
sprang429600d2017-01-26 06:12:26 -08007513 size_t expected_num_streams,
7514 bool screenshare,
7515 bool conference_mode) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02007516 cricket::VideoSendParameters parameters;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02007517 parameters.codecs.push_back(codec);
sprang429600d2017-01-26 06:12:26 -08007518 parameters.conference_mode = conference_mode;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02007519 ASSERT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007520
Peter Boström0c4e06b2015-10-07 12:23:21 +02007521 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
henrikg91d6ede2015-09-17 00:24:34 -07007522 RTC_DCHECK(num_configured_streams <= ssrcs.size());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007523 ssrcs.resize(num_configured_streams);
7524
sprangf24a0642017-02-28 13:23:26 -08007525 AddSendStream(CreateSimStreamParams("cname", ssrcs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00007526 // Send a full-size frame to trigger a stream reconfiguration to use all
7527 // expected simulcast layers.
Niels Möller805a27e2019-01-21 12:21:27 +01007528 webrtc::test::FrameForwarder frame_forwarder;
7529 cricket::FakeFrameSource frame_source(capture_width, capture_height,
7530 rtc::kNumMicrosecsPerSec / 30);
7531
sprangf24a0642017-02-28 13:23:26 -08007532 VideoOptions options;
7533 if (screenshare)
Oskar Sundbom78807582017-11-16 11:09:55 +01007534 options.is_screencast = screenshare;
Niels Möller805a27e2019-01-21 12:21:27 +01007535 EXPECT_TRUE(
7536 channel_->SetVideoSend(ssrcs.front(), &options, &frame_forwarder));
sprangf24a0642017-02-28 13:23:26 -08007537 // Fetch the latest stream since SetVideoSend() may recreate it if the
7538 // screen content setting is changed.
7539 FakeVideoSendStream* stream = fake_call_.GetVideoSendStreams().front();
pbos@webrtc.org86196c42015-02-16 21:02:00 +00007540 channel_->SetSend(true);
Niels Möller805a27e2019-01-21 12:21:27 +01007541 frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007542
Zach Stein3ca452b2018-01-18 10:01:24 -08007543 auto rtp_parameters = channel_->GetRtpSendParameters(kSsrcs3[0]);
7544 EXPECT_EQ(num_configured_streams, rtp_parameters.encodings.size());
7545
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007546 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
7547 ASSERT_EQ(expected_num_streams, video_streams.size());
Ilya Nikolaevskiy33d2a912019-04-02 11:05:03 +02007548 EXPECT_LE(expected_num_streams, stream->GetConfig().rtp.ssrcs.size());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007549
sprang429600d2017-01-26 06:12:26 -08007550 std::vector<webrtc::VideoStream> expected_streams;
Florent Castelli66b38602019-07-10 16:57:57 +02007551 if (num_configured_streams > 1 || conference_mode) {
sprang429600d2017-01-26 06:12:26 -08007552 expected_streams = GetSimulcastConfig(
Florent Castelli668ce0c2019-07-04 17:06:04 +02007553 num_configured_streams, capture_width, capture_height,
Florent Castelli66b38602019-07-10 16:57:57 +02007554 webrtc::kDefaultBitratePriority, kDefaultQpMax,
7555 screenshare && conference_mode, true);
7556 if (screenshare && conference_mode) {
sprang3ebabf12017-02-16 07:35:22 -08007557 for (const webrtc::VideoStream& stream : expected_streams) {
7558 // Never scale screen content.
Danil Chapovalov350531e2018-06-08 11:04:04 +00007559 EXPECT_EQ(stream.width, rtc::checked_cast<size_t>(capture_width));
7560 EXPECT_EQ(stream.height, rtc::checked_cast<size_t>(capture_height));
sprang3ebabf12017-02-16 07:35:22 -08007561 }
7562 }
sprang429600d2017-01-26 06:12:26 -08007563 } else {
7564 webrtc::VideoStream stream;
7565 stream.width = capture_width;
7566 stream.height = capture_height;
7567 stream.max_framerate = kDefaultVideoMaxFramerate;
Åsa Persson45bbc8a2017-11-13 10:16:47 +01007568 stream.min_bitrate_bps = cricket::kMinVideoBitrateBps;
sprang429600d2017-01-26 06:12:26 -08007569 stream.target_bitrate_bps = stream.max_bitrate_bps =
Åsa Perssonbdee46d2018-06-25 11:28:06 +02007570 GetMaxDefaultBitrateBps(capture_width, capture_height);
sprang429600d2017-01-26 06:12:26 -08007571 stream.max_qp = kDefaultQpMax;
7572 expected_streams.push_back(stream);
7573 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007574
7575 ASSERT_EQ(expected_streams.size(), video_streams.size());
7576
7577 size_t num_streams = video_streams.size();
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00007578 int total_max_bitrate_bps = 0;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007579 for (size_t i = 0; i < num_streams; ++i) {
7580 EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
7581 EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
7582
7583 EXPECT_GT(video_streams[i].max_framerate, 0);
7584 EXPECT_EQ(expected_streams[i].max_framerate,
7585 video_streams[i].max_framerate);
7586
7587 EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
7588 EXPECT_EQ(expected_streams[i].min_bitrate_bps,
7589 video_streams[i].min_bitrate_bps);
7590
7591 EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
7592 EXPECT_EQ(expected_streams[i].target_bitrate_bps,
7593 video_streams[i].target_bitrate_bps);
7594
7595 EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
7596 EXPECT_EQ(expected_streams[i].max_bitrate_bps,
7597 video_streams[i].max_bitrate_bps);
7598
7599 EXPECT_GT(video_streams[i].max_qp, 0);
7600 EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
7601
Florent Castelli66b38602019-07-10 16:57:57 +02007602 EXPECT_EQ(num_configured_streams > 1 || conference_mode,
Sergey Silkina796a7e2018-03-01 15:11:29 +01007603 expected_streams[i].num_temporal_layers.has_value());
7604
7605 if (conference_mode) {
7606 EXPECT_EQ(expected_streams[i].num_temporal_layers,
7607 video_streams[i].num_temporal_layers);
7608 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00007609
7610 if (i == num_streams - 1) {
7611 total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
7612 } else {
7613 total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
7614 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007615 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00007616
Niels Möllerff40b142018-04-09 08:49:14 +02007617 EXPECT_TRUE(channel_->SetVideoSend(ssrcs.front(), nullptr, nullptr));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007618 }
7619
7620 FakeVideoSendStream* AddSendStream() {
7621 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
7622 }
7623
7624 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
Yves Gerey665174f2018-06-19 15:03:05 +02007625 size_t num_streams = fake_call_.GetVideoSendStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007626 EXPECT_TRUE(channel_->AddSendStream(sp));
7627 std::vector<FakeVideoSendStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02007628 fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007629 EXPECT_EQ(num_streams + 1, streams.size());
7630 return streams[streams.size() - 1];
7631 }
7632
7633 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02007634 return fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007635 }
7636
7637 FakeVideoReceiveStream* AddRecvStream() {
7638 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
7639 }
7640
7641 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
Yves Gerey665174f2018-06-19 15:03:05 +02007642 size_t num_streams = fake_call_.GetVideoReceiveStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007643 EXPECT_TRUE(channel_->AddRecvStream(sp));
7644 std::vector<FakeVideoReceiveStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02007645 fake_call_.GetVideoReceiveStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007646 EXPECT_EQ(num_streams + 1, streams.size());
7647 return streams[streams.size() - 1];
7648 }
7649
Danil Chapovalov83bbe912019-08-07 12:24:53 +02007650 webrtc::RtcEventLogNull event_log_;
Fredrik Solenberg709ed672015-09-15 12:26:33 +02007651 FakeCall fake_call_;
Magnus Jedvert02e7a192017-09-23 17:21:32 +02007652 cricket::FakeWebRtcVideoEncoderFactory* encoder_factory_;
7653 cricket::FakeWebRtcVideoDecoderFactory* decoder_factory_;
Jonas Orelanda3aa9bd2019-04-17 07:38:40 +02007654 std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory>
7655 mock_rate_allocator_factory_;
eladalonf1841382017-06-12 01:16:46 -07007656 WebRtcVideoEngine engine_;
kwiberg686a8ef2016-02-26 03:00:35 -08007657 std::unique_ptr<VideoMediaChannel> channel_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02007658 uint32_t last_ssrc_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007659};
7660
eladalonf1841382017-06-12 01:16:46 -07007661TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWith2SimulcastStreams) {
sprang429600d2017-01-26 06:12:26 -08007662 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2, false,
7663 true);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007664}
7665
eladalonf1841382017-06-12 01:16:46 -07007666TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWith3SimulcastStreams) {
sprang429600d2017-01-26 06:12:26 -08007667 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3, false,
7668 true);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007669}
7670
7671// Test that we normalize send codec format size in simulcast.
eladalonf1841382017-06-12 01:16:46 -07007672TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
sprang429600d2017-01-26 06:12:26 -08007673 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2, false,
7674 true);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00007675}
sprang429600d2017-01-26 06:12:26 -08007676
Ilya Nikolaevskiy3df1d5d2018-08-22 09:26:51 +02007677TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsForScreenshare) {
Florent Castelli66b38602019-07-10 16:57:57 +02007678 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3, true,
Ilya Nikolaevskiy3df1d5d2018-08-22 09:26:51 +02007679 false);
7680}
7681
eladalonf1841382017-06-12 01:16:46 -07007682TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsForSimulcastScreenshare) {
sprang429600d2017-01-26 06:12:26 -08007683 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 2, true,
7684 true);
7685}
7686
Florent Castelli66b38602019-07-10 16:57:57 +02007687TEST_F(WebRtcVideoChannelSimulcastTest, SimulcastScreenshareWithoutConference) {
7688 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3, true,
sprangfe627f32017-03-29 08:24:59 -07007689 false);
7690}
7691
Chen Xing90f3b892019-06-25 10:16:14 +02007692TEST_F(WebRtcVideoChannelBaseTest, GetSources) {
7693 EXPECT_THAT(channel_->GetSources(kSsrc), IsEmpty());
Jonas Oreland49ac5952018-09-26 16:04:32 +02007694
Chen Xing90f3b892019-06-25 10:16:14 +02007695 EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
Jonas Oreland49ac5952018-09-26 16:04:32 +02007696 EXPECT_TRUE(SetDefaultCodec());
7697 EXPECT_TRUE(SetSend(true));
Chen Xing90f3b892019-06-25 10:16:14 +02007698 EXPECT_EQ(renderer_.num_rendered_frames(), 0);
Jonas Oreland49ac5952018-09-26 16:04:32 +02007699
Chen Xing90f3b892019-06-25 10:16:14 +02007700 // Send and receive one frame.
7701 SendFrame();
7702 EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
Jonas Oreland49ac5952018-09-26 16:04:32 +02007703
Chen Xing90f3b892019-06-25 10:16:14 +02007704 EXPECT_THAT(channel_->GetSources(kSsrc - 1), IsEmpty());
7705 EXPECT_THAT(channel_->GetSources(kSsrc), SizeIs(1));
7706 EXPECT_THAT(channel_->GetSources(kSsrc + 1), IsEmpty());
Jonas Oreland49ac5952018-09-26 16:04:32 +02007707
Chen Xing90f3b892019-06-25 10:16:14 +02007708 webrtc::RtpSource source = channel_->GetSources(kSsrc)[0];
7709 EXPECT_EQ(source.source_id(), kSsrc);
7710 EXPECT_EQ(source.source_type(), webrtc::RtpSourceType::SSRC);
7711 int64_t rtp_timestamp_1 = source.rtp_timestamp();
7712 int64_t timestamp_ms_1 = source.timestamp_ms();
Jonas Oreland49ac5952018-09-26 16:04:32 +02007713
Chen Xing90f3b892019-06-25 10:16:14 +02007714 // Send and receive another frame.
7715 SendFrame();
7716 EXPECT_FRAME_WAIT(2, kVideoWidth, kVideoHeight, kTimeout);
Jonas Oreland49ac5952018-09-26 16:04:32 +02007717
Chen Xing90f3b892019-06-25 10:16:14 +02007718 EXPECT_THAT(channel_->GetSources(kSsrc - 1), IsEmpty());
7719 EXPECT_THAT(channel_->GetSources(kSsrc), SizeIs(1));
7720 EXPECT_THAT(channel_->GetSources(kSsrc + 1), IsEmpty());
Jonas Oreland49ac5952018-09-26 16:04:32 +02007721
Chen Xing90f3b892019-06-25 10:16:14 +02007722 source = channel_->GetSources(kSsrc)[0];
7723 EXPECT_EQ(source.source_id(), kSsrc);
7724 EXPECT_EQ(source.source_type(), webrtc::RtpSourceType::SSRC);
7725 int64_t rtp_timestamp_2 = source.rtp_timestamp();
7726 int64_t timestamp_ms_2 = source.timestamp_ms();
Jonas Oreland49ac5952018-09-26 16:04:32 +02007727
Chen Xing90f3b892019-06-25 10:16:14 +02007728 EXPECT_GT(rtp_timestamp_2, rtp_timestamp_1);
7729 EXPECT_GT(timestamp_ms_2, timestamp_ms_1);
Jonas Oreland49ac5952018-09-26 16:04:32 +02007730}
7731
Amit Hilbuchb000b712019-02-25 10:22:14 -08007732TEST_F(WebRtcVideoChannelTest, SetsRidsOnSendStream) {
7733 StreamParams sp = CreateSimStreamParams("cname", {123, 456, 789});
7734
7735 std::vector<std::string> rids = {"f", "h", "q"};
7736 std::vector<cricket::RidDescription> rid_descriptions;
7737 for (const auto& rid : rids) {
7738 rid_descriptions.emplace_back(rid, cricket::RidDirection::kSend);
7739 }
7740 sp.set_rids(rid_descriptions);
7741
7742 ASSERT_TRUE(channel_->AddSendStream(sp));
7743 const auto& streams = fake_call_->GetVideoSendStreams();
7744 ASSERT_EQ(1u, streams.size());
7745 auto stream = streams[0];
7746 ASSERT_NE(stream, nullptr);
7747 const auto& config = stream->GetConfig();
7748 EXPECT_THAT(config.rtp.rids, ::testing::ElementsAreArray(rids));
7749}
7750
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00007751} // namespace cricket