blob: fd416404511f53219debcfa9815723c930407e46 [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
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +000011#include <algorithm>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000012#include <map>
kwiberg686a8ef2016-02-26 03:00:35 -080013#include <memory>
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000014#include <vector>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000015
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +000016#include "webrtc/base/arraysize.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000017#include "webrtc/base/gunit.h"
18#include "webrtc/base/stringutils.h"
kjellandera96e2d72016-02-04 23:52:28 -080019#include "webrtc/media/base/testutils.h"
20#include "webrtc/media/base/videoengine_unittest.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010021#include "webrtc/media/engine/fakewebrtccall.h"
22#include "webrtc/media/engine/fakewebrtcvideoengine.h"
23#include "webrtc/media/engine/simulcast.h"
24#include "webrtc/media/engine/webrtcvideochannelfactory.h"
25#include "webrtc/media/engine/webrtcvideoengine2.h"
26#include "webrtc/media/engine/webrtcvoiceengine.h"
stefanc1aeaf02015-10-15 07:26:07 -070027#include "webrtc/test/field_trial.h"
pbos@webrtc.org42684be2014-10-03 11:25:45 +000028#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000029
isheriff6f8d6862016-05-26 11:24:55 -070030using webrtc::RtpExtension;
31
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000032namespace {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000033static const int kDefaultQpMax = 56;
34static const int kDefaultFramerate = 30;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000035
deadbeef67cf2c12016-04-13 10:07:16 -070036static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30);
37static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30);
38static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000039
deadbeef67cf2c12016-04-13 10:07:16 -070040static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30);
41static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30);
42static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000043
deadbeef67cf2c12016-04-13 10:07:16 -070044static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0);
45static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000046
noahricd10a68e2015-07-10 11:27:55 -070047static const uint8_t kRedRtxPayloadType = 125;
48
Peter Boström0c4e06b2015-10-07 12:23:21 +020049static const uint32_t kSsrcs1[] = {1};
50static const uint32_t kSsrcs3[] = {1, 2, 3};
51static const uint32_t kRtxSsrcs1[] = {4};
52static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
pbos@webrtc.org3c107582014-07-20 15:27:35 +000053static const char kUnsupportedExtensionName[] =
54 "urn:ietf:params:rtp-hdrext:unsupported";
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000055
56void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
57 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
58 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
59 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
60 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
61 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
62 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
63 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
stefan43edf0f2015-11-20 18:05:48 -080064 cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty)));
65 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000066 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
67}
68
nisse64ec8f82016-09-27 00:17:25 -070069static rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateBlackFrameBuffer(
70 int width,
71 int height) {
72 rtc::scoped_refptr<webrtc::I420Buffer> buffer =
73 webrtc::I420Buffer::Create(width, height);
74 buffer->SetToBlack();
75 return buffer;
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000076}
77
Shao Changbine62202f2015-04-21 20:24:50 +080078void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
79 const std::map<int, int>& rtx_types) {
80 std::map<int, int>::const_iterator it;
81 it = rtx_types.find(config.encoder_settings.payload_type);
82 EXPECT_TRUE(it != rtx_types.end() &&
83 it->second == config.rtp.rtx.payload_type);
84
brandtrb5f2c3f2016-10-04 23:28:39 -070085 if (config.rtp.ulpfec.red_rtx_payload_type != -1) {
86 it = rtx_types.find(config.rtp.ulpfec.red_payload_type);
Shao Changbine62202f2015-04-21 20:24:50 +080087 EXPECT_TRUE(it != rtx_types.end() &&
brandtrb5f2c3f2016-10-04 23:28:39 -070088 it->second == config.rtp.ulpfec.red_rtx_payload_type);
Shao Changbine62202f2015-04-21 20:24:50 +080089 }
90}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000091} // namespace
92
93namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000094class WebRtcVideoEngine2Test : public ::testing::Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000095 public:
stefanc1aeaf02015-10-15 07:26:07 -070096 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {}
97 explicit WebRtcVideoEngine2Test(const char* field_trials)
stefanc1aeaf02015-10-15 07:26:07 -070098 : override_field_trials_(field_trials),
99 call_(webrtc::Call::Create(webrtc::Call::Config())),
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200100 engine_() {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000101 std::vector<VideoCodec> engine_codecs = engine_.codecs();
henrikg91d6ede2015-09-17 00:24:34 -0700102 RTC_DCHECK(!engine_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000103 bool codec_set = false;
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000104 for (size_t i = 0; i < engine_codecs.size(); ++i) {
105 if (engine_codecs[i].name == "red") {
106 default_red_codec_ = engine_codecs[i];
107 } else if (engine_codecs[i].name == "ulpfec") {
108 default_ulpfec_codec_ = engine_codecs[i];
109 } else if (engine_codecs[i].name == "rtx") {
Shao Changbine62202f2015-04-21 20:24:50 +0800110 int associated_payload_type;
111 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
112 &associated_payload_type)) {
113 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id;
114 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000115 } else if (!codec_set) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000116 default_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000117 codec_set = true;
118 }
119 }
120
henrikg91d6ede2015-09-17 00:24:34 -0700121 RTC_DCHECK(codec_set);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000122 }
123
124 protected:
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000125 VideoMediaChannel* SetUpForExternalEncoderFactory(
126 cricket::WebRtcVideoEncoderFactory* encoder_factory,
127 const std::vector<VideoCodec>& codecs);
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000128
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000129 VideoMediaChannel* SetUpForExternalDecoderFactory(
130 cricket::WebRtcVideoDecoderFactory* decoder_factory,
131 const std::vector<VideoCodec>& codecs);
132
Peter Boströme4499152016-02-05 11:13:28 +0100133 void TestExtendedEncoderOveruse(bool use_external_encoder);
134
stefanc1aeaf02015-10-15 07:26:07 -0700135 webrtc::test::ScopedFieldTrials override_field_trials_;
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000136 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
137 // initialized when the constructor is called.
kwiberg686a8ef2016-02-26 03:00:35 -0800138 std::unique_ptr<webrtc::Call> call_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000139 WebRtcVideoEngine2 engine_;
140 VideoCodec default_codec_;
141 VideoCodec default_red_codec_;
142 VideoCodec default_ulpfec_codec_;
Shao Changbine62202f2015-04-21 20:24:50 +0800143 std::map<int, int> default_apt_rtx_types_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000144};
145
Peter Boström12996152016-05-14 02:03:18 +0200146TEST_F(WebRtcVideoEngine2Test, AnnouncesVp9AccordingToBuildFlags) {
147 bool claims_vp9_support = false;
148 for (const cricket::VideoCodec& codec : engine_.codecs()) {
149 if (codec.name == "VP9") {
150 claims_vp9_support = true;
151 break;
152 }
153 }
154#if defined(RTC_DISABLE_VP9)
155 EXPECT_FALSE(claims_vp9_support);
156#else
157 EXPECT_TRUE(claims_vp9_support);
158#endif // defined(RTC_DISABLE_VP9)
159}
160
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000161TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
162 std::vector<VideoCodec> engine_codecs = engine_.codecs();
163 for (size_t i = 0; i < engine_codecs.size(); ++i) {
164 if (engine_codecs[i].name != kRtxCodecName)
165 continue;
166 int associated_payload_type;
167 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000168 &associated_payload_type));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000169 EXPECT_EQ(default_codec_.id, associated_payload_type);
170 return;
171 }
172 FAIL() << "No RTX codec found among default codecs.";
173}
174
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000175TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100176 RtpCapabilities capabilities = engine_.GetCapabilities();
177 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700178 for (const RtpExtension& extension : capabilities.header_extensions) {
179 if (extension.uri == RtpExtension::kTimestampOffsetUri) {
180 EXPECT_EQ(RtpExtension::kTimestampOffsetDefaultId, extension.id);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000181 return;
182 }
183 }
184 FAIL() << "Timestamp offset extension not in header-extension list.";
185}
186
187TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100188 RtpCapabilities capabilities = engine_.GetCapabilities();
189 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700190 for (const RtpExtension& extension : capabilities.header_extensions) {
191 if (extension.uri == RtpExtension::kAbsSendTimeUri) {
192 EXPECT_EQ(RtpExtension::kAbsSendTimeDefaultId, extension.id);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000193 return;
194 }
195 }
196 FAIL() << "Absolute Sender Time extension not in header-extension list.";
197}
198
Stefan Holmer06a5e1a2016-09-02 12:36:49 +0200199TEST_F(WebRtcVideoEngine2Test, SupportsTransportSequenceNumberHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100200 RtpCapabilities capabilities = engine_.GetCapabilities();
201 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700202 for (const RtpExtension& extension : capabilities.header_extensions) {
203 if (extension.uri == RtpExtension::kTransportSequenceNumberUri) {
204 EXPECT_EQ(RtpExtension::kTransportSequenceNumberDefaultId, extension.id);
stefanc1aeaf02015-10-15 07:26:07 -0700205 return;
206 }
207 }
208 FAIL() << "Transport sequence number extension not in header-extension list.";
209}
210
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700211TEST_F(WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100212 RtpCapabilities capabilities = engine_.GetCapabilities();
213 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700214 for (const RtpExtension& extension : capabilities.header_extensions) {
215 if (extension.uri == RtpExtension::kVideoRotationUri) {
216 EXPECT_EQ(RtpExtension::kVideoRotationDefaultId, extension.id);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700217 return;
218 }
219 }
220 FAIL() << "Video Rotation extension not in header-extension list.";
221}
222
223TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
224 // Allocate the capturer first to prevent early destruction before channel's
225 // dtor is called.
226 cricket::FakeVideoCapturer capturer;
227
228 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
229 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200230 cricket::VideoSendParameters parameters;
231 parameters.codecs.push_back(kVp8Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700232
kwiberg686a8ef2016-02-26 03:00:35 -0800233 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200234 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700235 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
236
237 // Add CVO extension.
238 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200239 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700240 RtpExtension(RtpExtension::kVideoRotationUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200241 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700242
243 // Set capturer.
deadbeef5a4a75a2016-06-02 16:23:38 -0700244 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700245
246 // Verify capturer has turned off applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700247 EXPECT_FALSE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700248
249 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200250 parameters.extensions.clear();
251 EXPECT_TRUE(channel->SetSendParameters(parameters));
nisse47ac4622016-05-25 08:47:01 -0700252 EXPECT_TRUE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700253}
254
perkj91e1c152016-03-02 05:34:00 -0800255TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) {
256 // Allocate the capturer first to prevent early destruction before channel's
257 // dtor is called.
258 cricket::FakeVideoCapturer capturer;
259
260 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
261 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
262 cricket::VideoSendParameters parameters;
263 parameters.codecs.push_back(kVp8Codec);
264
265 std::unique_ptr<VideoMediaChannel> channel(
266 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
267 // Add CVO extension.
268 const int id = 1;
269 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700270 RtpExtension(RtpExtension::kVideoRotationUri, id));
perkj91e1c152016-03-02 05:34:00 -0800271 EXPECT_TRUE(channel->SetSendParameters(parameters));
272 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
273
274 // Set capturer.
deadbeef5a4a75a2016-06-02 16:23:38 -0700275 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
perkj91e1c152016-03-02 05:34:00 -0800276
277 // Verify capturer has turned off applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700278 EXPECT_FALSE(capturer.apply_rotation());
perkj91e1c152016-03-02 05:34:00 -0800279}
280
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700281TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
282 cricket::FakeVideoCapturer capturer;
283
284 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
285 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
perkjcaafdba2016-03-20 07:34:29 -0700286 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200287 cricket::VideoSendParameters parameters;
288 parameters.codecs.push_back(kVp8Codec);
perkjcaafdba2016-03-20 07:34:29 -0700289 parameters.codecs.push_back(kVp9Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700290
kwiberg686a8ef2016-02-26 03:00:35 -0800291 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200292 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700293 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
294
295 // Set capturer.
deadbeef5a4a75a2016-06-02 16:23:38 -0700296 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700297
perkjcaafdba2016-03-20 07:34:29 -0700298 // Verify capturer has turned on applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700299 EXPECT_TRUE(capturer.apply_rotation());
perkjcaafdba2016-03-20 07:34:29 -0700300
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700301 // Add CVO extension.
302 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200303 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700304 RtpExtension(RtpExtension::kVideoRotationUri, id));
perkjcaafdba2016-03-20 07:34:29 -0700305 // Also remove the first codec to trigger a codec change as well.
306 parameters.codecs.erase(parameters.codecs.begin());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200307 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700308
309 // Verify capturer has turned off applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700310 EXPECT_FALSE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700311
312 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200313 parameters.extensions.clear();
314 EXPECT_TRUE(channel->SetSendParameters(parameters));
nisse47ac4622016-05-25 08:47:01 -0700315 EXPECT_TRUE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700316}
317
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000318TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200319 engine_.Init();
kwiberg686a8ef2016-02-26 03:00:35 -0800320 std::unique_ptr<VideoMediaChannel> channel(
nisse51542be2016-02-12 02:27:06 -0800321 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000322
323 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
324
325 EXPECT_FALSE(channel->SetSend(true))
326 << "Channel should not start without codecs.";
327 EXPECT_TRUE(channel->SetSend(false))
328 << "Channel should be stoppable even without set codecs.";
329}
330
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000331TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200332 engine_.Init();
kwiberg686a8ef2016-02-26 03:00:35 -0800333 std::unique_ptr<VideoMediaChannel> channel(
nisse51542be2016-02-12 02:27:06 -0800334 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000335 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
336 VideoMediaInfo info;
337 channel->GetStats(&info);
338}
339
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000340TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
341 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
342 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200343 cricket::VideoSendParameters parameters;
344 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000345
kwiberg686a8ef2016-02-26 03:00:35 -0800346 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200347 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000348
349 EXPECT_TRUE(
350 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pbos14fe7082016-04-20 06:35:56 -0700351 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000352 ASSERT_EQ(1u, encoder_factory.encoders().size());
353 EXPECT_TRUE(channel->SetSend(true));
354
355 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -0700356 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000357 EXPECT_EQ(cricket::CS_RUNNING,
358 capturer.Start(capturer.GetSupportedFormats()->front()));
359 EXPECT_TRUE(capturer.CaptureFrame());
pbos14fe7082016-04-20 06:35:56 -0700360 // Sending one frame will have reallocated the encoder since input size
361 // changes from a small default to the actual frame width/height. Wait for
362 // that to happen then for the frame to be sent.
363 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000364 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
365 kTimeout);
366
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000367 int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
368 EXPECT_EQ(num_created_encoders, 2);
369
370 // Setting codecs of the same type should not reallocate any encoders
371 // (expecting a no-op).
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200372 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000373 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000374
375 // Remove stream previously added to free the external encoder instance.
376 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
377 EXPECT_EQ(0u, encoder_factory.encoders().size());
378}
379
Taylor Brandstetter6c3e7882016-06-29 11:14:19 -0700380// Test that when an external encoder factory supports a codec we don't
381// internally support, we still add an RTX codec for it.
382// TODO(deadbeef): Currently this test is only effective if WebRTC is
383// built with no internal H264 support. This test should be updated
384// if/when we start adding RTX codecs for unrecognized codec names.
385TEST_F(WebRtcVideoEngine2Test, RtxCodecAddedForExternalCodec) {
386 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
387 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
388 engine_.SetExternalEncoderFactory(&encoder_factory);
389 engine_.Init();
390
391 auto codecs = engine_.codecs();
392 // First figure out what payload type the test codec got assigned.
393 auto test_codec_it =
394 std::find_if(codecs.begin(), codecs.end(),
395 [](const VideoCodec& c) { return c.name == "H264"; });
396 ASSERT_NE(codecs.end(), test_codec_it);
397 // Now search for an RTX codec for it.
398 EXPECT_TRUE(std::any_of(codecs.begin(), codecs.end(),
399 [&test_codec_it](const VideoCodec& c) {
400 int associated_payload_type;
401 return c.name == "rtx" &&
402 c.GetParam(kCodecParamAssociatedPayloadType,
403 &associated_payload_type) &&
404 associated_payload_type == test_codec_it->id;
405 }));
406}
407
Peter Boströme4499152016-02-05 11:13:28 +0100408void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse(
409 bool use_external_encoder) {
410 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
411 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
412 cricket::VideoSendParameters parameters;
413 parameters.codecs.push_back(kVp8Codec);
kwiberg686a8ef2016-02-26 03:00:35 -0800414 std::unique_ptr<VideoMediaChannel> channel;
Peter Boströme4499152016-02-05 11:13:28 +0100415 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
416 call_.reset(fake_call);
417 if (use_external_encoder) {
418 channel.reset(
419 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
420 } else {
421 engine_.Init();
nisse51542be2016-02-12 02:27:06 -0800422 channel.reset(
423 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
Peter Boströme4499152016-02-05 11:13:28 +0100424 }
425 ASSERT_TRUE(
426 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
427 EXPECT_TRUE(channel->SetSendParameters(parameters));
428 EXPECT_TRUE(channel->SetSend(true));
429 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
430
431 EXPECT_EQ(use_external_encoder,
432 stream->GetConfig().encoder_settings.full_overuse_time);
433 // Remove stream previously added to free the external encoder instance.
434 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
435}
436
437TEST_F(WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders) {
438 TestExtendedEncoderOveruse(true);
439}
440
441TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) {
442 TestExtendedEncoderOveruse(false);
443}
444
Peter Boström12996152016-05-14 02:03:18 +0200445#if !defined(RTC_DISABLE_VP9)
Peter Boström53eda3d2015-03-27 15:53:18 +0100446TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
447 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
448 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
449 std::vector<cricket::VideoCodec> codecs;
450 codecs.push_back(kVp9Codec);
451
kwiberg686a8ef2016-02-26 03:00:35 -0800452 std::unique_ptr<VideoMediaChannel> channel(
Peter Boström53eda3d2015-03-27 15:53:18 +0100453 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
454
455 EXPECT_TRUE(
456 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
457}
Peter Boström12996152016-05-14 02:03:18 +0200458#endif // !defined(RTC_DISABLE_VP9)
Peter Boström53eda3d2015-03-27 15:53:18 +0100459
qiangchenc27d89f2015-07-16 10:27:16 -0700460TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
461 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
462 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
463 std::vector<cricket::VideoCodec> codecs;
464 codecs.push_back(kVp8Codec);
465
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200466 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
467 call_.reset(fake_call);
kwiberg686a8ef2016-02-26 03:00:35 -0800468 std::unique_ptr<VideoMediaChannel> channel(
qiangchenc27d89f2015-07-16 10:27:16 -0700469 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
470
471 EXPECT_TRUE(
472 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
473
474 FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -0700475 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
qiangchenc27d89f2015-07-16 10:27:16 -0700476 capturer.Start(cricket::VideoFormat(1280, 720,
477 cricket::VideoFormat::FpsToInterval(60),
478 cricket::FOURCC_I420));
479 channel->SetSend(true);
480
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200481 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
qiangchenc27d89f2015-07-16 10:27:16 -0700482
483 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700484 int64_t last_timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700485 for (int i = 0; i < 10; i++) {
486 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700487 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700488 int64_t interval = timestamp - last_timestamp;
489
490 // Precision changes from nanosecond to millisecond.
491 // Allow error to be no more than 1.
492 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(60) / 1E6, interval, 1);
493
494 last_timestamp = timestamp;
495 }
496
497 capturer.Start(cricket::VideoFormat(1280, 720,
498 cricket::VideoFormat::FpsToInterval(30),
499 cricket::FOURCC_I420));
500
501 EXPECT_TRUE(capturer.CaptureFrame());
502 last_timestamp = stream->GetLastTimestamp();
503 for (int i = 0; i < 10; i++) {
504 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700505 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700506 int64_t interval = timestamp - last_timestamp;
507
508 // Precision changes from nanosecond to millisecond.
509 // Allow error to be no more than 1.
510 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1);
511
512 last_timestamp = timestamp;
513 }
514
515 // Remove stream previously added to free the external encoder instance.
516 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
517}
518
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000519VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
520 cricket::WebRtcVideoEncoderFactory* encoder_factory,
521 const std::vector<VideoCodec>& codecs) {
522 engine_.SetExternalEncoderFactory(encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200523 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000524
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000525 VideoMediaChannel* channel =
nisse51542be2016-02-12 02:27:06 -0800526 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200527 cricket::VideoSendParameters parameters;
528 parameters.codecs = codecs;
529 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000530
531 return channel;
532}
533
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000534VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
535 cricket::WebRtcVideoDecoderFactory* decoder_factory,
536 const std::vector<VideoCodec>& codecs) {
537 engine_.SetExternalDecoderFactory(decoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200538 engine_.Init();
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000539
540 VideoMediaChannel* channel =
nisse51542be2016-02-12 02:27:06 -0800541 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200542 cricket::VideoRecvParameters parameters;
543 parameters.codecs = codecs;
544 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000545
546 return channel;
547}
548
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000549TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
550 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
551 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
552 std::vector<cricket::VideoCodec> codecs;
553 codecs.push_back(kVp8Codec);
554
kwiberg686a8ef2016-02-26 03:00:35 -0800555 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000556 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
557
Peter Boström0c4e06b2015-10-07 12:23:21 +0200558 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000559
560 EXPECT_TRUE(
561 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
562 EXPECT_TRUE(channel->SetSend(true));
563
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000564 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -0700565 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer));
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000566 EXPECT_EQ(cricket::CS_RUNNING,
567 capturer.Start(capturer.GetSupportedFormats()->front()));
568 EXPECT_TRUE(capturer.CaptureFrame());
569
pbos14fe7082016-04-20 06:35:56 -0700570 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000571
572 // Verify that encoders are configured for simulcast through adapter
573 // (increasing resolution and only configured to send one stream each).
574 int prev_width = -1;
575 for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
pbos14fe7082016-04-20 06:35:56 -0700576 ASSERT_TRUE(encoder_factory.encoders()[i]->WaitForInitEncode());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000577 webrtc::VideoCodec codec_settings =
578 encoder_factory.encoders()[i]->GetCodecSettings();
579 EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
580 EXPECT_GT(codec_settings.width, prev_width);
581 prev_width = codec_settings.width;
582 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000583
deadbeef5a4a75a2016-06-02 16:23:38 -0700584 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, nullptr));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000585
586 channel.reset();
587 ASSERT_EQ(0u, encoder_factory.encoders().size());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000588}
589
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000590TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
591 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
592 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
593 std::vector<cricket::VideoCodec> codecs;
594 codecs.push_back(kH264Codec);
595
kwiberg686a8ef2016-02-26 03:00:35 -0800596 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000597 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
598
599 EXPECT_TRUE(
600 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
601 ASSERT_EQ(1u, encoder_factory.encoders().size());
602
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200603 cricket::VideoSendParameters parameters;
604 parameters.codecs.push_back(kVp8Codec);
605 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000606 ASSERT_EQ(0u, encoder_factory.encoders().size());
607}
608
609TEST_F(WebRtcVideoEngine2Test,
610 DontUseExternalEncoderFactoryForUnsupportedCodecs) {
611 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
612 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
613 std::vector<cricket::VideoCodec> codecs;
614 codecs.push_back(kVp8Codec);
615
kwiberg686a8ef2016-02-26 03:00:35 -0800616 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000617 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
618
619 EXPECT_TRUE(
620 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000621 // Make sure DestroyVideoEncoder was called on the factory.
622 ASSERT_EQ(0u, encoder_factory.encoders().size());
623}
624
625TEST_F(WebRtcVideoEngine2Test,
626 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
627 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
628 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
629 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
630
631 std::vector<cricket::VideoCodec> codecs;
632 codecs.push_back(kVp8Codec);
633
kwiberg686a8ef2016-02-26 03:00:35 -0800634 std::unique_ptr<VideoMediaChannel> channel(
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000635 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
636
Peter Boström0c4e06b2015-10-07 12:23:21 +0200637 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000638
639 EXPECT_TRUE(
640 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
641 EXPECT_TRUE(channel->SetSend(true));
642
643 // Send a fake frame, or else the media engine will configure the simulcast
644 // encoder adapter at a low-enough size that it'll only create a single
645 // encoder layer.
646 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -0700647 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000648 EXPECT_EQ(cricket::CS_RUNNING,
649 capturer.Start(capturer.GetSupportedFormats()->front()));
650 EXPECT_TRUE(capturer.CaptureFrame());
651
pbos14fe7082016-04-20 06:35:56 -0700652 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
653 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000654 EXPECT_EQ(webrtc::kVideoCodecVP8,
655 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
656
657 channel.reset();
658 // Make sure DestroyVideoEncoder was called on the factory.
659 EXPECT_EQ(0u, encoder_factory.encoders().size());
660}
661
662TEST_F(WebRtcVideoEngine2Test,
663 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
664 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
665 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
666 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
667
668 std::vector<cricket::VideoCodec> codecs;
669 codecs.push_back(kH264Codec);
670
kwiberg686a8ef2016-02-26 03:00:35 -0800671 std::unique_ptr<VideoMediaChannel> channel(
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000672 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
673
674 EXPECT_TRUE(
675 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
676 ASSERT_EQ(1u, encoder_factory.encoders().size());
pbos14fe7082016-04-20 06:35:56 -0700677 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000678 EXPECT_EQ(webrtc::kVideoCodecH264,
679 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
680
681 channel.reset();
682 // Make sure DestroyVideoEncoder was called on the factory.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000683 ASSERT_EQ(0u, encoder_factory.encoders().size());
684}
685
noahricfdac5162015-08-27 01:59:29 -0700686TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) {
687 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
688 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
689 std::vector<cricket::VideoCodec> codecs;
690 codecs.push_back(kH264Codec);
691
kwiberg686a8ef2016-02-26 03:00:35 -0800692 std::unique_ptr<VideoMediaChannel> channel(
noahricfdac5162015-08-27 01:59:29 -0700693 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
694
Peter Boström0c4e06b2015-10-07 12:23:21 +0200695 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
noahricfdac5162015-08-27 01:59:29 -0700696 EXPECT_TRUE(
697 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
Peter Boströmce23bee2016-02-02 14:14:30 +0100698
699 // Send a frame of 720p. This should trigger a "real" encoder initialization.
noahricfdac5162015-08-27 01:59:29 -0700700 cricket::VideoFormat format(
701 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
Peter Boströmce23bee2016-02-02 14:14:30 +0100702 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -0700703 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, &capturer));
Peter Boströmce23bee2016-02-02 14:14:30 +0100704 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
705 EXPECT_TRUE(capturer.CaptureFrame());
706
noahricfdac5162015-08-27 01:59:29 -0700707 ASSERT_EQ(1u, encoder_factory.encoders().size());
708 FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0];
pbos14fe7082016-04-20 06:35:56 -0700709 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
noahricfdac5162015-08-27 01:59:29 -0700710 EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
711 EXPECT_EQ(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
deadbeef5a4a75a2016-06-02 16:23:38 -0700712 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, nullptr));
noahricfdac5162015-08-27 01:59:29 -0700713}
714
hbosbab934b2016-01-27 01:36:03 -0800715// Test that external codecs are added to the end of the supported codec list.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000716TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) {
717 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
hbosbab934b2016-01-27 01:36:03 -0800718 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecUnknown,
719 "FakeExternalCodec");
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000720 engine_.SetExternalEncoderFactory(&encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200721 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000722
723 std::vector<cricket::VideoCodec> codecs(engine_.codecs());
724 ASSERT_GE(codecs.size(), 2u);
725 cricket::VideoCodec internal_codec = codecs.front();
726 cricket::VideoCodec external_codec = codecs.back();
727
728 // The external codec will appear at last.
729 EXPECT_EQ("VP8", internal_codec.name);
hbosbab934b2016-01-27 01:36:03 -0800730 EXPECT_EQ("FakeExternalCodec", external_codec.name);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000731}
732
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000733TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
734 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
735 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200736 cricket::VideoRecvParameters parameters;
737 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000738
kwiberg686a8ef2016-02-26 03:00:35 -0800739 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200740 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000741
742 EXPECT_TRUE(
743 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
744 ASSERT_EQ(1u, decoder_factory.decoders().size());
745
746 // Setting codecs of the same type should not reallocate the decoder.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200747 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000748 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
749
750 // Remove stream previously added to free the external decoder instance.
751 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
752 EXPECT_EQ(0u, decoder_factory.decoders().size());
753}
754
755// Verifies that we can set up decoders that are not internally supported.
756TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
757 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
758 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
759 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
760 // codecs.
761 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
762 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
763 engine_.SetExternalEncoderFactory(&encoder_factory);
764 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
765 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
766 std::vector<cricket::VideoCodec> codecs;
767 codecs.push_back(kH264Codec);
768
kwiberg686a8ef2016-02-26 03:00:35 -0800769 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000770 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
771
772 EXPECT_TRUE(
773 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
774 ASSERT_EQ(1u, decoder_factory.decoders().size());
775}
776
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000777class WebRtcVideoChannel2BaseTest
778 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
779 protected:
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000780 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000781
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000782 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000783};
784
sakal1fd95952016-06-22 00:46:15 -0700785// Verifies that id given in stream params is passed to the decoder factory.
786TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) {
787 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
788 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
789 cricket::VideoRecvParameters parameters;
790 parameters.codecs.push_back(kVp8Codec);
791
792 std::unique_ptr<VideoMediaChannel> channel(
793 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
794
795 StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc);
796 sp.id = "FakeStreamParamsId";
797 EXPECT_TRUE(channel->AddRecvStream(sp));
798 EXPECT_EQ(1u, decoder_factory.decoders().size());
799
800 std::vector<cricket::VideoDecoderParams> params = decoder_factory.params();
801 ASSERT_EQ(1u, params.size());
802 EXPECT_EQ(sp.id, params[0].receive_stream_id);
803}
804
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000805#define WEBRTC_BASE_TEST(test) \
806 TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); }
807
808#define WEBRTC_DISABLED_BASE_TEST(test) \
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000809 TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); }
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000810
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000811WEBRTC_BASE_TEST(SetSend);
812WEBRTC_BASE_TEST(SetSendWithoutCodecs);
813WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000814
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000815WEBRTC_BASE_TEST(GetStats);
816WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams);
817WEBRTC_BASE_TEST(GetStatsMultipleSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000818
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000819WEBRTC_BASE_TEST(SetSendBandwidth);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000820
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000821WEBRTC_BASE_TEST(SetSendSsrc);
822WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000823
nisse08582ff2016-02-04 01:24:52 -0800824WEBRTC_BASE_TEST(SetSink);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000825
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000826WEBRTC_BASE_TEST(AddRemoveSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000827
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000828WEBRTC_BASE_TEST(SimulateConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000829
Alejandro Luebs947c02d2016-06-15 15:39:46 -0700830WEBRTC_DISABLED_BASE_TEST(AddRemoveCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000831
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000832WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000833
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000834WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000835
836// TODO(pbos): Figure out why this fails so often.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000837WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000838
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000839WEBRTC_BASE_TEST(RejectEmptyStreamParams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000840
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000841WEBRTC_BASE_TEST(AdaptResolution16x10);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000842
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000843WEBRTC_BASE_TEST(AdaptResolution4x3);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000844
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000845// TODO(juberti): Restore this test once we support sending 0 fps.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000846WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000847// TODO(juberti): Understand why we get decode errors on this test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000848WEBRTC_DISABLED_BASE_TEST(AdaptFramerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000849
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +0000850WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames);
851
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +0000852WEBRTC_BASE_TEST(MultipleSendStreams);
853
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000854TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
deadbeef67cf2c12016-04-13 10:07:16 -0700855 SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000856}
857
858TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
deadbeef67cf2c12016-04-13 10:07:16 -0700859 SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000860}
861
862TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
deadbeef67cf2c12016-04-13 10:07:16 -0700863 SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000864}
865
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000866TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
Peter Boströmd1f584b2016-04-20 16:31:53 +0200867 // Set a high bitrate to not be downscaled by VP8 due to low initial start
868 // bitrates. This currently happens at <250k, and two streams sharing 300k
869 // initially will use QVGA instead of VGA.
870 // TODO(pbos): Set up the quality scaler so that both senders reliably start
871 // at QVGA, then verify that instead.
872 cricket::VideoCodec codec = kVp8Codec;
873 codec.params[kCodecParamStartBitrate] = "1000000";
874 Base::TwoStreamsSendAndReceive(codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000875}
876
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200877class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000878 public:
stefanc1aeaf02015-10-15 07:26:07 -0700879 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {}
880 explicit WebRtcVideoChannel2Test(const char* field_trials)
881 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000882 void SetUp() override {
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200883 fake_call_.reset(new FakeCall(webrtc::Call::Config()));
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200884 engine_.Init();
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200885 channel_.reset(
nisse51542be2016-02-12 02:27:06 -0800886 engine_.CreateChannel(fake_call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000887 last_ssrc_ = 123;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200888 send_parameters_.codecs = engine_.codecs();
889 recv_parameters_.codecs = engine_.codecs();
890 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000891 }
892
893 protected:
894 FakeVideoSendStream* AddSendStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000895 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000896 }
897
898 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000899 size_t num_streams = fake_call_->GetVideoSendStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000900 EXPECT_TRUE(channel_->AddSendStream(sp));
901 std::vector<FakeVideoSendStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000902 fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000903 EXPECT_EQ(num_streams + 1, streams.size());
904 return streams[streams.size() - 1];
905 }
906
907 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000908 return fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000909 }
910
911 FakeVideoReceiveStream* AddRecvStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000912 return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000913 }
914
915 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000916 size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000917 EXPECT_TRUE(channel_->AddRecvStream(sp));
918 std::vector<FakeVideoReceiveStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000919 fake_call_->GetVideoReceiveStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000920 EXPECT_EQ(num_streams + 1, streams.size());
921 return streams[streams.size() - 1];
922 }
923
pbos@webrtc.org00873182014-11-25 14:03:34 +0000924 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
925 int expected_min_bitrate_bps,
926 const char* start_bitrate_kbps,
927 int expected_start_bitrate_bps,
928 const char* max_bitrate_kbps,
929 int expected_max_bitrate_bps) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200930 auto& codecs = send_parameters_.codecs;
931 codecs.clear();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000932 codecs.push_back(kVp8Codec);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000933 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
934 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
935 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200936 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000937
pbos@webrtc.org00873182014-11-25 14:03:34 +0000938 EXPECT_EQ(expected_min_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100939 fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000940 EXPECT_EQ(expected_start_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100941 fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000942 EXPECT_EQ(expected_max_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100943 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000944 }
945
isheriff6f8d6862016-05-26 11:24:55 -0700946 void TestSetSendRtpHeaderExtensions(const std::string& ext_uri) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000947 // Enable extension.
948 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200949 cricket::VideoSendParameters parameters = send_parameters_;
isheriff6f8d6862016-05-26 11:24:55 -0700950 parameters.extensions.push_back(RtpExtension(ext_uri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200951 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000952 FakeVideoSendStream* send_stream =
953 AddSendStream(cricket::StreamParams::CreateLegacy(123));
954
955 // Verify the send extension id.
956 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
957 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -0700958 EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000959 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200960 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000961 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
962 // receivers.
963 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
964 ->GetConfig()
965 .rtp.extensions.empty());
966
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000967 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200968 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200969 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
970 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000971 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
972
973 // Verify that adding receive RTP header extensions adds them for existing
974 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200975 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200976 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000977 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
978 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -0700979 EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000980 }
981
isheriff6f8d6862016-05-26 11:24:55 -0700982 void TestSetRecvRtpHeaderExtensions(const std::string& ext_uri) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000983 // Enable extension.
984 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200985 cricket::VideoRecvParameters parameters = recv_parameters_;
isheriff6f8d6862016-05-26 11:24:55 -0700986 parameters.extensions.push_back(RtpExtension(ext_uri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200987 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000988
989 FakeVideoReceiveStream* recv_stream =
990 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
991
992 // Verify the recv extension id.
993 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
994 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -0700995 EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000996 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200997 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000998
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000999 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
1000 // senders.
1001 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
1002 ->GetConfig()
1003 .rtp.extensions.empty());
1004
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001005 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001006 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001007 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
1008 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001009 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
1010
1011 // Verify that adding receive RTP header extensions adds them for existing
1012 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001013 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001014 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001015 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1016 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07001017 EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001018 }
1019
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001020 void TestExtensionFilter(const std::vector<std::string>& extensions,
1021 const std::string& expected_extension) {
1022 cricket::VideoSendParameters parameters = send_parameters_;
1023 int expected_id = -1;
1024 int id = 1;
1025 for (const std::string& extension : extensions) {
1026 if (extension == expected_extension)
1027 expected_id = id;
isheriff6f8d6862016-05-26 11:24:55 -07001028 parameters.extensions.push_back(RtpExtension(extension, id++));
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001029 }
1030 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1031 FakeVideoSendStream* send_stream =
1032 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1033
1034 // Verify that only one of them has been set, and that it is the one with
1035 // highest priority (transport sequence number).
1036 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1037 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
1038 EXPECT_EQ(expected_extension,
isheriff6f8d6862016-05-26 11:24:55 -07001039 send_stream->GetConfig().rtp.extensions[0].uri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001040 }
1041
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001042 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
Peter Boström3548dd22015-05-22 18:48:36 +02001043 void TestReceiverLocalSsrcConfiguration(bool receiver_first);
noahricd10a68e2015-07-10 11:27:55 -07001044 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
1045 bool expect_created_receive_stream);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001046
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001047 FakeVideoSendStream* SetDenoisingOption(
nisse05103312016-03-16 02:22:50 -07001048 uint32_t ssrc,
nisse0db023a2016-03-01 04:29:59 -08001049 cricket::FakeVideoCapturer* capturer,
1050 bool enabled) {
nisse05103312016-03-16 02:22:50 -07001051 cricket::VideoOptions options;
1052 options.video_noise_reduction = rtc::Optional<bool>(enabled);
deadbeef5a4a75a2016-06-02 16:23:38 -07001053 EXPECT_TRUE(channel_->SetVideoSend(ssrc, true, &options, capturer));
nisse0db023a2016-03-01 04:29:59 -08001054 // Options only take effect on the next frame.
1055 EXPECT_TRUE(capturer->CaptureFrame());
1056
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001057 return fake_call_->GetVideoSendStreams().back();
1058 }
1059
Peter Boström2feafdb2015-09-09 14:32:14 +02001060 FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
1061 const int kRtxSsrcOffset = 0xDEADBEEF;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001062 last_ssrc_ += 3;
Peter Boström2feafdb2015-09-09 14:32:14 +02001063 std::vector<uint32_t> ssrcs;
1064 std::vector<uint32_t> rtx_ssrcs;
1065 uint32_t num_streams = enabled ? 3 : 1;
1066 for (uint32_t i = 0; i < num_streams; ++i) {
1067 uint32_t ssrc = last_ssrc_ + i;
1068 ssrcs.push_back(ssrc);
1069 if (with_rtx) {
1070 rtx_ssrcs.push_back(ssrc + kRtxSsrcOffset);
1071 }
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001072 }
Peter Boström2feafdb2015-09-09 14:32:14 +02001073 if (with_rtx) {
1074 return AddSendStream(
1075 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1076 }
1077 return AddSendStream(CreateSimStreamParams("cname", ssrcs));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001078 }
1079
perkjfa10b552016-10-02 23:45:26 -07001080 int GetMaxEncoderBitrate() {
skvladdc1c62c2016-03-16 19:07:43 -07001081 std::vector<FakeVideoSendStream*> streams =
1082 fake_call_->GetVideoSendStreams();
perkjfa10b552016-10-02 23:45:26 -07001083 EXPECT_EQ(1u, streams.size());
skvladdc1c62c2016-03-16 19:07:43 -07001084 FakeVideoSendStream* stream = streams[streams.size() - 1];
perkjfa10b552016-10-02 23:45:26 -07001085 EXPECT_EQ(1, stream->GetEncoderConfig().number_of_streams);
1086 return stream->GetVideoStreams()[0].max_bitrate_bps;
skvladdc1c62c2016-03-16 19:07:43 -07001087 }
1088
perkjfa10b552016-10-02 23:45:26 -07001089 void SetAndExpectMaxBitrate(int global_max,
skvladdc1c62c2016-03-16 19:07:43 -07001090 int stream_max,
1091 int expected_encoder_bitrate) {
1092 VideoSendParameters limited_send_params = send_parameters_;
1093 limited_send_params.max_bandwidth_bps = global_max;
1094 EXPECT_TRUE(channel_->SetSendParameters(limited_send_params));
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001095 webrtc::RtpParameters parameters =
1096 channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07001097 EXPECT_EQ(1UL, parameters.encodings.size());
1098 parameters.encodings[0].max_bitrate_bps = stream_max;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001099 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07001100 // Read back the parameteres and verify they have the correct value
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001101 parameters = channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07001102 EXPECT_EQ(1UL, parameters.encodings.size());
1103 EXPECT_EQ(stream_max, parameters.encodings[0].max_bitrate_bps);
1104 // Verify that the new value propagated down to the encoder
perkjfa10b552016-10-02 23:45:26 -07001105 EXPECT_EQ(expected_encoder_bitrate, GetMaxEncoderBitrate());
skvladdc1c62c2016-03-16 19:07:43 -07001106 }
1107
kwiberg686a8ef2016-02-26 03:00:35 -08001108 std::unique_ptr<FakeCall> fake_call_;
1109 std::unique_ptr<VideoMediaChannel> channel_;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001110 cricket::VideoSendParameters send_parameters_;
1111 cricket::VideoRecvParameters recv_parameters_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001112 uint32_t last_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001113};
1114
pbos8fc7fa72015-07-15 08:02:58 -07001115TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001116 const uint32_t kVideoSsrc = 123;
pbos8fc7fa72015-07-15 08:02:58 -07001117 const std::string kSyncLabel = "AvSyncLabel";
1118
1119 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
1120 sp.sync_label = kSyncLabel;
1121 EXPECT_TRUE(channel_->AddRecvStream(sp));
1122
1123 EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size());
1124 EXPECT_EQ(kSyncLabel,
1125 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
1126 << "SyncGroup should be set based on sync_label";
1127}
1128
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001129TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001130 cricket::VideoSendParameters parameters;
1131 parameters.codecs = engine_.codecs();
1132 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001133 EXPECT_TRUE(channel_->SetSend(true));
nisse4b4dc862016-02-17 05:25:36 -08001134 parameters.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001135 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001136
1137 // Send side.
Peter Boström0c4e06b2015-10-07 12:23:21 +02001138 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
1139 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001140 FakeVideoSendStream* send_stream = AddSendStream(
1141 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1142
1143 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
1144 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
1145 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
1146
1147 // Receiver side.
1148 FakeVideoReceiveStream* recv_stream = AddRecvStream(
1149 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
Peter Boströmd8b01092016-05-12 16:44:36 +02001150 EXPECT_FALSE(recv_stream->GetConfig().rtp.rtx.empty());
1151 EXPECT_EQ(recv_stream->GetConfig().decoders.size(),
1152 recv_stream->GetConfig().rtp.rtx.size())
1153 << "RTX should be mapped for all decoders/payload types.";
1154 for (const auto& kv : recv_stream->GetConfig().rtp.rtx) {
1155 EXPECT_EQ(rtx_ssrcs[0], kv.second.ssrc);
1156 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001157}
1158
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001159TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
1160 // Setup one channel with an associated RTX stream.
1161 cricket::StreamParams params =
1162 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1163 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
1164 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001165 EXPECT_EQ(kRtxSsrcs1[0],
1166 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001167}
1168
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001169TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
1170 // Setup one channel without an associated RTX stream.
1171 cricket::StreamParams params =
1172 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1173 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1174 ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001175}
1176
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001177TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
1178 FakeVideoSendStream* send_stream =
1179 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1180 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1181
1182 FakeVideoReceiveStream* recv_stream =
1183 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1184 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001185}
1186
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001187// Test support for RTP timestamp offset header extension.
1188TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001189 TestSetSendRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001190}
isheriff6f8d6862016-05-26 11:24:55 -07001191
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001192TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001193 TestSetRecvRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001194}
1195
1196// Test support for absolute send time header extension.
1197TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001198 TestSetSendRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001199}
isheriff6f8d6862016-05-26 11:24:55 -07001200
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001201TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001202 TestSetRecvRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001203}
1204
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001205TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksTransportSeqNum) {
1206 // Enable three redundant extensions.
1207 std::vector<std::string> extensions;
isheriff6f8d6862016-05-26 11:24:55 -07001208 extensions.push_back(RtpExtension::kAbsSendTimeUri);
1209 extensions.push_back(RtpExtension::kTimestampOffsetUri);
1210 extensions.push_back(RtpExtension::kTransportSequenceNumberUri);
1211 TestExtensionFilter(extensions, RtpExtension::kTransportSequenceNumberUri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001212}
1213
1214TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksAbsSendTime) {
1215 // Enable two redundant extensions.
1216 std::vector<std::string> extensions;
isheriff6f8d6862016-05-26 11:24:55 -07001217 extensions.push_back(RtpExtension::kAbsSendTimeUri);
1218 extensions.push_back(RtpExtension::kTimestampOffsetUri);
1219 TestExtensionFilter(extensions, RtpExtension::kAbsSendTimeUri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001220}
1221
stefanc1aeaf02015-10-15 07:26:07 -07001222// Test support for transport sequence number header extension.
Stefan Holmer06a5e1a2016-09-02 12:36:49 +02001223TEST_F(WebRtcVideoChannel2Test, SendTransportSequenceNumberHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001224 TestSetSendRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
stefanc1aeaf02015-10-15 07:26:07 -07001225}
Stefan Holmer06a5e1a2016-09-02 12:36:49 +02001226TEST_F(WebRtcVideoChannel2Test, RecvTransportSequenceNumberHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001227 TestSetRecvRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
stefanc1aeaf02015-10-15 07:26:07 -07001228}
1229
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001230// Test support for video rotation header extension.
1231TEST_F(WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001232 TestSetSendRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001233}
1234TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001235 TestSetRecvRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001236}
1237
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001238TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001239 const int kAbsSendTimeId = 1;
1240 const int kVideoRotationId = 2;
isheriff6f8d6862016-05-26 11:24:55 -07001241 send_parameters_.extensions.push_back(
1242 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
1243 send_parameters_.extensions.push_back(
1244 RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001245
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001246 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001247 FakeVideoSendStream* send_stream =
1248 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1249
1250 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001251 ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001252
1253 // Setting the same extensions (even if in different order) shouldn't
1254 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001255 std::reverse(send_parameters_.extensions.begin(),
1256 send_parameters_.extensions.end());
1257 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001258
1259 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1260
1261 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001262 send_parameters_.extensions.resize(1);
1263 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001264
1265 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
1266}
1267
1268TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
1269 const int kTOffsetId = 1;
1270 const int kAbsSendTimeId = 2;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001271 const int kVideoRotationId = 3;
isheriff6f8d6862016-05-26 11:24:55 -07001272 recv_parameters_.extensions.push_back(
1273 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
1274 recv_parameters_.extensions.push_back(
1275 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
1276 recv_parameters_.extensions.push_back(
1277 RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001278
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001279 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Peter Boström54be3e02015-05-25 15:04:24 +02001280 FakeVideoReceiveStream* recv_stream =
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001281 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1282
1283 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
Peter Boström54be3e02015-05-25 15:04:24 +02001284 ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001285
1286 // Setting the same extensions (even if in different order) shouldn't
1287 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001288 std::reverse(recv_parameters_.extensions.begin(),
1289 recv_parameters_.extensions.end());
1290 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001291
1292 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
1293
1294 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001295 recv_parameters_.extensions.resize(1);
1296 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001297
1298 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
1299}
1300
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001301TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001302 SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001303 const int kUnsupportedId = 1;
1304 const int kTOffsetId = 2;
1305
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001306 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001307 RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001308 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001309 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001310 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001311 FakeVideoSendStream* send_stream =
1312 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1313
1314 // Only timestamp offset extension is set to send stream,
1315 // unsupported rtp extension is ignored.
1316 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -07001317 EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
1318 send_stream->GetConfig().rtp.extensions[0].uri.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001319}
1320
1321TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001322 SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001323 const int kUnsupportedId = 1;
1324 const int kTOffsetId = 2;
1325
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001326 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001327 RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001328 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001329 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001330 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001331 FakeVideoReceiveStream* recv_stream =
1332 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1333
1334 // Only timestamp offset extension is set to receive stream,
1335 // unsupported rtp extension is ignored.
1336 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -07001337 EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
1338 recv_stream->GetConfig().rtp.extensions[0].uri.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001339}
1340
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001341TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001342 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001343 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
isheriff6f8d6862016-05-26 11:24:55 -07001344 send_parameters_.extensions.push_back(
1345 RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001346 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001347 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1348 }
1349}
1350
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001351TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001352 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001353 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
isheriff6f8d6862016-05-26 11:24:55 -07001354 recv_parameters_.extensions.push_back(
1355 RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001356 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001357 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1358 }
1359}
1360
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001361TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001362 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001363 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001364 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001365 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001366 RtpExtension(RtpExtension::kAbsSendTimeUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001367 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001368
1369 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001370 send_parameters_.extensions.clear();
1371 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001372 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001373 send_parameters_.extensions.push_back(send_parameters_.extensions.back());
1374 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001375}
1376
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001377TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001378 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001379 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001380 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001381 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001382 RtpExtension(RtpExtension::kAbsSendTimeUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001383 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001384
1385 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001386 recv_parameters_.extensions.clear();
1387 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001388 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001389 recv_parameters_.extensions.push_back(recv_parameters_.extensions.back());
1390 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001391}
1392
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001393TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
1394 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001395 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001396}
1397
Peter Boströmd7da1202015-06-05 14:09:38 +02001398TEST_F(WebRtcVideoChannel2Test, RtcpIsCompoundByDefault) {
1399 FakeVideoReceiveStream* stream = AddRecvStream();
pbosda903ea2015-10-02 02:36:56 -07001400 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
Peter Boströmd7da1202015-06-05 14:09:38 +02001401}
1402
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001403TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
1404 FakeVideoReceiveStream* stream = AddRecvStream();
1405 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001406}
1407
stefan43edf0f2015-11-20 18:05:48 -08001408TEST_F(WebRtcVideoChannel2Test, TransportCcIsEnabledByDefault) {
1409 FakeVideoReceiveStream* stream = AddRecvStream();
1410 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1411}
1412
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001413TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1414 FakeVideoReceiveStream* stream = AddRecvStream();
1415 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1416
Peter Boström126c03e2015-05-11 12:48:12 +02001417 // Verify that REMB is turned off when send(!) codecs without REMB are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001418 cricket::VideoSendParameters parameters;
1419 parameters.codecs.push_back(kVp8Codec);
1420 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1421 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001422 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001423 EXPECT_FALSE(stream->GetConfig().rtp.remb);
1424
1425 // Verify that REMB is turned on when setting default codecs since the
1426 // default codecs have REMB enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001427 parameters.codecs = engine_.codecs();
1428 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001429 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001430 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001431}
1432
stefan43edf0f2015-11-20 18:05:48 -08001433TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) {
1434 FakeVideoReceiveStream* stream = AddRecvStream();
1435 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1436
1437 // Verify that transport cc feedback is turned off when send(!) codecs without
1438 // transport cc feedback are set.
1439 cricket::VideoSendParameters parameters;
1440 parameters.codecs.push_back(kVp8Codec);
1441 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1442 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1443 stream = fake_call_->GetVideoReceiveStreams()[0];
1444 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc);
1445
1446 // Verify that transport cc feedback is turned on when setting default codecs
1447 // since the default codecs have transport cc feedback enabled.
1448 parameters.codecs = engine_.codecs();
1449 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1450 stream = fake_call_->GetVideoReceiveStreams()[0];
1451 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1452}
1453
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001454TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
1455 VerifyCodecHasDefaultFeedbackParams(default_codec_);
1456
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001457 cricket::VideoSendParameters parameters;
1458 parameters.codecs = engine_.codecs();
1459 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org19864742014-05-30 07:35:47 +00001460 EXPECT_TRUE(channel_->SetSend(true));
1461
1462 // Send side.
1463 FakeVideoSendStream* send_stream =
1464 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1465 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1466
1467 // Receiver side.
1468 FakeVideoReceiveStream* recv_stream =
1469 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1470 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1471
1472 // Nack history size should match between sender and receiver.
1473 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
1474 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001475}
1476
Peter Boström67c9df72015-05-11 14:34:58 +02001477TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
Peter Boström67c9df72015-05-11 14:34:58 +02001478 FakeVideoSendStream* send_stream = AddSendStream();
Peter Boström3548dd22015-05-22 18:48:36 +02001479 FakeVideoReceiveStream* recv_stream = AddRecvStream();
Peter Boström67c9df72015-05-11 14:34:58 +02001480
1481 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1482 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1483
1484 // Verify that NACK is turned off when send(!) codecs without NACK are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001485 cricket::VideoSendParameters parameters;
1486 parameters.codecs.push_back(kVp8Codec);
1487 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1488 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001489 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1490 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1491 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001492 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1493
Peter Boström67c9df72015-05-11 14:34:58 +02001494 // Verify that NACK is turned on when setting default codecs since the
1495 // default codecs have NACK enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001496 parameters.codecs = engine_.codecs();
1497 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001498 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1499 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1500 send_stream = fake_call_->GetVideoSendStreams()[0];
1501 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001502}
1503
Peter Boströme7ba0862016-03-12 00:02:28 +01001504// This test verifies that new frame sizes reconfigures encoders even though not
1505// (yet) sending. The purpose of this is to permit encoding as quickly as
1506// possible once we start sending. Likely the frames being input are from the
1507// same source that will be sent later, which just means that we're ready
1508// earlier.
1509TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) {
1510 cricket::VideoSendParameters parameters;
1511 parameters.codecs.push_back(kVp8Codec720p);
1512 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1513 channel_->SetSend(false);
1514
1515 FakeVideoSendStream* stream = AddSendStream();
1516
perkjfa10b552016-10-02 23:45:26 -07001517 // No frames entered.
Peter Boströme7ba0862016-03-12 00:02:28 +01001518 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
perkjfa10b552016-10-02 23:45:26 -07001519 EXPECT_EQ(0u, streams[0].width);
1520 EXPECT_EQ(0u, streams[0].height);
Peter Boströme7ba0862016-03-12 00:02:28 +01001521
1522 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07001523 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
Peter Boströme7ba0862016-03-12 00:02:28 +01001524 EXPECT_EQ(cricket::CS_RUNNING,
1525 capturer.Start(capturer.GetSupportedFormats()->front()));
1526 EXPECT_TRUE(capturer.CaptureFrame());
1527
1528 // Frame entered, should be reconfigured to new dimensions.
1529 streams = stream->GetVideoStreams();
1530 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
1531 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
Peter Boströme7ba0862016-03-12 00:02:28 +01001532
deadbeef5a4a75a2016-06-02 16:23:38 -07001533 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
Peter Boströme7ba0862016-03-12 00:02:28 +01001534}
1535
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001536TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1537 static const int kScreenshareMinBitrateKbps = 800;
1538 cricket::VideoCodec codec = kVp8Codec360p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001539 cricket::VideoSendParameters parameters;
1540 parameters.codecs.push_back(codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001541 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001542 AddSendStream();
1543
deadbeef5a4a75a2016-06-02 16:23:38 -07001544 cricket::FakeVideoCapturer capturer;
nisse05103312016-03-16 02:22:50 -07001545 VideoOptions min_bitrate_options;
1546 min_bitrate_options.screencast_min_bitrate_kbps =
1547 rtc::Optional<int>(kScreenshareMinBitrateKbps);
deadbeef5a4a75a2016-06-02 16:23:38 -07001548 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options,
1549 &capturer));
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001550 cricket::VideoFormat capture_format_hd =
1551 capturer.GetSupportedFormats()->front();
1552 EXPECT_EQ(1280, capture_format_hd.width);
1553 EXPECT_EQ(720, capture_format_hd.height);
1554 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1555
1556 EXPECT_TRUE(channel_->SetSend(true));
1557
1558 EXPECT_TRUE(capturer.CaptureFrame());
1559 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1560 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1561
1562 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1563
1564 // Verify non-screencast settings.
perkj26091b12016-09-01 01:17:40 -07001565 webrtc::VideoEncoderConfig encoder_config =
1566 send_stream->GetEncoderConfig().Copy();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001567 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001568 encoder_config.content_type);
perkjfa10b552016-10-02 23:45:26 -07001569 std::vector<webrtc::VideoStream> streams = send_stream->GetVideoStreams();
1570 EXPECT_EQ(capture_format_hd.width, streams.front().width);
1571 EXPECT_EQ(capture_format_hd.height, streams.front().height);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001572 EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
1573 << "Non-screenshare shouldn't use min-transmit bitrate.";
1574
deadbeef5a4a75a2016-06-02 16:23:38 -07001575 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
perkj2d5f0912016-02-29 00:04:41 -08001576 // Removing a capturer triggers a black frame to be sent.
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001577 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
nisse05103312016-03-16 02:22:50 -07001578 VideoOptions screencast_options;
1579 screencast_options.is_screencast = rtc::Optional<bool>(true);
deadbeef5a4a75a2016-06-02 16:23:38 -07001580 EXPECT_TRUE(
1581 channel_->SetVideoSend(last_ssrc_, true, &screencast_options, &capturer));
perkj2d5f0912016-02-29 00:04:41 -08001582 EXPECT_TRUE(capturer.CaptureFrame());
Niels Möller60653ba2016-03-02 11:41:36 +01001583 // Send stream not recreated after option change.
1584 ASSERT_EQ(send_stream, fake_call_->GetVideoSendStreams().front());
perkj2d5f0912016-02-29 00:04:41 -08001585 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001586
1587 // Verify screencast settings.
perkj26091b12016-09-01 01:17:40 -07001588 encoder_config = send_stream->GetEncoderConfig().Copy();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001589 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001590 encoder_config.content_type);
1591 EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
1592 encoder_config.min_transmit_bitrate_bps);
1593
perkjfa10b552016-10-02 23:45:26 -07001594 streams = send_stream->GetVideoStreams();
1595 EXPECT_EQ(capture_format_hd.width, streams.front().width);
1596 EXPECT_EQ(capture_format_hd.height, streams.front().height);
1597 EXPECT_TRUE(streams[0].temporal_layer_thresholds_bps.empty());
deadbeef5a4a75a2016-06-02 16:23:38 -07001598 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001599}
1600
Niels Möller60653ba2016-03-02 11:41:36 +01001601TEST_F(WebRtcVideoChannel2Test, NoRecreateStreamForScreencast) {
1602 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
1603 ASSERT_TRUE(
1604 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
1605 EXPECT_TRUE(channel_->SetSend(true));
1606
1607 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07001608 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, &capturer));
Niels Möller60653ba2016-03-02 11:41:36 +01001609 EXPECT_EQ(cricket::CS_RUNNING,
1610 capturer.Start(capturer.GetSupportedFormats()->front()));
1611 EXPECT_TRUE(capturer.CaptureFrame());
1612
1613 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1614 FakeVideoSendStream* stream = fake_call_->GetVideoSendStreams().front();
perkj26091b12016-09-01 01:17:40 -07001615 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy();
Niels Möller60653ba2016-03-02 11:41:36 +01001616 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
1617 encoder_config.content_type);
1618
1619 EXPECT_EQ(1, stream->GetNumberOfSwappedFrames());
1620
1621 /* Switch to screencast source. We expect a reconfigure of the
1622 * encoder, but no change of the send stream. */
1623 struct VideoOptions video_options;
1624 video_options.is_screencast = rtc::Optional<bool>(true);
deadbeef5a4a75a2016-06-02 16:23:38 -07001625 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, &video_options, &capturer));
Niels Möller60653ba2016-03-02 11:41:36 +01001626
1627 EXPECT_TRUE(capturer.CaptureFrame());
1628 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1629 ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front());
1630 EXPECT_EQ(2, stream->GetNumberOfSwappedFrames());
1631
perkj26091b12016-09-01 01:17:40 -07001632 encoder_config = stream->GetEncoderConfig().Copy();
Niels Möller60653ba2016-03-02 11:41:36 +01001633 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
1634 encoder_config.content_type);
1635
1636 /* Switch back. */
1637 video_options.is_screencast = rtc::Optional<bool>(false);
deadbeef5a4a75a2016-06-02 16:23:38 -07001638 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, &video_options, &capturer));
Niels Möller60653ba2016-03-02 11:41:36 +01001639
1640 EXPECT_TRUE(capturer.CaptureFrame());
1641 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1642 ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front());
1643 EXPECT_EQ(3, stream->GetNumberOfSwappedFrames());
1644
perkj26091b12016-09-01 01:17:40 -07001645 encoder_config = stream->GetEncoderConfig().Copy();
Niels Möller60653ba2016-03-02 11:41:36 +01001646 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
1647 encoder_config.content_type);
1648
deadbeef5a4a75a2016-06-02 16:23:38 -07001649 EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr));
Niels Möller60653ba2016-03-02 11:41:36 +01001650}
1651
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001652TEST_F(WebRtcVideoChannel2Test,
1653 ConferenceModeScreencastConfiguresTemporalLayer) {
Erik SprĂ¥ng2c4c9142015-06-24 11:24:44 +02001654 static const int kConferenceScreencastTemporalBitrateBps =
1655 ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
nisse4b4dc862016-02-17 05:25:36 -08001656 send_parameters_.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001657 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001658
1659 AddSendStream();
nisse05103312016-03-16 02:22:50 -07001660 VideoOptions options;
1661 options.is_screencast = rtc::Optional<bool>(true);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001662 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07001663 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001664 cricket::VideoFormat capture_format_hd =
1665 capturer.GetSupportedFormats()->front();
1666 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1667
1668 EXPECT_TRUE(channel_->SetSend(true));
1669
1670 EXPECT_TRUE(capturer.CaptureFrame());
1671 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1672 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1673
perkj26091b12016-09-01 01:17:40 -07001674 webrtc::VideoEncoderConfig encoder_config =
1675 send_stream->GetEncoderConfig().Copy();
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001676
1677 // Verify screencast settings.
perkj26091b12016-09-01 01:17:40 -07001678 encoder_config = send_stream->GetEncoderConfig().Copy();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001679 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001680 encoder_config.content_type);
perkjfa10b552016-10-02 23:45:26 -07001681
1682 std::vector<webrtc::VideoStream> streams = send_stream->GetVideoStreams();
1683 ASSERT_EQ(1u, streams.size());
1684 ASSERT_EQ(1u, streams[0].temporal_layer_thresholds_bps.size());
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001685 EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
perkjfa10b552016-10-02 23:45:26 -07001686 streams[0].temporal_layer_thresholds_bps[0]);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001687
deadbeef5a4a75a2016-06-02 16:23:38 -07001688 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001689}
1690
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001691TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
1692 FakeVideoSendStream* stream = AddSendStream();
1693 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1694}
1695
nisse0db023a2016-03-01 04:29:59 -08001696TEST_F(WebRtcVideoChannel2Test, SetMediaConfigSuspendBelowMinBitrate) {
1697 MediaConfig media_config = MediaConfig();
1698 media_config.video.suspend_below_min_bitrate = true;
1699
1700 channel_.reset(
1701 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1702
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001703 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001704
1705 FakeVideoSendStream* stream = AddSendStream();
1706 EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
1707
nisse0db023a2016-03-01 04:29:59 -08001708 media_config.video.suspend_below_min_bitrate = false;
1709 channel_.reset(
1710 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1711
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001712 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001713
nisse0db023a2016-03-01 04:29:59 -08001714 stream = AddSendStream();
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001715 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1716}
1717
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001718TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1719 FakeVideoSendStream* stream = AddSendStream();
1720 webrtc::VideoCodecVP8 vp8_settings;
1721 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1722 EXPECT_TRUE(vp8_settings.denoisingOn);
1723}
1724
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001725TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001726 cricket::VideoSendParameters parameters;
1727 parameters.codecs.push_back(kVp8Codec720p);
1728 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001729
Peter Boström2feafdb2015-09-09 14:32:14 +02001730 // Single-stream settings should apply with RTX as well (verifies that we
1731 // check number of regular SSRCs and not StreamParams::ssrcs which contains
1732 // both RTX and regular SSRCs).
1733 FakeVideoSendStream* stream = SetUpSimulcast(false, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001734
1735 cricket::FakeVideoCapturer capturer;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001736 EXPECT_EQ(cricket::CS_RUNNING,
1737 capturer.Start(capturer.GetSupportedFormats()->front()));
deadbeef5a4a75a2016-06-02 16:23:38 -07001738 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001739 channel_->SetSend(true);
1740
1741 EXPECT_TRUE(capturer.CaptureFrame());
1742
pbos4cba4eb2015-10-26 11:18:18 -07001743 webrtc::VideoCodecVP8 vp8_settings;
1744 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1745 EXPECT_TRUE(vp8_settings.denoisingOn)
1746 << "VP8 denoising should be on by default.";
1747
nisse05103312016-03-16 02:22:50 -07001748 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001749
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001750 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1751 EXPECT_FALSE(vp8_settings.denoisingOn);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001752 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1753 EXPECT_TRUE(vp8_settings.frameDroppingOn);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001754
nisse05103312016-03-16 02:22:50 -07001755 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001756
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001757 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1758 EXPECT_TRUE(vp8_settings.denoisingOn);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001759 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1760 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1761
deadbeef5a4a75a2016-06-02 16:23:38 -07001762 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
Peter Boström2feafdb2015-09-09 14:32:14 +02001763 stream = SetUpSimulcast(true, false);
deadbeef5a4a75a2016-06-02 16:23:38 -07001764 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001765 channel_->SetSend(true);
1766 EXPECT_TRUE(capturer.CaptureFrame());
1767
1768 EXPECT_EQ(3, stream->GetVideoStreams().size());
1769 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1770 // Autmatic resize off when using simulcast.
1771 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1772 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1773
1774 // In screen-share mode, denoising is forced off and simulcast disabled.
nisse05103312016-03-16 02:22:50 -07001775 VideoOptions options;
1776 options.is_screencast = rtc::Optional<bool>(true);
deadbeef5a4a75a2016-06-02 16:23:38 -07001777 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
Niels Möller60653ba2016-03-02 11:41:36 +01001778
nisse05103312016-03-16 02:22:50 -07001779 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001780
1781 EXPECT_EQ(1, stream->GetVideoStreams().size());
1782 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1783 EXPECT_FALSE(vp8_settings.denoisingOn);
1784 // Resizing and frame dropping always off for screen sharing.
1785 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1786 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1787
nisse05103312016-03-16 02:22:50 -07001788 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001789
1790 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1791 EXPECT_FALSE(vp8_settings.denoisingOn);
1792 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1793 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1794
deadbeef5a4a75a2016-06-02 16:23:38 -07001795 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001796}
1797
deadbeef119760a2016-04-04 11:43:27 -07001798// Test that setting the same options doesn't result in the encoder being
1799// reconfigured.
1800TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) {
1801 VideoOptions options;
1802 cricket::FakeVideoCapturer capturer;
1803
perkjfa10b552016-10-02 23:45:26 -07001804 AddSendStream();
deadbeef119760a2016-04-04 11:43:27 -07001805 EXPECT_EQ(cricket::CS_RUNNING,
1806 capturer.Start(capturer.GetSupportedFormats()->front()));
perkjfa10b552016-10-02 23:45:26 -07001807 cricket::VideoSendParameters parameters;
1808 parameters.codecs.push_back(kVp8Codec720p);
1809 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1810 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1811
1812 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
deadbeef5a4a75a2016-06-02 16:23:38 -07001813 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
deadbeef119760a2016-04-04 11:43:27 -07001814 EXPECT_TRUE(capturer.CaptureFrame());
perkjfa10b552016-10-02 23:45:26 -07001815 // Expect 1 reconfigurations at this point from the initial configuration.
1816 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations());
deadbeef119760a2016-04-04 11:43:27 -07001817
1818 // Set the options one more time and expect no additional reconfigurations.
deadbeef5a4a75a2016-06-02 16:23:38 -07001819 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
perkjfa10b552016-10-02 23:45:26 -07001820 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations());
1821
1822 // Change |options| and expect 2 reconfigurations.
1823 options.is_screencast = rtc::Optional<bool>(true);
1824 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
deadbeef119760a2016-04-04 11:43:27 -07001825 EXPECT_EQ(2, send_stream->num_encoder_reconfigurations());
1826
deadbeef5a4a75a2016-06-02 16:23:38 -07001827 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
deadbeef119760a2016-04-04 11:43:27 -07001828}
1829
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001830class Vp9SettingsTest : public WebRtcVideoChannel2Test {
1831 public:
asaperssonc5dabdd2016-03-21 04:15:50 -07001832 Vp9SettingsTest() : Vp9SettingsTest("") {}
1833 explicit Vp9SettingsTest(const char* field_trials)
1834 : WebRtcVideoChannel2Test(field_trials) {
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001835 encoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
1836 }
1837 virtual ~Vp9SettingsTest() {}
1838
1839 protected:
1840 void SetUp() override {
1841 engine_.SetExternalEncoderFactory(&encoder_factory_);
1842
1843 WebRtcVideoChannel2Test::SetUp();
1844 }
1845
1846 void TearDown() override {
1847 // Remove references to encoder_factory_ since this will be destroyed
1848 // before channel_ and engine_.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001849 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001850 }
1851
1852 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
1853};
1854
1855TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001856 cricket::VideoSendParameters parameters;
1857 parameters.codecs.push_back(kVp9Codec);
1858 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001859
Peter Boström2feafdb2015-09-09 14:32:14 +02001860 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001861
1862 cricket::FakeVideoCapturer capturer;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001863 EXPECT_EQ(cricket::CS_RUNNING,
1864 capturer.Start(capturer.GetSupportedFormats()->front()));
deadbeef5a4a75a2016-06-02 16:23:38 -07001865 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001866 channel_->SetSend(true);
1867
1868 EXPECT_TRUE(capturer.CaptureFrame());
1869
pbos4cba4eb2015-10-26 11:18:18 -07001870 webrtc::VideoCodecVP9 vp9_settings;
1871 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1872 EXPECT_FALSE(vp9_settings.denoisingOn)
1873 << "VP9 denoising should be off by default.";
1874
nisse05103312016-03-16 02:22:50 -07001875 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001876
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001877 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1878 EXPECT_FALSE(vp9_settings.denoisingOn);
1879 // Frame dropping always on for real time video.
1880 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1881
nisse05103312016-03-16 02:22:50 -07001882 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001883
1884 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1885 EXPECT_TRUE(vp9_settings.denoisingOn);
1886 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1887
1888 // In screen-share mode, denoising is forced off.
nisse05103312016-03-16 02:22:50 -07001889 VideoOptions options;
1890 options.is_screencast = rtc::Optional<bool>(true);
deadbeef5a4a75a2016-06-02 16:23:38 -07001891 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
perkj2d5f0912016-02-29 00:04:41 -08001892
nisse05103312016-03-16 02:22:50 -07001893 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001894
1895 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1896 EXPECT_FALSE(vp9_settings.denoisingOn);
1897 // Frame dropping always off for screen sharing.
1898 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1899
nisse05103312016-03-16 02:22:50 -07001900 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001901
1902 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1903 EXPECT_FALSE(vp9_settings.denoisingOn);
1904 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1905
deadbeef5a4a75a2016-06-02 16:23:38 -07001906 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001907}
1908
asaperssonc5dabdd2016-03-21 04:15:50 -07001909class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest {
1910 public:
1911 Vp9SettingsTestWithFieldTrial(const char* field_trials)
1912 : Vp9SettingsTest(field_trials) {}
1913
1914 protected:
1915 void VerifySettings(int num_spatial_layers, int num_temporal_layers) {
1916 cricket::VideoSendParameters parameters;
1917 parameters.codecs.push_back(kVp9Codec);
1918 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1919
1920 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
1921
1922 cricket::FakeVideoCapturer capturer;
1923 EXPECT_EQ(cricket::CS_RUNNING,
1924 capturer.Start(capturer.GetSupportedFormats()->front()));
deadbeef5a4a75a2016-06-02 16:23:38 -07001925 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
asaperssonc5dabdd2016-03-21 04:15:50 -07001926 channel_->SetSend(true);
1927
1928 EXPECT_TRUE(capturer.CaptureFrame());
1929
1930 webrtc::VideoCodecVP9 vp9_settings;
1931 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1932 EXPECT_EQ(num_spatial_layers, vp9_settings.numberOfSpatialLayers);
1933 EXPECT_EQ(num_temporal_layers, vp9_settings.numberOfTemporalLayers);
1934
deadbeef5a4a75a2016-06-02 16:23:38 -07001935 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
asaperssonc5dabdd2016-03-21 04:15:50 -07001936 }
1937};
1938
1939class Vp9SettingsTestWithNoFlag : public Vp9SettingsTestWithFieldTrial {
1940 public:
1941 Vp9SettingsTestWithNoFlag() : Vp9SettingsTestWithFieldTrial("") {}
1942};
1943
1944TEST_F(Vp9SettingsTestWithNoFlag, VerifySettings) {
1945 const int kNumSpatialLayers = 1;
1946 const int kNumTemporalLayers = 1;
1947 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1948}
1949
1950class Vp9SettingsTestWithInvalidFlag : public Vp9SettingsTestWithFieldTrial {
1951 public:
1952 Vp9SettingsTestWithInvalidFlag()
1953 : Vp9SettingsTestWithFieldTrial("WebRTC-SupportVP9SVC/Default/") {}
1954};
1955
1956TEST_F(Vp9SettingsTestWithInvalidFlag, VerifySettings) {
1957 const int kNumSpatialLayers = 1;
1958 const int kNumTemporalLayers = 1;
1959 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1960}
1961
1962class Vp9SettingsTestWith2SL3TLFlag : public Vp9SettingsTestWithFieldTrial {
1963 public:
1964 Vp9SettingsTestWith2SL3TLFlag()
1965 : Vp9SettingsTestWithFieldTrial(
1966 "WebRTC-SupportVP9SVC/EnabledByFlag_2SL3TL/") {}
1967};
1968
1969TEST_F(Vp9SettingsTestWith2SL3TLFlag, VerifySettings) {
1970 const int kNumSpatialLayers = 2;
1971 const int kNumTemporalLayers = 3;
1972 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1973}
1974
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001975TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) {
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001976 TestCpuAdaptation(true, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001977}
1978
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001979TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001980 TestCpuAdaptation(false, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001981}
1982
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001983TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
1984 TestCpuAdaptation(true, true);
1985}
1986
perkj2d5f0912016-02-29 00:04:41 -08001987TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) {
1988 cricket::VideoCodec codec = kVp8Codec720p;
1989 cricket::VideoSendParameters parameters;
1990 parameters.codecs.push_back(codec);
1991
1992 MediaConfig media_config = MediaConfig();
1993 channel_.reset(
1994 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1995 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1996
1997 AddSendStream();
1998
1999 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07002000 ASSERT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
perkj2d5f0912016-02-29 00:04:41 -08002001 ASSERT_EQ(cricket::CS_RUNNING,
2002 capturer.Start(capturer.GetSupportedFormats()->front()));
2003 ASSERT_TRUE(channel_->SetSend(true));
2004
2005 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2006 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
2007 webrtc::LoadObserver* overuse_callback =
2008 send_stream->GetConfig().overuse_callback;
2009 ASSERT_TRUE(overuse_callback != NULL);
2010
2011 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2012 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2013 EXPECT_EQ(1280, send_stream->GetLastWidth());
2014 EXPECT_EQ(720, send_stream->GetLastHeight());
2015
2016 // Trigger overuse.
2017 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2018 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2019 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
2020 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2021 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2022
2023 // Trigger overuse again.
2024 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2025 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2026 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
2027 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth());
2028 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight());
2029
Per766ad3b2016-04-05 15:23:49 +02002030 // Trigger overuse again. This should not decrease the resolution since we
2031 // should only adapt the resolution down max two steps.
2032 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2033 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2034 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
2035 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth());
2036 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight());
2037
perkj2d5f0912016-02-29 00:04:41 -08002038 // Change input resolution.
2039 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
Per766ad3b2016-04-05 15:23:49 +02002040 EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames());
perkj2d5f0912016-02-29 00:04:41 -08002041 EXPECT_EQ(1284 / 2, send_stream->GetLastWidth());
2042 EXPECT_EQ(724 / 2, send_stream->GetLastHeight());
2043
2044 // Trigger underuse which should go back up in resolution.
2045 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2046 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
Per766ad3b2016-04-05 15:23:49 +02002047 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames());
perkj2d5f0912016-02-29 00:04:41 -08002048 EXPECT_EQ(1284 * 3 / 4, send_stream->GetLastWidth());
2049 EXPECT_EQ(724 * 3 / 4, send_stream->GetLastHeight());
2050
2051 // Trigger underuse which should go back up in resolution.
2052 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2053 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
Per766ad3b2016-04-05 15:23:49 +02002054 EXPECT_EQ(7, send_stream->GetNumberOfSwappedFrames());
perkj2d5f0912016-02-29 00:04:41 -08002055 EXPECT_EQ(1284, send_stream->GetLastWidth());
2056 EXPECT_EQ(724, send_stream->GetLastHeight());
2057
deadbeef5a4a75a2016-06-02 16:23:38 -07002058 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
perkj2d5f0912016-02-29 00:04:41 -08002059}
2060
Per766ad3b2016-04-05 15:23:49 +02002061TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) {
2062 cricket::VideoCodec codec = kVp8Codec720p;
2063 cricket::VideoSendParameters parameters;
2064 parameters.codecs.push_back(codec);
2065
2066 MediaConfig media_config = MediaConfig();
2067 channel_.reset(
2068 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2069 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2070
2071 AddSendStream();
2072
2073 cricket::FakeVideoCapturer capturer;
Per766ad3b2016-04-05 15:23:49 +02002074 ASSERT_EQ(cricket::CS_RUNNING,
2075 capturer.Start(capturer.GetSupportedFormats()->front()));
2076 ASSERT_TRUE(channel_->SetSend(true));
2077 cricket::VideoOptions camera_options;
deadbeef5a4a75a2016-06-02 16:23:38 -07002078 channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options,
2079 &capturer);
Per766ad3b2016-04-05 15:23:49 +02002080
2081 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2082 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
2083 webrtc::LoadObserver* overuse_callback =
2084 send_stream->GetConfig().overuse_callback;
2085 ASSERT_TRUE(overuse_callback != NULL);
2086
2087 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2088 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2089 EXPECT_EQ(1280, send_stream->GetLastWidth());
2090 EXPECT_EQ(720, send_stream->GetLastHeight());
2091
2092 // Trigger overuse.
2093 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2094 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2095 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
2096 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2097 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2098
2099 // Switch to screen share. Expect no CPU adaptation.
2100 cricket::FakeVideoCapturer screen_share(true);
2101 ASSERT_EQ(cricket::CS_RUNNING,
2102 screen_share.Start(screen_share.GetSupportedFormats()->front()));
Per766ad3b2016-04-05 15:23:49 +02002103 cricket::VideoOptions screenshare_options;
2104 screenshare_options.is_screencast = rtc::Optional<bool>(true);
deadbeef5a4a75a2016-06-02 16:23:38 -07002105 channel_->SetVideoSend(last_ssrc_, true /* enable */, &screenshare_options,
2106 &screen_share);
Per766ad3b2016-04-05 15:23:49 +02002107 EXPECT_TRUE(screen_share.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
2108 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
2109 EXPECT_EQ(1284, send_stream->GetLastWidth());
2110 EXPECT_EQ(724, send_stream->GetLastHeight());
2111
2112 // Switch back to the normal capturer. Expect the frame to be CPU adapted.
deadbeef5a4a75a2016-06-02 16:23:38 -07002113 channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options,
2114 &capturer);
Per766ad3b2016-04-05 15:23:49 +02002115 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2116 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
2117 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2118 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2119
deadbeef5a4a75a2016-06-02 16:23:38 -07002120 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
Per766ad3b2016-04-05 15:23:49 +02002121}
2122
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02002123void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
2124 bool is_screenshare) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002125 cricket::VideoCodec codec = kVp8Codec720p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002126 cricket::VideoSendParameters parameters;
2127 parameters.codecs.push_back(codec);
nisse51542be2016-02-12 02:27:06 -08002128
2129 MediaConfig media_config = MediaConfig();
Peter Boströme4328002015-04-14 22:45:29 +02002130 if (!enable_overuse) {
nisse0db023a2016-03-01 04:29:59 -08002131 media_config.video.enable_cpu_overuse_detection = false;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002132 }
nisse51542be2016-02-12 02:27:06 -08002133 channel_.reset(
2134 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2135
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002136 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002137
2138 AddSendStream();
2139
deadbeef5a4a75a2016-06-02 16:23:38 -07002140 cricket::FakeVideoCapturer capturer;
nisse05103312016-03-16 02:22:50 -07002141 VideoOptions options;
2142 options.is_screencast = rtc::Optional<bool>(is_screenshare);
deadbeef5a4a75a2016-06-02 16:23:38 -07002143 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002144 EXPECT_EQ(cricket::CS_RUNNING,
2145 capturer.Start(capturer.GetSupportedFormats()->front()));
2146
2147 EXPECT_TRUE(channel_->SetSend(true));
2148
2149 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07002150 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2151 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002152 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07002153 send_stream->GetConfig().overuse_callback;
perkj2d5f0912016-02-29 00:04:41 -08002154
2155 if (!enable_overuse) {
2156 ASSERT_TRUE(overuse_callback == NULL);
2157
2158 EXPECT_TRUE(capturer.CaptureFrame());
2159 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2160
2161 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2162 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
2163
deadbeef5a4a75a2016-06-02 16:23:38 -07002164 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
perkj2d5f0912016-02-29 00:04:41 -08002165 return;
2166 }
2167
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002168 ASSERT_TRUE(overuse_callback != NULL);
perkj2d5f0912016-02-29 00:04:41 -08002169 EXPECT_TRUE(capturer.CaptureFrame());
2170 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002171 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2172
2173 EXPECT_TRUE(capturer.CaptureFrame());
perkj2d5f0912016-02-29 00:04:41 -08002174 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002175
perkj2d5f0912016-02-29 00:04:41 -08002176 if (is_screenshare) {
2177 // Do not adapt screen share.
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002178 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2179 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
perkj2d5f0912016-02-29 00:04:41 -08002180 } else {
2181 EXPECT_LT(send_stream->GetLastWidth(), codec.width);
2182 EXPECT_LT(send_stream->GetLastHeight(), codec.height);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002183 }
2184
2185 // Trigger underuse which should go back to normal resolution.
2186 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2187 EXPECT_TRUE(capturer.CaptureFrame());
perkj2d5f0912016-02-29 00:04:41 -08002188 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002189
2190 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2191 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
2192
deadbeef5a4a75a2016-06-02 16:23:38 -07002193 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002194}
2195
magjedb09b6602015-10-01 03:02:44 -07002196TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly) {
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002197 // Start at last timestamp to verify that wraparounds are estimated correctly.
2198 static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
2199 static const int64_t kInitialNtpTimeMs = 1247891230;
2200 static const int kFrameOffsetMs = 20;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002201 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002202
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002203 FakeVideoReceiveStream* stream = AddRecvStream();
2204 cricket::FakeVideoRenderer renderer;
nisse08582ff2016-02-04 01:24:52 -08002205 EXPECT_TRUE(channel_->SetSink(last_ssrc_, &renderer));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002206
nisse64ec8f82016-09-27 00:17:25 -07002207 webrtc::VideoFrame video_frame(CreateBlackFrameBuffer(4, 4),
2208 kInitialTimestamp, 0,
2209 webrtc::kVideoRotation_0);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002210 // Initial NTP time is not available on the first frame, but should still be
2211 // able to be estimated.
nisseeb83a1a2016-03-21 01:27:56 -07002212 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002213
2214 EXPECT_EQ(1, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002215
2216 // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which
2217 // triggers a constant-overflow warning, hence we're calculating it explicitly
2218 // here.
2219 video_frame.set_timestamp(kFrameOffsetMs * 90 - 1);
2220 video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs);
nisseeb83a1a2016-03-21 01:27:56 -07002221 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002222
2223 EXPECT_EQ(2, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002224
2225 // Verify that NTP time has been correctly deduced.
2226 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002227 ASSERT_TRUE(channel_->GetStats(&info));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002228 ASSERT_EQ(1u, info.receivers.size());
2229 EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002230}
2231
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002232TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002233 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002234
2235 VideoCodec codec;
2236 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00002237 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002238
2239 // Using a RTX setup to verify that the default RTX payload type is good.
Peter Boström0c4e06b2015-10-07 12:23:21 +02002240 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2241 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002242 FakeVideoSendStream* stream = AddSendStream(
2243 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
perkj26091b12016-09-01 01:17:40 -07002244 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002245
2246 // Make sure NACK and FEC are enabled on the correct payload types.
2247 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
brandtrb5f2c3f2016-10-04 23:28:39 -07002248 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.ulpfec.ulpfec_payload_type);
2249 EXPECT_EQ(default_red_codec_.id, config.rtp.ulpfec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002250
2251 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
2252 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
Shao Changbine62202f2015-04-21 20:24:50 +08002253 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002254 // TODO(juberti): Check RTCP, PLI, TMMBR.
2255}
2256
2257TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002258 cricket::VideoSendParameters parameters;
2259 parameters.codecs.push_back(kVp8Codec);
2260 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002261
2262 FakeVideoSendStream* stream = AddSendStream();
perkj26091b12016-09-01 01:17:40 -07002263 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002264
brandtrb5f2c3f2016-10-04 23:28:39 -07002265 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type);
2266 EXPECT_EQ(-1, config.rtp.ulpfec.red_payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002267}
2268
2269TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002270 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002271 cricket::VideoSendParameters parameters;
deadbeef67cf2c12016-04-13 10:07:16 -07002272 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002273 parameters.codecs.push_back(rtx_codec);
2274 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002275 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002276}
2277
2278TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002279 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002280 cricket::VideoSendParameters parameters;
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002281 cricket::VideoCodec rtx_codec =
2282 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002283 parameters.codecs.push_back(kVp8Codec);
2284 parameters.codecs.push_back(rtx_codec);
2285 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002286
2287 cricket::VideoCodec rtx_codec2 =
2288 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002289 parameters.codecs.pop_back();
2290 parameters.codecs.push_back(rtx_codec2);
2291 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002292 << "RTX without matching video codec should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002293}
2294
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002295TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002296 cricket::VideoSendParameters parameters;
2297 parameters.codecs.push_back(kVp8Codec);
2298 parameters.codecs.push_back(kUlpfecCodec);
2299 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002300
2301 FakeVideoSendStream* stream = AddSendStream();
perkj26091b12016-09-01 01:17:40 -07002302 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002303
brandtrb5f2c3f2016-10-04 23:28:39 -07002304 EXPECT_EQ(kUlpfecCodec.id, config.rtp.ulpfec.ulpfec_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002305
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002306 parameters.codecs.pop_back();
2307 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002308 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002309 ASSERT_TRUE(stream != NULL);
perkj26091b12016-09-01 01:17:40 -07002310 config = stream->GetConfig().Copy();
brandtrb5f2c3f2016-10-04 23:28:39 -07002311 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type)
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002312 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002313}
2314
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002315TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002316 cricket::VideoSendParameters parameters;
perkjfa10b552016-10-02 23:45:26 -07002317 cricket::VideoCodec codec720p(100, "VP8", 1280, 720, 30);
2318 codec720p.SetParam(kCodecParamMaxQuantization, kDefaultQpMax);
2319 parameters.codecs.push_back(codec720p);
2320
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002321 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002322 channel_->SetSend(true);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002323
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002324 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002325 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07002326 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002327
2328 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
perkjfa10b552016-10-02 23:45:26 -07002329 EXPECT_EQ(kDefaultQpMax, streams[0].max_qp);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002330
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002331 parameters.codecs.clear();
perkjfa10b552016-10-02 23:45:26 -07002332 codec720p.SetParam(kCodecParamMaxQuantization, kDefaultQpMax + 1);
2333 parameters.codecs.push_back(codec720p);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002334 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002335 streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
perkjfa10b552016-10-02 23:45:26 -07002336 EXPECT_EQ(kDefaultQpMax + 1, streams[0].max_qp);
deadbeef5a4a75a2016-06-02 16:23:38 -07002337 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002338}
2339
pbos@webrtc.org00873182014-11-25 14:03:34 +00002340TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
2341 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2342 200000);
2343}
2344
pbos@webrtc.orga5f6fb52015-03-23 22:29:39 +00002345TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
2346 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
2347 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
2348 ASSERT_EQ(1u, streams.size());
2349 EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
2350}
2351
pbos@webrtc.org00873182014-11-25 14:03:34 +00002352TEST_F(WebRtcVideoChannel2Test,
2353 SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
2354 SetSendCodecsShouldWorkForBitrates(
2355 "", 0, "", -1, "", -1);
2356}
2357
2358TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
2359 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002360}
2361
2362TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002363 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300";
2364 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200";
2365 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002366}
2367
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07002368// Test that when both the codec-specific bitrate params and max_bandwidth_bps
2369// are present in the same send parameters, the settings are combined correctly.
2370TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitratesAndMaxSendBandwidth) {
2371 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "100";
2372 send_parameters_.codecs[0].params[kCodecParamStartBitrate] = "200";
2373 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "300";
2374 send_parameters_.max_bandwidth_bps = 400000;
2375 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2376 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2377 EXPECT_EQ(200000, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2378 // We expect max_bandwidth_bps to take priority, if set.
2379 EXPECT_EQ(400000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2380
2381 // Decrease max_bandwidth_bps.
2382 send_parameters_.max_bandwidth_bps = 350000;
2383 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2384 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2385 // Since the codec isn't changing, start_bitrate_bps should be -1.
2386 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2387 EXPECT_EQ(350000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2388
2389 // Now try again with the values flipped around.
2390 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "400";
2391 send_parameters_.max_bandwidth_bps = 300000;
2392 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2393 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2394 EXPECT_EQ(200000, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2395 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2396
2397 // If we change the codec max, max_bandwidth_bps should still apply.
2398 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "350";
2399 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2400 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2401 EXPECT_EQ(200000, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2402 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2403}
2404
pbos@webrtc.org00873182014-11-25 14:03:34 +00002405TEST_F(WebRtcVideoChannel2Test,
2406 SetMaxSendBandwidthShouldPreserveOtherBitrates) {
2407 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2408 200000);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002409 send_parameters_.max_bandwidth_bps = 300000;
2410 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002411 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002412 << "Setting max bitrate should keep previous min bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002413 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002414 << "Setting max bitrate should not reset start bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002415 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002416}
2417
2418TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002419 send_parameters_.max_bandwidth_bps = 300000;
2420 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002421 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002422 // <= 0 means disable (infinite) max bitrate.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002423 send_parameters_.max_bandwidth_bps = 0;
2424 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002425 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002426 << "Setting zero max bitrate did not reset start bitrate.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002427}
2428
perkjfa10b552016-10-02 23:45:26 -07002429TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthAndAddSendStream) {
2430 send_parameters_.max_bandwidth_bps = 99999;
2431 FakeVideoSendStream* stream = AddSendStream();
2432 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
2433 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
2434 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2435 ASSERT_EQ(1u, stream->GetVideoStreams().size());
2436 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
2437 stream->GetVideoStreams()[0].max_bitrate_bps);
2438
2439 send_parameters_.max_bandwidth_bps = 77777;
2440 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
2441 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
2442 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2443 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
2444 stream->GetVideoStreams()[0].max_bitrate_bps);
2445}
2446
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002447TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002448 cricket::VideoSendParameters parameters;
2449 parameters.codecs.push_back(kVp8Codec720p);
2450 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002451 channel_->SetSend(true);
2452
2453 FakeVideoSendStream* stream = AddSendStream();
2454
Peter Boström3afc8c42016-01-27 16:45:21 +01002455 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07002456 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
Peter Boström3afc8c42016-01-27 16:45:21 +01002457 EXPECT_EQ(cricket::CS_RUNNING,
2458 capturer.Start(capturer.GetSupportedFormats()->front()));
2459
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002460 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2461 int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
2462 EXPECT_GT(initial_max_bitrate_bps, 0);
2463
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002464 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2465 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01002466 // Insert a frame to update the encoder config.
2467 EXPECT_TRUE(capturer.CaptureFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002468 streams = stream->GetVideoStreams();
2469 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
deadbeef5a4a75a2016-06-02 16:23:38 -07002470 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002471}
2472
2473TEST_F(WebRtcVideoChannel2Test,
2474 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002475 cricket::VideoSendParameters parameters;
2476 parameters.codecs.push_back(kVp8Codec720p);
2477 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002478 channel_->SetSend(true);
2479
2480 FakeVideoSendStream* stream = AddSendStream(
2481 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2482
2483 // Send a frame to make sure this scales up to >1 stream (simulcast).
2484 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07002485 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &capturer));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002486 EXPECT_EQ(cricket::CS_RUNNING,
2487 capturer.Start(capturer.GetSupportedFormats()->front()));
2488 EXPECT_TRUE(capturer.CaptureFrame());
2489
2490 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2491 ASSERT_GT(streams.size(), 1u)
2492 << "Without simulcast this test doesn't make sense.";
pbosbe16f792015-10-16 12:49:39 -07002493 int initial_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002494 EXPECT_GT(initial_max_bitrate_bps, 0);
2495
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002496 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2497 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01002498 // Insert a frame to update the encoder config.
2499 EXPECT_TRUE(capturer.CaptureFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002500 streams = stream->GetVideoStreams();
pbosbe16f792015-10-16 12:49:39 -07002501 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002502 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
2503
deadbeef5a4a75a2016-06-02 16:23:38 -07002504 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002505}
2506
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002507TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
2508 static const char* kMaxQuantization = "21";
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002509 cricket::VideoSendParameters parameters;
2510 parameters.codecs.push_back(kVp8Codec);
2511 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
2512 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002513 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
2514 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002515
2516 VideoCodec codec;
2517 EXPECT_TRUE(channel_->GetSendCodec(&codec));
2518 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
2519}
2520
2521TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002522 cricket::VideoSendParameters parameters;
2523 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002524
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002525 parameters.codecs[0].width = 0;
2526 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002527 << "Codec set though codec width is zero.";
2528
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002529 parameters.codecs[0].width = kVp8Codec.width;
2530 parameters.codecs[0].height = 0;
2531 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002532 << "Codec set though codec height is zero.";
2533}
2534
2535TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
2536 // TODO(pbos): Should we only allow the dynamic range?
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002537 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002538 cricket::VideoSendParameters parameters;
2539 parameters.codecs.push_back(kVp8Codec);
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002540 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002541 parameters.codecs[0].id = kIncorrectPayloads[i];
2542 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002543 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002544 }
2545}
2546
2547TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002548 cricket::VideoSendParameters parameters;
2549 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002550 for (int payload_type = 0; payload_type <= 127; ++payload_type) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002551 parameters.codecs[0].id = payload_type;
2552 EXPECT_TRUE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002553 << "Payload type '" << payload_type << "' rejected.";
2554 }
2555}
2556
deadbeef67cf2c12016-04-13 10:07:16 -07002557// Test that setting the a different set of codecs but with an identical front
2558// codec doesn't result in the stream being recreated.
2559// This may happen when a subsequent negotiation includes fewer codecs, as a
2560// result of one of the codecs being rejected.
2561TEST_F(WebRtcVideoChannel2Test,
2562 SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) {
2563 cricket::VideoSendParameters parameters1;
2564 parameters1.codecs.push_back(kVp8Codec);
2565 parameters1.codecs.push_back(kVp9Codec);
2566 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
2567
2568 AddSendStream();
2569 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
2570
2571 cricket::VideoSendParameters parameters2;
2572 parameters2.codecs.push_back(kVp8Codec);
2573 EXPECT_TRUE(channel_->SetSendParameters(parameters2));
2574 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
2575}
2576
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002577TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002578 cricket::VideoRecvParameters parameters;
2579 parameters.codecs.push_back(kVp8Codec);
2580 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002581}
2582
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002583// Test that we set our inbound RTX codecs properly.
2584TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002585 cricket::VideoRecvParameters parameters;
2586 parameters.codecs.push_back(kVp8Codec);
deadbeef67cf2c12016-04-13 10:07:16 -07002587 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002588 parameters.codecs.push_back(rtx_codec);
2589 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002590 << "RTX codec without associated payload should be rejected.";
2591
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002592 parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1);
2593 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002594 << "RTX codec with invalid associated payload type should be rejected.";
2595
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002596 parameters.codecs[1].SetParam("apt", kVp8Codec.id);
2597 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002598
deadbeef67cf2c12016-04-13 10:07:16 -07002599 cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002600 rtx_codec2.SetParam("apt", rtx_codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002601 parameters.codecs.push_back(rtx_codec2);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002602
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002603 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) <<
2604 "RTX codec with another RTX as associated payload type should be "
2605 "rejected.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002606}
2607
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002608TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002609 cricket::VideoRecvParameters parameters;
2610 parameters.codecs.push_back(kVp8Codec);
2611 parameters.codecs[0].id = 99;
2612 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002613}
2614
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002615TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002616 cricket::VideoRecvParameters parameters;
2617 parameters.codecs = engine_.codecs();
2618 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002619
2620 FakeVideoReceiveStream* stream = AddRecvStream();
Tommi733b5472016-06-10 17:58:01 +02002621 const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002622 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
2623 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002624}
2625
2626TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002627 cricket::VideoRecvParameters parameters;
2628 parameters.codecs.push_back(kVp8Codec);
deadbeef67cf2c12016-04-13 10:07:16 -07002629 parameters.codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002630 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002631}
2632
2633// TODO(pbos): Enable VP9 through external codec support
2634TEST_F(WebRtcVideoChannel2Test,
2635 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002636 cricket::VideoRecvParameters parameters;
2637 parameters.codecs.push_back(kVp8Codec);
2638 parameters.codecs.push_back(kVp9Codec);
2639 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002640}
2641
2642TEST_F(WebRtcVideoChannel2Test,
2643 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002644 cricket::VideoRecvParameters parameters;
2645 parameters.codecs.push_back(kVp8Codec);
2646 parameters.codecs.push_back(kVp9Codec);
2647 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002648 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
2649}
2650
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002651TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002652 cricket::VideoSendParameters send_parameters;
2653 send_parameters.codecs.push_back(kVp8Codec);
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002654 send_parameters.codecs.push_back(kRedCodec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002655 send_parameters.codecs.push_back(kUlpfecCodec);
2656 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002657
2658 FakeVideoReceiveStream* stream = AddRecvStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002659
brandtrb5f2c3f2016-10-04 23:28:39 -07002660 EXPECT_EQ(kUlpfecCodec.id,
2661 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002662
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002663 cricket::VideoRecvParameters recv_parameters;
2664 recv_parameters.codecs.push_back(kVp8Codec);
2665 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002666 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002667 ASSERT_TRUE(stream != NULL);
brandtrb5f2c3f2016-10-04 23:28:39 -07002668 EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002669 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002670}
2671
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002672TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithoutFecDisablesReceivingFec) {
2673 FakeVideoReceiveStream* stream = AddRecvStream();
brandtrb5f2c3f2016-10-04 23:28:39 -07002674 EXPECT_EQ(kUlpfecCodec.id,
2675 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002676
2677 cricket::VideoRecvParameters recv_parameters;
2678 recv_parameters.codecs.push_back(kVp8Codec);
2679 recv_parameters.codecs.push_back(kRedCodec);
2680 recv_parameters.codecs.push_back(kUlpfecCodec);
2681 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
2682 stream = fake_call_->GetVideoReceiveStreams()[0];
2683 ASSERT_TRUE(stream != NULL);
brandtrb5f2c3f2016-10-04 23:28:39 -07002684 EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002685 << "FEC should be enabled on the recieve stream.";
2686
2687 cricket::VideoSendParameters send_parameters;
2688 send_parameters.codecs.push_back(kVp8Codec);
2689 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
2690 stream = fake_call_->GetVideoReceiveStreams()[0];
brandtrb5f2c3f2016-10-04 23:28:39 -07002691 EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002692 << "FEC should have been disabled when we know the other side won't do "
2693 "FEC.";
2694
2695 send_parameters.codecs.push_back(kRedCodec);
2696 send_parameters.codecs.push_back(kUlpfecCodec);
2697 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
2698 stream = fake_call_->GetVideoReceiveStreams()[0];
brandtrb5f2c3f2016-10-04 23:28:39 -07002699 EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002700 << "FEC should be enabled on the recieve stream.";
2701}
2702
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002703TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002704 cricket::VideoRecvParameters parameters;
2705 parameters.codecs.push_back(kVp8Codec);
2706 parameters.codecs.push_back(kRedCodec);
2707 parameters.codecs[1].id = parameters.codecs[0].id;
2708 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002709}
2710
2711TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002712 cricket::VideoRecvParameters parameters;
2713 parameters.codecs.push_back(kVp8Codec);
2714 parameters.codecs.push_back(kVp9Codec);
2715 parameters.codecs[1].id = parameters.codecs[0].id;
2716 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002717}
2718
2719TEST_F(WebRtcVideoChannel2Test,
2720 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002721 cricket::VideoRecvParameters parameters;
2722 parameters.codecs.push_back(kVp8Codec);
2723 parameters.codecs.push_back(kVp8Codec);
2724 parameters.codecs[1].id += 1;
2725 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002726}
2727
deadbeef67cf2c12016-04-13 10:07:16 -07002728// Test that setting the same codecs but with a different order
deadbeef874ca3a2015-08-20 17:19:20 -07002729// doesn't result in the stream being recreated.
2730TEST_F(WebRtcVideoChannel2Test,
deadbeef67cf2c12016-04-13 10:07:16 -07002731 SetRecvCodecsDifferentOrderDoesntRecreateStream) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002732 cricket::VideoRecvParameters parameters1;
2733 parameters1.codecs.push_back(kVp8Codec);
2734 parameters1.codecs.push_back(kRedCodec);
2735 EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
deadbeef874ca3a2015-08-20 17:19:20 -07002736
2737 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2738 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2739
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002740 cricket::VideoRecvParameters parameters2;
2741 parameters2.codecs.push_back(kRedCodec);
2742 parameters2.codecs.push_back(kVp8Codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002743 EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
deadbeef874ca3a2015-08-20 17:19:20 -07002744 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2745}
2746
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002747TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
2748 EXPECT_FALSE(AddSendStream()->IsSending());
2749}
2750
pbos@webrtc.org85f42942014-07-22 09:14:58 +00002751TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
2752 EXPECT_TRUE(AddRecvStream()->IsReceiving());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002753}
2754
2755TEST_F(WebRtcVideoChannel2Test, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002756 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002757 EXPECT_FALSE(stream->IsSending());
2758
2759 // false->true
2760 EXPECT_TRUE(channel_->SetSend(true));
2761 EXPECT_TRUE(stream->IsSending());
2762 // true->true
2763 EXPECT_TRUE(channel_->SetSend(true));
2764 EXPECT_TRUE(stream->IsSending());
2765 // true->false
2766 EXPECT_TRUE(channel_->SetSend(false));
2767 EXPECT_FALSE(stream->IsSending());
2768 // false->false
2769 EXPECT_TRUE(channel_->SetSend(false));
2770 EXPECT_FALSE(stream->IsSending());
2771
2772 EXPECT_TRUE(channel_->SetSend(true));
2773 FakeVideoSendStream* new_stream = AddSendStream();
2774 EXPECT_TRUE(new_stream->IsSending())
2775 << "Send stream created after SetSend(true) not sending initially.";
2776}
2777
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002778// This test verifies DSCP settings are properly applied on video media channel.
2779TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
kwiberg686a8ef2016-02-26 03:00:35 -08002780 std::unique_ptr<cricket::FakeNetworkInterface> network_interface(
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002781 new cricket::FakeNetworkInterface);
nisse51542be2016-02-12 02:27:06 -08002782 MediaConfig config;
kwiberg686a8ef2016-02-26 03:00:35 -08002783 std::unique_ptr<VideoMediaChannel> channel;
nisse51542be2016-02-12 02:27:06 -08002784
2785 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2786 channel->SetInterface(network_interface.get());
2787 // Default value when DSCP is disabled should be DSCP_DEFAULT.
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002788 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
nisse51542be2016-02-12 02:27:06 -08002789
2790 config.enable_dscp = true;
2791 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2792 channel->SetInterface(network_interface.get());
2793 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2794
2795 // Verify that setting the option to false resets the
2796 // DiffServCodePoint.
2797 config.enable_dscp = false;
2798 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2799 channel->SetInterface(network_interface.get());
2800 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002801}
2802
deadbeef13871492015-12-09 12:37:51 -08002803// This test verifies that the RTCP reduced size mode is properly applied to
2804// send video streams.
2805TEST_F(WebRtcVideoChannel2Test, TestSetSendRtcpReducedSize) {
2806 // Create stream, expecting that default mode is "compound".
2807 FakeVideoSendStream* stream1 = AddSendStream();
2808 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
2809
2810 // Now enable reduced size mode.
2811 send_parameters_.rtcp.reduced_size = true;
2812 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2813 stream1 = fake_call_->GetVideoSendStreams()[0];
2814 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
2815
2816 // Create a new stream and ensure it picks up the reduced size mode.
2817 FakeVideoSendStream* stream2 = AddSendStream();
2818 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
2819}
2820
2821// This test verifies that the RTCP reduced size mode is properly applied to
2822// receive video streams.
2823TEST_F(WebRtcVideoChannel2Test, TestSetRecvRtcpReducedSize) {
2824 // Create stream, expecting that default mode is "compound".
2825 FakeVideoReceiveStream* stream1 = AddRecvStream();
2826 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
2827
2828 // Now enable reduced size mode.
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002829 // TODO(deadbeef): Once "recv_parameters" becomes "receiver_parameters",
2830 // the reduced_size flag should come from that.
2831 send_parameters_.rtcp.reduced_size = true;
2832 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
deadbeef13871492015-12-09 12:37:51 -08002833 stream1 = fake_call_->GetVideoReceiveStreams()[0];
2834 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
2835
2836 // Create a new stream and ensure it picks up the reduced size mode.
2837 FakeVideoReceiveStream* stream2 = AddRecvStream();
2838 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
2839}
2840
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002841TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
skvlad7a43d252016-03-22 15:32:27 -07002842 EXPECT_EQ(webrtc::kNetworkUp,
2843 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2844 EXPECT_EQ(webrtc::kNetworkUp,
2845 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002846
2847 channel_->OnReadyToSend(false);
skvlad7a43d252016-03-22 15:32:27 -07002848 EXPECT_EQ(webrtc::kNetworkDown,
2849 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2850 EXPECT_EQ(webrtc::kNetworkUp,
2851 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002852
2853 channel_->OnReadyToSend(true);
skvlad7a43d252016-03-22 15:32:27 -07002854 EXPECT_EQ(webrtc::kNetworkUp,
2855 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2856 EXPECT_EQ(webrtc::kNetworkUp,
2857 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002858}
2859
Peter Boström74d9ed72015-03-26 16:28:31 +01002860TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002861 cricket::VideoSendParameters parameters;
2862 parameters.codecs.push_back(kVp8Codec);
2863 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström74d9ed72015-03-26 16:28:31 +01002864
2865 AddSendStream();
2866
2867 cricket::VideoMediaInfo info;
2868 ASSERT_TRUE(channel_->GetStats(&info));
2869 EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name);
2870}
2871
Peter Boströmb7d9a972015-12-18 16:01:11 +01002872TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) {
2873 FakeVideoSendStream* stream = AddSendStream();
2874 webrtc::VideoSendStream::Stats stats;
2875 stats.encoder_implementation_name = "encoder_implementation_name";
2876 stream->SetStats(stats);
2877
2878 cricket::VideoMediaInfo info;
2879 ASSERT_TRUE(channel_->GetStats(&info));
2880 EXPECT_EQ(stats.encoder_implementation_name,
2881 info.senders[0].encoder_implementation_name);
2882}
2883
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002884TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) {
2885 FakeVideoSendStream* stream = AddSendStream();
2886 webrtc::VideoSendStream::Stats stats;
2887 stats.avg_encode_time_ms = 13;
2888 stats.encode_usage_percent = 42;
2889 stream->SetStats(stats);
2890
2891 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002892 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002893 EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms);
2894 EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent);
2895}
2896
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002897TEST_F(WebRtcVideoChannel2Test, GetStatsReportsUpperResolution) {
2898 FakeVideoSendStream* stream = AddSendStream();
2899 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002900 stats.substreams[17].width = 123;
2901 stats.substreams[17].height = 40;
2902 stats.substreams[42].width = 80;
2903 stats.substreams[42].height = 31;
2904 stats.substreams[11].width = 20;
2905 stats.substreams[11].height = 90;
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002906 stream->SetStats(stats);
2907
2908 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002909 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002910 ASSERT_EQ(1u, info.senders.size());
2911 EXPECT_EQ(123, info.senders[0].send_frame_width);
2912 EXPECT_EQ(90, info.senders[0].send_frame_height);
2913}
2914
Pera48ddb72016-09-29 11:48:50 +02002915TEST_F(WebRtcVideoChannel2Test, GetStatsReportsPreferredBitrate) {
2916 FakeVideoSendStream* stream = AddSendStream();
2917 webrtc::VideoSendStream::Stats stats;
2918 stats.preferred_media_bitrate_bps = 5;
2919 stream->SetStats(stats);
2920
2921 cricket::VideoMediaInfo info;
2922 ASSERT_TRUE(channel_->GetStats(&info));
2923 ASSERT_EQ(1u, info.senders.size());
2924 EXPECT_EQ(5, info.senders[0].preferred_bitrate);
2925}
2926
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002927TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) {
2928 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2929
2930 // Capture format VGA.
2931 cricket::FakeVideoCapturer video_capturer_vga;
2932 const std::vector<cricket::VideoFormat>* formats =
2933 video_capturer_vga.GetSupportedFormats();
2934 cricket::VideoFormat capture_format_vga = (*formats)[1];
2935 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
deadbeef5a4a75a2016-06-02 16:23:38 -07002936 EXPECT_TRUE(
2937 channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &video_capturer_vga));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002938 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2939
deadbeef67cf2c12016-04-13 10:07:16 -07002940 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002941 cricket::VideoSendParameters parameters;
2942 parameters.codecs.push_back(send_codec);
2943 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002944 EXPECT_TRUE(channel_->SetSend(true));
2945
2946 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
solenberge5269742015-09-08 05:13:22 -07002947
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002948 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07002949 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002950 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07002951 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
2952 ASSERT_TRUE(overuse_callback != NULL);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002953 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2954
2955 // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
2956 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2957 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002958 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002959 ASSERT_EQ(1U, info.senders.size());
2960 EXPECT_EQ(1, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02002961 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002962
2963 // Trigger upgrade and verify that we adapt back up to VGA.
2964 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2965 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2966 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002967 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002968 ASSERT_EQ(1U, info.senders.size());
2969 EXPECT_EQ(2, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02002970 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002971 info.senders[0].adapt_reason);
2972
2973 // No capturer (no adapter). Adapt changes from old adapter should be kept.
deadbeef5a4a75a2016-06-02 16:23:38 -07002974 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002975 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002976 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002977 ASSERT_EQ(1U, info.senders.size());
2978 EXPECT_EQ(2, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02002979 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002980 info.senders[0].adapt_reason);
2981
2982 // Set new capturer, capture format HD.
2983 cricket::FakeVideoCapturer video_capturer_hd;
2984 cricket::VideoFormat capture_format_hd = (*formats)[0];
2985 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd));
deadbeef5a4a75a2016-06-02 16:23:38 -07002986 EXPECT_TRUE(
2987 channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &video_capturer_hd));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002988 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2989
2990 // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2.
2991 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2992 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2993 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002994 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002995 ASSERT_EQ(1U, info.senders.size());
2996 EXPECT_EQ(3, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02002997 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002998
deadbeef5a4a75a2016-06-02 16:23:38 -07002999 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00003000}
3001
asapersson17821db2015-12-14 02:08:12 -08003002TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationAndBandwidthStats) {
3003 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
3004
3005 // Capture format VGA.
3006 cricket::FakeVideoCapturer video_capturer_vga;
3007 const std::vector<cricket::VideoFormat>* formats =
3008 video_capturer_vga.GetSupportedFormats();
3009 cricket::VideoFormat capture_format_vga = (*formats)[1];
3010 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
deadbeef5a4a75a2016-06-02 16:23:38 -07003011 EXPECT_TRUE(
3012 channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &video_capturer_vga));
asapersson17821db2015-12-14 02:08:12 -08003013 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
3014
deadbeef67cf2c12016-04-13 10:07:16 -07003015 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30);
asapersson17821db2015-12-14 02:08:12 -08003016 cricket::VideoSendParameters parameters;
3017 parameters.codecs.push_back(send_codec);
3018 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3019 EXPECT_TRUE(channel_->SetSend(true));
3020
3021 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
asapersson17821db2015-12-14 02:08:12 -08003022
3023 // Trigger overuse -> adapt CPU.
3024 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
3025 webrtc::LoadObserver* overuse_callback =
3026 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
3027 ASSERT_TRUE(overuse_callback != NULL);
3028 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
3029 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
3030 cricket::VideoMediaInfo info;
3031 EXPECT_TRUE(channel_->GetStats(&info));
3032 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003033 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
asapersson17821db2015-12-14 02:08:12 -08003034
3035 // Set bandwidth limitation stats for the stream -> adapt CPU + BW.
3036 webrtc::VideoSendStream::Stats stats;
3037 stats.bw_limited_resolution = true;
3038 fake_call_->GetVideoSendStreams().front()->SetStats(stats);
3039 info.Clear();
3040 EXPECT_TRUE(channel_->GetStats(&info));
3041 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003042 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU |
3043 WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08003044 info.senders[0].adapt_reason);
3045
3046 // Trigger upgrade -> adapt BW.
3047 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
3048 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
3049 info.Clear();
3050 EXPECT_TRUE(channel_->GetStats(&info));
3051 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003052 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08003053 info.senders[0].adapt_reason);
3054
3055 // Reset bandwidth limitation state -> adapt NONE.
3056 stats.bw_limited_resolution = false;
3057 fake_call_->GetVideoSendStreams().front()->SetStats(stats);
3058 info.Clear();
3059 EXPECT_TRUE(channel_->GetStats(&info));
3060 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003061 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
asapersson17821db2015-12-14 02:08:12 -08003062 info.senders[0].adapt_reason);
3063
deadbeef5a4a75a2016-06-02 16:23:38 -07003064 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr));
asapersson17821db2015-12-14 02:08:12 -08003065}
3066
3067TEST_F(WebRtcVideoChannel2Test,
3068 GetStatsTranslatesBandwidthLimitedResolutionCorrectly) {
3069 FakeVideoSendStream* stream = AddSendStream();
3070 webrtc::VideoSendStream::Stats stats;
3071 stats.bw_limited_resolution = true;
3072 stream->SetStats(stats);
3073
3074 cricket::VideoMediaInfo info;
3075 EXPECT_TRUE(channel_->GetStats(&info));
3076 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003077 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08003078 info.senders[0].adapt_reason);
3079}
3080
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00003081TEST_F(WebRtcVideoChannel2Test,
3082 GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
3083 FakeVideoSendStream* stream = AddSendStream();
3084 webrtc::VideoSendStream::Stats stats;
3085 stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
3086 stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
3087 stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
3088
3089 stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5;
3090 stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7;
3091 stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9;
3092
3093 stream->SetStats(stats);
3094
3095 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003096 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00003097 EXPECT_EQ(7, info.senders[0].firs_rcvd);
3098 EXPECT_EQ(10, info.senders[0].nacks_rcvd);
3099 EXPECT_EQ(13, info.senders[0].plis_rcvd);
3100}
3101
3102TEST_F(WebRtcVideoChannel2Test,
3103 GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
3104 FakeVideoReceiveStream* stream = AddRecvStream();
3105 webrtc::VideoReceiveStream::Stats stats;
3106 stats.rtcp_packet_type_counts.fir_packets = 2;
3107 stats.rtcp_packet_type_counts.nack_packets = 3;
3108 stats.rtcp_packet_type_counts.pli_packets = 4;
3109 stream->SetStats(stats);
3110
3111 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003112 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00003113 EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
3114 info.receivers[0].firs_sent);
3115 EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
3116 info.receivers[0].nacks_sent);
3117 EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
3118 info.receivers[0].plis_sent);
3119}
3120
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003121TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly) {
3122 FakeVideoReceiveStream* stream = AddRecvStream();
3123 webrtc::VideoReceiveStream::Stats stats;
Peter Boströmb7d9a972015-12-18 16:01:11 +01003124 stats.decoder_implementation_name = "decoder_implementation_name";
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003125 stats.decode_ms = 2;
3126 stats.max_decode_ms = 3;
3127 stats.current_delay_ms = 4;
3128 stats.target_delay_ms = 5;
3129 stats.jitter_buffer_ms = 6;
3130 stats.min_playout_delay_ms = 7;
3131 stats.render_delay_ms = 8;
asapersson26dd92b2016-08-30 00:45:45 -07003132 stats.width = 9;
3133 stats.height = 10;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003134 stream->SetStats(stats);
3135
3136 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003137 ASSERT_TRUE(channel_->GetStats(&info));
Peter Boströmb7d9a972015-12-18 16:01:11 +01003138 EXPECT_EQ(stats.decoder_implementation_name,
3139 info.receivers[0].decoder_implementation_name);
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003140 EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms);
3141 EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms);
3142 EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms);
3143 EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms);
3144 EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms);
3145 EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms);
3146 EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
asapersson26dd92b2016-08-30 00:45:45 -07003147 EXPECT_EQ(stats.width, info.receivers[0].frame_width);
3148 EXPECT_EQ(stats.height, info.receivers[0].frame_height);
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003149}
3150
Peter Boström393347f2015-04-22 14:52:45 +02003151TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesReceivePacketStatsCorrectly) {
3152 FakeVideoReceiveStream* stream = AddRecvStream();
3153 webrtc::VideoReceiveStream::Stats stats;
3154 stats.rtp_stats.transmitted.payload_bytes = 2;
3155 stats.rtp_stats.transmitted.header_bytes = 3;
3156 stats.rtp_stats.transmitted.padding_bytes = 4;
3157 stats.rtp_stats.transmitted.packets = 5;
3158 stats.rtcp_stats.cumulative_lost = 6;
3159 stats.rtcp_stats.fraction_lost = 7;
3160 stream->SetStats(stats);
3161
3162 cricket::VideoMediaInfo info;
3163 ASSERT_TRUE(channel_->GetStats(&info));
3164 EXPECT_EQ(stats.rtp_stats.transmitted.payload_bytes +
3165 stats.rtp_stats.transmitted.header_bytes +
3166 stats.rtp_stats.transmitted.padding_bytes,
3167 info.receivers[0].bytes_rcvd);
3168 EXPECT_EQ(stats.rtp_stats.transmitted.packets,
3169 info.receivers[0].packets_rcvd);
3170 EXPECT_EQ(stats.rtcp_stats.cumulative_lost, info.receivers[0].packets_lost);
3171 EXPECT_EQ(static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8),
3172 info.receivers[0].fraction_lost);
3173}
3174
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00003175TEST_F(WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly) {
3176 AddSendStream();
3177 AddSendStream();
3178 webrtc::Call::Stats stats;
3179 stats.rtt_ms = 123;
3180 fake_call_->SetStats(stats);
3181
3182 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003183 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00003184 ASSERT_EQ(2u, info.senders.size());
3185 EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms);
3186 EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms);
3187}
3188
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003189TEST_F(WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly) {
3190 FakeVideoSendStream* stream = AddSendStream();
3191 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003192 stats.target_media_bitrate_bps = 156;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003193 stats.media_bitrate_bps = 123;
3194 stats.substreams[17].total_bitrate_bps = 1;
3195 stats.substreams[17].retransmit_bitrate_bps = 2;
3196 stats.substreams[42].total_bitrate_bps = 3;
3197 stats.substreams[42].retransmit_bitrate_bps = 4;
3198 stream->SetStats(stats);
3199
3200 FakeVideoSendStream* stream2 = AddSendStream();
3201 webrtc::VideoSendStream::Stats stats2;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003202 stats2.target_media_bitrate_bps = 200;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003203 stats2.media_bitrate_bps = 321;
3204 stats2.substreams[13].total_bitrate_bps = 5;
3205 stats2.substreams[13].retransmit_bitrate_bps = 6;
3206 stats2.substreams[21].total_bitrate_bps = 7;
3207 stats2.substreams[21].retransmit_bitrate_bps = 8;
3208 stream2->SetStats(stats2);
3209
3210 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003211 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003212 ASSERT_EQ(2u, info.senders.size());
3213 // Assuming stream and stream2 corresponds to senders[0] and [1] respectively
3214 // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
3215 EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
3216 EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003217 EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
3218 info.bw_estimations[0].target_enc_bitrate);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003219 EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
3220 info.bw_estimations[0].actual_enc_bitrate);
3221 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
3222 << "Bandwidth stats should take all streams into account.";
3223 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
3224 << "Bandwidth stats should take all streams into account.";
3225}
3226
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003227TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003228 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003229
Peter Boström0c4e06b2015-10-07 12:23:21 +02003230 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3231 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003232
3233 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
3234 const size_t kDataLength = 12;
3235 uint8_t data[kDataLength];
3236 memset(data, 0, sizeof(data));
3237 rtc::SetBE32(&data[8], ssrcs[0]);
jbaucheec21bd2016-03-20 06:15:43 -07003238 rtc::CopyOnWriteBuffer packet(data, kDataLength);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003239 rtc::PacketTime packet_time;
3240 channel_->OnPacketReceived(&packet, packet_time);
3241
3242 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3243 << "No default receive stream created.";
3244 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
Peter Boströmd8b01092016-05-12 16:44:36 +02003245 EXPECT_TRUE(recv_stream->GetConfig().rtp.rtx.empty())
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003246 << "Default receive stream should not have configured RTX";
3247
3248 EXPECT_TRUE(channel_->AddRecvStream(
3249 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
3250 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3251 << "AddRecvStream should've reconfigured, not added a new receiver.";
3252 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
Peter Boströmd8b01092016-05-12 16:44:36 +02003253 EXPECT_FALSE(recv_stream->GetConfig().rtp.rtx.empty());
3254 EXPECT_EQ(recv_stream->GetConfig().decoders.size(),
3255 recv_stream->GetConfig().rtp.rtx.size())
3256 << "RTX should be mapped for all decoders/payload types.";
3257 for (const auto& kv : recv_stream->GetConfig().rtp.rtx) {
3258 EXPECT_EQ(rtx_ssrcs[0], kv.second.ssrc);
3259 }
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003260}
3261
Peter Boströmd4362cd2015-03-25 14:17:23 +01003262TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003263 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd4362cd2015-03-25 14:17:23 +01003264
Peter Boström0c4e06b2015-10-07 12:23:21 +02003265 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3266 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd4362cd2015-03-25 14:17:23 +01003267
3268 StreamParams sp =
3269 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
3270 sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
3271
3272 EXPECT_FALSE(channel_->AddSendStream(sp));
3273 EXPECT_FALSE(channel_->AddRecvStream(sp));
3274}
3275
Peter Boströmd6f4c252015-03-26 16:23:04 +01003276TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003277 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003278
Peter Boström0c4e06b2015-10-07 12:23:21 +02003279 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3280 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd6f4c252015-03-26 16:23:04 +01003281
3282 StreamParams sp =
3283 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
3284
3285 EXPECT_TRUE(channel_->AddSendStream(sp));
3286 EXPECT_TRUE(channel_->AddRecvStream(sp));
3287
3288 // The RTX SSRC is already used in previous streams, using it should fail.
3289 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
3290 EXPECT_FALSE(channel_->AddSendStream(sp));
3291 EXPECT_FALSE(channel_->AddRecvStream(sp));
3292
3293 // After removing the original stream this should be fine to add (makes sure
3294 // that RTX ssrcs are not forever taken).
3295 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
3296 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
3297 EXPECT_TRUE(channel_->AddSendStream(sp));
3298 EXPECT_TRUE(channel_->AddRecvStream(sp));
3299}
3300
3301TEST_F(WebRtcVideoChannel2Test,
3302 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02003303 static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3};
3304 static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003305 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003306
Peter Boströmd6f4c252015-03-26 16:23:04 +01003307 StreamParams sp =
3308 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
3309
3310 EXPECT_TRUE(channel_->AddSendStream(sp));
3311 EXPECT_TRUE(channel_->AddRecvStream(sp));
3312
3313 // One of the SSRCs is already used in previous streams, using it should fail.
3314 sp = cricket::CreateSimStreamParams("cname",
3315 MAKE_VECTOR(kOverlappingStreamSsrcs));
3316 EXPECT_FALSE(channel_->AddSendStream(sp));
3317 EXPECT_FALSE(channel_->AddRecvStream(sp));
3318
3319 // After removing the original stream this should be fine to add (makes sure
3320 // that RTX ssrcs are not forever taken).
Peter Boström3548dd22015-05-22 18:48:36 +02003321 EXPECT_TRUE(channel_->RemoveSendStream(kFirstStreamSsrcs[0]));
3322 EXPECT_TRUE(channel_->RemoveRecvStream(kFirstStreamSsrcs[0]));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003323 EXPECT_TRUE(channel_->AddSendStream(sp));
3324 EXPECT_TRUE(channel_->AddRecvStream(sp));
3325}
3326
Peter Boström259bd202015-05-28 13:39:50 +02003327TEST_F(WebRtcVideoChannel2Test, ReportsSsrcGroupsInStats) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003328 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström259bd202015-05-28 13:39:50 +02003329
3330 static const uint32_t kSenderSsrcs[] = {4, 7, 10};
3331 static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11};
3332
3333 StreamParams sender_sp = cricket::CreateSimWithRtxStreamParams(
3334 "cname", MAKE_VECTOR(kSenderSsrcs), MAKE_VECTOR(kSenderRtxSsrcs));
3335
3336 EXPECT_TRUE(channel_->AddSendStream(sender_sp));
3337
3338 static const uint32_t kReceiverSsrcs[] = {3};
3339 static const uint32_t kReceiverRtxSsrcs[] = {2};
3340
3341 StreamParams receiver_sp = cricket::CreateSimWithRtxStreamParams(
3342 "cname", MAKE_VECTOR(kReceiverSsrcs), MAKE_VECTOR(kReceiverRtxSsrcs));
3343 EXPECT_TRUE(channel_->AddRecvStream(receiver_sp));
3344
3345 cricket::VideoMediaInfo info;
3346 ASSERT_TRUE(channel_->GetStats(&info));
3347
3348 ASSERT_EQ(1u, info.senders.size());
3349 ASSERT_EQ(1u, info.receivers.size());
3350
3351 EXPECT_NE(sender_sp.ssrc_groups, receiver_sp.ssrc_groups);
3352 EXPECT_EQ(sender_sp.ssrc_groups, info.senders[0].ssrc_groups);
3353 EXPECT_EQ(receiver_sp.ssrc_groups, info.receivers[0].ssrc_groups);
3354}
3355
pbosf42376c2015-08-28 07:35:32 -07003356TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) {
3357 FakeVideoReceiveStream* stream = AddRecvStream();
3358 webrtc::VideoReceiveStream::Stats stats;
3359 cricket::VideoMediaInfo info;
3360
3361 // Report no codec name before receiving.
3362 stream->SetStats(stats);
3363 ASSERT_TRUE(channel_->GetStats(&info));
3364 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3365
3366 // Report VP8 if we're receiving it.
3367 stats.current_payload_type = kDefaultVp8PlType;
3368 stream->SetStats(stats);
3369 ASSERT_TRUE(channel_->GetStats(&info));
3370 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str());
3371
3372 // Report no codec name for unknown playload types.
3373 stats.current_payload_type = 3;
3374 stream->SetStats(stats);
3375 ASSERT_TRUE(channel_->GetStats(&info));
3376 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3377}
3378
noahricd10a68e2015-07-10 11:27:55 -07003379void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket(
3380 uint8_t payload_type,
3381 bool expect_created_receive_stream) {
noahricd10a68e2015-07-10 11:27:55 -07003382 // Add a RED RTX codec.
3383 VideoCodec red_rtx_codec =
3384 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003385 recv_parameters_.codecs.push_back(red_rtx_codec);
3386 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
noahricd10a68e2015-07-10 11:27:55 -07003387
3388 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
3389 const size_t kDataLength = 12;
3390 uint8_t data[kDataLength];
3391 memset(data, 0, sizeof(data));
3392
3393 rtc::Set8(data, 1, payload_type);
3394 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
jbaucheec21bd2016-03-20 06:15:43 -07003395 rtc::CopyOnWriteBuffer packet(data, kDataLength);
noahricd10a68e2015-07-10 11:27:55 -07003396 rtc::PacketTime packet_time;
3397 channel_->OnPacketReceived(&packet, packet_time);
3398
3399 if (expect_created_receive_stream) {
3400 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3401 << "Should have created a receive stream for payload type: "
3402 << payload_type;
3403 } else {
3404 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size())
3405 << "Shouldn't have created a receive stream for payload type: "
3406 << payload_type;
3407 }
3408}
3409
3410TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) {
3411 TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true);
3412}
3413
3414TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) {
3415 TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true);
3416}
3417
3418TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) {
3419 TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false);
3420}
3421
3422TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
3423 TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false);
3424}
3425
3426TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
3427 TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false);
3428}
3429
skvladdc1c62c2016-03-16 19:07:43 -07003430TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) {
3431 AddSendStream();
3432
3433 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07003434 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
skvladdc1c62c2016-03-16 19:07:43 -07003435 cricket::VideoFormat capture_format_hd =
3436 capturer.GetSupportedFormats()->front();
3437 EXPECT_EQ(1280, capture_format_hd.width);
3438 EXPECT_EQ(720, capture_format_hd.height);
3439 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
3440 EXPECT_TRUE(channel_->SetSend(true));
perkjfa10b552016-10-02 23:45:26 -07003441 capturer.CaptureFrame();
skvladdc1c62c2016-03-16 19:07:43 -07003442
perkjfa10b552016-10-02 23:45:26 -07003443 int default_encoder_bitrate = GetMaxEncoderBitrate();
skvladdc1c62c2016-03-16 19:07:43 -07003444 EXPECT_TRUE(default_encoder_bitrate > 1000);
3445
3446 // TODO(skvlad): Resolve the inconsistency between the interpretation
3447 // of the global bitrate limit for audio and video:
3448 // - Audio: max_bandwidth_bps = 0 - fail the operation,
3449 // max_bandwidth_bps = -1 - remove the bandwidth limit
3450 // - Video: max_bandwidth_bps = 0 - remove the bandwidth limit,
3451 // max_bandwidth_bps = -1 - do not change the previously set
3452 // limit.
3453
perkjfa10b552016-10-02 23:45:26 -07003454 SetAndExpectMaxBitrate(1000, 0, 1000);
3455 SetAndExpectMaxBitrate(1000, 800, 800);
3456 SetAndExpectMaxBitrate(600, 800, 600);
3457 SetAndExpectMaxBitrate(0, 800, 800);
3458 SetAndExpectMaxBitrate(0, 0, default_encoder_bitrate);
skvladdc1c62c2016-03-16 19:07:43 -07003459
deadbeef5a4a75a2016-06-02 16:23:38 -07003460 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
skvladdc1c62c2016-03-16 19:07:43 -07003461}
3462
3463TEST_F(WebRtcVideoChannel2Test, CannotSetMaxBitrateForNonexistentStream) {
3464 webrtc::RtpParameters nonexistent_parameters =
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003465 channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07003466 EXPECT_EQ(0, nonexistent_parameters.encodings.size());
3467
3468 nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003469 EXPECT_FALSE(
3470 channel_->SetRtpSendParameters(last_ssrc_, nonexistent_parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003471}
3472
3473TEST_F(WebRtcVideoChannel2Test,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003474 CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) {
skvladdc1c62c2016-03-16 19:07:43 -07003475 // This test verifies that setting RtpParameters succeeds only if
3476 // the structure contains exactly one encoding.
deadbeefdbe2b872016-03-22 15:42:00 -07003477 // TODO(skvlad): Update this test when we start supporting setting parameters
skvladdc1c62c2016-03-16 19:07:43 -07003478 // for each encoding individually.
3479
3480 AddSendStream();
3481 // Setting RtpParameters with no encoding is expected to fail.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003482 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
3483 parameters.encodings.clear();
3484 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003485 // Setting RtpParameters with exactly one encoding should succeed.
3486 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003487 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003488 // Two or more encodings should result in failure.
3489 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003490 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003491}
3492
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07003493// Test that a stream will not be sending if its encoding is made inactive
3494// through SetRtpSendParameters.
deadbeefdbe2b872016-03-22 15:42:00 -07003495// TODO(deadbeef): Update this test when we start supporting setting parameters
3496// for each encoding individually.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003497TEST_F(WebRtcVideoChannel2Test, SetRtpSendParametersEncodingsActive) {
deadbeefdbe2b872016-03-22 15:42:00 -07003498 FakeVideoSendStream* stream = AddSendStream();
3499 EXPECT_TRUE(channel_->SetSend(true));
3500 EXPECT_TRUE(stream->IsSending());
3501
3502 // Get current parameters and change "active" to false.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003503 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
deadbeefdbe2b872016-03-22 15:42:00 -07003504 ASSERT_EQ(1u, parameters.encodings.size());
3505 ASSERT_TRUE(parameters.encodings[0].active);
3506 parameters.encodings[0].active = false;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003507 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
deadbeefdbe2b872016-03-22 15:42:00 -07003508 EXPECT_FALSE(stream->IsSending());
3509
3510 // Now change it back to active and verify we resume sending.
3511 parameters.encodings[0].active = true;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003512 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
deadbeefdbe2b872016-03-22 15:42:00 -07003513 EXPECT_TRUE(stream->IsSending());
3514}
3515
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07003516// Test that if a stream is reconfigured (due to a codec change or other
3517// change) while its encoding is still inactive, it doesn't start sending.
3518TEST_F(WebRtcVideoChannel2Test,
3519 InactiveStreamDoesntStartSendingWhenReconfigured) {
3520 // Set an initial codec list, which will be modified later.
3521 cricket::VideoSendParameters parameters1;
3522 parameters1.codecs.push_back(kVp8Codec);
3523 parameters1.codecs.push_back(kVp9Codec);
3524 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
3525
3526 FakeVideoSendStream* stream = AddSendStream();
3527 EXPECT_TRUE(channel_->SetSend(true));
3528 EXPECT_TRUE(stream->IsSending());
3529
3530 // Get current parameters and change "active" to false.
3531 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
3532 ASSERT_EQ(1u, parameters.encodings.size());
3533 ASSERT_TRUE(parameters.encodings[0].active);
3534 parameters.encodings[0].active = false;
3535 EXPECT_EQ(1u, GetFakeSendStreams().size());
3536 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
3537 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
3538 EXPECT_FALSE(stream->IsSending());
3539
3540 // Reorder the codec list, causing the stream to be reconfigured.
3541 cricket::VideoSendParameters parameters2;
3542 parameters2.codecs.push_back(kVp9Codec);
3543 parameters2.codecs.push_back(kVp8Codec);
3544 EXPECT_TRUE(channel_->SetSendParameters(parameters2));
3545 auto new_streams = GetFakeSendStreams();
3546 // Assert that a new underlying stream was created due to the codec change.
3547 // Otherwise, this test isn't testing what it set out to test.
3548 EXPECT_EQ(1u, GetFakeSendStreams().size());
3549 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
3550
3551 // Verify that we still are not sending anything, due to the inactive
3552 // encoding.
3553 EXPECT_FALSE(new_streams[0]->IsSending());
3554}
3555
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003556// Test that GetRtpSendParameters returns the currently configured codecs.
3557TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003558 AddSendStream();
3559 cricket::VideoSendParameters parameters;
3560 parameters.codecs.push_back(kVp8Codec);
3561 parameters.codecs.push_back(kVp9Codec);
3562 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3563
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003564 webrtc::RtpParameters rtp_parameters =
3565 channel_->GetRtpSendParameters(last_ssrc_);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003566 ASSERT_EQ(2u, rtp_parameters.codecs.size());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003567 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]);
3568 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003569}
3570
3571// Test that if we set/get parameters multiple times, we get the same results.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003572TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003573 AddSendStream();
3574 cricket::VideoSendParameters parameters;
3575 parameters.codecs.push_back(kVp8Codec);
3576 parameters.codecs.push_back(kVp9Codec);
3577 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3578
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003579 webrtc::RtpParameters initial_params =
3580 channel_->GetRtpSendParameters(last_ssrc_);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003581
3582 // We should be able to set the params we just got.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003583 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, initial_params));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003584
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003585 // ... And this shouldn't change the params returned by GetRtpSendParameters.
3586 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(last_ssrc_));
3587}
3588
3589// Test that GetRtpReceiveParameters returns the currently configured codecs.
3590TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) {
3591 AddRecvStream();
3592 cricket::VideoRecvParameters parameters;
3593 parameters.codecs.push_back(kVp8Codec);
3594 parameters.codecs.push_back(kVp9Codec);
3595 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
3596
3597 webrtc::RtpParameters rtp_parameters =
3598 channel_->GetRtpReceiveParameters(last_ssrc_);
3599 ASSERT_EQ(2u, rtp_parameters.codecs.size());
3600 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]);
3601 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]);
3602}
3603
johan073ece42016-08-26 02:59:47 -07003604#if defined(WEBRTC_USE_H264)
johan3859c892016-08-05 09:19:25 -07003605TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveFmtpSprop) {
johan073ece42016-08-26 02:59:47 -07003606#else
3607TEST_F(WebRtcVideoChannel2Test, DISABLED_GetRtpReceiveFmtpSprop) {
3608#endif
johan3859c892016-08-05 09:19:25 -07003609 cricket::VideoRecvParameters parameters;
3610 cricket::VideoCodec kH264sprop1(101, "H264", 640, 400, 15);
3611 kH264sprop1.SetParam("sprop-parameter-sets", "uvw");
3612 parameters.codecs.push_back(kH264sprop1);
3613 cricket::VideoCodec kH264sprop2(102, "H264", 640, 400, 15);
3614 kH264sprop2.SetParam("sprop-parameter-sets", "xyz");
3615 parameters.codecs.push_back(kH264sprop2);
3616 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
3617
3618 FakeVideoReceiveStream* recv_stream = AddRecvStream();
3619 const webrtc::VideoReceiveStream::Config& cfg = recv_stream->GetConfig();
3620 webrtc::RtpParameters rtp_parameters =
3621 channel_->GetRtpReceiveParameters(last_ssrc_);
3622 ASSERT_EQ(2u, rtp_parameters.codecs.size());
3623 EXPECT_EQ(kH264sprop1.ToCodecParameters(), rtp_parameters.codecs[0]);
3624 ASSERT_EQ(2u, cfg.decoders.size());
3625 EXPECT_EQ(101, cfg.decoders[0].payload_type);
3626 EXPECT_EQ("H264", cfg.decoders[0].payload_name);
3627 std::string sprop;
3628 const webrtc::DecoderSpecificSettings* decoder_specific;
3629 decoder_specific = &cfg.decoders[0].decoder_specific;
3630 ASSERT_TRUE(static_cast<bool>(decoder_specific->h264_extra_settings));
3631 sprop = decoder_specific->h264_extra_settings->sprop_parameter_sets;
3632 EXPECT_EQ("uvw", sprop);
3633
3634 EXPECT_EQ(102, cfg.decoders[1].payload_type);
3635 EXPECT_EQ("H264", cfg.decoders[1].payload_name);
3636 decoder_specific = &cfg.decoders[1].decoder_specific;
3637 ASSERT_TRUE(static_cast<bool>(decoder_specific->h264_extra_settings));
3638 sprop = decoder_specific->h264_extra_settings->sprop_parameter_sets;
3639 EXPECT_EQ("xyz", sprop);
3640}
3641
sakal1fd95952016-06-22 00:46:15 -07003642// Test that RtpParameters for receive stream has one encoding and it has
3643// the correct SSRC.
3644TEST_F(WebRtcVideoChannel2Test, RtpEncodingParametersSsrcIsSet) {
3645 AddRecvStream();
3646
3647 webrtc::RtpParameters rtp_parameters =
3648 channel_->GetRtpReceiveParameters(last_ssrc_);
3649 ASSERT_EQ(1u, rtp_parameters.encodings.size());
3650 EXPECT_EQ(rtc::Optional<uint32_t>(last_ssrc_),
3651 rtp_parameters.encodings[0].ssrc);
3652}
3653
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003654// Test that if we set/get parameters multiple times, we get the same results.
3655TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) {
3656 AddRecvStream();
3657 cricket::VideoRecvParameters parameters;
3658 parameters.codecs.push_back(kVp8Codec);
3659 parameters.codecs.push_back(kVp9Codec);
3660 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
3661
3662 webrtc::RtpParameters initial_params =
3663 channel_->GetRtpReceiveParameters(last_ssrc_);
3664
3665 // We should be able to set the params we just got.
3666 EXPECT_TRUE(channel_->SetRtpReceiveParameters(last_ssrc_, initial_params));
3667
3668 // ... And this shouldn't change the params returned by
3669 // GetRtpReceiveParameters.
3670 EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(last_ssrc_));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003671}
3672
Peter Boström3548dd22015-05-22 18:48:36 +02003673void WebRtcVideoChannel2Test::TestReceiverLocalSsrcConfiguration(
3674 bool receiver_first) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003675 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström3548dd22015-05-22 18:48:36 +02003676
3677 const uint32_t kSenderSsrc = 0xC0FFEE;
Peter Boströmdfa28152015-10-21 17:21:10 +02003678 const uint32_t kSecondSenderSsrc = 0xBADCAFE;
Peter Boström3548dd22015-05-22 18:48:36 +02003679 const uint32_t kReceiverSsrc = 0x4711;
Peter Boströmdfa28152015-10-21 17:21:10 +02003680 const uint32_t kExpectedDefaultReceiverSsrc = 1;
Peter Boström3548dd22015-05-22 18:48:36 +02003681
3682 if (receiver_first) {
3683 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
3684 std::vector<FakeVideoReceiveStream*> receive_streams =
3685 fake_call_->GetVideoReceiveStreams();
3686 ASSERT_EQ(1u, receive_streams.size());
Peter Boströmdfa28152015-10-21 17:21:10 +02003687 // Default local SSRC when we have no sender.
3688 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
3689 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02003690 }
3691 AddSendStream(StreamParams::CreateLegacy(kSenderSsrc));
3692 if (!receiver_first)
3693 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
3694 std::vector<FakeVideoReceiveStream*> receive_streams =
3695 fake_call_->GetVideoReceiveStreams();
3696 ASSERT_EQ(1u, receive_streams.size());
3697 EXPECT_EQ(kSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boströmdfa28152015-10-21 17:21:10 +02003698
3699 // Removing first sender should fall back to another (in this case the second)
3700 // local send stream's SSRC.
3701 AddSendStream(StreamParams::CreateLegacy(kSecondSenderSsrc));
3702 ASSERT_TRUE(channel_->RemoveSendStream(kSenderSsrc));
3703 receive_streams =
3704 fake_call_->GetVideoReceiveStreams();
3705 ASSERT_EQ(1u, receive_streams.size());
3706 EXPECT_EQ(kSecondSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
3707
3708 // Removing the last sender should fall back to default local SSRC.
3709 ASSERT_TRUE(channel_->RemoveSendStream(kSecondSenderSsrc));
3710 receive_streams =
3711 fake_call_->GetVideoReceiveStreams();
3712 ASSERT_EQ(1u, receive_streams.size());
3713 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
3714 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02003715}
3716
3717TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrc) {
3718 TestReceiverLocalSsrcConfiguration(false);
3719}
3720
3721TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) {
3722 TestReceiverLocalSsrcConfiguration(true);
3723}
3724
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003725class WebRtcVideoChannel2SimulcastTest : public testing::Test {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003726 public:
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003727 WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {}
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003728
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00003729 void SetUp() override {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +02003730 engine_.Init();
nisse51542be2016-02-12 02:27:06 -08003731 channel_.reset(
3732 engine_.CreateChannel(&fake_call_, MediaConfig(), VideoOptions()));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003733 last_ssrc_ = 123;
3734 }
3735
3736 protected:
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003737 void VerifySimulcastSettings(const VideoCodec& codec,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003738 size_t num_configured_streams,
pbosbe16f792015-10-16 12:49:39 -07003739 size_t expected_num_streams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003740 cricket::VideoSendParameters parameters;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003741 parameters.codecs.push_back(codec);
3742 ASSERT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003743
Peter Boström0c4e06b2015-10-07 12:23:21 +02003744 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
henrikg91d6ede2015-09-17 00:24:34 -07003745 RTC_DCHECK(num_configured_streams <= ssrcs.size());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003746 ssrcs.resize(num_configured_streams);
3747
3748 FakeVideoSendStream* stream =
3749 AddSendStream(CreateSimStreamParams("cname", ssrcs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003750 // Send a full-size frame to trigger a stream reconfiguration to use all
3751 // expected simulcast layers.
3752 cricket::FakeVideoCapturer capturer;
deadbeef5a4a75a2016-06-02 16:23:38 -07003753 EXPECT_TRUE(
3754 channel_->SetVideoSend(ssrcs.front(), true, nullptr, &capturer));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003755 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
3756 codec.width, codec.height,
3757 cricket::VideoFormat::FpsToInterval(30),
3758 cricket::FOURCC_I420)));
3759 channel_->SetSend(true);
3760 EXPECT_TRUE(capturer.CaptureFrame());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003761
3762 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
3763 ASSERT_EQ(expected_num_streams, video_streams.size());
3764
3765 std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
pbosbe16f792015-10-16 12:49:39 -07003766 num_configured_streams, codec.width, codec.height, 0, kDefaultQpMax,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003767 codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
3768
3769 ASSERT_EQ(expected_streams.size(), video_streams.size());
3770
3771 size_t num_streams = video_streams.size();
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003772 int total_max_bitrate_bps = 0;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003773 for (size_t i = 0; i < num_streams; ++i) {
3774 EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
3775 EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
3776
3777 EXPECT_GT(video_streams[i].max_framerate, 0);
3778 EXPECT_EQ(expected_streams[i].max_framerate,
3779 video_streams[i].max_framerate);
3780
3781 EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
3782 EXPECT_EQ(expected_streams[i].min_bitrate_bps,
3783 video_streams[i].min_bitrate_bps);
3784
3785 EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
3786 EXPECT_EQ(expected_streams[i].target_bitrate_bps,
3787 video_streams[i].target_bitrate_bps);
3788
3789 EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
3790 EXPECT_EQ(expected_streams[i].max_bitrate_bps,
3791 video_streams[i].max_bitrate_bps);
3792
3793 EXPECT_GT(video_streams[i].max_qp, 0);
3794 EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
3795
3796 EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty());
3797 EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps,
3798 video_streams[i].temporal_layer_thresholds_bps);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003799
3800 if (i == num_streams - 1) {
3801 total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
3802 } else {
3803 total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
3804 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003805 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003806
deadbeef5a4a75a2016-06-02 16:23:38 -07003807 EXPECT_TRUE(channel_->SetVideoSend(ssrcs.front(), true, nullptr, nullptr));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003808 }
3809
3810 FakeVideoSendStream* AddSendStream() {
3811 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
3812 }
3813
3814 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
3815 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003816 fake_call_.GetVideoSendStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003817 EXPECT_TRUE(channel_->AddSendStream(sp));
3818 std::vector<FakeVideoSendStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003819 fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003820 EXPECT_EQ(num_streams + 1, streams.size());
3821 return streams[streams.size() - 1];
3822 }
3823
3824 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003825 return fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003826 }
3827
3828 FakeVideoReceiveStream* AddRecvStream() {
3829 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
3830 }
3831
3832 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
3833 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003834 fake_call_.GetVideoReceiveStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003835 EXPECT_TRUE(channel_->AddRecvStream(sp));
3836 std::vector<FakeVideoReceiveStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003837 fake_call_.GetVideoReceiveStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003838 EXPECT_EQ(num_streams + 1, streams.size());
3839 return streams[streams.size() - 1];
3840 }
3841
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003842 FakeCall fake_call_;
3843 WebRtcVideoEngine2 engine_;
kwiberg686a8ef2016-02-26 03:00:35 -08003844 std::unique_ptr<VideoMediaChannel> channel_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02003845 uint32_t last_ssrc_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003846};
3847
3848TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003849 VerifySimulcastSettings(kVp8Codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003850}
3851
3852TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003853 VerifySimulcastSettings(kVp8Codec720p, 3, 3);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003854}
3855
3856// Test that we normalize send codec format size in simulcast.
3857TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
3858 cricket::VideoCodec codec(kVp8Codec270p);
3859 codec.width += 1;
3860 codec.height += 1;
pbosbe16f792015-10-16 12:49:39 -07003861 VerifySimulcastSettings(codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003862}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003863} // namespace cricket