blob: b0145b472bee66f57e081fbed7735499cc6607cd [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
30namespace {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000031static const int kDefaultQpMax = 56;
32static const int kDefaultFramerate = 30;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000033
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000034static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0);
35static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30, 0);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000036static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30, 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000037
38static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0);
39static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000040static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0);
41
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000042static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0);
43static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0);
44
noahricd10a68e2015-07-10 11:27:55 -070045static const uint8_t kRedRtxPayloadType = 125;
46
Peter Boström0c4e06b2015-10-07 12:23:21 +020047static const uint32_t kSsrcs1[] = {1};
48static const uint32_t kSsrcs3[] = {1, 2, 3};
49static const uint32_t kRtxSsrcs1[] = {4};
50static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
pbos@webrtc.org3c107582014-07-20 15:27:35 +000051static const char kUnsupportedExtensionName[] =
52 "urn:ietf:params:rtp-hdrext:unsupported";
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000053
54void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
55 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
56 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
57 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
58 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
59 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
60 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
61 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
stefan43edf0f2015-11-20 18:05:48 -080062 cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty)));
63 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000064 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
65}
66
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -070067static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000068 int width,
69 int height) {
70 video_frame->CreateEmptyFrame(
71 width, height, width, (width + 1) / 2, (width + 1) / 2);
72 memset(video_frame->buffer(webrtc::kYPlane), 16,
73 video_frame->allocated_size(webrtc::kYPlane));
74 memset(video_frame->buffer(webrtc::kUPlane), 128,
75 video_frame->allocated_size(webrtc::kUPlane));
76 memset(video_frame->buffer(webrtc::kVPlane), 128,
77 video_frame->allocated_size(webrtc::kVPlane));
78}
79
Shao Changbine62202f2015-04-21 20:24:50 +080080void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
81 const std::map<int, int>& rtx_types) {
82 std::map<int, int>::const_iterator it;
83 it = rtx_types.find(config.encoder_settings.payload_type);
84 EXPECT_TRUE(it != rtx_types.end() &&
85 it->second == config.rtp.rtx.payload_type);
86
87 if (config.rtp.fec.red_rtx_payload_type != -1) {
88 it = rtx_types.find(config.rtp.fec.red_payload_type);
89 EXPECT_TRUE(it != rtx_types.end() &&
90 it->second == config.rtp.fec.red_rtx_payload_type);
91 }
92}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000093} // namespace
94
95namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000096class WebRtcVideoEngine2Test : public ::testing::Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000097 public:
stefanc1aeaf02015-10-15 07:26:07 -070098 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {}
99 explicit WebRtcVideoEngine2Test(const char* field_trials)
100 : WebRtcVideoEngine2Test(nullptr, field_trials) {}
101 WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine,
102 const char* field_trials)
103 : override_field_trials_(field_trials),
104 call_(webrtc::Call::Create(webrtc::Call::Config())),
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200105 engine_() {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000106 std::vector<VideoCodec> engine_codecs = engine_.codecs();
henrikg91d6ede2015-09-17 00:24:34 -0700107 RTC_DCHECK(!engine_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000108 bool codec_set = false;
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000109 for (size_t i = 0; i < engine_codecs.size(); ++i) {
110 if (engine_codecs[i].name == "red") {
111 default_red_codec_ = engine_codecs[i];
112 } else if (engine_codecs[i].name == "ulpfec") {
113 default_ulpfec_codec_ = engine_codecs[i];
114 } else if (engine_codecs[i].name == "rtx") {
Shao Changbine62202f2015-04-21 20:24:50 +0800115 int associated_payload_type;
116 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
117 &associated_payload_type)) {
118 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id;
119 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000120 } else if (!codec_set) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000121 default_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000122 codec_set = true;
123 }
124 }
125
henrikg91d6ede2015-09-17 00:24:34 -0700126 RTC_DCHECK(codec_set);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000127 }
128
129 protected:
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000130 VideoMediaChannel* SetUpForExternalEncoderFactory(
131 cricket::WebRtcVideoEncoderFactory* encoder_factory,
132 const std::vector<VideoCodec>& codecs);
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000133
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000134 VideoMediaChannel* SetUpForExternalDecoderFactory(
135 cricket::WebRtcVideoDecoderFactory* decoder_factory,
136 const std::vector<VideoCodec>& codecs);
137
Peter Boströme4499152016-02-05 11:13:28 +0100138 void TestExtendedEncoderOveruse(bool use_external_encoder);
139
stefanc1aeaf02015-10-15 07:26:07 -0700140 webrtc::test::ScopedFieldTrials override_field_trials_;
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000141 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
142 // initialized when the constructor is called.
kwiberg686a8ef2016-02-26 03:00:35 -0800143 std::unique_ptr<webrtc::Call> call_;
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000144 WebRtcVoiceEngine voice_engine_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000145 WebRtcVideoEngine2 engine_;
146 VideoCodec default_codec_;
147 VideoCodec default_red_codec_;
148 VideoCodec default_ulpfec_codec_;
Shao Changbine62202f2015-04-21 20:24:50 +0800149 std::map<int, int> default_apt_rtx_types_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000150};
151
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000152TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
153 std::vector<VideoCodec> engine_codecs = engine_.codecs();
154 for (size_t i = 0; i < engine_codecs.size(); ++i) {
155 if (engine_codecs[i].name != kRtxCodecName)
156 continue;
157 int associated_payload_type;
158 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000159 &associated_payload_type));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000160 EXPECT_EQ(default_codec_.id, associated_payload_type);
161 return;
162 }
163 FAIL() << "No RTX codec found among default codecs.";
164}
165
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000166TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100167 RtpCapabilities capabilities = engine_.GetCapabilities();
168 ASSERT_FALSE(capabilities.header_extensions.empty());
169 for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
170 if (extension.uri == kRtpTimestampOffsetHeaderExtension) {
171 EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extension.id);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000172 return;
173 }
174 }
175 FAIL() << "Timestamp offset extension not in header-extension list.";
176}
177
178TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100179 RtpCapabilities capabilities = engine_.GetCapabilities();
180 ASSERT_FALSE(capabilities.header_extensions.empty());
181 for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
182 if (extension.uri == kRtpAbsoluteSenderTimeHeaderExtension) {
183 EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId, extension.id);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000184 return;
185 }
186 }
187 FAIL() << "Absolute Sender Time extension not in header-extension list.";
188}
189
stefanc1aeaf02015-10-15 07:26:07 -0700190class WebRtcVideoEngine2WithSendSideBweTest : public WebRtcVideoEngine2Test {
191 public:
192 WebRtcVideoEngine2WithSendSideBweTest()
193 : WebRtcVideoEngine2Test("WebRTC-SendSideBwe/Enabled/") {}
194};
195
196TEST_F(WebRtcVideoEngine2WithSendSideBweTest,
197 SupportsTransportSequenceNumberHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100198 RtpCapabilities capabilities = engine_.GetCapabilities();
199 ASSERT_FALSE(capabilities.header_extensions.empty());
200 for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
201 if (extension.uri == kRtpTransportSequenceNumberHeaderExtension) {
stefanc1aeaf02015-10-15 07:26:07 -0700202 EXPECT_EQ(kRtpTransportSequenceNumberHeaderExtensionDefaultId,
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100203 extension.id);
stefanc1aeaf02015-10-15 07:26:07 -0700204 return;
205 }
206 }
207 FAIL() << "Transport sequence number extension not in header-extension list.";
208}
209
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700210TEST_F(WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100211 RtpCapabilities capabilities = engine_.GetCapabilities();
212 ASSERT_FALSE(capabilities.header_extensions.empty());
213 for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
214 if (extension.uri == kRtpVideoRotationHeaderExtension) {
215 EXPECT_EQ(kRtpVideoRotationHeaderExtensionDefaultId, extension.id);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700216 return;
217 }
218 }
219 FAIL() << "Video Rotation extension not in header-extension list.";
220}
221
222TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
223 // Allocate the capturer first to prevent early destruction before channel's
224 // dtor is called.
225 cricket::FakeVideoCapturer capturer;
226
227 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
228 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200229 cricket::VideoSendParameters parameters;
230 parameters.codecs.push_back(kVp8Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700231
kwiberg686a8ef2016-02-26 03:00:35 -0800232 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200233 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700234 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
235
236 // Add CVO extension.
237 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200238 parameters.extensions.push_back(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700239 cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200240 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700241
242 // Set capturer.
243 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
244
245 // Verify capturer has turned off applying rotation.
246 EXPECT_FALSE(capturer.GetApplyRotation());
247
248 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200249 parameters.extensions.clear();
250 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700251 EXPECT_TRUE(capturer.GetApplyRotation());
252}
253
perkj91e1c152016-03-02 05:34:00 -0800254TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) {
255 // Allocate the capturer first to prevent early destruction before channel's
256 // dtor is called.
257 cricket::FakeVideoCapturer capturer;
258
259 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
260 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
261 cricket::VideoSendParameters parameters;
262 parameters.codecs.push_back(kVp8Codec);
263
264 std::unique_ptr<VideoMediaChannel> channel(
265 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
266 // Add CVO extension.
267 const int id = 1;
268 parameters.extensions.push_back(
269 cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
270 EXPECT_TRUE(channel->SetSendParameters(parameters));
271 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
272
273 // Set capturer.
274 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
275
276 // Verify capturer has turned off applying rotation.
277 EXPECT_FALSE(capturer.GetApplyRotation());
278}
279
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700280TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
281 cricket::FakeVideoCapturer capturer;
282
283 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
284 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
perkjcaafdba2016-03-20 07:34:29 -0700285 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200286 cricket::VideoSendParameters parameters;
287 parameters.codecs.push_back(kVp8Codec);
perkjcaafdba2016-03-20 07:34:29 -0700288 parameters.codecs.push_back(kVp9Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700289
kwiberg686a8ef2016-02-26 03:00:35 -0800290 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200291 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700292 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
293
294 // Set capturer.
295 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
296
perkjcaafdba2016-03-20 07:34:29 -0700297 // Verify capturer has turned on applying rotation.
298 EXPECT_TRUE(capturer.GetApplyRotation());
299
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700300 // Add CVO extension.
301 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200302 parameters.extensions.push_back(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700303 cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
perkjcaafdba2016-03-20 07:34:29 -0700304 // Also remove the first codec to trigger a codec change as well.
305 parameters.codecs.erase(parameters.codecs.begin());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200306 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700307
308 // Verify capturer has turned off applying rotation.
309 EXPECT_FALSE(capturer.GetApplyRotation());
310
311 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200312 parameters.extensions.clear();
313 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700314 EXPECT_TRUE(capturer.GetApplyRotation());
315}
316
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000317TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200318 engine_.Init();
kwiberg686a8ef2016-02-26 03:00:35 -0800319 std::unique_ptr<VideoMediaChannel> channel(
nisse51542be2016-02-12 02:27:06 -0800320 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000321
322 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
323
324 EXPECT_FALSE(channel->SetSend(true))
325 << "Channel should not start without codecs.";
326 EXPECT_TRUE(channel->SetSend(false))
327 << "Channel should be stoppable even without set codecs.";
328}
329
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000330TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200331 engine_.Init();
kwiberg686a8ef2016-02-26 03:00:35 -0800332 std::unique_ptr<VideoMediaChannel> channel(
nisse51542be2016-02-12 02:27:06 -0800333 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000334 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
335 VideoMediaInfo info;
336 channel->GetStats(&info);
337}
338
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000339TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
340 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
341 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200342 cricket::VideoSendParameters parameters;
343 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000344
kwiberg686a8ef2016-02-26 03:00:35 -0800345 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200346 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000347
348 EXPECT_TRUE(
349 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
350 ASSERT_EQ(1u, encoder_factory.encoders().size());
351 EXPECT_TRUE(channel->SetSend(true));
352
353 cricket::FakeVideoCapturer capturer;
354 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
355 EXPECT_EQ(cricket::CS_RUNNING,
356 capturer.Start(capturer.GetSupportedFormats()->front()));
357 EXPECT_TRUE(capturer.CaptureFrame());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000358 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
359 kTimeout);
360
Peter Boström81cbd922016-03-22 12:19:07 +0100361 // Sending one frame will have reallocated the encoder since input size
362 // changes from a small default to the actual frame width/height.
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000363 int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
364 EXPECT_EQ(num_created_encoders, 2);
365
366 // Setting codecs of the same type should not reallocate any encoders
367 // (expecting a no-op).
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200368 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000369 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000370
371 // Remove stream previously added to free the external encoder instance.
372 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
373 EXPECT_EQ(0u, encoder_factory.encoders().size());
374}
375
Peter Boströme4499152016-02-05 11:13:28 +0100376void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse(
377 bool use_external_encoder) {
378 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
379 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
380 cricket::VideoSendParameters parameters;
381 parameters.codecs.push_back(kVp8Codec);
kwiberg686a8ef2016-02-26 03:00:35 -0800382 std::unique_ptr<VideoMediaChannel> channel;
Peter Boströme4499152016-02-05 11:13:28 +0100383 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
384 call_.reset(fake_call);
385 if (use_external_encoder) {
386 channel.reset(
387 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
388 } else {
389 engine_.Init();
nisse51542be2016-02-12 02:27:06 -0800390 channel.reset(
391 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
Peter Boströme4499152016-02-05 11:13:28 +0100392 }
393 ASSERT_TRUE(
394 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
395 EXPECT_TRUE(channel->SetSendParameters(parameters));
396 EXPECT_TRUE(channel->SetSend(true));
397 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
398
399 EXPECT_EQ(use_external_encoder,
400 stream->GetConfig().encoder_settings.full_overuse_time);
401 // Remove stream previously added to free the external encoder instance.
402 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
403}
404
405TEST_F(WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders) {
406 TestExtendedEncoderOveruse(true);
407}
408
409TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) {
410 TestExtendedEncoderOveruse(false);
411}
412
Peter Boström53eda3d2015-03-27 15:53:18 +0100413TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
414 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
415 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
416 std::vector<cricket::VideoCodec> codecs;
417 codecs.push_back(kVp9Codec);
418
kwiberg686a8ef2016-02-26 03:00:35 -0800419 std::unique_ptr<VideoMediaChannel> channel(
Peter Boström53eda3d2015-03-27 15:53:18 +0100420 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
421
422 EXPECT_TRUE(
423 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
424}
425
qiangchenc27d89f2015-07-16 10:27:16 -0700426TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
427 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
428 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
429 std::vector<cricket::VideoCodec> codecs;
430 codecs.push_back(kVp8Codec);
431
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200432 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
433 call_.reset(fake_call);
kwiberg686a8ef2016-02-26 03:00:35 -0800434 std::unique_ptr<VideoMediaChannel> channel(
qiangchenc27d89f2015-07-16 10:27:16 -0700435 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
436
437 EXPECT_TRUE(
438 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
439
440 FakeVideoCapturer capturer;
441 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
442 capturer.Start(cricket::VideoFormat(1280, 720,
443 cricket::VideoFormat::FpsToInterval(60),
444 cricket::FOURCC_I420));
445 channel->SetSend(true);
446
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200447 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
qiangchenc27d89f2015-07-16 10:27:16 -0700448
449 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700450 int64_t last_timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700451 for (int i = 0; i < 10; i++) {
452 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700453 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700454 int64_t interval = timestamp - last_timestamp;
455
456 // Precision changes from nanosecond to millisecond.
457 // Allow error to be no more than 1.
458 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(60) / 1E6, interval, 1);
459
460 last_timestamp = timestamp;
461 }
462
463 capturer.Start(cricket::VideoFormat(1280, 720,
464 cricket::VideoFormat::FpsToInterval(30),
465 cricket::FOURCC_I420));
466
467 EXPECT_TRUE(capturer.CaptureFrame());
468 last_timestamp = stream->GetLastTimestamp();
469 for (int i = 0; i < 10; i++) {
470 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700471 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700472 int64_t interval = timestamp - last_timestamp;
473
474 // Precision changes from nanosecond to millisecond.
475 // Allow error to be no more than 1.
476 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1);
477
478 last_timestamp = timestamp;
479 }
480
481 // Remove stream previously added to free the external encoder instance.
482 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
483}
484
pbos1cb121d2015-09-14 11:38:38 -0700485TEST_F(WebRtcVideoEngine2Test,
486 ProducesIncreasingTimestampsWithResetInputSources) {
487 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
488 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
489 std::vector<cricket::VideoCodec> codecs;
490 codecs.push_back(kVp8Codec);
491
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200492 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
493 call_.reset(fake_call);
kwiberg686a8ef2016-02-26 03:00:35 -0800494 std::unique_ptr<VideoMediaChannel> channel(
pbos1cb121d2015-09-14 11:38:38 -0700495 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
496
497 EXPECT_TRUE(
498 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
499 channel->SetSend(true);
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200500 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
pbos1cb121d2015-09-14 11:38:38 -0700501
502 FakeVideoCapturer capturer1;
503 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer1));
504
505 cricket::CapturedFrame frame;
506 frame.width = 1280;
507 frame.height = 720;
508 frame.fourcc = cricket::FOURCC_I420;
nissed73c99c2016-02-12 01:01:11 -0800509 frame.data_size = frame.width * frame.height +
510 2 * ((frame.width + 1) / 2) * ((frame.height + 1) / 2);
kwiberg686a8ef2016-02-26 03:00:35 -0800511 std::unique_ptr<char[]> data(new char[frame.data_size]);
pbos1cb121d2015-09-14 11:38:38 -0700512 frame.data = data.get();
513 memset(frame.data, 1, frame.data_size);
pbos1cb121d2015-09-14 11:38:38 -0700514 const int kInitialTimestamp = 123456;
515 frame.time_stamp = kInitialTimestamp;
516
517 // Deliver initial frame.
518 capturer1.SignalCapturedFrame(&frame);
519 // Deliver next frame 1 second later.
520 frame.time_stamp += rtc::kNumNanosecsPerSec;
521 rtc::Thread::Current()->SleepMs(1000);
522 capturer1.SignalCapturedFrame(&frame);
523
524 int64_t capturer1_last_timestamp = stream->GetLastTimestamp();
525 // Reset input source, should still be continuous even though input-frame
526 // timestamp is less than before.
527 FakeVideoCapturer capturer2;
528 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer2));
529
530 rtc::Thread::Current()->SleepMs(1);
531 // Deliver with a timestamp (10 seconds) before the previous initial one,
532 // these should not be related at all anymore and it should still work fine.
533 frame.time_stamp = kInitialTimestamp - 10000;
534 capturer2.SignalCapturedFrame(&frame);
535
536 // New timestamp should be at least 1ms in the future and not old.
537 EXPECT_GT(stream->GetLastTimestamp(), capturer1_last_timestamp);
538
539 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
540}
541
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000542VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
543 cricket::WebRtcVideoEncoderFactory* encoder_factory,
544 const std::vector<VideoCodec>& codecs) {
545 engine_.SetExternalEncoderFactory(encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200546 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000547
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000548 VideoMediaChannel* channel =
nisse51542be2016-02-12 02:27:06 -0800549 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200550 cricket::VideoSendParameters parameters;
551 parameters.codecs = codecs;
552 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000553
554 return channel;
555}
556
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000557VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
558 cricket::WebRtcVideoDecoderFactory* decoder_factory,
559 const std::vector<VideoCodec>& codecs) {
560 engine_.SetExternalDecoderFactory(decoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200561 engine_.Init();
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000562
563 VideoMediaChannel* channel =
nisse51542be2016-02-12 02:27:06 -0800564 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200565 cricket::VideoRecvParameters parameters;
566 parameters.codecs = codecs;
567 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000568
569 return channel;
570}
571
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000572TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
573 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
574 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
575 std::vector<cricket::VideoCodec> codecs;
576 codecs.push_back(kVp8Codec);
577
kwiberg686a8ef2016-02-26 03:00:35 -0800578 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000579 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
580
Peter Boström0c4e06b2015-10-07 12:23:21 +0200581 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000582
583 EXPECT_TRUE(
584 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
585 EXPECT_TRUE(channel->SetSend(true));
586
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000587 cricket::FakeVideoCapturer capturer;
588 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
589 EXPECT_EQ(cricket::CS_RUNNING,
590 capturer.Start(capturer.GetSupportedFormats()->front()));
591 EXPECT_TRUE(capturer.CaptureFrame());
592
Peter Boström81cbd922016-03-22 12:19:07 +0100593 EXPECT_GT(encoder_factory.encoders().size(), 1u);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000594
595 // Verify that encoders are configured for simulcast through adapter
596 // (increasing resolution and only configured to send one stream each).
597 int prev_width = -1;
598 for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
599 webrtc::VideoCodec codec_settings =
600 encoder_factory.encoders()[i]->GetCodecSettings();
601 EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
602 EXPECT_GT(codec_settings.width, prev_width);
603 prev_width = codec_settings.width;
604 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000605
606 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), NULL));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000607
608 channel.reset();
609 ASSERT_EQ(0u, encoder_factory.encoders().size());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000610}
611
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000612TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
613 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
614 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
615 std::vector<cricket::VideoCodec> codecs;
616 codecs.push_back(kH264Codec);
617
kwiberg686a8ef2016-02-26 03:00:35 -0800618 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000619 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
620
621 EXPECT_TRUE(
622 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
623 ASSERT_EQ(1u, encoder_factory.encoders().size());
624
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200625 cricket::VideoSendParameters parameters;
626 parameters.codecs.push_back(kVp8Codec);
627 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000628 ASSERT_EQ(0u, encoder_factory.encoders().size());
629}
630
631TEST_F(WebRtcVideoEngine2Test,
632 DontUseExternalEncoderFactoryForUnsupportedCodecs) {
633 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
634 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
635 std::vector<cricket::VideoCodec> codecs;
636 codecs.push_back(kVp8Codec);
637
kwiberg686a8ef2016-02-26 03:00:35 -0800638 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000639 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
640
641 EXPECT_TRUE(
642 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000643 // Make sure DestroyVideoEncoder was called on the factory.
644 ASSERT_EQ(0u, encoder_factory.encoders().size());
645}
646
647TEST_F(WebRtcVideoEngine2Test,
648 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
649 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
650 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
651 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
652
653 std::vector<cricket::VideoCodec> codecs;
654 codecs.push_back(kVp8Codec);
655
kwiberg686a8ef2016-02-26 03:00:35 -0800656 std::unique_ptr<VideoMediaChannel> channel(
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000657 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
658
Peter Boström0c4e06b2015-10-07 12:23:21 +0200659 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000660
661 EXPECT_TRUE(
662 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
663 EXPECT_TRUE(channel->SetSend(true));
664
665 // Send a fake frame, or else the media engine will configure the simulcast
666 // encoder adapter at a low-enough size that it'll only create a single
667 // encoder layer.
668 cricket::FakeVideoCapturer capturer;
669 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
670 EXPECT_EQ(cricket::CS_RUNNING,
671 capturer.Start(capturer.GetSupportedFormats()->front()));
672 EXPECT_TRUE(capturer.CaptureFrame());
673
Peter Boström81cbd922016-03-22 12:19:07 +0100674 ASSERT_GT(encoder_factory.encoders().size(), 1u);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000675 EXPECT_EQ(webrtc::kVideoCodecVP8,
676 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
677
678 channel.reset();
679 // Make sure DestroyVideoEncoder was called on the factory.
680 EXPECT_EQ(0u, encoder_factory.encoders().size());
681}
682
683TEST_F(WebRtcVideoEngine2Test,
684 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
685 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
686 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
687 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
688
689 std::vector<cricket::VideoCodec> codecs;
690 codecs.push_back(kH264Codec);
691
kwiberg686a8ef2016-02-26 03:00:35 -0800692 std::unique_ptr<VideoMediaChannel> channel(
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000693 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
694
695 EXPECT_TRUE(
696 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
697 ASSERT_EQ(1u, encoder_factory.encoders().size());
698 EXPECT_EQ(webrtc::kVideoCodecH264,
699 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
700
701 channel.reset();
702 // Make sure DestroyVideoEncoder was called on the factory.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000703 ASSERT_EQ(0u, encoder_factory.encoders().size());
704}
705
noahricfdac5162015-08-27 01:59:29 -0700706TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) {
707 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
708 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
709 std::vector<cricket::VideoCodec> codecs;
710 codecs.push_back(kH264Codec);
711
kwiberg686a8ef2016-02-26 03:00:35 -0800712 std::unique_ptr<VideoMediaChannel> channel(
noahricfdac5162015-08-27 01:59:29 -0700713 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
714
Peter Boström0c4e06b2015-10-07 12:23:21 +0200715 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
noahricfdac5162015-08-27 01:59:29 -0700716 EXPECT_TRUE(
717 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
Peter Boströmce23bee2016-02-02 14:14:30 +0100718
719 // Send a frame of 720p. This should trigger a "real" encoder initialization.
noahricfdac5162015-08-27 01:59:29 -0700720 cricket::VideoFormat format(
721 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
Peter Boströmce23bee2016-02-02 14:14:30 +0100722 cricket::FakeVideoCapturer capturer;
723 EXPECT_TRUE(channel->SetCapturer(ssrcs[0], &capturer));
724 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
725 EXPECT_TRUE(capturer.CaptureFrame());
726
noahricfdac5162015-08-27 01:59:29 -0700727 ASSERT_EQ(1u, encoder_factory.encoders().size());
728 FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0];
729 EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
730 EXPECT_EQ(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
Peter Boströmce23bee2016-02-02 14:14:30 +0100731 EXPECT_TRUE(channel->SetCapturer(ssrcs[0], nullptr));
noahricfdac5162015-08-27 01:59:29 -0700732}
733
hbosbab934b2016-01-27 01:36:03 -0800734// Test that external codecs are added to the end of the supported codec list.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000735TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) {
736 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
hbosbab934b2016-01-27 01:36:03 -0800737 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecUnknown,
738 "FakeExternalCodec");
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000739 engine_.SetExternalEncoderFactory(&encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200740 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000741
742 std::vector<cricket::VideoCodec> codecs(engine_.codecs());
743 ASSERT_GE(codecs.size(), 2u);
744 cricket::VideoCodec internal_codec = codecs.front();
745 cricket::VideoCodec external_codec = codecs.back();
746
747 // The external codec will appear at last.
748 EXPECT_EQ("VP8", internal_codec.name);
hbosbab934b2016-01-27 01:36:03 -0800749 EXPECT_EQ("FakeExternalCodec", external_codec.name);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000750}
751
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000752TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
753 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
754 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200755 cricket::VideoRecvParameters parameters;
756 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000757
kwiberg686a8ef2016-02-26 03:00:35 -0800758 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200759 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000760
761 EXPECT_TRUE(
762 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
763 ASSERT_EQ(1u, decoder_factory.decoders().size());
764
765 // Setting codecs of the same type should not reallocate the decoder.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200766 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000767 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
768
769 // Remove stream previously added to free the external decoder instance.
770 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
771 EXPECT_EQ(0u, decoder_factory.decoders().size());
772}
773
774// Verifies that we can set up decoders that are not internally supported.
775TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
776 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
777 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
778 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
779 // codecs.
780 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
781 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
782 engine_.SetExternalEncoderFactory(&encoder_factory);
783 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
784 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
785 std::vector<cricket::VideoCodec> codecs;
786 codecs.push_back(kH264Codec);
787
kwiberg686a8ef2016-02-26 03:00:35 -0800788 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000789 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
790
791 EXPECT_TRUE(
792 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
793 ASSERT_EQ(1u, decoder_factory.decoders().size());
794}
795
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000796class WebRtcVideoChannel2BaseTest
797 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
798 protected:
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000799 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000800
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000801 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000802};
803
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000804#define WEBRTC_BASE_TEST(test) \
805 TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); }
806
807#define WEBRTC_DISABLED_BASE_TEST(test) \
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000808 TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); }
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000809
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000810WEBRTC_BASE_TEST(SetSend);
811WEBRTC_BASE_TEST(SetSendWithoutCodecs);
812WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000813
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000814WEBRTC_BASE_TEST(GetStats);
815WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams);
816WEBRTC_BASE_TEST(GetStatsMultipleSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000817
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000818WEBRTC_BASE_TEST(SetSendBandwidth);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000819
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000820WEBRTC_BASE_TEST(SetSendSsrc);
821WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000822
nisse08582ff2016-02-04 01:24:52 -0800823WEBRTC_BASE_TEST(SetSink);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000824
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000825WEBRTC_BASE_TEST(AddRemoveSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000826
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000827WEBRTC_BASE_TEST(SimulateConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000828
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000829WEBRTC_BASE_TEST(AddRemoveCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000830
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000831WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000832
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000833WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000834
835// TODO(pbos): Figure out why this fails so often.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000836WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000837
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000838WEBRTC_BASE_TEST(RejectEmptyStreamParams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000839
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000840WEBRTC_BASE_TEST(AdaptResolution16x10);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000841
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000842WEBRTC_BASE_TEST(AdaptResolution4x3);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000843
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000844// TODO(juberti): Restore this test once we support sending 0 fps.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000845WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000846// TODO(juberti): Understand why we get decode errors on this test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000847WEBRTC_DISABLED_BASE_TEST(AdaptFramerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000848
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +0000849WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames);
850
851WEBRTC_BASE_TEST(MuteStream);
852
853WEBRTC_BASE_TEST(MultipleSendStreams);
854
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000855TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
856 SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30, 0));
857}
858
859TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
860 SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30, 0));
861}
862
863TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
864 SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30, 0));
865}
866
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000867TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
868 Base::TwoStreamsSendAndReceive(kVp8Codec);
869}
870
871TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsReUseFirstStream) {
872 Base::TwoStreamsReUseFirstStream(kVp8Codec);
873}
874
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200875class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000876 public:
stefanc1aeaf02015-10-15 07:26:07 -0700877 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {}
878 explicit WebRtcVideoChannel2Test(const char* field_trials)
879 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000880 void SetUp() override {
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200881 fake_call_.reset(new FakeCall(webrtc::Call::Config()));
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200882 engine_.Init();
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200883 channel_.reset(
nisse51542be2016-02-12 02:27:06 -0800884 engine_.CreateChannel(fake_call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000885 last_ssrc_ = 123;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200886 send_parameters_.codecs = engine_.codecs();
887 recv_parameters_.codecs = engine_.codecs();
888 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000889 }
890
891 protected:
892 FakeVideoSendStream* AddSendStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000893 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000894 }
895
896 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000897 size_t num_streams = fake_call_->GetVideoSendStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000898 EXPECT_TRUE(channel_->AddSendStream(sp));
899 std::vector<FakeVideoSendStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000900 fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000901 EXPECT_EQ(num_streams + 1, streams.size());
902 return streams[streams.size() - 1];
903 }
904
905 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000906 return fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000907 }
908
909 FakeVideoReceiveStream* AddRecvStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000910 return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000911 }
912
913 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000914 size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000915 EXPECT_TRUE(channel_->AddRecvStream(sp));
916 std::vector<FakeVideoReceiveStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000917 fake_call_->GetVideoReceiveStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000918 EXPECT_EQ(num_streams + 1, streams.size());
919 return streams[streams.size() - 1];
920 }
921
pbos@webrtc.org00873182014-11-25 14:03:34 +0000922 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
923 int expected_min_bitrate_bps,
924 const char* start_bitrate_kbps,
925 int expected_start_bitrate_bps,
926 const char* max_bitrate_kbps,
927 int expected_max_bitrate_bps) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200928 auto& codecs = send_parameters_.codecs;
929 codecs.clear();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000930 codecs.push_back(kVp8Codec);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000931 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
932 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
933 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200934 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000935
pbos@webrtc.org00873182014-11-25 14:03:34 +0000936 EXPECT_EQ(expected_min_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100937 fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000938 EXPECT_EQ(expected_start_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100939 fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000940 EXPECT_EQ(expected_max_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100941 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000942 }
943
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000944 void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
945 const std::string& webrtc_ext) {
946 // Enable extension.
947 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200948 cricket::VideoSendParameters parameters = send_parameters_;
949 parameters.extensions.push_back(
950 cricket::RtpHeaderExtension(cricket_ext, id));
951 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);
958 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
959 // 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);
979 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000980 }
981
982 void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
983 const std::string& webrtc_ext) {
984 // Enable extension.
985 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200986 cricket::VideoRecvParameters parameters = recv_parameters_;
987 parameters.extensions.push_back(
988 cricket::RtpHeaderExtension(cricket_ext, id));
989 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000990
991 FakeVideoReceiveStream* recv_stream =
992 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
993
994 // Verify the recv extension id.
995 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
996 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
997 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
998 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200999 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001000
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001001 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
1002 // senders.
1003 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
1004 ->GetConfig()
1005 .rtp.extensions.empty());
1006
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001007 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001008 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001009 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
1010 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001011 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
1012
1013 // Verify that adding receive RTP header extensions adds them for existing
1014 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001015 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001016 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001017 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1018 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
1019 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001020 }
1021
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001022 void TestExtensionFilter(const std::vector<std::string>& extensions,
1023 const std::string& expected_extension) {
1024 cricket::VideoSendParameters parameters = send_parameters_;
1025 int expected_id = -1;
1026 int id = 1;
1027 for (const std::string& extension : extensions) {
1028 if (extension == expected_extension)
1029 expected_id = id;
1030 parameters.extensions.push_back(
1031 cricket::RtpHeaderExtension(extension, id++));
1032 }
1033 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1034 FakeVideoSendStream* send_stream =
1035 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1036
1037 // Verify that only one of them has been set, and that it is the one with
1038 // highest priority (transport sequence number).
1039 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1040 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
1041 EXPECT_EQ(expected_extension,
1042 send_stream->GetConfig().rtp.extensions[0].name);
1043 }
1044
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001045 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
Peter Boström3548dd22015-05-22 18:48:36 +02001046 void TestReceiverLocalSsrcConfiguration(bool receiver_first);
noahricd10a68e2015-07-10 11:27:55 -07001047 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
1048 bool expect_created_receive_stream);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001049
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001050 FakeVideoSendStream* SetDenoisingOption(
nisse05103312016-03-16 02:22:50 -07001051 uint32_t ssrc,
nisse0db023a2016-03-01 04:29:59 -08001052 cricket::FakeVideoCapturer* capturer,
1053 bool enabled) {
nisse05103312016-03-16 02:22:50 -07001054 cricket::VideoOptions options;
1055 options.video_noise_reduction = rtc::Optional<bool>(enabled);
1056 channel_->SetVideoSend(ssrc, true, &options);
nisse0db023a2016-03-01 04:29:59 -08001057 // Options only take effect on the next frame.
1058 EXPECT_TRUE(capturer->CaptureFrame());
1059
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001060 return fake_call_->GetVideoSendStreams().back();
1061 }
1062
Peter Boström2feafdb2015-09-09 14:32:14 +02001063 FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
1064 const int kRtxSsrcOffset = 0xDEADBEEF;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001065 last_ssrc_ += 3;
Peter Boström2feafdb2015-09-09 14:32:14 +02001066 std::vector<uint32_t> ssrcs;
1067 std::vector<uint32_t> rtx_ssrcs;
1068 uint32_t num_streams = enabled ? 3 : 1;
1069 for (uint32_t i = 0; i < num_streams; ++i) {
1070 uint32_t ssrc = last_ssrc_ + i;
1071 ssrcs.push_back(ssrc);
1072 if (with_rtx) {
1073 rtx_ssrcs.push_back(ssrc + kRtxSsrcOffset);
1074 }
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001075 }
Peter Boström2feafdb2015-09-09 14:32:14 +02001076 if (with_rtx) {
1077 return AddSendStream(
1078 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1079 }
1080 return AddSendStream(CreateSimStreamParams("cname", ssrcs));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001081 }
1082
skvladdc1c62c2016-03-16 19:07:43 -07001083 int GetMaxEncoderBitrate(cricket::FakeVideoCapturer& capturer) {
1084 EXPECT_TRUE(capturer.CaptureFrame());
1085
1086 std::vector<FakeVideoSendStream*> streams =
1087 fake_call_->GetVideoSendStreams();
1088 EXPECT_TRUE(streams.size() > 0);
1089 FakeVideoSendStream* stream = streams[streams.size() - 1];
1090
1091 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig();
1092 EXPECT_EQ(1, encoder_config.streams.size());
1093 return encoder_config.streams[0].max_bitrate_bps;
1094 }
1095
1096 void SetAndExpectMaxBitrate(cricket::FakeVideoCapturer& capturer,
1097 int global_max,
1098 int stream_max,
1099 int expected_encoder_bitrate) {
1100 VideoSendParameters limited_send_params = send_parameters_;
1101 limited_send_params.max_bandwidth_bps = global_max;
1102 EXPECT_TRUE(channel_->SetSendParameters(limited_send_params));
1103 webrtc::RtpParameters parameters = channel_->GetRtpParameters(last_ssrc_);
1104 EXPECT_EQ(1UL, parameters.encodings.size());
1105 parameters.encodings[0].max_bitrate_bps = stream_max;
1106 EXPECT_TRUE(channel_->SetRtpParameters(last_ssrc_, parameters));
1107 // Read back the parameteres and verify they have the correct value
1108 parameters = channel_->GetRtpParameters(last_ssrc_);
1109 EXPECT_EQ(1UL, parameters.encodings.size());
1110 EXPECT_EQ(stream_max, parameters.encodings[0].max_bitrate_bps);
1111 // Verify that the new value propagated down to the encoder
1112 EXPECT_EQ(expected_encoder_bitrate, GetMaxEncoderBitrate(capturer));
1113 }
1114
kwiberg686a8ef2016-02-26 03:00:35 -08001115 std::unique_ptr<FakeCall> fake_call_;
1116 std::unique_ptr<VideoMediaChannel> channel_;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001117 cricket::VideoSendParameters send_parameters_;
1118 cricket::VideoRecvParameters recv_parameters_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001119 uint32_t last_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001120};
1121
pbos8fc7fa72015-07-15 08:02:58 -07001122TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001123 const uint32_t kVideoSsrc = 123;
pbos8fc7fa72015-07-15 08:02:58 -07001124 const std::string kSyncLabel = "AvSyncLabel";
1125
1126 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
1127 sp.sync_label = kSyncLabel;
1128 EXPECT_TRUE(channel_->AddRecvStream(sp));
1129
1130 EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size());
1131 EXPECT_EQ(kSyncLabel,
1132 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
1133 << "SyncGroup should be set based on sync_label";
1134}
1135
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001136TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001137 cricket::VideoSendParameters parameters;
1138 parameters.codecs = engine_.codecs();
1139 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001140 EXPECT_TRUE(channel_->SetSend(true));
nisse4b4dc862016-02-17 05:25:36 -08001141 parameters.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001142 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001143
1144 // Send side.
Peter Boström0c4e06b2015-10-07 12:23:21 +02001145 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
1146 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001147 FakeVideoSendStream* send_stream = AddSendStream(
1148 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1149
1150 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
1151 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
1152 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
1153
1154 // Receiver side.
1155 FakeVideoReceiveStream* recv_stream = AddRecvStream(
1156 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1157 ASSERT_GT(recv_stream->GetConfig().rtp.rtx.size(), 0u)
1158 << "No SSRCs for RTX configured by AddRecvStream.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001159 EXPECT_EQ(rtx_ssrcs[0],
1160 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
1161 // TODO(pbos): Make sure we set the RTX for correct payloads etc.
1162}
1163
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001164TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
1165 // Setup one channel with an associated RTX stream.
1166 cricket::StreamParams params =
1167 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1168 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
1169 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001170 EXPECT_EQ(kRtxSsrcs1[0],
1171 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001172}
1173
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001174TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
1175 // Setup one channel without an associated RTX stream.
1176 cricket::StreamParams params =
1177 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1178 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1179 ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001180}
1181
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001182TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
1183 FakeVideoSendStream* send_stream =
1184 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1185 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1186
1187 FakeVideoReceiveStream* recv_stream =
1188 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1189 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001190}
1191
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001192// Test support for RTP timestamp offset header extension.
1193TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
1194 TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1195 webrtc::RtpExtension::kTOffset);
1196}
1197TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
1198 TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1199 webrtc::RtpExtension::kTOffset);
1200}
1201
1202// Test support for absolute send time header extension.
1203TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
1204 TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1205 webrtc::RtpExtension::kAbsSendTime);
1206}
1207TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
1208 TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1209 webrtc::RtpExtension::kAbsSendTime);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001210}
1211
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001212TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksTransportSeqNum) {
1213 // Enable three redundant extensions.
1214 std::vector<std::string> extensions;
1215 extensions.push_back(kRtpAbsoluteSenderTimeHeaderExtension);
1216 extensions.push_back(kRtpTimestampOffsetHeaderExtension);
1217 extensions.push_back(kRtpTransportSequenceNumberHeaderExtension);
1218 TestExtensionFilter(extensions, kRtpTransportSequenceNumberHeaderExtension);
1219}
1220
1221TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksAbsSendTime) {
1222 // Enable two redundant extensions.
1223 std::vector<std::string> extensions;
1224 extensions.push_back(kRtpAbsoluteSenderTimeHeaderExtension);
1225 extensions.push_back(kRtpTimestampOffsetHeaderExtension);
1226 TestExtensionFilter(extensions, kRtpAbsoluteSenderTimeHeaderExtension);
1227}
1228
stefanc1aeaf02015-10-15 07:26:07 -07001229class WebRtcVideoChannel2WithSendSideBweTest : public WebRtcVideoChannel2Test {
1230 public:
1231 WebRtcVideoChannel2WithSendSideBweTest()
1232 : WebRtcVideoChannel2Test("WebRTC-SendSideBwe/Enabled/") {}
1233};
1234
1235// Test support for transport sequence number header extension.
1236TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
1237 SendTransportSequenceNumberHeaderExtensions) {
1238 TestSetSendRtpHeaderExtensions(
1239 kRtpTransportSequenceNumberHeaderExtension,
1240 webrtc::RtpExtension::kTransportSequenceNumber);
1241}
1242TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
1243 RecvTransportSequenceNumberHeaderExtensions) {
1244 TestSetRecvRtpHeaderExtensions(
1245 kRtpTransportSequenceNumberHeaderExtension,
1246 webrtc::RtpExtension::kTransportSequenceNumber);
1247}
1248
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001249// Test support for video rotation header extension.
1250TEST_F(WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions) {
1251 TestSetSendRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
1252 webrtc::RtpExtension::kVideoRotation);
1253}
1254TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) {
1255 TestSetRecvRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
1256 webrtc::RtpExtension::kVideoRotation);
1257}
1258
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001259TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001260 const int kAbsSendTimeId = 1;
1261 const int kVideoRotationId = 2;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001262 send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001263 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001264 send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001265 kRtpVideoRotationHeaderExtension, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001266
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001267 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001268 FakeVideoSendStream* send_stream =
1269 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1270
1271 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001272 ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001273
1274 // Setting the same extensions (even if in different order) shouldn't
1275 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001276 std::reverse(send_parameters_.extensions.begin(),
1277 send_parameters_.extensions.end());
1278 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001279
1280 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1281
1282 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001283 send_parameters_.extensions.resize(1);
1284 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001285
1286 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
1287}
1288
1289TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
1290 const int kTOffsetId = 1;
1291 const int kAbsSendTimeId = 2;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001292 const int kVideoRotationId = 3;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001293 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001294 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001295 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001296 kRtpTimestampOffsetHeaderExtension, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001297 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001298 kRtpVideoRotationHeaderExtension, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001299
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001300 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Peter Boström54be3e02015-05-25 15:04:24 +02001301 FakeVideoReceiveStream* recv_stream =
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001302 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1303
1304 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
Peter Boström54be3e02015-05-25 15:04:24 +02001305 ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001306
1307 // Setting the same extensions (even if in different order) shouldn't
1308 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001309 std::reverse(recv_parameters_.extensions.begin(),
1310 recv_parameters_.extensions.end());
1311 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001312
1313 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
1314
1315 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001316 recv_parameters_.extensions.resize(1);
1317 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001318
1319 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
1320}
1321
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001322TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001323 SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001324 const int kUnsupportedId = 1;
1325 const int kTOffsetId = 2;
1326
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001327 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001328 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001329 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001330 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001331 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001332 FakeVideoSendStream* send_stream =
1333 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1334
1335 // Only timestamp offset extension is set to send stream,
1336 // unsupported rtp extension is ignored.
1337 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1338 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001339 send_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001340}
1341
1342TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001343 SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001344 const int kUnsupportedId = 1;
1345 const int kTOffsetId = 2;
1346
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001347 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001348 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001349 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001350 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001351 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001352 FakeVideoReceiveStream* recv_stream =
1353 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1354
1355 // Only timestamp offset extension is set to receive stream,
1356 // unsupported rtp extension is ignored.
1357 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1358 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001359 recv_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001360}
1361
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001362TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001363 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001364 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001365 send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001366 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001367 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001368 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1369 }
1370}
1371
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001372TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001373 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001374 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001375 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001376 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001377 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001378 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1379 }
1380}
1381
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001382TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001383 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001384 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001385 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001386 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001387 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001388 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001389
1390 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001391 send_parameters_.extensions.clear();
1392 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001393 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001394 send_parameters_.extensions.push_back(send_parameters_.extensions.back());
1395 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001396}
1397
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001398TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001399 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001400 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001401 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001402 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001403 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001404 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001405
1406 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001407 recv_parameters_.extensions.clear();
1408 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001409 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001410 recv_parameters_.extensions.push_back(recv_parameters_.extensions.back());
1411 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001412}
1413
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001414TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
1415 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001416 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001417}
1418
Peter Boströmd7da1202015-06-05 14:09:38 +02001419TEST_F(WebRtcVideoChannel2Test, RtcpIsCompoundByDefault) {
1420 FakeVideoReceiveStream* stream = AddRecvStream();
pbosda903ea2015-10-02 02:36:56 -07001421 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
Peter Boströmd7da1202015-06-05 14:09:38 +02001422}
1423
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001424TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
1425 FakeVideoReceiveStream* stream = AddRecvStream();
1426 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001427}
1428
stefan43edf0f2015-11-20 18:05:48 -08001429TEST_F(WebRtcVideoChannel2Test, TransportCcIsEnabledByDefault) {
1430 FakeVideoReceiveStream* stream = AddRecvStream();
1431 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1432}
1433
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001434TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1435 FakeVideoReceiveStream* stream = AddRecvStream();
1436 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1437
Peter Boström126c03e2015-05-11 12:48:12 +02001438 // Verify that REMB is turned off when send(!) codecs without REMB are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001439 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));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001443 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001444 EXPECT_FALSE(stream->GetConfig().rtp.remb);
1445
1446 // Verify that REMB is turned on when setting default codecs since the
1447 // default codecs have REMB enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001448 parameters.codecs = engine_.codecs();
1449 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001450 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001451 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001452}
1453
stefan43edf0f2015-11-20 18:05:48 -08001454TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) {
1455 FakeVideoReceiveStream* stream = AddRecvStream();
1456 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1457
1458 // Verify that transport cc feedback is turned off when send(!) codecs without
1459 // transport cc feedback are set.
1460 cricket::VideoSendParameters parameters;
1461 parameters.codecs.push_back(kVp8Codec);
1462 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1463 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1464 stream = fake_call_->GetVideoReceiveStreams()[0];
1465 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc);
1466
1467 // Verify that transport cc feedback is turned on when setting default codecs
1468 // since the default codecs have transport cc feedback enabled.
1469 parameters.codecs = engine_.codecs();
1470 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1471 stream = fake_call_->GetVideoReceiveStreams()[0];
1472 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1473}
1474
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001475TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
1476 VerifyCodecHasDefaultFeedbackParams(default_codec_);
1477
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001478 cricket::VideoSendParameters parameters;
1479 parameters.codecs = engine_.codecs();
1480 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org19864742014-05-30 07:35:47 +00001481 EXPECT_TRUE(channel_->SetSend(true));
1482
1483 // Send side.
1484 FakeVideoSendStream* send_stream =
1485 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1486 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1487
1488 // Receiver side.
1489 FakeVideoReceiveStream* recv_stream =
1490 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1491 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1492
1493 // Nack history size should match between sender and receiver.
1494 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
1495 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001496}
1497
Peter Boström67c9df72015-05-11 14:34:58 +02001498TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
Peter Boström67c9df72015-05-11 14:34:58 +02001499 FakeVideoSendStream* send_stream = AddSendStream();
Peter Boström3548dd22015-05-22 18:48:36 +02001500 FakeVideoReceiveStream* recv_stream = AddRecvStream();
Peter Boström67c9df72015-05-11 14:34:58 +02001501
1502 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1503 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1504
1505 // Verify that NACK is turned off when send(!) codecs without NACK are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001506 cricket::VideoSendParameters parameters;
1507 parameters.codecs.push_back(kVp8Codec);
1508 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1509 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001510 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1511 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1512 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001513 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1514
Peter Boström67c9df72015-05-11 14:34:58 +02001515 // Verify that NACK is turned on when setting default codecs since the
1516 // default codecs have NACK enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001517 parameters.codecs = engine_.codecs();
1518 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001519 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1520 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1521 send_stream = fake_call_->GetVideoSendStreams()[0];
1522 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001523}
1524
Peter Boströme7ba0862016-03-12 00:02:28 +01001525// This test verifies that new frame sizes reconfigures encoders even though not
1526// (yet) sending. The purpose of this is to permit encoding as quickly as
1527// possible once we start sending. Likely the frames being input are from the
1528// same source that will be sent later, which just means that we're ready
1529// earlier.
1530TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) {
1531 cricket::VideoSendParameters parameters;
1532 parameters.codecs.push_back(kVp8Codec720p);
1533 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1534 channel_->SetSend(false);
1535
1536 FakeVideoSendStream* stream = AddSendStream();
1537
1538 // No frames entered, using default dimensions.
1539 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
1540 EXPECT_EQ(176u, streams[0].width);
1541 EXPECT_EQ(144u, streams[0].height);
1542
1543 cricket::FakeVideoCapturer capturer;
1544 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1545 EXPECT_EQ(cricket::CS_RUNNING,
1546 capturer.Start(capturer.GetSupportedFormats()->front()));
1547 EXPECT_TRUE(capturer.CaptureFrame());
1548
1549 // Frame entered, should be reconfigured to new dimensions.
1550 streams = stream->GetVideoStreams();
1551 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
1552 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
1553 // No frames should have been actually put in there though.
1554 EXPECT_EQ(0, stream->GetNumberOfSwappedFrames());
1555
1556 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1557}
1558
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001559TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1560 static const int kScreenshareMinBitrateKbps = 800;
1561 cricket::VideoCodec codec = kVp8Codec360p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001562 cricket::VideoSendParameters parameters;
1563 parameters.codecs.push_back(codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001564 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001565 AddSendStream();
1566
nisse05103312016-03-16 02:22:50 -07001567 VideoOptions min_bitrate_options;
1568 min_bitrate_options.screencast_min_bitrate_kbps =
1569 rtc::Optional<int>(kScreenshareMinBitrateKbps);
1570 channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options);
1571
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001572 cricket::FakeVideoCapturer capturer;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001573 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1574 cricket::VideoFormat capture_format_hd =
1575 capturer.GetSupportedFormats()->front();
1576 EXPECT_EQ(1280, capture_format_hd.width);
1577 EXPECT_EQ(720, capture_format_hd.height);
1578 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1579
1580 EXPECT_TRUE(channel_->SetSend(true));
1581
1582 EXPECT_TRUE(capturer.CaptureFrame());
1583 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1584 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1585
1586 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1587
1588 // Verify non-screencast settings.
1589 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001590 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001591 encoder_config.content_type);
1592 EXPECT_EQ(codec.width, encoder_config.streams.front().width);
1593 EXPECT_EQ(codec.height, encoder_config.streams.front().height);
1594 EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
1595 << "Non-screenshare shouldn't use min-transmit bitrate.";
1596
perkj2d5f0912016-02-29 00:04:41 -08001597 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, nullptr));
1598 // Removing a capturer triggers a black frame to be sent.
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001599 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
perkj2d5f0912016-02-29 00:04:41 -08001600 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
nisse05103312016-03-16 02:22:50 -07001601 VideoOptions screencast_options;
1602 screencast_options.is_screencast = rtc::Optional<bool>(true);
1603 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &screencast_options));
perkj2d5f0912016-02-29 00:04:41 -08001604 EXPECT_TRUE(capturer.CaptureFrame());
Niels Möller60653ba2016-03-02 11:41:36 +01001605 // Send stream not recreated after option change.
1606 ASSERT_EQ(send_stream, fake_call_->GetVideoSendStreams().front());
perkj2d5f0912016-02-29 00:04:41 -08001607 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001608
1609 // Verify screencast settings.
1610 encoder_config = send_stream->GetEncoderConfig();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001611 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001612 encoder_config.content_type);
1613 EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
1614 encoder_config.min_transmit_bitrate_bps);
1615
1616 EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width);
1617 EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001618 EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
1619
1620 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1621}
1622
Niels Möller60653ba2016-03-02 11:41:36 +01001623TEST_F(WebRtcVideoChannel2Test, NoRecreateStreamForScreencast) {
1624 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
1625 ASSERT_TRUE(
1626 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
1627 EXPECT_TRUE(channel_->SetSend(true));
1628
1629 cricket::FakeVideoCapturer capturer;
1630 EXPECT_TRUE(channel_->SetCapturer(kSsrc, &capturer));
1631 EXPECT_EQ(cricket::CS_RUNNING,
1632 capturer.Start(capturer.GetSupportedFormats()->front()));
1633 EXPECT_TRUE(capturer.CaptureFrame());
1634
1635 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1636 FakeVideoSendStream* stream = fake_call_->GetVideoSendStreams().front();
1637 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig();
1638 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
1639 encoder_config.content_type);
1640
1641 EXPECT_EQ(1, stream->GetNumberOfSwappedFrames());
1642
1643 /* Switch to screencast source. We expect a reconfigure of the
1644 * encoder, but no change of the send stream. */
1645 struct VideoOptions video_options;
1646 video_options.is_screencast = rtc::Optional<bool>(true);
1647 channel_->SetVideoSend(kSsrc, true, &video_options);
1648
1649 EXPECT_TRUE(capturer.CaptureFrame());
1650 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1651 ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front());
1652 EXPECT_EQ(2, stream->GetNumberOfSwappedFrames());
1653
1654 encoder_config = stream->GetEncoderConfig();
1655 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
1656 encoder_config.content_type);
1657
1658 /* Switch back. */
1659 video_options.is_screencast = rtc::Optional<bool>(false);
1660 channel_->SetVideoSend(kSsrc, true, &video_options);
1661
1662 EXPECT_TRUE(capturer.CaptureFrame());
1663 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1664 ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front());
1665 EXPECT_EQ(3, stream->GetNumberOfSwappedFrames());
1666
1667 encoder_config = stream->GetEncoderConfig();
1668 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
1669 encoder_config.content_type);
1670
1671 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1672}
1673
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001674TEST_F(WebRtcVideoChannel2Test,
1675 ConferenceModeScreencastConfiguresTemporalLayer) {
Erik SprĂ¥ng2c4c9142015-06-24 11:24:44 +02001676 static const int kConferenceScreencastTemporalBitrateBps =
1677 ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
nisse4b4dc862016-02-17 05:25:36 -08001678 send_parameters_.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001679 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001680
1681 AddSendStream();
nisse05103312016-03-16 02:22:50 -07001682 VideoOptions options;
1683 options.is_screencast = rtc::Optional<bool>(true);
1684 channel_->SetVideoSend(last_ssrc_, true, &options);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001685 cricket::FakeVideoCapturer capturer;
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001686 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1687 cricket::VideoFormat capture_format_hd =
1688 capturer.GetSupportedFormats()->front();
1689 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1690
1691 EXPECT_TRUE(channel_->SetSend(true));
1692
1693 EXPECT_TRUE(capturer.CaptureFrame());
1694 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1695 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1696
1697 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1698
1699 // Verify screencast settings.
1700 encoder_config = send_stream->GetEncoderConfig();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001701 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001702 encoder_config.content_type);
1703 ASSERT_EQ(1u, encoder_config.streams.size());
1704 ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size());
1705 EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
1706 encoder_config.streams[0].temporal_layer_thresholds_bps[0]);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001707
1708 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001709}
1710
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001711TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
1712 FakeVideoSendStream* stream = AddSendStream();
1713 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1714}
1715
nisse0db023a2016-03-01 04:29:59 -08001716TEST_F(WebRtcVideoChannel2Test, SetMediaConfigSuspendBelowMinBitrate) {
1717 MediaConfig media_config = MediaConfig();
1718 media_config.video.suspend_below_min_bitrate = true;
1719
1720 channel_.reset(
1721 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1722
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001723 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001724
1725 FakeVideoSendStream* stream = AddSendStream();
1726 EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
1727
nisse0db023a2016-03-01 04:29:59 -08001728 media_config.video.suspend_below_min_bitrate = false;
1729 channel_.reset(
1730 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1731
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001732 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001733
nisse0db023a2016-03-01 04:29:59 -08001734 stream = AddSendStream();
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001735 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1736}
1737
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001738TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1739 FakeVideoSendStream* stream = AddSendStream();
1740 webrtc::VideoCodecVP8 vp8_settings;
1741 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1742 EXPECT_TRUE(vp8_settings.denoisingOn);
1743}
1744
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001745TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001746 cricket::VideoSendParameters parameters;
1747 parameters.codecs.push_back(kVp8Codec720p);
1748 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001749
Peter Boström2feafdb2015-09-09 14:32:14 +02001750 // Single-stream settings should apply with RTX as well (verifies that we
1751 // check number of regular SSRCs and not StreamParams::ssrcs which contains
1752 // both RTX and regular SSRCs).
1753 FakeVideoSendStream* stream = SetUpSimulcast(false, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001754
1755 cricket::FakeVideoCapturer capturer;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001756 EXPECT_EQ(cricket::CS_RUNNING,
1757 capturer.Start(capturer.GetSupportedFormats()->front()));
1758 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1759 channel_->SetSend(true);
1760
1761 EXPECT_TRUE(capturer.CaptureFrame());
1762
pbos4cba4eb2015-10-26 11:18:18 -07001763 webrtc::VideoCodecVP8 vp8_settings;
1764 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1765 EXPECT_TRUE(vp8_settings.denoisingOn)
1766 << "VP8 denoising should be on by default.";
1767
nisse05103312016-03-16 02:22:50 -07001768 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001769
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001770 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1771 EXPECT_FALSE(vp8_settings.denoisingOn);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001772 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1773 EXPECT_TRUE(vp8_settings.frameDroppingOn);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001774
nisse05103312016-03-16 02:22:50 -07001775 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001776
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001777 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1778 EXPECT_TRUE(vp8_settings.denoisingOn);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001779 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1780 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1781
1782 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
Peter Boström2feafdb2015-09-09 14:32:14 +02001783 stream = SetUpSimulcast(true, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001784 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1785 channel_->SetSend(true);
1786 EXPECT_TRUE(capturer.CaptureFrame());
1787
1788 EXPECT_EQ(3, stream->GetVideoStreams().size());
1789 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1790 // Autmatic resize off when using simulcast.
1791 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1792 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1793
1794 // In screen-share mode, denoising is forced off and simulcast disabled.
nisse05103312016-03-16 02:22:50 -07001795 VideoOptions options;
1796 options.is_screencast = rtc::Optional<bool>(true);
1797 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
Niels Möller60653ba2016-03-02 11:41:36 +01001798
nisse05103312016-03-16 02:22:50 -07001799 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001800
1801 EXPECT_EQ(1, stream->GetVideoStreams().size());
1802 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1803 EXPECT_FALSE(vp8_settings.denoisingOn);
1804 // Resizing and frame dropping always off for screen sharing.
1805 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1806 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1807
nisse05103312016-03-16 02:22:50 -07001808 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001809
1810 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1811 EXPECT_FALSE(vp8_settings.denoisingOn);
1812 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1813 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1814
1815 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1816}
1817
1818class Vp9SettingsTest : public WebRtcVideoChannel2Test {
1819 public:
asaperssonc5dabdd2016-03-21 04:15:50 -07001820 Vp9SettingsTest() : Vp9SettingsTest("") {}
1821 explicit Vp9SettingsTest(const char* field_trials)
1822 : WebRtcVideoChannel2Test(field_trials) {
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001823 encoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
1824 }
1825 virtual ~Vp9SettingsTest() {}
1826
1827 protected:
1828 void SetUp() override {
1829 engine_.SetExternalEncoderFactory(&encoder_factory_);
1830
1831 WebRtcVideoChannel2Test::SetUp();
1832 }
1833
1834 void TearDown() override {
1835 // Remove references to encoder_factory_ since this will be destroyed
1836 // before channel_ and engine_.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001837 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001838 }
1839
1840 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
1841};
1842
1843TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001844 cricket::VideoSendParameters parameters;
1845 parameters.codecs.push_back(kVp9Codec);
1846 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001847
Peter Boström2feafdb2015-09-09 14:32:14 +02001848 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001849
1850 cricket::FakeVideoCapturer capturer;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001851 EXPECT_EQ(cricket::CS_RUNNING,
1852 capturer.Start(capturer.GetSupportedFormats()->front()));
1853 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1854 channel_->SetSend(true);
1855
1856 EXPECT_TRUE(capturer.CaptureFrame());
1857
pbos4cba4eb2015-10-26 11:18:18 -07001858 webrtc::VideoCodecVP9 vp9_settings;
1859 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1860 EXPECT_FALSE(vp9_settings.denoisingOn)
1861 << "VP9 denoising should be off by default.";
1862
nisse05103312016-03-16 02:22:50 -07001863 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001864
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001865 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1866 EXPECT_FALSE(vp9_settings.denoisingOn);
1867 // Frame dropping always on for real time video.
1868 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1869
nisse05103312016-03-16 02:22:50 -07001870 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001871
1872 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1873 EXPECT_TRUE(vp9_settings.denoisingOn);
1874 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1875
1876 // In screen-share mode, denoising is forced off.
nisse05103312016-03-16 02:22:50 -07001877 VideoOptions options;
1878 options.is_screencast = rtc::Optional<bool>(true);
1879 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
perkj2d5f0912016-02-29 00:04:41 -08001880
nisse05103312016-03-16 02:22:50 -07001881 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001882
1883 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1884 EXPECT_FALSE(vp9_settings.denoisingOn);
1885 // Frame dropping always off for screen sharing.
1886 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1887
nisse05103312016-03-16 02:22:50 -07001888 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001889
1890 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1891 EXPECT_FALSE(vp9_settings.denoisingOn);
1892 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1893
1894 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001895}
1896
asaperssonc5dabdd2016-03-21 04:15:50 -07001897class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest {
1898 public:
1899 Vp9SettingsTestWithFieldTrial(const char* field_trials)
1900 : Vp9SettingsTest(field_trials) {}
1901
1902 protected:
1903 void VerifySettings(int num_spatial_layers, int num_temporal_layers) {
1904 cricket::VideoSendParameters parameters;
1905 parameters.codecs.push_back(kVp9Codec);
1906 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1907
1908 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
1909
1910 cricket::FakeVideoCapturer capturer;
1911 EXPECT_EQ(cricket::CS_RUNNING,
1912 capturer.Start(capturer.GetSupportedFormats()->front()));
1913 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1914 channel_->SetSend(true);
1915
1916 EXPECT_TRUE(capturer.CaptureFrame());
1917
1918 webrtc::VideoCodecVP9 vp9_settings;
1919 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1920 EXPECT_EQ(num_spatial_layers, vp9_settings.numberOfSpatialLayers);
1921 EXPECT_EQ(num_temporal_layers, vp9_settings.numberOfTemporalLayers);
1922
1923 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1924 }
1925};
1926
1927class Vp9SettingsTestWithNoFlag : public Vp9SettingsTestWithFieldTrial {
1928 public:
1929 Vp9SettingsTestWithNoFlag() : Vp9SettingsTestWithFieldTrial("") {}
1930};
1931
1932TEST_F(Vp9SettingsTestWithNoFlag, VerifySettings) {
1933 const int kNumSpatialLayers = 1;
1934 const int kNumTemporalLayers = 1;
1935 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1936}
1937
1938class Vp9SettingsTestWithInvalidFlag : public Vp9SettingsTestWithFieldTrial {
1939 public:
1940 Vp9SettingsTestWithInvalidFlag()
1941 : Vp9SettingsTestWithFieldTrial("WebRTC-SupportVP9SVC/Default/") {}
1942};
1943
1944TEST_F(Vp9SettingsTestWithInvalidFlag, VerifySettings) {
1945 const int kNumSpatialLayers = 1;
1946 const int kNumTemporalLayers = 1;
1947 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1948}
1949
1950class Vp9SettingsTestWith2SL3TLFlag : public Vp9SettingsTestWithFieldTrial {
1951 public:
1952 Vp9SettingsTestWith2SL3TLFlag()
1953 : Vp9SettingsTestWithFieldTrial(
1954 "WebRTC-SupportVP9SVC/EnabledByFlag_2SL3TL/") {}
1955};
1956
1957TEST_F(Vp9SettingsTestWith2SL3TLFlag, VerifySettings) {
1958 const int kNumSpatialLayers = 2;
1959 const int kNumTemporalLayers = 3;
1960 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1961}
1962
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001963TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) {
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001964 TestCpuAdaptation(true, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001965}
1966
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001967TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001968 TestCpuAdaptation(false, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001969}
1970
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001971TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
1972 TestCpuAdaptation(true, true);
1973}
1974
perkj2d5f0912016-02-29 00:04:41 -08001975TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) {
1976 cricket::VideoCodec codec = kVp8Codec720p;
1977 cricket::VideoSendParameters parameters;
1978 parameters.codecs.push_back(codec);
1979
1980 MediaConfig media_config = MediaConfig();
1981 channel_.reset(
1982 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1983 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1984
1985 AddSendStream();
1986
1987 cricket::FakeVideoCapturer capturer;
perkj2d5f0912016-02-29 00:04:41 -08001988 ASSERT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1989 ASSERT_EQ(cricket::CS_RUNNING,
1990 capturer.Start(capturer.GetSupportedFormats()->front()));
1991 ASSERT_TRUE(channel_->SetSend(true));
1992
1993 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1994 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1995 webrtc::LoadObserver* overuse_callback =
1996 send_stream->GetConfig().overuse_callback;
1997 ASSERT_TRUE(overuse_callback != NULL);
1998
1999 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2000 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2001 EXPECT_EQ(1280, send_stream->GetLastWidth());
2002 EXPECT_EQ(720, send_stream->GetLastHeight());
2003
2004 // Trigger overuse.
2005 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2006 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2007 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
2008 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2009 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2010
2011 // Trigger overuse again.
2012 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2013 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2014 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
2015 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth());
2016 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight());
2017
2018 // Change input resolution.
2019 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
2020 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
2021 EXPECT_EQ(1284 / 2, send_stream->GetLastWidth());
2022 EXPECT_EQ(724 / 2, send_stream->GetLastHeight());
2023
2024 // Trigger underuse which should go back up in resolution.
2025 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2026 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
2027 EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames());
2028 EXPECT_EQ(1284 * 3 / 4, send_stream->GetLastWidth());
2029 EXPECT_EQ(724 * 3 / 4, send_stream->GetLastHeight());
2030
2031 // Trigger underuse which should go back up in resolution.
2032 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2033 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
2034 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames());
2035 EXPECT_EQ(1284, send_stream->GetLastWidth());
2036 EXPECT_EQ(724, send_stream->GetLastHeight());
2037
2038 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
2039}
2040
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02002041void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
2042 bool is_screenshare) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002043 cricket::VideoCodec codec = kVp8Codec720p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002044 cricket::VideoSendParameters parameters;
2045 parameters.codecs.push_back(codec);
nisse51542be2016-02-12 02:27:06 -08002046
2047 MediaConfig media_config = MediaConfig();
Peter Boströme4328002015-04-14 22:45:29 +02002048 if (!enable_overuse) {
nisse0db023a2016-03-01 04:29:59 -08002049 media_config.video.enable_cpu_overuse_detection = false;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002050 }
nisse51542be2016-02-12 02:27:06 -08002051 channel_.reset(
2052 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2053
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002054 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002055
2056 AddSendStream();
2057
nisse05103312016-03-16 02:22:50 -07002058 VideoOptions options;
2059 options.is_screencast = rtc::Optional<bool>(is_screenshare);
2060 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
2061
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002062 cricket::FakeVideoCapturer capturer;
2063 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
2064 EXPECT_EQ(cricket::CS_RUNNING,
2065 capturer.Start(capturer.GetSupportedFormats()->front()));
2066
2067 EXPECT_TRUE(channel_->SetSend(true));
2068
2069 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07002070 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2071 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002072 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07002073 send_stream->GetConfig().overuse_callback;
perkj2d5f0912016-02-29 00:04:41 -08002074
2075 if (!enable_overuse) {
2076 ASSERT_TRUE(overuse_callback == NULL);
2077
2078 EXPECT_TRUE(capturer.CaptureFrame());
2079 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2080
2081 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2082 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
2083
2084 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
2085 return;
2086 }
2087
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002088 ASSERT_TRUE(overuse_callback != NULL);
perkj2d5f0912016-02-29 00:04:41 -08002089 EXPECT_TRUE(capturer.CaptureFrame());
2090 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002091 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2092
2093 EXPECT_TRUE(capturer.CaptureFrame());
perkj2d5f0912016-02-29 00:04:41 -08002094 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002095
perkj2d5f0912016-02-29 00:04:41 -08002096 if (is_screenshare) {
2097 // Do not adapt screen share.
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002098 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2099 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
perkj2d5f0912016-02-29 00:04:41 -08002100 } else {
2101 EXPECT_LT(send_stream->GetLastWidth(), codec.width);
2102 EXPECT_LT(send_stream->GetLastHeight(), codec.height);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002103 }
2104
2105 // Trigger underuse which should go back to normal resolution.
2106 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2107 EXPECT_TRUE(capturer.CaptureFrame());
perkj2d5f0912016-02-29 00:04:41 -08002108 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002109
2110 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2111 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
2112
2113 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002114}
2115
magjedb09b6602015-10-01 03:02:44 -07002116TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly) {
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002117 // Start at last timestamp to verify that wraparounds are estimated correctly.
2118 static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
2119 static const int64_t kInitialNtpTimeMs = 1247891230;
2120 static const int kFrameOffsetMs = 20;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002121 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002122
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002123 FakeVideoReceiveStream* stream = AddRecvStream();
2124 cricket::FakeVideoRenderer renderer;
nisse08582ff2016-02-04 01:24:52 -08002125 EXPECT_TRUE(channel_->SetSink(last_ssrc_, &renderer));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002126
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07002127 webrtc::VideoFrame video_frame;
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002128 CreateBlackFrame(&video_frame, 4, 4);
2129 video_frame.set_timestamp(kInitialTimestamp);
2130 // Initial NTP time is not available on the first frame, but should still be
2131 // able to be estimated.
nisseeb83a1a2016-03-21 01:27:56 -07002132 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002133
2134 EXPECT_EQ(1, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002135
2136 // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which
2137 // triggers a constant-overflow warning, hence we're calculating it explicitly
2138 // here.
2139 video_frame.set_timestamp(kFrameOffsetMs * 90 - 1);
2140 video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs);
nisseeb83a1a2016-03-21 01:27:56 -07002141 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002142
2143 EXPECT_EQ(2, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002144
2145 // Verify that NTP time has been correctly deduced.
2146 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002147 ASSERT_TRUE(channel_->GetStats(&info));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002148 ASSERT_EQ(1u, info.receivers.size());
2149 EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002150}
2151
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002152TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002153 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002154
2155 VideoCodec codec;
2156 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00002157 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002158
2159 // Using a RTX setup to verify that the default RTX payload type is good.
Peter Boström0c4e06b2015-10-07 12:23:21 +02002160 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2161 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002162 FakeVideoSendStream* stream = AddSendStream(
2163 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
2164 webrtc::VideoSendStream::Config config = stream->GetConfig();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002165
2166 // Make sure NACK and FEC are enabled on the correct payload types.
2167 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
2168 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
2169 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002170
2171 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
2172 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
Shao Changbine62202f2015-04-21 20:24:50 +08002173 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002174 // TODO(juberti): Check RTCP, PLI, TMMBR.
2175}
2176
2177TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002178 cricket::VideoSendParameters parameters;
2179 parameters.codecs.push_back(kVp8Codec);
2180 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002181
2182 FakeVideoSendStream* stream = AddSendStream();
2183 webrtc::VideoSendStream::Config config = stream->GetConfig();
2184
2185 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
2186 EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
2187}
2188
2189TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002190 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002191 cricket::VideoSendParameters parameters;
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002192 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002193 parameters.codecs.push_back(rtx_codec);
2194 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002195 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002196}
2197
2198TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002199 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002200 cricket::VideoSendParameters parameters;
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002201 cricket::VideoCodec rtx_codec =
2202 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002203 parameters.codecs.push_back(kVp8Codec);
2204 parameters.codecs.push_back(rtx_codec);
2205 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002206
2207 cricket::VideoCodec rtx_codec2 =
2208 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002209 parameters.codecs.pop_back();
2210 parameters.codecs.push_back(rtx_codec2);
2211 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002212 << "RTX without matching video codec should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002213}
2214
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002215TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002216 cricket::VideoSendParameters parameters;
2217 parameters.codecs.push_back(kVp8Codec);
2218 parameters.codecs.push_back(kUlpfecCodec);
2219 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002220
2221 FakeVideoSendStream* stream = AddSendStream();
2222 webrtc::VideoSendStream::Config config = stream->GetConfig();
2223
2224 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2225
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002226 parameters.codecs.pop_back();
2227 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002228 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002229 ASSERT_TRUE(stream != NULL);
2230 config = stream->GetConfig();
2231 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2232 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002233}
2234
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002235TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002236 cricket::VideoSendParameters parameters;
2237 parameters.codecs.push_back(kVp8Codec720p);
2238 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002239 channel_->SetSend(true);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002240
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002241 FakeVideoSendStream* stream = AddSendStream();
2242
2243 cricket::FakeVideoCapturer capturer;
2244 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
2245 EXPECT_EQ(cricket::CS_RUNNING,
2246 capturer.Start(capturer.GetSupportedFormats()->front()));
2247 EXPECT_TRUE(capturer.CaptureFrame());
2248
2249 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002250 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
2251 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
2252
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002253 parameters.codecs.clear();
2254 parameters.codecs.push_back(kVp8Codec360p);
2255 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002256 streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002257 EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
2258 EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002259 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002260}
2261
pbos@webrtc.org00873182014-11-25 14:03:34 +00002262TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
2263 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2264 200000);
2265}
2266
pbos@webrtc.orga5f6fb52015-03-23 22:29:39 +00002267TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
2268 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
2269 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
2270 ASSERT_EQ(1u, streams.size());
2271 EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
2272}
2273
pbos@webrtc.org00873182014-11-25 14:03:34 +00002274TEST_F(WebRtcVideoChannel2Test,
2275 SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
2276 SetSendCodecsShouldWorkForBitrates(
2277 "", 0, "", -1, "", -1);
2278}
2279
2280TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
2281 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002282}
2283
2284TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002285 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300";
2286 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200";
2287 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002288}
2289
pbos@webrtc.org00873182014-11-25 14:03:34 +00002290TEST_F(WebRtcVideoChannel2Test,
2291 SetMaxSendBandwidthShouldPreserveOtherBitrates) {
2292 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2293 200000);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002294 send_parameters_.max_bandwidth_bps = 300000;
2295 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002296 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002297 << "Setting max bitrate should keep previous min bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002298 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002299 << "Setting max bitrate should not reset start bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002300 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002301}
2302
2303TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002304 send_parameters_.max_bandwidth_bps = 300000;
2305 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002306 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002307 // <= 0 means disable (infinite) max bitrate.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002308 send_parameters_.max_bandwidth_bps = 0;
2309 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002310 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002311 << "Setting zero max bitrate did not reset start bitrate.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002312}
2313
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002314TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002315 cricket::VideoSendParameters parameters;
2316 parameters.codecs.push_back(kVp8Codec720p);
2317 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002318 channel_->SetSend(true);
2319
2320 FakeVideoSendStream* stream = AddSendStream();
2321
Peter Boström3afc8c42016-01-27 16:45:21 +01002322 cricket::FakeVideoCapturer capturer;
2323 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
2324 EXPECT_EQ(cricket::CS_RUNNING,
2325 capturer.Start(capturer.GetSupportedFormats()->front()));
2326
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002327 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2328 int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
2329 EXPECT_GT(initial_max_bitrate_bps, 0);
2330
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002331 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2332 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01002333 // Insert a frame to update the encoder config.
2334 EXPECT_TRUE(capturer.CaptureFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002335 streams = stream->GetVideoStreams();
2336 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
Peter Boström3afc8c42016-01-27 16:45:21 +01002337 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, nullptr));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002338}
2339
2340TEST_F(WebRtcVideoChannel2Test,
2341 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002342 cricket::VideoSendParameters parameters;
2343 parameters.codecs.push_back(kVp8Codec720p);
2344 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002345 channel_->SetSend(true);
2346
2347 FakeVideoSendStream* stream = AddSendStream(
2348 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2349
2350 // Send a frame to make sure this scales up to >1 stream (simulcast).
2351 cricket::FakeVideoCapturer capturer;
2352 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &capturer));
2353 EXPECT_EQ(cricket::CS_RUNNING,
2354 capturer.Start(capturer.GetSupportedFormats()->front()));
2355 EXPECT_TRUE(capturer.CaptureFrame());
2356
2357 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2358 ASSERT_GT(streams.size(), 1u)
2359 << "Without simulcast this test doesn't make sense.";
pbosbe16f792015-10-16 12:49:39 -07002360 int initial_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002361 EXPECT_GT(initial_max_bitrate_bps, 0);
2362
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002363 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2364 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01002365 // Insert a frame to update the encoder config.
2366 EXPECT_TRUE(capturer.CaptureFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002367 streams = stream->GetVideoStreams();
pbosbe16f792015-10-16 12:49:39 -07002368 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002369 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
2370
2371 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], nullptr));
2372}
2373
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002374TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
2375 static const char* kMaxQuantization = "21";
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002376 cricket::VideoSendParameters parameters;
2377 parameters.codecs.push_back(kVp8Codec);
2378 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
2379 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002380 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
2381 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002382
2383 VideoCodec codec;
2384 EXPECT_TRUE(channel_->GetSendCodec(&codec));
2385 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
2386}
2387
2388TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002389 cricket::VideoSendParameters parameters;
2390 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002391
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002392 parameters.codecs[0].width = 0;
2393 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002394 << "Codec set though codec width is zero.";
2395
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002396 parameters.codecs[0].width = kVp8Codec.width;
2397 parameters.codecs[0].height = 0;
2398 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002399 << "Codec set though codec height is zero.";
2400}
2401
2402TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
2403 // TODO(pbos): Should we only allow the dynamic range?
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002404 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002405 cricket::VideoSendParameters parameters;
2406 parameters.codecs.push_back(kVp8Codec);
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002407 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002408 parameters.codecs[0].id = kIncorrectPayloads[i];
2409 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002410 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002411 }
2412}
2413
2414TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002415 cricket::VideoSendParameters parameters;
2416 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002417 for (int payload_type = 0; payload_type <= 127; ++payload_type) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002418 parameters.codecs[0].id = payload_type;
2419 EXPECT_TRUE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002420 << "Payload type '" << payload_type << "' rejected.";
2421 }
2422}
2423
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002424TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002425 cricket::VideoRecvParameters parameters;
2426 parameters.codecs.push_back(kVp8Codec);
2427 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002428}
2429
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002430// Test that we set our inbound RTX codecs properly.
2431TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002432 cricket::VideoRecvParameters parameters;
2433 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002434 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002435 parameters.codecs.push_back(rtx_codec);
2436 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002437 << "RTX codec without associated payload should be rejected.";
2438
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002439 parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1);
2440 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002441 << "RTX codec with invalid associated payload type should be rejected.";
2442
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002443 parameters.codecs[1].SetParam("apt", kVp8Codec.id);
2444 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002445
2446 cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0);
2447 rtx_codec2.SetParam("apt", rtx_codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002448 parameters.codecs.push_back(rtx_codec2);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002449
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002450 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) <<
2451 "RTX codec with another RTX as associated payload type should be "
2452 "rejected.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002453}
2454
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002455TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002456 cricket::VideoRecvParameters parameters;
2457 parameters.codecs.push_back(kVp8Codec);
2458 parameters.codecs[0].id = 99;
2459 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002460}
2461
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002462TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002463 cricket::VideoRecvParameters parameters;
2464 parameters.codecs = engine_.codecs();
2465 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002466
2467 FakeVideoReceiveStream* stream = AddRecvStream();
2468 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002469 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
2470 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002471}
2472
2473TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002474 cricket::VideoRecvParameters parameters;
2475 parameters.codecs.push_back(kVp8Codec);
2476 parameters.codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
2477 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002478}
2479
2480// TODO(pbos): Enable VP9 through external codec support
2481TEST_F(WebRtcVideoChannel2Test,
2482 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002483 cricket::VideoRecvParameters parameters;
2484 parameters.codecs.push_back(kVp8Codec);
2485 parameters.codecs.push_back(kVp9Codec);
2486 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002487}
2488
2489TEST_F(WebRtcVideoChannel2Test,
2490 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002491 cricket::VideoRecvParameters parameters;
2492 parameters.codecs.push_back(kVp8Codec);
2493 parameters.codecs.push_back(kVp9Codec);
2494 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002495 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
2496}
2497
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002498TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002499 cricket::VideoSendParameters send_parameters;
2500 send_parameters.codecs.push_back(kVp8Codec);
2501 send_parameters.codecs.push_back(kUlpfecCodec);
2502 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002503
2504 FakeVideoReceiveStream* stream = AddRecvStream();
2505 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
2506
2507 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2508
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002509 cricket::VideoRecvParameters recv_parameters;
2510 recv_parameters.codecs.push_back(kVp8Codec);
2511 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002512 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002513 ASSERT_TRUE(stream != NULL);
2514 config = stream->GetConfig();
2515 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2516 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002517}
2518
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002519TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002520 cricket::VideoRecvParameters parameters;
2521 parameters.codecs.push_back(kVp8Codec);
2522 parameters.codecs.push_back(kRedCodec);
2523 parameters.codecs[1].id = parameters.codecs[0].id;
2524 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002525}
2526
2527TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002528 cricket::VideoRecvParameters parameters;
2529 parameters.codecs.push_back(kVp8Codec);
2530 parameters.codecs.push_back(kVp9Codec);
2531 parameters.codecs[1].id = parameters.codecs[0].id;
2532 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002533}
2534
2535TEST_F(WebRtcVideoChannel2Test,
2536 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002537 cricket::VideoRecvParameters parameters;
2538 parameters.codecs.push_back(kVp8Codec);
2539 parameters.codecs.push_back(kVp8Codec);
2540 parameters.codecs[1].id += 1;
2541 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002542}
2543
deadbeef874ca3a2015-08-20 17:19:20 -07002544// Test that setting the same codecs but with a different order and preference
2545// doesn't result in the stream being recreated.
2546TEST_F(WebRtcVideoChannel2Test,
2547 SetRecvCodecsDifferentOrderAndPreferenceDoesntRecreateStream) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002548 cricket::VideoRecvParameters parameters1;
2549 parameters1.codecs.push_back(kVp8Codec);
2550 parameters1.codecs.push_back(kRedCodec);
2551 EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
deadbeef874ca3a2015-08-20 17:19:20 -07002552
2553 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2554 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2555
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002556 cricket::VideoRecvParameters parameters2;
2557 parameters2.codecs.push_back(kRedCodec);
2558 parameters2.codecs.push_back(kVp8Codec);
2559 parameters2.codecs[1].preference += 1;
2560 EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
deadbeef874ca3a2015-08-20 17:19:20 -07002561 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2562}
2563
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002564TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
2565 EXPECT_FALSE(AddSendStream()->IsSending());
2566}
2567
pbos@webrtc.org85f42942014-07-22 09:14:58 +00002568TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
2569 EXPECT_TRUE(AddRecvStream()->IsReceiving());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002570}
2571
2572TEST_F(WebRtcVideoChannel2Test, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002573 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002574 EXPECT_FALSE(stream->IsSending());
2575
2576 // false->true
2577 EXPECT_TRUE(channel_->SetSend(true));
2578 EXPECT_TRUE(stream->IsSending());
2579 // true->true
2580 EXPECT_TRUE(channel_->SetSend(true));
2581 EXPECT_TRUE(stream->IsSending());
2582 // true->false
2583 EXPECT_TRUE(channel_->SetSend(false));
2584 EXPECT_FALSE(stream->IsSending());
2585 // false->false
2586 EXPECT_TRUE(channel_->SetSend(false));
2587 EXPECT_FALSE(stream->IsSending());
2588
2589 EXPECT_TRUE(channel_->SetSend(true));
2590 FakeVideoSendStream* new_stream = AddSendStream();
2591 EXPECT_TRUE(new_stream->IsSending())
2592 << "Send stream created after SetSend(true) not sending initially.";
2593}
2594
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002595// This test verifies DSCP settings are properly applied on video media channel.
2596TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
kwiberg686a8ef2016-02-26 03:00:35 -08002597 std::unique_ptr<cricket::FakeNetworkInterface> network_interface(
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002598 new cricket::FakeNetworkInterface);
nisse51542be2016-02-12 02:27:06 -08002599 MediaConfig config;
kwiberg686a8ef2016-02-26 03:00:35 -08002600 std::unique_ptr<VideoMediaChannel> channel;
nisse51542be2016-02-12 02:27:06 -08002601
2602 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2603 channel->SetInterface(network_interface.get());
2604 // Default value when DSCP is disabled should be DSCP_DEFAULT.
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002605 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
nisse51542be2016-02-12 02:27:06 -08002606
2607 config.enable_dscp = true;
2608 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2609 channel->SetInterface(network_interface.get());
2610 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2611
2612 // Verify that setting the option to false resets the
2613 // DiffServCodePoint.
2614 config.enable_dscp = false;
2615 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2616 channel->SetInterface(network_interface.get());
2617 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002618}
2619
deadbeef13871492015-12-09 12:37:51 -08002620// This test verifies that the RTCP reduced size mode is properly applied to
2621// send video streams.
2622TEST_F(WebRtcVideoChannel2Test, TestSetSendRtcpReducedSize) {
2623 // Create stream, expecting that default mode is "compound".
2624 FakeVideoSendStream* stream1 = AddSendStream();
2625 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
2626
2627 // Now enable reduced size mode.
2628 send_parameters_.rtcp.reduced_size = true;
2629 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2630 stream1 = fake_call_->GetVideoSendStreams()[0];
2631 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
2632
2633 // Create a new stream and ensure it picks up the reduced size mode.
2634 FakeVideoSendStream* stream2 = AddSendStream();
2635 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
2636}
2637
2638// This test verifies that the RTCP reduced size mode is properly applied to
2639// receive video streams.
2640TEST_F(WebRtcVideoChannel2Test, TestSetRecvRtcpReducedSize) {
2641 // Create stream, expecting that default mode is "compound".
2642 FakeVideoReceiveStream* stream1 = AddRecvStream();
2643 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
2644
2645 // Now enable reduced size mode.
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002646 // TODO(deadbeef): Once "recv_parameters" becomes "receiver_parameters",
2647 // the reduced_size flag should come from that.
2648 send_parameters_.rtcp.reduced_size = true;
2649 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
deadbeef13871492015-12-09 12:37:51 -08002650 stream1 = fake_call_->GetVideoReceiveStreams()[0];
2651 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
2652
2653 // Create a new stream and ensure it picks up the reduced size mode.
2654 FakeVideoReceiveStream* stream2 = AddRecvStream();
2655 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
2656}
2657
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002658TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
skvlad7a43d252016-03-22 15:32:27 -07002659 EXPECT_EQ(webrtc::kNetworkUp,
2660 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2661 EXPECT_EQ(webrtc::kNetworkUp,
2662 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002663
2664 channel_->OnReadyToSend(false);
skvlad7a43d252016-03-22 15:32:27 -07002665 EXPECT_EQ(webrtc::kNetworkDown,
2666 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2667 EXPECT_EQ(webrtc::kNetworkUp,
2668 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002669
2670 channel_->OnReadyToSend(true);
skvlad7a43d252016-03-22 15:32:27 -07002671 EXPECT_EQ(webrtc::kNetworkUp,
2672 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2673 EXPECT_EQ(webrtc::kNetworkUp,
2674 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002675}
2676
Peter Boström74d9ed72015-03-26 16:28:31 +01002677TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002678 cricket::VideoSendParameters parameters;
2679 parameters.codecs.push_back(kVp8Codec);
2680 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström74d9ed72015-03-26 16:28:31 +01002681
2682 AddSendStream();
2683
2684 cricket::VideoMediaInfo info;
2685 ASSERT_TRUE(channel_->GetStats(&info));
2686 EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name);
2687}
2688
Peter Boströmb7d9a972015-12-18 16:01:11 +01002689TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) {
2690 FakeVideoSendStream* stream = AddSendStream();
2691 webrtc::VideoSendStream::Stats stats;
2692 stats.encoder_implementation_name = "encoder_implementation_name";
2693 stream->SetStats(stats);
2694
2695 cricket::VideoMediaInfo info;
2696 ASSERT_TRUE(channel_->GetStats(&info));
2697 EXPECT_EQ(stats.encoder_implementation_name,
2698 info.senders[0].encoder_implementation_name);
2699}
2700
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002701TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) {
2702 FakeVideoSendStream* stream = AddSendStream();
2703 webrtc::VideoSendStream::Stats stats;
2704 stats.avg_encode_time_ms = 13;
2705 stats.encode_usage_percent = 42;
2706 stream->SetStats(stats);
2707
2708 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002709 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002710 EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms);
2711 EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent);
2712}
2713
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002714TEST_F(WebRtcVideoChannel2Test, GetStatsReportsUpperResolution) {
2715 FakeVideoSendStream* stream = AddSendStream();
2716 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002717 stats.substreams[17].width = 123;
2718 stats.substreams[17].height = 40;
2719 stats.substreams[42].width = 80;
2720 stats.substreams[42].height = 31;
2721 stats.substreams[11].width = 20;
2722 stats.substreams[11].height = 90;
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002723 stream->SetStats(stats);
2724
2725 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002726 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002727 ASSERT_EQ(1u, info.senders.size());
2728 EXPECT_EQ(123, info.senders[0].send_frame_width);
2729 EXPECT_EQ(90, info.senders[0].send_frame_height);
2730}
2731
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002732TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) {
2733 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2734
2735 // Capture format VGA.
2736 cricket::FakeVideoCapturer video_capturer_vga;
2737 const std::vector<cricket::VideoFormat>* formats =
2738 video_capturer_vga.GetSupportedFormats();
2739 cricket::VideoFormat capture_format_vga = (*formats)[1];
2740 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
2741 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_vga));
2742 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2743
2744 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002745 cricket::VideoSendParameters parameters;
2746 parameters.codecs.push_back(send_codec);
2747 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002748 EXPECT_TRUE(channel_->SetSend(true));
2749
2750 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
solenberge5269742015-09-08 05:13:22 -07002751
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002752 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07002753 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002754 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07002755 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
2756 ASSERT_TRUE(overuse_callback != NULL);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002757 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2758
2759 // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
2760 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2761 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002762 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002763 ASSERT_EQ(1U, info.senders.size());
2764 EXPECT_EQ(1, info.senders[0].adapt_changes);
2765 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2766 info.senders[0].adapt_reason);
2767
2768 // Trigger upgrade and verify that we adapt back up to VGA.
2769 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2770 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2771 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002772 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002773 ASSERT_EQ(1U, info.senders.size());
2774 EXPECT_EQ(2, info.senders[0].adapt_changes);
2775 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2776 info.senders[0].adapt_reason);
2777
2778 // No capturer (no adapter). Adapt changes from old adapter should be kept.
2779 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2780 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002781 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002782 ASSERT_EQ(1U, info.senders.size());
2783 EXPECT_EQ(2, info.senders[0].adapt_changes);
2784 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2785 info.senders[0].adapt_reason);
2786
2787 // Set new capturer, capture format HD.
2788 cricket::FakeVideoCapturer video_capturer_hd;
2789 cricket::VideoFormat capture_format_hd = (*formats)[0];
2790 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd));
2791 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_hd));
2792 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2793
2794 // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2.
2795 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2796 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2797 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002798 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002799 ASSERT_EQ(1U, info.senders.size());
2800 EXPECT_EQ(3, info.senders[0].adapt_changes);
2801 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2802 info.senders[0].adapt_reason);
2803
2804 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2805}
2806
asapersson17821db2015-12-14 02:08:12 -08002807TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationAndBandwidthStats) {
2808 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2809
2810 // Capture format VGA.
2811 cricket::FakeVideoCapturer video_capturer_vga;
2812 const std::vector<cricket::VideoFormat>* formats =
2813 video_capturer_vga.GetSupportedFormats();
2814 cricket::VideoFormat capture_format_vga = (*formats)[1];
2815 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
2816 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_vga));
2817 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2818
2819 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30, 0);
2820 cricket::VideoSendParameters parameters;
2821 parameters.codecs.push_back(send_codec);
2822 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2823 EXPECT_TRUE(channel_->SetSend(true));
2824
2825 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
asapersson17821db2015-12-14 02:08:12 -08002826
2827 // Trigger overuse -> adapt CPU.
2828 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2829 webrtc::LoadObserver* overuse_callback =
2830 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
2831 ASSERT_TRUE(overuse_callback != NULL);
2832 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2833 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2834 cricket::VideoMediaInfo info;
2835 EXPECT_TRUE(channel_->GetStats(&info));
2836 ASSERT_EQ(1U, info.senders.size());
2837 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2838 info.senders[0].adapt_reason);
2839
2840 // Set bandwidth limitation stats for the stream -> adapt CPU + BW.
2841 webrtc::VideoSendStream::Stats stats;
2842 stats.bw_limited_resolution = true;
2843 fake_call_->GetVideoSendStreams().front()->SetStats(stats);
2844 info.Clear();
2845 EXPECT_TRUE(channel_->GetStats(&info));
2846 ASSERT_EQ(1U, info.senders.size());
2847 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU +
2848 CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH,
2849 info.senders[0].adapt_reason);
2850
2851 // Trigger upgrade -> adapt BW.
2852 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2853 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2854 info.Clear();
2855 EXPECT_TRUE(channel_->GetStats(&info));
2856 ASSERT_EQ(1U, info.senders.size());
2857 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH,
2858 info.senders[0].adapt_reason);
2859
2860 // Reset bandwidth limitation state -> adapt NONE.
2861 stats.bw_limited_resolution = false;
2862 fake_call_->GetVideoSendStreams().front()->SetStats(stats);
2863 info.Clear();
2864 EXPECT_TRUE(channel_->GetStats(&info));
2865 ASSERT_EQ(1U, info.senders.size());
2866 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2867 info.senders[0].adapt_reason);
2868
2869 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2870}
2871
2872TEST_F(WebRtcVideoChannel2Test,
2873 GetStatsTranslatesBandwidthLimitedResolutionCorrectly) {
2874 FakeVideoSendStream* stream = AddSendStream();
2875 webrtc::VideoSendStream::Stats stats;
2876 stats.bw_limited_resolution = true;
2877 stream->SetStats(stats);
2878
2879 cricket::VideoMediaInfo info;
2880 EXPECT_TRUE(channel_->GetStats(&info));
2881 ASSERT_EQ(1U, info.senders.size());
2882 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH,
2883 info.senders[0].adapt_reason);
2884}
2885
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002886TEST_F(WebRtcVideoChannel2Test,
2887 GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
2888 FakeVideoSendStream* stream = AddSendStream();
2889 webrtc::VideoSendStream::Stats stats;
2890 stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
2891 stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
2892 stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
2893
2894 stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5;
2895 stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7;
2896 stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9;
2897
2898 stream->SetStats(stats);
2899
2900 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002901 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002902 EXPECT_EQ(7, info.senders[0].firs_rcvd);
2903 EXPECT_EQ(10, info.senders[0].nacks_rcvd);
2904 EXPECT_EQ(13, info.senders[0].plis_rcvd);
2905}
2906
2907TEST_F(WebRtcVideoChannel2Test,
2908 GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
2909 FakeVideoReceiveStream* stream = AddRecvStream();
2910 webrtc::VideoReceiveStream::Stats stats;
2911 stats.rtcp_packet_type_counts.fir_packets = 2;
2912 stats.rtcp_packet_type_counts.nack_packets = 3;
2913 stats.rtcp_packet_type_counts.pli_packets = 4;
2914 stream->SetStats(stats);
2915
2916 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002917 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002918 EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
2919 info.receivers[0].firs_sent);
2920 EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
2921 info.receivers[0].nacks_sent);
2922 EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
2923 info.receivers[0].plis_sent);
2924}
2925
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002926TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly) {
2927 FakeVideoReceiveStream* stream = AddRecvStream();
2928 webrtc::VideoReceiveStream::Stats stats;
Peter Boströmb7d9a972015-12-18 16:01:11 +01002929 stats.decoder_implementation_name = "decoder_implementation_name";
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002930 stats.decode_ms = 2;
2931 stats.max_decode_ms = 3;
2932 stats.current_delay_ms = 4;
2933 stats.target_delay_ms = 5;
2934 stats.jitter_buffer_ms = 6;
2935 stats.min_playout_delay_ms = 7;
2936 stats.render_delay_ms = 8;
2937 stream->SetStats(stats);
2938
2939 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002940 ASSERT_TRUE(channel_->GetStats(&info));
Peter Boströmb7d9a972015-12-18 16:01:11 +01002941 EXPECT_EQ(stats.decoder_implementation_name,
2942 info.receivers[0].decoder_implementation_name);
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002943 EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms);
2944 EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms);
2945 EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms);
2946 EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms);
2947 EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms);
2948 EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms);
2949 EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
2950}
2951
Peter Boström393347f2015-04-22 14:52:45 +02002952TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesReceivePacketStatsCorrectly) {
2953 FakeVideoReceiveStream* stream = AddRecvStream();
2954 webrtc::VideoReceiveStream::Stats stats;
2955 stats.rtp_stats.transmitted.payload_bytes = 2;
2956 stats.rtp_stats.transmitted.header_bytes = 3;
2957 stats.rtp_stats.transmitted.padding_bytes = 4;
2958 stats.rtp_stats.transmitted.packets = 5;
2959 stats.rtcp_stats.cumulative_lost = 6;
2960 stats.rtcp_stats.fraction_lost = 7;
2961 stream->SetStats(stats);
2962
2963 cricket::VideoMediaInfo info;
2964 ASSERT_TRUE(channel_->GetStats(&info));
2965 EXPECT_EQ(stats.rtp_stats.transmitted.payload_bytes +
2966 stats.rtp_stats.transmitted.header_bytes +
2967 stats.rtp_stats.transmitted.padding_bytes,
2968 info.receivers[0].bytes_rcvd);
2969 EXPECT_EQ(stats.rtp_stats.transmitted.packets,
2970 info.receivers[0].packets_rcvd);
2971 EXPECT_EQ(stats.rtcp_stats.cumulative_lost, info.receivers[0].packets_lost);
2972 EXPECT_EQ(static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8),
2973 info.receivers[0].fraction_lost);
2974}
2975
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002976TEST_F(WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly) {
2977 AddSendStream();
2978 AddSendStream();
2979 webrtc::Call::Stats stats;
2980 stats.rtt_ms = 123;
2981 fake_call_->SetStats(stats);
2982
2983 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002984 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002985 ASSERT_EQ(2u, info.senders.size());
2986 EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms);
2987 EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms);
2988}
2989
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002990TEST_F(WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly) {
2991 FakeVideoSendStream* stream = AddSendStream();
2992 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002993 stats.target_media_bitrate_bps = 156;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002994 stats.media_bitrate_bps = 123;
2995 stats.substreams[17].total_bitrate_bps = 1;
2996 stats.substreams[17].retransmit_bitrate_bps = 2;
2997 stats.substreams[42].total_bitrate_bps = 3;
2998 stats.substreams[42].retransmit_bitrate_bps = 4;
2999 stream->SetStats(stats);
3000
3001 FakeVideoSendStream* stream2 = AddSendStream();
3002 webrtc::VideoSendStream::Stats stats2;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003003 stats2.target_media_bitrate_bps = 200;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003004 stats2.media_bitrate_bps = 321;
3005 stats2.substreams[13].total_bitrate_bps = 5;
3006 stats2.substreams[13].retransmit_bitrate_bps = 6;
3007 stats2.substreams[21].total_bitrate_bps = 7;
3008 stats2.substreams[21].retransmit_bitrate_bps = 8;
3009 stream2->SetStats(stats2);
3010
3011 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003012 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003013 ASSERT_EQ(2u, info.senders.size());
3014 // Assuming stream and stream2 corresponds to senders[0] and [1] respectively
3015 // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
3016 EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
3017 EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003018 EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
3019 info.bw_estimations[0].target_enc_bitrate);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003020 EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
3021 info.bw_estimations[0].actual_enc_bitrate);
3022 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
3023 << "Bandwidth stats should take all streams into account.";
3024 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
3025 << "Bandwidth stats should take all streams into account.";
3026}
3027
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003028TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003029 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003030
Peter Boström0c4e06b2015-10-07 12:23:21 +02003031 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3032 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003033
3034 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
3035 const size_t kDataLength = 12;
3036 uint8_t data[kDataLength];
3037 memset(data, 0, sizeof(data));
3038 rtc::SetBE32(&data[8], ssrcs[0]);
jbaucheec21bd2016-03-20 06:15:43 -07003039 rtc::CopyOnWriteBuffer packet(data, kDataLength);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003040 rtc::PacketTime packet_time;
3041 channel_->OnPacketReceived(&packet, packet_time);
3042
3043 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3044 << "No default receive stream created.";
3045 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
3046 EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size())
3047 << "Default receive stream should not have configured RTX";
3048
3049 EXPECT_TRUE(channel_->AddRecvStream(
3050 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
3051 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3052 << "AddRecvStream should've reconfigured, not added a new receiver.";
3053 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
Stefan Holmer10880012016-02-03 13:29:59 +01003054 ASSERT_GE(2u, recv_stream->GetConfig().rtp.rtx.size());
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003055 EXPECT_EQ(rtx_ssrcs[0],
3056 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
3057}
3058
Peter Boströmd4362cd2015-03-25 14:17:23 +01003059TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003060 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd4362cd2015-03-25 14:17:23 +01003061
Peter Boström0c4e06b2015-10-07 12:23:21 +02003062 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3063 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd4362cd2015-03-25 14:17:23 +01003064
3065 StreamParams sp =
3066 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
3067 sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
3068
3069 EXPECT_FALSE(channel_->AddSendStream(sp));
3070 EXPECT_FALSE(channel_->AddRecvStream(sp));
3071}
3072
Peter Boströmd6f4c252015-03-26 16:23:04 +01003073TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003074 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003075
Peter Boström0c4e06b2015-10-07 12:23:21 +02003076 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3077 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd6f4c252015-03-26 16:23:04 +01003078
3079 StreamParams sp =
3080 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
3081
3082 EXPECT_TRUE(channel_->AddSendStream(sp));
3083 EXPECT_TRUE(channel_->AddRecvStream(sp));
3084
3085 // The RTX SSRC is already used in previous streams, using it should fail.
3086 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
3087 EXPECT_FALSE(channel_->AddSendStream(sp));
3088 EXPECT_FALSE(channel_->AddRecvStream(sp));
3089
3090 // After removing the original stream this should be fine to add (makes sure
3091 // that RTX ssrcs are not forever taken).
3092 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
3093 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
3094 EXPECT_TRUE(channel_->AddSendStream(sp));
3095 EXPECT_TRUE(channel_->AddRecvStream(sp));
3096}
3097
3098TEST_F(WebRtcVideoChannel2Test,
3099 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02003100 static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3};
3101 static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003102 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003103
Peter Boströmd6f4c252015-03-26 16:23:04 +01003104 StreamParams sp =
3105 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
3106
3107 EXPECT_TRUE(channel_->AddSendStream(sp));
3108 EXPECT_TRUE(channel_->AddRecvStream(sp));
3109
3110 // One of the SSRCs is already used in previous streams, using it should fail.
3111 sp = cricket::CreateSimStreamParams("cname",
3112 MAKE_VECTOR(kOverlappingStreamSsrcs));
3113 EXPECT_FALSE(channel_->AddSendStream(sp));
3114 EXPECT_FALSE(channel_->AddRecvStream(sp));
3115
3116 // After removing the original stream this should be fine to add (makes sure
3117 // that RTX ssrcs are not forever taken).
Peter Boström3548dd22015-05-22 18:48:36 +02003118 EXPECT_TRUE(channel_->RemoveSendStream(kFirstStreamSsrcs[0]));
3119 EXPECT_TRUE(channel_->RemoveRecvStream(kFirstStreamSsrcs[0]));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003120 EXPECT_TRUE(channel_->AddSendStream(sp));
3121 EXPECT_TRUE(channel_->AddRecvStream(sp));
3122}
3123
Peter Boström259bd202015-05-28 13:39:50 +02003124TEST_F(WebRtcVideoChannel2Test, ReportsSsrcGroupsInStats) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003125 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström259bd202015-05-28 13:39:50 +02003126
3127 static const uint32_t kSenderSsrcs[] = {4, 7, 10};
3128 static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11};
3129
3130 StreamParams sender_sp = cricket::CreateSimWithRtxStreamParams(
3131 "cname", MAKE_VECTOR(kSenderSsrcs), MAKE_VECTOR(kSenderRtxSsrcs));
3132
3133 EXPECT_TRUE(channel_->AddSendStream(sender_sp));
3134
3135 static const uint32_t kReceiverSsrcs[] = {3};
3136 static const uint32_t kReceiverRtxSsrcs[] = {2};
3137
3138 StreamParams receiver_sp = cricket::CreateSimWithRtxStreamParams(
3139 "cname", MAKE_VECTOR(kReceiverSsrcs), MAKE_VECTOR(kReceiverRtxSsrcs));
3140 EXPECT_TRUE(channel_->AddRecvStream(receiver_sp));
3141
3142 cricket::VideoMediaInfo info;
3143 ASSERT_TRUE(channel_->GetStats(&info));
3144
3145 ASSERT_EQ(1u, info.senders.size());
3146 ASSERT_EQ(1u, info.receivers.size());
3147
3148 EXPECT_NE(sender_sp.ssrc_groups, receiver_sp.ssrc_groups);
3149 EXPECT_EQ(sender_sp.ssrc_groups, info.senders[0].ssrc_groups);
3150 EXPECT_EQ(receiver_sp.ssrc_groups, info.receivers[0].ssrc_groups);
3151}
3152
pbosf42376c2015-08-28 07:35:32 -07003153TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) {
3154 FakeVideoReceiveStream* stream = AddRecvStream();
3155 webrtc::VideoReceiveStream::Stats stats;
3156 cricket::VideoMediaInfo info;
3157
3158 // Report no codec name before receiving.
3159 stream->SetStats(stats);
3160 ASSERT_TRUE(channel_->GetStats(&info));
3161 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3162
3163 // Report VP8 if we're receiving it.
3164 stats.current_payload_type = kDefaultVp8PlType;
3165 stream->SetStats(stats);
3166 ASSERT_TRUE(channel_->GetStats(&info));
3167 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str());
3168
3169 // Report no codec name for unknown playload types.
3170 stats.current_payload_type = 3;
3171 stream->SetStats(stats);
3172 ASSERT_TRUE(channel_->GetStats(&info));
3173 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3174}
3175
noahricd10a68e2015-07-10 11:27:55 -07003176void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket(
3177 uint8_t payload_type,
3178 bool expect_created_receive_stream) {
noahricd10a68e2015-07-10 11:27:55 -07003179 // Add a RED RTX codec.
3180 VideoCodec red_rtx_codec =
3181 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003182 recv_parameters_.codecs.push_back(red_rtx_codec);
3183 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
noahricd10a68e2015-07-10 11:27:55 -07003184
3185 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
3186 const size_t kDataLength = 12;
3187 uint8_t data[kDataLength];
3188 memset(data, 0, sizeof(data));
3189
3190 rtc::Set8(data, 1, payload_type);
3191 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
jbaucheec21bd2016-03-20 06:15:43 -07003192 rtc::CopyOnWriteBuffer packet(data, kDataLength);
noahricd10a68e2015-07-10 11:27:55 -07003193 rtc::PacketTime packet_time;
3194 channel_->OnPacketReceived(&packet, packet_time);
3195
3196 if (expect_created_receive_stream) {
3197 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3198 << "Should have created a receive stream for payload type: "
3199 << payload_type;
3200 } else {
3201 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size())
3202 << "Shouldn't have created a receive stream for payload type: "
3203 << payload_type;
3204 }
3205}
3206
3207TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) {
3208 TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true);
3209}
3210
3211TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) {
3212 TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true);
3213}
3214
3215TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) {
3216 TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false);
3217}
3218
3219TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
3220 TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false);
3221}
3222
3223TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
3224 TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false);
3225}
3226
skvladdc1c62c2016-03-16 19:07:43 -07003227TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) {
3228 AddSendStream();
3229
3230 cricket::FakeVideoCapturer capturer;
3231 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
3232 cricket::VideoFormat capture_format_hd =
3233 capturer.GetSupportedFormats()->front();
3234 EXPECT_EQ(1280, capture_format_hd.width);
3235 EXPECT_EQ(720, capture_format_hd.height);
3236 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
3237 EXPECT_TRUE(channel_->SetSend(true));
3238
3239 int default_encoder_bitrate = GetMaxEncoderBitrate(capturer);
3240 EXPECT_TRUE(default_encoder_bitrate > 1000);
3241
3242 // TODO(skvlad): Resolve the inconsistency between the interpretation
3243 // of the global bitrate limit for audio and video:
3244 // - Audio: max_bandwidth_bps = 0 - fail the operation,
3245 // max_bandwidth_bps = -1 - remove the bandwidth limit
3246 // - Video: max_bandwidth_bps = 0 - remove the bandwidth limit,
3247 // max_bandwidth_bps = -1 - do not change the previously set
3248 // limit.
3249
3250 SetAndExpectMaxBitrate(capturer, 1000, 0, 1000);
3251 SetAndExpectMaxBitrate(capturer, 1000, 800, 800);
3252 SetAndExpectMaxBitrate(capturer, 600, 800, 600);
3253 SetAndExpectMaxBitrate(capturer, 0, 800, 800);
3254 SetAndExpectMaxBitrate(capturer, 0, 0, default_encoder_bitrate);
3255
3256 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
3257}
3258
3259TEST_F(WebRtcVideoChannel2Test, CannotSetMaxBitrateForNonexistentStream) {
3260 webrtc::RtpParameters nonexistent_parameters =
3261 channel_->GetRtpParameters(last_ssrc_);
3262 EXPECT_EQ(0, nonexistent_parameters.encodings.size());
3263
3264 nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
3265 EXPECT_FALSE(channel_->SetRtpParameters(last_ssrc_, nonexistent_parameters));
3266}
3267
3268TEST_F(WebRtcVideoChannel2Test,
3269 CannotSetRtpParametersWithIncorrectNumberOfEncodings) {
3270 // This test verifies that setting RtpParameters succeeds only if
3271 // the structure contains exactly one encoding.
3272 // TODO(skvlad): Update this test when we strat supporting setting parameters
3273 // for each encoding individually.
3274
3275 AddSendStream();
3276 // Setting RtpParameters with no encoding is expected to fail.
3277 webrtc::RtpParameters parameters;
3278 EXPECT_FALSE(channel_->SetRtpParameters(last_ssrc_, parameters));
3279 // Setting RtpParameters with exactly one encoding should succeed.
3280 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
3281 EXPECT_TRUE(channel_->SetRtpParameters(last_ssrc_, parameters));
3282 // Two or more encodings should result in failure.
3283 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
3284 EXPECT_FALSE(channel_->SetRtpParameters(last_ssrc_, parameters));
3285}
3286
Peter Boström3548dd22015-05-22 18:48:36 +02003287void WebRtcVideoChannel2Test::TestReceiverLocalSsrcConfiguration(
3288 bool receiver_first) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003289 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström3548dd22015-05-22 18:48:36 +02003290
3291 const uint32_t kSenderSsrc = 0xC0FFEE;
Peter Boströmdfa28152015-10-21 17:21:10 +02003292 const uint32_t kSecondSenderSsrc = 0xBADCAFE;
Peter Boström3548dd22015-05-22 18:48:36 +02003293 const uint32_t kReceiverSsrc = 0x4711;
Peter Boströmdfa28152015-10-21 17:21:10 +02003294 const uint32_t kExpectedDefaultReceiverSsrc = 1;
Peter Boström3548dd22015-05-22 18:48:36 +02003295
3296 if (receiver_first) {
3297 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
3298 std::vector<FakeVideoReceiveStream*> receive_streams =
3299 fake_call_->GetVideoReceiveStreams();
3300 ASSERT_EQ(1u, receive_streams.size());
Peter Boströmdfa28152015-10-21 17:21:10 +02003301 // Default local SSRC when we have no sender.
3302 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
3303 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02003304 }
3305 AddSendStream(StreamParams::CreateLegacy(kSenderSsrc));
3306 if (!receiver_first)
3307 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
3308 std::vector<FakeVideoReceiveStream*> receive_streams =
3309 fake_call_->GetVideoReceiveStreams();
3310 ASSERT_EQ(1u, receive_streams.size());
3311 EXPECT_EQ(kSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boströmdfa28152015-10-21 17:21:10 +02003312
3313 // Removing first sender should fall back to another (in this case the second)
3314 // local send stream's SSRC.
3315 AddSendStream(StreamParams::CreateLegacy(kSecondSenderSsrc));
3316 ASSERT_TRUE(channel_->RemoveSendStream(kSenderSsrc));
3317 receive_streams =
3318 fake_call_->GetVideoReceiveStreams();
3319 ASSERT_EQ(1u, receive_streams.size());
3320 EXPECT_EQ(kSecondSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
3321
3322 // Removing the last sender should fall back to default local SSRC.
3323 ASSERT_TRUE(channel_->RemoveSendStream(kSecondSenderSsrc));
3324 receive_streams =
3325 fake_call_->GetVideoReceiveStreams();
3326 ASSERT_EQ(1u, receive_streams.size());
3327 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
3328 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02003329}
3330
3331TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrc) {
3332 TestReceiverLocalSsrcConfiguration(false);
3333}
3334
3335TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) {
3336 TestReceiverLocalSsrcConfiguration(true);
3337}
3338
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003339class WebRtcVideoChannel2SimulcastTest : public testing::Test {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003340 public:
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003341 WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {}
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003342
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00003343 void SetUp() override {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +02003344 engine_.Init();
nisse51542be2016-02-12 02:27:06 -08003345 channel_.reset(
3346 engine_.CreateChannel(&fake_call_, MediaConfig(), VideoOptions()));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003347 last_ssrc_ = 123;
3348 }
3349
3350 protected:
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003351 void VerifySimulcastSettings(const VideoCodec& codec,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003352 size_t num_configured_streams,
pbosbe16f792015-10-16 12:49:39 -07003353 size_t expected_num_streams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003354 cricket::VideoSendParameters parameters;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003355 parameters.codecs.push_back(codec);
3356 ASSERT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003357
Peter Boström0c4e06b2015-10-07 12:23:21 +02003358 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
henrikg91d6ede2015-09-17 00:24:34 -07003359 RTC_DCHECK(num_configured_streams <= ssrcs.size());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003360 ssrcs.resize(num_configured_streams);
3361
3362 FakeVideoSendStream* stream =
3363 AddSendStream(CreateSimStreamParams("cname", ssrcs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003364 // Send a full-size frame to trigger a stream reconfiguration to use all
3365 // expected simulcast layers.
3366 cricket::FakeVideoCapturer capturer;
3367 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer));
3368 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
3369 codec.width, codec.height,
3370 cricket::VideoFormat::FpsToInterval(30),
3371 cricket::FOURCC_I420)));
3372 channel_->SetSend(true);
3373 EXPECT_TRUE(capturer.CaptureFrame());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003374
3375 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
3376 ASSERT_EQ(expected_num_streams, video_streams.size());
3377
3378 std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
pbosbe16f792015-10-16 12:49:39 -07003379 num_configured_streams, codec.width, codec.height, 0, kDefaultQpMax,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003380 codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
3381
3382 ASSERT_EQ(expected_streams.size(), video_streams.size());
3383
3384 size_t num_streams = video_streams.size();
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003385 int total_max_bitrate_bps = 0;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003386 for (size_t i = 0; i < num_streams; ++i) {
3387 EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
3388 EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
3389
3390 EXPECT_GT(video_streams[i].max_framerate, 0);
3391 EXPECT_EQ(expected_streams[i].max_framerate,
3392 video_streams[i].max_framerate);
3393
3394 EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
3395 EXPECT_EQ(expected_streams[i].min_bitrate_bps,
3396 video_streams[i].min_bitrate_bps);
3397
3398 EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
3399 EXPECT_EQ(expected_streams[i].target_bitrate_bps,
3400 video_streams[i].target_bitrate_bps);
3401
3402 EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
3403 EXPECT_EQ(expected_streams[i].max_bitrate_bps,
3404 video_streams[i].max_bitrate_bps);
3405
3406 EXPECT_GT(video_streams[i].max_qp, 0);
3407 EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
3408
3409 EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty());
3410 EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps,
3411 video_streams[i].temporal_layer_thresholds_bps);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003412
3413 if (i == num_streams - 1) {
3414 total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
3415 } else {
3416 total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
3417 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003418 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003419 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003420 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003421 ASSERT_EQ(1u, info.senders.size());
3422 EXPECT_EQ(total_max_bitrate_bps, info.senders[0].preferred_bitrate);
3423
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003424 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003425 }
3426
3427 FakeVideoSendStream* AddSendStream() {
3428 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
3429 }
3430
3431 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
3432 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003433 fake_call_.GetVideoSendStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003434 EXPECT_TRUE(channel_->AddSendStream(sp));
3435 std::vector<FakeVideoSendStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003436 fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003437 EXPECT_EQ(num_streams + 1, streams.size());
3438 return streams[streams.size() - 1];
3439 }
3440
3441 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003442 return fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003443 }
3444
3445 FakeVideoReceiveStream* AddRecvStream() {
3446 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
3447 }
3448
3449 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
3450 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003451 fake_call_.GetVideoReceiveStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003452 EXPECT_TRUE(channel_->AddRecvStream(sp));
3453 std::vector<FakeVideoReceiveStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003454 fake_call_.GetVideoReceiveStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003455 EXPECT_EQ(num_streams + 1, streams.size());
3456 return streams[streams.size() - 1];
3457 }
3458
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003459 FakeCall fake_call_;
3460 WebRtcVideoEngine2 engine_;
kwiberg686a8ef2016-02-26 03:00:35 -08003461 std::unique_ptr<VideoMediaChannel> channel_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02003462 uint32_t last_ssrc_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003463};
3464
3465TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003466 VerifySimulcastSettings(kVp8Codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003467}
3468
3469TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003470 VerifySimulcastSettings(kVp8Codec720p, 3, 3);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003471}
3472
3473// Test that we normalize send codec format size in simulcast.
3474TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
3475 cricket::VideoCodec codec(kVp8Codec270p);
3476 codec.width += 1;
3477 codec.height += 1;
pbosbe16f792015-10-16 12:49:39 -07003478 VerifySimulcastSettings(codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003479}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003480} // namespace cricket