blob: c0cd2ffa50d403851fa2a9b0c55e64d0122609ca [file] [log] [blame]
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001/*
2 * libjingle
3 * Copyright 2004 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +000028#include <algorithm>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000029#include <map>
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000030#include <vector>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000031
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000032#include "talk/media/base/testutils.h"
33#include "talk/media/base/videoengine_unittest.h"
Fredrik Solenbergb6728822015-04-22 15:35:17 +020034#include "talk/media/webrtc/fakewebrtccall.h"
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000035#include "talk/media/webrtc/fakewebrtcvideoengine.h"
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000036#include "talk/media/webrtc/simulcast.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000037#include "talk/media/webrtc/webrtcvideochannelfactory.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000038#include "talk/media/webrtc/webrtcvideoengine2.h"
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +000039#include "talk/media/webrtc/webrtcvoiceengine.h"
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +000040#include "webrtc/base/arraysize.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000041#include "webrtc/base/gunit.h"
42#include "webrtc/base/stringutils.h"
stefanc1aeaf02015-10-15 07:26:07 -070043#include "webrtc/test/field_trial.h"
pbos@webrtc.org42684be2014-10-03 11:25:45 +000044#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000045
46namespace {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000047static const int kDefaultQpMax = 56;
48static const int kDefaultFramerate = 30;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000049
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000050static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0);
51static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30, 0);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000052static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30, 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000053
54static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0);
55static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000056static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0);
57
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000058static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0);
59static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0);
60
noahricd10a68e2015-07-10 11:27:55 -070061static const uint8_t kRedRtxPayloadType = 125;
62
Peter Boström0c4e06b2015-10-07 12:23:21 +020063static const uint32_t kSsrcs1[] = {1};
64static const uint32_t kSsrcs3[] = {1, 2, 3};
65static const uint32_t kRtxSsrcs1[] = {4};
66static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
pbos@webrtc.org3c107582014-07-20 15:27:35 +000067static const char kUnsupportedExtensionName[] =
68 "urn:ietf:params:rtp-hdrext:unsupported";
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000069
70void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
71 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
72 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
73 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
74 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
75 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
76 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
77 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
78 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
79}
80
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -070081static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000082 int width,
83 int height) {
84 video_frame->CreateEmptyFrame(
85 width, height, width, (width + 1) / 2, (width + 1) / 2);
86 memset(video_frame->buffer(webrtc::kYPlane), 16,
87 video_frame->allocated_size(webrtc::kYPlane));
88 memset(video_frame->buffer(webrtc::kUPlane), 128,
89 video_frame->allocated_size(webrtc::kUPlane));
90 memset(video_frame->buffer(webrtc::kVPlane), 128,
91 video_frame->allocated_size(webrtc::kVPlane));
92}
93
Shao Changbine62202f2015-04-21 20:24:50 +080094void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
95 const std::map<int, int>& rtx_types) {
96 std::map<int, int>::const_iterator it;
97 it = rtx_types.find(config.encoder_settings.payload_type);
98 EXPECT_TRUE(it != rtx_types.end() &&
99 it->second == config.rtp.rtx.payload_type);
100
101 if (config.rtp.fec.red_rtx_payload_type != -1) {
102 it = rtx_types.find(config.rtp.fec.red_payload_type);
103 EXPECT_TRUE(it != rtx_types.end() &&
104 it->second == config.rtp.fec.red_rtx_payload_type);
105 }
106}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000107} // namespace
108
109namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000110class WebRtcVideoEngine2Test : public ::testing::Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000111 public:
stefanc1aeaf02015-10-15 07:26:07 -0700112 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {}
113 explicit WebRtcVideoEngine2Test(const char* field_trials)
114 : WebRtcVideoEngine2Test(nullptr, field_trials) {}
115 WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine,
116 const char* field_trials)
117 : override_field_trials_(field_trials),
118 call_(webrtc::Call::Create(webrtc::Call::Config())),
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200119 engine_() {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000120 std::vector<VideoCodec> engine_codecs = engine_.codecs();
henrikg91d6ede2015-09-17 00:24:34 -0700121 RTC_DCHECK(!engine_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000122 bool codec_set = false;
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000123 for (size_t i = 0; i < engine_codecs.size(); ++i) {
124 if (engine_codecs[i].name == "red") {
125 default_red_codec_ = engine_codecs[i];
126 } else if (engine_codecs[i].name == "ulpfec") {
127 default_ulpfec_codec_ = engine_codecs[i];
128 } else if (engine_codecs[i].name == "rtx") {
Shao Changbine62202f2015-04-21 20:24:50 +0800129 int associated_payload_type;
130 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
131 &associated_payload_type)) {
132 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id;
133 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000134 } else if (!codec_set) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000135 default_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000136 codec_set = true;
137 }
138 }
139
henrikg91d6ede2015-09-17 00:24:34 -0700140 RTC_DCHECK(codec_set);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000141 }
142
143 protected:
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000144 VideoMediaChannel* SetUpForExternalEncoderFactory(
145 cricket::WebRtcVideoEncoderFactory* encoder_factory,
146 const std::vector<VideoCodec>& codecs);
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000147
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000148 VideoMediaChannel* SetUpForExternalDecoderFactory(
149 cricket::WebRtcVideoDecoderFactory* decoder_factory,
150 const std::vector<VideoCodec>& codecs);
151
stefanc1aeaf02015-10-15 07:26:07 -0700152 webrtc::test::ScopedFieldTrials override_field_trials_;
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000153 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
154 // initialized when the constructor is called.
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200155 rtc::scoped_ptr<webrtc::Call> call_;
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000156 WebRtcVoiceEngine voice_engine_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000157 WebRtcVideoEngine2 engine_;
158 VideoCodec default_codec_;
159 VideoCodec default_red_codec_;
160 VideoCodec default_ulpfec_codec_;
Shao Changbine62202f2015-04-21 20:24:50 +0800161 std::map<int, int> default_apt_rtx_types_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000162};
163
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000164TEST_F(WebRtcVideoEngine2Test, FindCodec) {
165 const std::vector<cricket::VideoCodec>& c = engine_.codecs();
Shao Changbine62202f2015-04-21 20:24:50 +0800166 EXPECT_EQ(cricket::DefaultVideoCodecList().size(), c.size());
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000167
168 cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0);
169 EXPECT_TRUE(engine_.FindCodec(vp8));
170
171 cricket::VideoCodec vp8_ci(104, "vp8", 320, 200, 30, 0);
172 EXPECT_TRUE(engine_.FindCodec(vp8));
173
174 cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50);
175 EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref));
176
177 cricket::VideoCodec vp8_diff_id(95, "VP8", 320, 200, 30, 0);
178 EXPECT_FALSE(engine_.FindCodec(vp8_diff_id));
179 vp8_diff_id.id = 97;
180 EXPECT_TRUE(engine_.FindCodec(vp8_diff_id));
181
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000182 // FindCodec ignores the codec size.
183 // Test that FindCodec can accept uncommon codec size.
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000184 cricket::VideoCodec vp8_diff_res(104, "VP8", 320, 111, 30, 0);
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000185 EXPECT_TRUE(engine_.FindCodec(vp8_diff_res));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000186
187 // PeerConnection doesn't negotiate the resolution at this point.
188 // Test that FindCodec can handle the case when width/height is 0.
189 cricket::VideoCodec vp8_zero_res(104, "VP8", 0, 0, 30, 0);
190 EXPECT_TRUE(engine_.FindCodec(vp8_zero_res));
191
192 cricket::VideoCodec red(101, "RED", 0, 0, 30, 0);
193 EXPECT_TRUE(engine_.FindCodec(red));
194
195 cricket::VideoCodec red_ci(101, "red", 0, 0, 30, 0);
196 EXPECT_TRUE(engine_.FindCodec(red));
197
198 cricket::VideoCodec fec(102, "ULPFEC", 0, 0, 30, 0);
199 EXPECT_TRUE(engine_.FindCodec(fec));
200
201 cricket::VideoCodec fec_ci(102, "ulpfec", 0, 0, 30, 0);
202 EXPECT_TRUE(engine_.FindCodec(fec));
203
204 cricket::VideoCodec rtx(96, "rtx", 0, 0, 30, 0);
205 EXPECT_TRUE(engine_.FindCodec(rtx));
206}
207
pbos@webrtc.org2a72c652015-02-26 16:01:24 +0000208TEST_F(WebRtcVideoEngine2Test, SetDefaultEncoderConfigPreservesFeedbackParams) {
209 cricket::VideoCodec max_settings(
210 engine_.codecs()[0].id, engine_.codecs()[0].name,
211 engine_.codecs()[0].width / 2, engine_.codecs()[0].height / 2, 30, 0);
212 // This codec shouldn't have NACK by default or the test is pointless.
213 EXPECT_FALSE(max_settings.HasFeedbackParam(
214 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
215 // The engine should by default have it however.
216 EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam(
217 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
218
219 // Set constrained max codec settings.
220 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
221 cricket::VideoEncoderConfig(max_settings)));
222
223 // Verify that feedback parameters are retained.
224 EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam(
225 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
226}
227
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000228TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
229 std::vector<VideoCodec> engine_codecs = engine_.codecs();
230 for (size_t i = 0; i < engine_codecs.size(); ++i) {
231 if (engine_codecs[i].name != kRtxCodecName)
232 continue;
233 int associated_payload_type;
234 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000235 &associated_payload_type));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000236 EXPECT_EQ(default_codec_.id, associated_payload_type);
237 return;
238 }
239 FAIL() << "No RTX codec found among default codecs.";
240}
241
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000242TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
243 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
244 ASSERT_FALSE(extensions.empty());
245 for (size_t i = 0; i < extensions.size(); ++i) {
246 if (extensions[i].uri == kRtpTimestampOffsetHeaderExtension) {
247 EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extensions[i].id);
248 return;
249 }
250 }
251 FAIL() << "Timestamp offset extension not in header-extension list.";
252}
253
254TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
255 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
256 ASSERT_FALSE(extensions.empty());
257 for (size_t i = 0; i < extensions.size(); ++i) {
258 if (extensions[i].uri == kRtpAbsoluteSenderTimeHeaderExtension) {
259 EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId,
260 extensions[i].id);
261 return;
262 }
263 }
264 FAIL() << "Absolute Sender Time extension not in header-extension list.";
265}
266
stefanc1aeaf02015-10-15 07:26:07 -0700267class WebRtcVideoEngine2WithSendSideBweTest : public WebRtcVideoEngine2Test {
268 public:
269 WebRtcVideoEngine2WithSendSideBweTest()
270 : WebRtcVideoEngine2Test("WebRTC-SendSideBwe/Enabled/") {}
271};
272
273TEST_F(WebRtcVideoEngine2WithSendSideBweTest,
274 SupportsTransportSequenceNumberHeaderExtension) {
275 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
276 ASSERT_FALSE(extensions.empty());
277 for (size_t i = 0; i < extensions.size(); ++i) {
278 if (extensions[i].uri == kRtpTransportSequenceNumberHeaderExtension) {
279 EXPECT_EQ(kRtpTransportSequenceNumberHeaderExtensionDefaultId,
280 extensions[i].id);
281 return;
282 }
283 }
284 FAIL() << "Transport sequence number extension not in header-extension list.";
285}
286
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700287TEST_F(WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension) {
288 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
289 ASSERT_FALSE(extensions.empty());
290 for (size_t i = 0; i < extensions.size(); ++i) {
291 if (extensions[i].uri == kRtpVideoRotationHeaderExtension) {
292 EXPECT_EQ(kRtpVideoRotationHeaderExtensionDefaultId, extensions[i].id);
293 return;
294 }
295 }
296 FAIL() << "Video Rotation extension not in header-extension list.";
297}
298
299TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
300 // Allocate the capturer first to prevent early destruction before channel's
301 // dtor is called.
302 cricket::FakeVideoCapturer capturer;
303
304 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
305 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200306 cricket::VideoSendParameters parameters;
307 parameters.codecs.push_back(kVp8Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700308
309 rtc::scoped_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200310 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700311 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
312
313 // Add CVO extension.
314 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200315 parameters.extensions.push_back(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700316 cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200317 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700318
319 // Set capturer.
320 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
321
322 // Verify capturer has turned off applying rotation.
323 EXPECT_FALSE(capturer.GetApplyRotation());
324
325 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200326 parameters.extensions.clear();
327 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700328 EXPECT_TRUE(capturer.GetApplyRotation());
329}
330
331TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
332 cricket::FakeVideoCapturer capturer;
333
334 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
335 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200336 cricket::VideoSendParameters parameters;
337 parameters.codecs.push_back(kVp8Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700338
339 rtc::scoped_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200340 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700341 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
342
343 // Set capturer.
344 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
345
346 // Add CVO extension.
347 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200348 parameters.extensions.push_back(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700349 cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200350 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700351
352 // Verify capturer has turned off applying rotation.
353 EXPECT_FALSE(capturer.GetApplyRotation());
354
355 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200356 parameters.extensions.clear();
357 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700358 EXPECT_TRUE(capturer.GetApplyRotation());
359}
360
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000361TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200362 engine_.Init();
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000363 rtc::scoped_ptr<VideoMediaChannel> channel(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200364 engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000365
366 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
367
368 EXPECT_FALSE(channel->SetSend(true))
369 << "Channel should not start without codecs.";
370 EXPECT_TRUE(channel->SetSend(false))
371 << "Channel should be stoppable even without set codecs.";
372}
373
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000374TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200375 engine_.Init();
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000376 rtc::scoped_ptr<VideoMediaChannel> channel(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200377 engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000378 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
379 VideoMediaInfo info;
380 channel->GetStats(&info);
381}
382
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000383TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
384 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
385 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200386 cricket::VideoSendParameters parameters;
387 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000388
389 rtc::scoped_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200390 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000391
392 EXPECT_TRUE(
393 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
394 ASSERT_EQ(1u, encoder_factory.encoders().size());
395 EXPECT_TRUE(channel->SetSend(true));
396
397 cricket::FakeVideoCapturer capturer;
398 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
399 EXPECT_EQ(cricket::CS_RUNNING,
400 capturer.Start(capturer.GetSupportedFormats()->front()));
401 EXPECT_TRUE(capturer.CaptureFrame());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000402 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
403 kTimeout);
404
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000405 // Sending one frame will have reallocated the encoder since input size
406 // changes from a small default to the actual frame width/height.
407 int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
408 EXPECT_EQ(num_created_encoders, 2);
409
410 // Setting codecs of the same type should not reallocate any encoders
411 // (expecting a no-op).
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200412 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000413 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000414
415 // Remove stream previously added to free the external encoder instance.
416 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
417 EXPECT_EQ(0u, encoder_factory.encoders().size());
418}
419
Peter Boström53eda3d2015-03-27 15:53:18 +0100420TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
421 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
422 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
423 std::vector<cricket::VideoCodec> codecs;
424 codecs.push_back(kVp9Codec);
425
426 rtc::scoped_ptr<VideoMediaChannel> channel(
427 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
428
429 EXPECT_TRUE(
430 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
431}
432
qiangchenc27d89f2015-07-16 10:27:16 -0700433TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
434 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
435 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
436 std::vector<cricket::VideoCodec> codecs;
437 codecs.push_back(kVp8Codec);
438
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200439 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
440 call_.reset(fake_call);
qiangchenc27d89f2015-07-16 10:27:16 -0700441 rtc::scoped_ptr<VideoMediaChannel> channel(
442 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
443
444 EXPECT_TRUE(
445 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
446
447 FakeVideoCapturer capturer;
448 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
449 capturer.Start(cricket::VideoFormat(1280, 720,
450 cricket::VideoFormat::FpsToInterval(60),
451 cricket::FOURCC_I420));
452 channel->SetSend(true);
453
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200454 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
qiangchenc27d89f2015-07-16 10:27:16 -0700455
456 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700457 int64_t last_timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700458 for (int i = 0; i < 10; i++) {
459 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700460 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700461 int64_t interval = timestamp - last_timestamp;
462
463 // Precision changes from nanosecond to millisecond.
464 // Allow error to be no more than 1.
465 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(60) / 1E6, interval, 1);
466
467 last_timestamp = timestamp;
468 }
469
470 capturer.Start(cricket::VideoFormat(1280, 720,
471 cricket::VideoFormat::FpsToInterval(30),
472 cricket::FOURCC_I420));
473
474 EXPECT_TRUE(capturer.CaptureFrame());
475 last_timestamp = stream->GetLastTimestamp();
476 for (int i = 0; i < 10; i++) {
477 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700478 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700479 int64_t interval = timestamp - last_timestamp;
480
481 // Precision changes from nanosecond to millisecond.
482 // Allow error to be no more than 1.
483 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1);
484
485 last_timestamp = timestamp;
486 }
487
488 // Remove stream previously added to free the external encoder instance.
489 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
490}
491
pbos1cb121d2015-09-14 11:38:38 -0700492TEST_F(WebRtcVideoEngine2Test,
493 ProducesIncreasingTimestampsWithResetInputSources) {
494 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
495 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
496 std::vector<cricket::VideoCodec> codecs;
497 codecs.push_back(kVp8Codec);
498
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200499 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
500 call_.reset(fake_call);
pbos1cb121d2015-09-14 11:38:38 -0700501 rtc::scoped_ptr<VideoMediaChannel> channel(
502 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
503
504 EXPECT_TRUE(
505 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
506 channel->SetSend(true);
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200507 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
pbos1cb121d2015-09-14 11:38:38 -0700508
509 FakeVideoCapturer capturer1;
510 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer1));
511
512 cricket::CapturedFrame frame;
513 frame.width = 1280;
514 frame.height = 720;
515 frame.fourcc = cricket::FOURCC_I420;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200516 frame.data_size = static_cast<uint32_t>(
pbos1cb121d2015-09-14 11:38:38 -0700517 cricket::VideoFrame::SizeOf(frame.width, frame.height));
518 rtc::scoped_ptr<char[]> data(new char[frame.data_size]);
519 frame.data = data.get();
520 memset(frame.data, 1, frame.data_size);
pbos1cb121d2015-09-14 11:38:38 -0700521 const int kInitialTimestamp = 123456;
522 frame.time_stamp = kInitialTimestamp;
523
524 // Deliver initial frame.
525 capturer1.SignalCapturedFrame(&frame);
526 // Deliver next frame 1 second later.
527 frame.time_stamp += rtc::kNumNanosecsPerSec;
528 rtc::Thread::Current()->SleepMs(1000);
529 capturer1.SignalCapturedFrame(&frame);
530
531 int64_t capturer1_last_timestamp = stream->GetLastTimestamp();
532 // Reset input source, should still be continuous even though input-frame
533 // timestamp is less than before.
534 FakeVideoCapturer capturer2;
535 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer2));
536
537 rtc::Thread::Current()->SleepMs(1);
538 // Deliver with a timestamp (10 seconds) before the previous initial one,
539 // these should not be related at all anymore and it should still work fine.
540 frame.time_stamp = kInitialTimestamp - 10000;
541 capturer2.SignalCapturedFrame(&frame);
542
543 // New timestamp should be at least 1ms in the future and not old.
544 EXPECT_GT(stream->GetLastTimestamp(), capturer1_last_timestamp);
545
546 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
547}
548
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000549VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
550 cricket::WebRtcVideoEncoderFactory* encoder_factory,
551 const std::vector<VideoCodec>& codecs) {
552 engine_.SetExternalEncoderFactory(encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200553 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000554
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000555 VideoMediaChannel* channel =
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200556 engine_.CreateChannel(call_.get(), cricket::VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200557 cricket::VideoSendParameters parameters;
558 parameters.codecs = codecs;
559 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000560
561 return channel;
562}
563
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000564VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
565 cricket::WebRtcVideoDecoderFactory* decoder_factory,
566 const std::vector<VideoCodec>& codecs) {
567 engine_.SetExternalDecoderFactory(decoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200568 engine_.Init();
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000569
570 VideoMediaChannel* channel =
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200571 engine_.CreateChannel(call_.get(), cricket::VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200572 cricket::VideoRecvParameters parameters;
573 parameters.codecs = codecs;
574 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000575
576 return channel;
577}
578
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000579TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
580 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
581 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
582 std::vector<cricket::VideoCodec> codecs;
583 codecs.push_back(kVp8Codec);
584
585 rtc::scoped_ptr<VideoMediaChannel> channel(
586 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
587
Peter Boström0c4e06b2015-10-07 12:23:21 +0200588 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000589
590 EXPECT_TRUE(
591 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
592 EXPECT_TRUE(channel->SetSend(true));
593
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000594 cricket::FakeVideoCapturer capturer;
595 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
596 EXPECT_EQ(cricket::CS_RUNNING,
597 capturer.Start(capturer.GetSupportedFormats()->front()));
598 EXPECT_TRUE(capturer.CaptureFrame());
599
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000600 EXPECT_GT(encoder_factory.encoders().size(), 1u);
601
602 // Verify that encoders are configured for simulcast through adapter
603 // (increasing resolution and only configured to send one stream each).
604 int prev_width = -1;
605 for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
606 webrtc::VideoCodec codec_settings =
607 encoder_factory.encoders()[i]->GetCodecSettings();
608 EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
609 EXPECT_GT(codec_settings.width, prev_width);
610 prev_width = codec_settings.width;
611 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000612
613 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), NULL));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000614
615 channel.reset();
616 ASSERT_EQ(0u, encoder_factory.encoders().size());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000617}
618
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000619TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
620 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
621 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
622 std::vector<cricket::VideoCodec> codecs;
623 codecs.push_back(kH264Codec);
624
625 rtc::scoped_ptr<VideoMediaChannel> channel(
626 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
627
628 EXPECT_TRUE(
629 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
630 ASSERT_EQ(1u, encoder_factory.encoders().size());
631
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200632 cricket::VideoSendParameters parameters;
633 parameters.codecs.push_back(kVp8Codec);
634 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000635 ASSERT_EQ(0u, encoder_factory.encoders().size());
636}
637
638TEST_F(WebRtcVideoEngine2Test,
639 DontUseExternalEncoderFactoryForUnsupportedCodecs) {
640 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
641 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
642 std::vector<cricket::VideoCodec> codecs;
643 codecs.push_back(kVp8Codec);
644
645 rtc::scoped_ptr<VideoMediaChannel> channel(
646 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
647
648 EXPECT_TRUE(
649 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000650 // Make sure DestroyVideoEncoder was called on the factory.
651 ASSERT_EQ(0u, encoder_factory.encoders().size());
652}
653
654TEST_F(WebRtcVideoEngine2Test,
655 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
656 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
657 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
658 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
659
660 std::vector<cricket::VideoCodec> codecs;
661 codecs.push_back(kVp8Codec);
662
663 rtc::scoped_ptr<VideoMediaChannel> channel(
664 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
665
Peter Boström0c4e06b2015-10-07 12:23:21 +0200666 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000667
668 EXPECT_TRUE(
669 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
670 EXPECT_TRUE(channel->SetSend(true));
671
672 // Send a fake frame, or else the media engine will configure the simulcast
673 // encoder adapter at a low-enough size that it'll only create a single
674 // encoder layer.
675 cricket::FakeVideoCapturer capturer;
676 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
677 EXPECT_EQ(cricket::CS_RUNNING,
678 capturer.Start(capturer.GetSupportedFormats()->front()));
679 EXPECT_TRUE(capturer.CaptureFrame());
680
681 ASSERT_GT(encoder_factory.encoders().size(), 1u);
682 EXPECT_EQ(webrtc::kVideoCodecVP8,
683 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
684
685 channel.reset();
686 // Make sure DestroyVideoEncoder was called on the factory.
687 EXPECT_EQ(0u, encoder_factory.encoders().size());
688}
689
690TEST_F(WebRtcVideoEngine2Test,
691 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
692 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
693 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
694 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
695
696 std::vector<cricket::VideoCodec> codecs;
697 codecs.push_back(kH264Codec);
698
699 rtc::scoped_ptr<VideoMediaChannel> channel(
700 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
701
702 EXPECT_TRUE(
703 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
704 ASSERT_EQ(1u, encoder_factory.encoders().size());
705 EXPECT_EQ(webrtc::kVideoCodecH264,
706 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
707
708 channel.reset();
709 // Make sure DestroyVideoEncoder was called on the factory.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000710 ASSERT_EQ(0u, encoder_factory.encoders().size());
711}
712
noahricfdac5162015-08-27 01:59:29 -0700713TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) {
714 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
715 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
716 std::vector<cricket::VideoCodec> codecs;
717 codecs.push_back(kH264Codec);
718
719 rtc::scoped_ptr<VideoMediaChannel> channel(
720 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
721
Peter Boström0c4e06b2015-10-07 12:23:21 +0200722 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
noahricfdac5162015-08-27 01:59:29 -0700723 EXPECT_TRUE(
724 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
725 // Set the stream to 720p. This should trigger a "real" encoder
726 // initialization.
727 cricket::VideoFormat format(
728 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
729 EXPECT_TRUE(channel->SetSendStreamFormat(ssrcs[0], format));
730 ASSERT_EQ(1u, encoder_factory.encoders().size());
731 FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0];
732 EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
733 EXPECT_EQ(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
734}
735
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000736// Test external codec with be added to the end of the supported codec list.
737TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) {
738 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
739 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
740 engine_.SetExternalEncoderFactory(&encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200741 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000742
743 std::vector<cricket::VideoCodec> codecs(engine_.codecs());
744 ASSERT_GE(codecs.size(), 2u);
745 cricket::VideoCodec internal_codec = codecs.front();
746 cricket::VideoCodec external_codec = codecs.back();
747
748 // The external codec will appear at last.
749 EXPECT_EQ("VP8", internal_codec.name);
750 EXPECT_EQ("H264", external_codec.name);
751}
752
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000753TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
754 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
755 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200756 cricket::VideoRecvParameters parameters;
757 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000758
759 rtc::scoped_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200760 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000761
762 EXPECT_TRUE(
763 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
764 ASSERT_EQ(1u, decoder_factory.decoders().size());
765
766 // Setting codecs of the same type should not reallocate the decoder.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200767 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000768 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
769
770 // Remove stream previously added to free the external decoder instance.
771 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
772 EXPECT_EQ(0u, decoder_factory.decoders().size());
773}
774
775// Verifies that we can set up decoders that are not internally supported.
776TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
777 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
778 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
779 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
780 // codecs.
781 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
782 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
783 engine_.SetExternalEncoderFactory(&encoder_factory);
784 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
785 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
786 std::vector<cricket::VideoCodec> codecs;
787 codecs.push_back(kH264Codec);
788
789 rtc::scoped_ptr<VideoMediaChannel> channel(
790 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
791
792 EXPECT_TRUE(
793 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
794 ASSERT_EQ(1u, decoder_factory.decoders().size());
795}
796
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000797class WebRtcVideoEngine2BaseTest
798 : public VideoEngineTest<cricket::WebRtcVideoEngine2> {
799 protected:
800 typedef VideoEngineTest<cricket::WebRtcVideoEngine2> Base;
801};
802
803#define WEBRTC_ENGINE_BASE_TEST(test) \
804 TEST_F(WebRtcVideoEngine2BaseTest, test) { Base::test##Body(); }
805
806WEBRTC_ENGINE_BASE_TEST(ConstrainNewCodec2);
807
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000808class WebRtcVideoChannel2BaseTest
809 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
810 protected:
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000811 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000812
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000813 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000814};
815
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000816#define WEBRTC_BASE_TEST(test) \
817 TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); }
818
819#define WEBRTC_DISABLED_BASE_TEST(test) \
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000820 TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); }
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000821
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000822WEBRTC_BASE_TEST(SetSend);
823WEBRTC_BASE_TEST(SetSendWithoutCodecs);
824WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000825
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000826WEBRTC_BASE_TEST(GetStats);
827WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams);
828WEBRTC_BASE_TEST(GetStatsMultipleSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000829
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000830WEBRTC_BASE_TEST(SetSendBandwidth);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000831
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000832WEBRTC_BASE_TEST(SetSendSsrc);
833WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000834
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000835WEBRTC_BASE_TEST(SetRenderer);
836WEBRTC_BASE_TEST(AddRemoveRecvStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000837
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000838WEBRTC_DISABLED_BASE_TEST(AddRemoveRecvStreamAndRender);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000839
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000840WEBRTC_BASE_TEST(AddRemoveRecvStreamsNoConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000841
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000842WEBRTC_BASE_TEST(AddRemoveSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000843
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000844WEBRTC_BASE_TEST(SimulateConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000845
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000846WEBRTC_BASE_TEST(AddRemoveCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000847
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000848WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000849
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000850WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000851
852// TODO(pbos): Figure out why this fails so often.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000853WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000854
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000855WEBRTC_BASE_TEST(RejectEmptyStreamParams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000856
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000857WEBRTC_BASE_TEST(AdaptResolution16x10);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000858
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000859WEBRTC_BASE_TEST(AdaptResolution4x3);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000860
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000861// TODO(juberti): Restore this test once we support sending 0 fps.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000862WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000863// TODO(juberti): Understand why we get decode errors on this test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000864WEBRTC_DISABLED_BASE_TEST(AdaptFramerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000865
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +0000866WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames);
867
868WEBRTC_BASE_TEST(MuteStream);
869
870WEBRTC_BASE_TEST(MultipleSendStreams);
871
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000872WEBRTC_BASE_TEST(SetSendStreamFormat0x0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000873
874// TODO(zhurunz): Fix the flakey test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000875WEBRTC_DISABLED_BASE_TEST(SetSendStreamFormat);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000876
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000877TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
878 SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30, 0));
879}
880
881TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
882 SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30, 0));
883}
884
885TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
886 SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30, 0));
887}
888
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000889TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
890 Base::TwoStreamsSendAndReceive(kVp8Codec);
891}
892
893TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsReUseFirstStream) {
894 Base::TwoStreamsReUseFirstStream(kVp8Codec);
895}
896
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000897WEBRTC_BASE_TEST(SendManyResizeOnce);
898
899// TODO(pbos): Enable and figure out why this fails (or should work).
900TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_SendVp8HdAndReceiveAdaptedVp8Vga) {
901 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
902 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
903 channel_->UpdateAspectRatio(1280, 720);
904 video_capturer_.reset(new cricket::FakeVideoCapturer);
905 const std::vector<cricket::VideoFormat>* formats =
906 video_capturer_->GetSupportedFormats();
907 cricket::VideoFormat capture_format_hd = (*formats)[0];
908 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format_hd));
909 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
910
911 // Capture format HD -> adapt (OnOutputFormatRequest VGA) -> VGA.
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000912 cricket::VideoCodec codec = kVp8Codec720p;
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000913 EXPECT_TRUE(SetOneCodec(codec));
914 codec.width /= 2;
915 codec.height /= 2;
916 EXPECT_TRUE(SetSend(true));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000917 EXPECT_EQ(0, renderer_.num_rendered_frames());
918 EXPECT_TRUE(SendFrame());
919 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
920}
921
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200922class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000923 public:
stefanc1aeaf02015-10-15 07:26:07 -0700924 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {}
925 explicit WebRtcVideoChannel2Test(const char* field_trials)
926 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000927 void SetUp() override {
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200928 fake_call_.reset(new FakeCall(webrtc::Call::Config()));
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200929 engine_.Init();
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200930 channel_.reset(
931 engine_.CreateChannel(fake_call_.get(), cricket::VideoOptions()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000932 last_ssrc_ = 123;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200933 send_parameters_.codecs = engine_.codecs();
934 recv_parameters_.codecs = engine_.codecs();
935 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000936 }
937
938 protected:
939 FakeVideoSendStream* AddSendStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000940 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000941 }
942
943 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000944 size_t num_streams = fake_call_->GetVideoSendStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000945 EXPECT_TRUE(channel_->AddSendStream(sp));
946 std::vector<FakeVideoSendStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000947 fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000948 EXPECT_EQ(num_streams + 1, streams.size());
949 return streams[streams.size() - 1];
950 }
951
952 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000953 return fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000954 }
955
956 FakeVideoReceiveStream* AddRecvStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000957 return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000958 }
959
960 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000961 size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000962 EXPECT_TRUE(channel_->AddRecvStream(sp));
963 std::vector<FakeVideoReceiveStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000964 fake_call_->GetVideoReceiveStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000965 EXPECT_EQ(num_streams + 1, streams.size());
966 return streams[streams.size() - 1];
967 }
968
pbos@webrtc.org00873182014-11-25 14:03:34 +0000969 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
970 int expected_min_bitrate_bps,
971 const char* start_bitrate_kbps,
972 int expected_start_bitrate_bps,
973 const char* max_bitrate_kbps,
974 int expected_max_bitrate_bps) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200975 auto& codecs = send_parameters_.codecs;
976 codecs.clear();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000977 codecs.push_back(kVp8Codec);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000978 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
979 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
980 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200981 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000982
pbos@webrtc.org00873182014-11-25 14:03:34 +0000983 EXPECT_EQ(expected_min_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100984 fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000985 EXPECT_EQ(expected_start_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100986 fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000987 EXPECT_EQ(expected_max_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100988 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000989 }
990
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000991 void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
992 const std::string& webrtc_ext) {
993 // Enable extension.
994 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200995 cricket::VideoSendParameters parameters = send_parameters_;
996 parameters.extensions.push_back(
997 cricket::RtpHeaderExtension(cricket_ext, id));
998 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000999 FakeVideoSendStream* send_stream =
1000 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1001
1002 // Verify the send extension id.
1003 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1004 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
1005 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
1006 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001007 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001008 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
1009 // receivers.
1010 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
1011 ->GetConfig()
1012 .rtp.extensions.empty());
1013
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001014 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001015 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001016 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1017 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001018 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1019
1020 // Verify that adding receive RTP header extensions adds them for existing
1021 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001022 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001023 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001024 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1025 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
1026 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001027 }
1028
1029 void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
1030 const std::string& webrtc_ext) {
1031 // Enable extension.
1032 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001033 cricket::VideoRecvParameters parameters = recv_parameters_;
1034 parameters.extensions.push_back(
1035 cricket::RtpHeaderExtension(cricket_ext, id));
1036 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001037
1038 FakeVideoReceiveStream* recv_stream =
1039 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1040
1041 // Verify the recv extension id.
1042 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1043 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
1044 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
1045 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001046 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001047
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001048 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
1049 // senders.
1050 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
1051 ->GetConfig()
1052 .rtp.extensions.empty());
1053
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001054 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001055 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001056 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
1057 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001058 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
1059
1060 // Verify that adding receive RTP header extensions adds them for existing
1061 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001062 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001063 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001064 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1065 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
1066 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001067 }
1068
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001069 void TestExtensionFilter(const std::vector<std::string>& extensions,
1070 const std::string& expected_extension) {
1071 cricket::VideoSendParameters parameters = send_parameters_;
1072 int expected_id = -1;
1073 int id = 1;
1074 for (const std::string& extension : extensions) {
1075 if (extension == expected_extension)
1076 expected_id = id;
1077 parameters.extensions.push_back(
1078 cricket::RtpHeaderExtension(extension, id++));
1079 }
1080 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1081 FakeVideoSendStream* send_stream =
1082 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1083
1084 // Verify that only one of them has been set, and that it is the one with
1085 // highest priority (transport sequence number).
1086 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1087 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
1088 EXPECT_EQ(expected_extension,
1089 send_stream->GetConfig().rtp.extensions[0].name);
1090 }
1091
Erik Språngefbde372015-04-29 16:21:28 +02001092 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
Peter Boström3548dd22015-05-22 18:48:36 +02001093 void TestReceiverLocalSsrcConfiguration(bool receiver_first);
noahricd10a68e2015-07-10 11:27:55 -07001094 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
1095 bool expect_created_receive_stream);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001096
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001097 FakeVideoSendStream* SetDenoisingOption(
1098 const cricket::VideoSendParameters& parameters, bool enabled) {
1099 cricket::VideoSendParameters params = parameters;
1100 params.options.video_noise_reduction.Set(enabled);
1101 channel_->SetSendParameters(params);
Erik Språng143cec12015-04-28 10:01:41 +02001102 return fake_call_->GetVideoSendStreams().back();
1103 }
1104
Peter Boström2feafdb2015-09-09 14:32:14 +02001105 FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
1106 const int kRtxSsrcOffset = 0xDEADBEEF;
Erik Språng143cec12015-04-28 10:01:41 +02001107 last_ssrc_ += 3;
Peter Boström2feafdb2015-09-09 14:32:14 +02001108 std::vector<uint32_t> ssrcs;
1109 std::vector<uint32_t> rtx_ssrcs;
1110 uint32_t num_streams = enabled ? 3 : 1;
1111 for (uint32_t i = 0; i < num_streams; ++i) {
1112 uint32_t ssrc = last_ssrc_ + i;
1113 ssrcs.push_back(ssrc);
1114 if (with_rtx) {
1115 rtx_ssrcs.push_back(ssrc + kRtxSsrcOffset);
1116 }
Erik Språng143cec12015-04-28 10:01:41 +02001117 }
Peter Boström2feafdb2015-09-09 14:32:14 +02001118 if (with_rtx) {
1119 return AddSendStream(
1120 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1121 }
1122 return AddSendStream(CreateSimStreamParams("cname", ssrcs));
Erik Språng143cec12015-04-28 10:01:41 +02001123 }
1124
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001125 rtc::scoped_ptr<FakeCall> fake_call_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001126 rtc::scoped_ptr<VideoMediaChannel> channel_;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001127 cricket::VideoSendParameters send_parameters_;
1128 cricket::VideoRecvParameters recv_parameters_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001129 uint32_t last_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001130};
1131
pbos8fc7fa72015-07-15 08:02:58 -07001132TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001133 const uint32_t kVideoSsrc = 123;
pbos8fc7fa72015-07-15 08:02:58 -07001134 const std::string kSyncLabel = "AvSyncLabel";
1135
1136 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
1137 sp.sync_label = kSyncLabel;
1138 EXPECT_TRUE(channel_->AddRecvStream(sp));
1139
1140 EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size());
1141 EXPECT_EQ(kSyncLabel,
1142 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
1143 << "SyncGroup should be set based on sync_label";
1144}
1145
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001146TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001147 cricket::VideoSendParameters parameters;
1148 parameters.codecs = engine_.codecs();
1149 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001150 EXPECT_TRUE(channel_->SetSend(true));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001151 parameters.options.conference_mode.Set(true);
1152 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001153
1154 // Send side.
Peter Boström0c4e06b2015-10-07 12:23:21 +02001155 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
1156 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001157 FakeVideoSendStream* send_stream = AddSendStream(
1158 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1159
1160 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
1161 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
1162 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
1163
1164 // Receiver side.
1165 FakeVideoReceiveStream* recv_stream = AddRecvStream(
1166 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1167 ASSERT_GT(recv_stream->GetConfig().rtp.rtx.size(), 0u)
1168 << "No SSRCs for RTX configured by AddRecvStream.";
1169 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size())
1170 << "This test only works with one receive codec. Please update the test.";
1171 EXPECT_EQ(rtx_ssrcs[0],
1172 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
1173 // TODO(pbos): Make sure we set the RTX for correct payloads etc.
1174}
1175
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001176TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
1177 // Setup one channel with an associated RTX stream.
1178 cricket::StreamParams params =
1179 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1180 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
1181 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1182 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
1183 EXPECT_EQ(kRtxSsrcs1[0],
1184 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001185}
1186
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001187TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
1188 // Setup one channel without an associated RTX stream.
1189 cricket::StreamParams params =
1190 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1191 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1192 ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001193}
1194
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001195TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
1196 FakeVideoSendStream* send_stream =
1197 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1198 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1199
1200 FakeVideoReceiveStream* recv_stream =
1201 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1202 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001203}
1204
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001205// Test support for RTP timestamp offset header extension.
1206TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
1207 TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1208 webrtc::RtpExtension::kTOffset);
1209}
1210TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
1211 TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1212 webrtc::RtpExtension::kTOffset);
1213}
1214
1215// Test support for absolute send time header extension.
1216TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
1217 TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1218 webrtc::RtpExtension::kAbsSendTime);
1219}
1220TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
1221 TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1222 webrtc::RtpExtension::kAbsSendTime);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001223}
1224
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001225TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksTransportSeqNum) {
1226 // Enable three redundant extensions.
1227 std::vector<std::string> extensions;
1228 extensions.push_back(kRtpAbsoluteSenderTimeHeaderExtension);
1229 extensions.push_back(kRtpTimestampOffsetHeaderExtension);
1230 extensions.push_back(kRtpTransportSequenceNumberHeaderExtension);
1231 TestExtensionFilter(extensions, kRtpTransportSequenceNumberHeaderExtension);
1232}
1233
1234TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksAbsSendTime) {
1235 // Enable two redundant extensions.
1236 std::vector<std::string> extensions;
1237 extensions.push_back(kRtpAbsoluteSenderTimeHeaderExtension);
1238 extensions.push_back(kRtpTimestampOffsetHeaderExtension);
1239 TestExtensionFilter(extensions, kRtpAbsoluteSenderTimeHeaderExtension);
1240}
1241
stefanc1aeaf02015-10-15 07:26:07 -07001242class WebRtcVideoChannel2WithSendSideBweTest : public WebRtcVideoChannel2Test {
1243 public:
1244 WebRtcVideoChannel2WithSendSideBweTest()
1245 : WebRtcVideoChannel2Test("WebRTC-SendSideBwe/Enabled/") {}
1246};
1247
1248// Test support for transport sequence number header extension.
1249TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
1250 SendTransportSequenceNumberHeaderExtensions) {
1251 TestSetSendRtpHeaderExtensions(
1252 kRtpTransportSequenceNumberHeaderExtension,
1253 webrtc::RtpExtension::kTransportSequenceNumber);
1254}
1255TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
1256 RecvTransportSequenceNumberHeaderExtensions) {
1257 TestSetRecvRtpHeaderExtensions(
1258 kRtpTransportSequenceNumberHeaderExtension,
1259 webrtc::RtpExtension::kTransportSequenceNumber);
1260}
1261
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001262// Test support for video rotation header extension.
1263TEST_F(WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions) {
1264 TestSetSendRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
1265 webrtc::RtpExtension::kVideoRotation);
1266}
1267TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) {
1268 TestSetRecvRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
1269 webrtc::RtpExtension::kVideoRotation);
1270}
1271
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001272TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001273 const int kAbsSendTimeId = 1;
1274 const int kVideoRotationId = 2;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001275 send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001276 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001277 send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001278 kRtpVideoRotationHeaderExtension, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001279
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001280 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001281 FakeVideoSendStream* send_stream =
1282 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1283
1284 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001285 ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001286
1287 // Setting the same extensions (even if in different order) shouldn't
1288 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001289 std::reverse(send_parameters_.extensions.begin(),
1290 send_parameters_.extensions.end());
1291 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001292
1293 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1294
1295 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001296 send_parameters_.extensions.resize(1);
1297 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001298
1299 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
1300}
1301
1302TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
1303 const int kTOffsetId = 1;
1304 const int kAbsSendTimeId = 2;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001305 const int kVideoRotationId = 3;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001306 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001307 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001308 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001309 kRtpTimestampOffsetHeaderExtension, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001310 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001311 kRtpVideoRotationHeaderExtension, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001312
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001313 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Peter Boström54be3e02015-05-25 15:04:24 +02001314 FakeVideoReceiveStream* recv_stream =
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001315 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1316
1317 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
Peter Boström54be3e02015-05-25 15:04:24 +02001318 ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001319
1320 // Setting the same extensions (even if in different order) shouldn't
1321 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001322 std::reverse(recv_parameters_.extensions.begin(),
1323 recv_parameters_.extensions.end());
1324 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001325
1326 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
1327
1328 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001329 recv_parameters_.extensions.resize(1);
1330 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001331
1332 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
1333}
1334
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001335TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001336 SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001337 const int kUnsupportedId = 1;
1338 const int kTOffsetId = 2;
1339
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001340 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001341 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001342 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001343 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001344 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001345 FakeVideoSendStream* send_stream =
1346 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1347
1348 // Only timestamp offset extension is set to send stream,
1349 // unsupported rtp extension is ignored.
1350 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1351 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001352 send_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001353}
1354
1355TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001356 SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001357 const int kUnsupportedId = 1;
1358 const int kTOffsetId = 2;
1359
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001360 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001361 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001362 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001363 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001364 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001365 FakeVideoReceiveStream* recv_stream =
1366 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1367
1368 // Only timestamp offset extension is set to receive stream,
1369 // unsupported rtp extension is ignored.
1370 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1371 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001372 recv_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001373}
1374
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001375TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001376 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001377 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001378 send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001379 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001380 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001381 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1382 }
1383}
1384
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001385TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001386 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001387 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001388 recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001389 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001390 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001391 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1392 }
1393}
1394
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001395TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001396 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001397 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001398 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001399 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001400 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001401 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001402
1403 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001404 send_parameters_.extensions.clear();
1405 send_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001406 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001407 send_parameters_.extensions.push_back(send_parameters_.extensions.back());
1408 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001409}
1410
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001411TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001412 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001413 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001414 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001415 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001416 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001417 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001418
1419 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001420 recv_parameters_.extensions.clear();
1421 recv_parameters_.extensions.push_back(
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001422 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001423 recv_parameters_.extensions.push_back(recv_parameters_.extensions.back());
1424 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001425}
1426
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001427TEST_F(WebRtcVideoChannel2Test, DISABLED_LeakyBucketTest) {
1428 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1429}
1430
1431TEST_F(WebRtcVideoChannel2Test, DISABLED_BufferedModeLatency) {
1432 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1433}
1434
1435TEST_F(WebRtcVideoChannel2Test, DISABLED_AdditiveVideoOptions) {
1436 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1437}
1438
1439TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
1440 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001441 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001442}
1443
Peter Boströmd7da1202015-06-05 14:09:38 +02001444TEST_F(WebRtcVideoChannel2Test, RtcpIsCompoundByDefault) {
1445 FakeVideoReceiveStream* stream = AddRecvStream();
pbosda903ea2015-10-02 02:36:56 -07001446 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
Peter Boströmd7da1202015-06-05 14:09:38 +02001447}
1448
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001449TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
1450 FakeVideoReceiveStream* stream = AddRecvStream();
1451 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001452}
1453
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001454TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1455 FakeVideoReceiveStream* stream = AddRecvStream();
1456 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1457
Peter Boström126c03e2015-05-11 12:48:12 +02001458 // Verify that REMB is turned off when send(!) codecs without REMB are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001459 cricket::VideoSendParameters parameters;
1460 parameters.codecs.push_back(kVp8Codec);
1461 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1462 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001463 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001464 EXPECT_FALSE(stream->GetConfig().rtp.remb);
1465
1466 // Verify that REMB is turned on when setting default codecs since the
1467 // default codecs have REMB enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001468 parameters.codecs = engine_.codecs();
1469 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001470 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001471 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001472}
1473
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001474TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
1475 VerifyCodecHasDefaultFeedbackParams(default_codec_);
1476
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001477 cricket::VideoSendParameters parameters;
1478 parameters.codecs = engine_.codecs();
1479 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org19864742014-05-30 07:35:47 +00001480 EXPECT_TRUE(channel_->SetSend(true));
1481
1482 // Send side.
1483 FakeVideoSendStream* send_stream =
1484 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1485 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1486
1487 // Receiver side.
1488 FakeVideoReceiveStream* recv_stream =
1489 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1490 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1491
1492 // Nack history size should match between sender and receiver.
1493 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
1494 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001495}
1496
Peter Boström67c9df72015-05-11 14:34:58 +02001497TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
Peter Boström67c9df72015-05-11 14:34:58 +02001498 FakeVideoSendStream* send_stream = AddSendStream();
Peter Boström3548dd22015-05-22 18:48:36 +02001499 FakeVideoReceiveStream* recv_stream = AddRecvStream();
Peter Boström67c9df72015-05-11 14:34:58 +02001500
1501 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1502 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1503
1504 // Verify that NACK is turned off when send(!) codecs without NACK are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001505 cricket::VideoSendParameters parameters;
1506 parameters.codecs.push_back(kVp8Codec);
1507 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1508 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001509 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1510 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1511 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001512 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1513
Peter Boström67c9df72015-05-11 14:34:58 +02001514 // Verify that NACK is turned on when setting default codecs since the
1515 // default codecs have NACK enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001516 parameters.codecs = engine_.codecs();
1517 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001518 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1519 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1520 send_stream = fake_call_->GetVideoSendStreams()[0];
1521 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001522}
1523
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001524TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInterop) {
1525 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1526}
1527
1528TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInteropReversed) {
1529 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1530}
1531
1532TEST_F(WebRtcVideoChannel2Test, DISABLED_HybridNackFecConference) {
1533 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1534}
1535
1536TEST_F(WebRtcVideoChannel2Test, DISABLED_AddRemoveRecvStreamConference) {
1537 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1538}
1539
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001540TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAuto) {
1541 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1542}
1543
1544TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAutoCapped) {
1545 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1546}
1547
1548TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthFixed) {
1549 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1550}
1551
1552TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthInConference) {
1553 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1554}
1555
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001556TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1557 static const int kScreenshareMinBitrateKbps = 800;
1558 cricket::VideoCodec codec = kVp8Codec360p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001559 cricket::VideoSendParameters parameters;
1560 parameters.codecs.push_back(codec);
1561 parameters.options.screencast_min_bitrate.Set(kScreenshareMinBitrateKbps);
1562 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001563
1564 AddSendStream();
1565
1566 cricket::FakeVideoCapturer capturer;
1567 capturer.SetScreencast(false);
1568 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1569 cricket::VideoFormat capture_format_hd =
1570 capturer.GetSupportedFormats()->front();
1571 EXPECT_EQ(1280, capture_format_hd.width);
1572 EXPECT_EQ(720, capture_format_hd.height);
1573 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1574
1575 EXPECT_TRUE(channel_->SetSend(true));
1576
1577 EXPECT_TRUE(capturer.CaptureFrame());
1578 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1579 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1580
1581 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1582
1583 // Verify non-screencast settings.
1584 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
Erik Språng143cec12015-04-28 10:01:41 +02001585 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001586 encoder_config.content_type);
1587 EXPECT_EQ(codec.width, encoder_config.streams.front().width);
1588 EXPECT_EQ(codec.height, encoder_config.streams.front().height);
1589 EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
1590 << "Non-screenshare shouldn't use min-transmit bitrate.";
1591
1592 capturer.SetScreencast(true);
1593 EXPECT_TRUE(capturer.CaptureFrame());
1594
1595 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1596
1597 // Verify screencast settings.
1598 encoder_config = send_stream->GetEncoderConfig();
Erik Språng143cec12015-04-28 10:01:41 +02001599 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001600 encoder_config.content_type);
1601 EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
1602 encoder_config.min_transmit_bitrate_bps);
1603
1604 EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width);
1605 EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001606 EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
1607
1608 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1609}
1610
1611TEST_F(WebRtcVideoChannel2Test,
1612 ConferenceModeScreencastConfiguresTemporalLayer) {
Erik Språng2c4c9142015-06-24 11:24:44 +02001613 static const int kConferenceScreencastTemporalBitrateBps =
1614 ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001615 send_parameters_.options.conference_mode.Set(true);
1616 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001617
1618 AddSendStream();
1619
1620 cricket::FakeVideoCapturer capturer;
1621 capturer.SetScreencast(true);
1622 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1623 cricket::VideoFormat capture_format_hd =
1624 capturer.GetSupportedFormats()->front();
1625 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1626
1627 EXPECT_TRUE(channel_->SetSend(true));
1628
1629 EXPECT_TRUE(capturer.CaptureFrame());
1630 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1631 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1632
1633 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1634
1635 // Verify screencast settings.
1636 encoder_config = send_stream->GetEncoderConfig();
Erik Språng143cec12015-04-28 10:01:41 +02001637 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001638 encoder_config.content_type);
1639 ASSERT_EQ(1u, encoder_config.streams.size());
1640 ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size());
1641 EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
1642 encoder_config.streams[0].temporal_layer_thresholds_bps[0]);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001643
1644 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001645}
1646
1647TEST_F(WebRtcVideoChannel2Test, DISABLED_SetSendSsrcAndCname) {
1648 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1649}
1650
1651TEST_F(WebRtcVideoChannel2Test,
1652 DISABLED_SetSendSsrcAfterCreatingReceiveChannel) {
1653 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1654}
1655
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001656TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
1657 FakeVideoSendStream* stream = AddSendStream();
1658 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1659}
1660
1661TEST_F(WebRtcVideoChannel2Test, SetOptionsWithSuspendBelowMinBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001662 send_parameters_.options.suspend_below_min_bitrate.Set(true);
1663 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001664
1665 FakeVideoSendStream* stream = AddSendStream();
1666 EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
1667
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001668 send_parameters_.options.suspend_below_min_bitrate.Set(false);
1669 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001670
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001671 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001672 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1673}
1674
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001675TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1676 FakeVideoSendStream* stream = AddSendStream();
1677 webrtc::VideoCodecVP8 vp8_settings;
1678 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1679 EXPECT_TRUE(vp8_settings.denoisingOn);
1680}
1681
Erik Språng143cec12015-04-28 10:01:41 +02001682TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001683 cricket::VideoSendParameters parameters;
1684 parameters.codecs.push_back(kVp8Codec720p);
1685 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001686
Peter Boström2feafdb2015-09-09 14:32:14 +02001687 // Single-stream settings should apply with RTX as well (verifies that we
1688 // check number of regular SSRCs and not StreamParams::ssrcs which contains
1689 // both RTX and regular SSRCs).
1690 FakeVideoSendStream* stream = SetUpSimulcast(false, true);
Erik Språng143cec12015-04-28 10:01:41 +02001691
1692 cricket::FakeVideoCapturer capturer;
1693 capturer.SetScreencast(false);
1694 EXPECT_EQ(cricket::CS_RUNNING,
1695 capturer.Start(capturer.GetSupportedFormats()->front()));
1696 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1697 channel_->SetSend(true);
1698
1699 EXPECT_TRUE(capturer.CaptureFrame());
1700
pbos4cba4eb2015-10-26 11:18:18 -07001701 webrtc::VideoCodecVP8 vp8_settings;
1702 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1703 EXPECT_TRUE(vp8_settings.denoisingOn)
1704 << "VP8 denoising should be on by default.";
1705
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001706 stream = SetDenoisingOption(parameters, false);
Erik Språng143cec12015-04-28 10:01:41 +02001707
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001708 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1709 EXPECT_FALSE(vp8_settings.denoisingOn);
Erik Språng143cec12015-04-28 10:01:41 +02001710 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1711 EXPECT_TRUE(vp8_settings.frameDroppingOn);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001712
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001713 stream = SetDenoisingOption(parameters, true);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001714
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001715 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1716 EXPECT_TRUE(vp8_settings.denoisingOn);
Erik Språng143cec12015-04-28 10:01:41 +02001717 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1718 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1719
1720 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
Peter Boström2feafdb2015-09-09 14:32:14 +02001721 stream = SetUpSimulcast(true, false);
Erik Språng143cec12015-04-28 10:01:41 +02001722 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1723 channel_->SetSend(true);
1724 EXPECT_TRUE(capturer.CaptureFrame());
1725
1726 EXPECT_EQ(3, stream->GetVideoStreams().size());
1727 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1728 // Autmatic resize off when using simulcast.
1729 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1730 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1731
1732 // In screen-share mode, denoising is forced off and simulcast disabled.
1733 capturer.SetScreencast(true);
1734 EXPECT_TRUE(capturer.CaptureFrame());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001735 stream = SetDenoisingOption(parameters, false);
Erik Språng143cec12015-04-28 10:01:41 +02001736
1737 EXPECT_EQ(1, stream->GetVideoStreams().size());
1738 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1739 EXPECT_FALSE(vp8_settings.denoisingOn);
1740 // Resizing and frame dropping always off for screen sharing.
1741 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1742 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1743
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001744 stream = SetDenoisingOption(parameters, true);
Erik Språng143cec12015-04-28 10:01:41 +02001745
1746 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1747 EXPECT_FALSE(vp8_settings.denoisingOn);
1748 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1749 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1750
1751 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1752}
1753
1754class Vp9SettingsTest : public WebRtcVideoChannel2Test {
1755 public:
1756 Vp9SettingsTest() : WebRtcVideoChannel2Test() {
1757 encoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
1758 }
1759 virtual ~Vp9SettingsTest() {}
1760
1761 protected:
1762 void SetUp() override {
1763 engine_.SetExternalEncoderFactory(&encoder_factory_);
1764
1765 WebRtcVideoChannel2Test::SetUp();
1766 }
1767
1768 void TearDown() override {
1769 // Remove references to encoder_factory_ since this will be destroyed
1770 // before channel_ and engine_.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001771 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
Erik Språng143cec12015-04-28 10:01:41 +02001772 }
1773
1774 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
1775};
1776
1777TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001778 cricket::VideoSendParameters parameters;
1779 parameters.codecs.push_back(kVp9Codec);
1780 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Erik Språng143cec12015-04-28 10:01:41 +02001781
Peter Boström2feafdb2015-09-09 14:32:14 +02001782 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
Erik Språng143cec12015-04-28 10:01:41 +02001783
1784 cricket::FakeVideoCapturer capturer;
1785 capturer.SetScreencast(false);
1786 EXPECT_EQ(cricket::CS_RUNNING,
1787 capturer.Start(capturer.GetSupportedFormats()->front()));
1788 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1789 channel_->SetSend(true);
1790
1791 EXPECT_TRUE(capturer.CaptureFrame());
1792
pbos4cba4eb2015-10-26 11:18:18 -07001793 webrtc::VideoCodecVP9 vp9_settings;
1794 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1795 EXPECT_FALSE(vp9_settings.denoisingOn)
1796 << "VP9 denoising should be off by default.";
1797
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001798 stream = SetDenoisingOption(parameters, false);
Erik Språng143cec12015-04-28 10:01:41 +02001799
Erik Språng143cec12015-04-28 10:01:41 +02001800 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1801 EXPECT_FALSE(vp9_settings.denoisingOn);
1802 // Frame dropping always on for real time video.
1803 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1804
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001805 stream = SetDenoisingOption(parameters, true);
Erik Språng143cec12015-04-28 10:01:41 +02001806
1807 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1808 EXPECT_TRUE(vp9_settings.denoisingOn);
1809 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1810
1811 // In screen-share mode, denoising is forced off.
1812 capturer.SetScreencast(true);
1813 EXPECT_TRUE(capturer.CaptureFrame());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001814 stream = SetDenoisingOption(parameters, false);
Erik Språng143cec12015-04-28 10:01:41 +02001815
1816 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1817 EXPECT_FALSE(vp9_settings.denoisingOn);
1818 // Frame dropping always off for screen sharing.
1819 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1820
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001821 stream = SetDenoisingOption(parameters, false);
Erik Språng143cec12015-04-28 10:01:41 +02001822
1823 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1824 EXPECT_FALSE(vp9_settings.denoisingOn);
1825 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1826
1827 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001828}
1829
1830TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) {
1831 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1832}
1833
pbos@webrtc.org8aed9452014-07-26 10:16:49 +00001834TEST_F(WebRtcVideoChannel2Test, DISABLED_SendReceiveBitratesStats) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001835 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1836}
1837
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001838TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) {
Erik Språngefbde372015-04-29 16:21:28 +02001839 TestCpuAdaptation(true, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001840}
1841
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001842TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
Erik Språngefbde372015-04-29 16:21:28 +02001843 TestCpuAdaptation(false, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001844}
1845
Erik Språngefbde372015-04-29 16:21:28 +02001846TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
1847 TestCpuAdaptation(true, true);
1848}
1849
1850void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
1851 bool is_screenshare) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001852 cricket::VideoCodec codec = kVp8Codec720p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001853 cricket::VideoSendParameters parameters;
1854 parameters.codecs.push_back(codec);
Peter Boströme4328002015-04-14 22:45:29 +02001855 if (!enable_overuse) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001856 parameters.options.cpu_overuse_detection.Set(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001857 }
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001858 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001859
1860 AddSendStream();
1861
1862 cricket::FakeVideoCapturer capturer;
Erik Språngefbde372015-04-29 16:21:28 +02001863 capturer.SetScreencast(is_screenshare);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001864 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1865 EXPECT_EQ(cricket::CS_RUNNING,
1866 capturer.Start(capturer.GetSupportedFormats()->front()));
1867
1868 EXPECT_TRUE(channel_->SetSend(true));
1869
1870 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07001871 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1872 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001873 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07001874 send_stream->GetConfig().overuse_callback;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001875 ASSERT_TRUE(overuse_callback != NULL);
1876 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
1877
1878 EXPECT_TRUE(capturer.CaptureFrame());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001879 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1880
Erik Språngefbde372015-04-29 16:21:28 +02001881 if (enable_overuse && !is_screenshare) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001882 EXPECT_LT(send_stream->GetLastWidth(), codec.width);
1883 EXPECT_LT(send_stream->GetLastHeight(), codec.height);
1884 } else {
1885 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1886 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1887 }
1888
1889 // Trigger underuse which should go back to normal resolution.
1890 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
1891 EXPECT_TRUE(capturer.CaptureFrame());
1892
1893 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1894
1895 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1896 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1897
1898 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001899}
1900
magjedb09b6602015-10-01 03:02:44 -07001901TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly) {
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001902 // Start at last timestamp to verify that wraparounds are estimated correctly.
1903 static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
1904 static const int64_t kInitialNtpTimeMs = 1247891230;
1905 static const int kFrameOffsetMs = 20;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001906 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001907
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001908 FakeVideoReceiveStream* stream = AddRecvStream();
1909 cricket::FakeVideoRenderer renderer;
1910 EXPECT_TRUE(channel_->SetRenderer(last_ssrc_, &renderer));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001911
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001912 webrtc::VideoFrame video_frame;
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001913 CreateBlackFrame(&video_frame, 4, 4);
1914 video_frame.set_timestamp(kInitialTimestamp);
1915 // Initial NTP time is not available on the first frame, but should still be
1916 // able to be estimated.
1917 stream->InjectFrame(video_frame, 0);
1918
1919 EXPECT_EQ(1, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001920
1921 // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which
1922 // triggers a constant-overflow warning, hence we're calculating it explicitly
1923 // here.
1924 video_frame.set_timestamp(kFrameOffsetMs * 90 - 1);
1925 video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs);
1926 stream->InjectFrame(video_frame, 0);
1927
1928 EXPECT_EQ(2, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001929
1930 // Verify that NTP time has been correctly deduced.
1931 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001932 ASSERT_TRUE(channel_->GetStats(&info));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001933 ASSERT_EQ(1u, info.receivers.size());
1934 EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001935}
1936
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001937TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001938 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001939
1940 VideoCodec codec;
1941 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001942 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001943
1944 // Using a RTX setup to verify that the default RTX payload type is good.
Peter Boström0c4e06b2015-10-07 12:23:21 +02001945 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
1946 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001947 FakeVideoSendStream* stream = AddSendStream(
1948 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1949 webrtc::VideoSendStream::Config config = stream->GetConfig();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001950
1951 // Make sure NACK and FEC are enabled on the correct payload types.
1952 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
1953 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
1954 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001955
1956 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
1957 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
Shao Changbine62202f2015-04-21 20:24:50 +08001958 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001959 // TODO(juberti): Check RTCP, PLI, TMMBR.
1960}
1961
1962TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001963 cricket::VideoSendParameters parameters;
1964 parameters.codecs.push_back(kVp8Codec);
1965 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001966
1967 FakeVideoSendStream* stream = AddSendStream();
1968 webrtc::VideoSendStream::Config config = stream->GetConfig();
1969
1970 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
1971 EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
1972}
1973
1974TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001975 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001976 cricket::VideoSendParameters parameters;
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001977 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001978 parameters.codecs.push_back(rtx_codec);
1979 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001980 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001981}
1982
1983TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001984 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001985 cricket::VideoSendParameters parameters;
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001986 cricket::VideoCodec rtx_codec =
1987 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001988 parameters.codecs.push_back(kVp8Codec);
1989 parameters.codecs.push_back(rtx_codec);
1990 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001991
1992 cricket::VideoCodec rtx_codec2 =
1993 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001994 parameters.codecs.pop_back();
1995 parameters.codecs.push_back(rtx_codec2);
1996 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001997 << "RTX without matching video codec should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001998}
1999
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002000TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002001 cricket::VideoSendParameters parameters;
2002 parameters.codecs.push_back(kVp8Codec);
2003 parameters.codecs.push_back(kUlpfecCodec);
2004 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002005
2006 FakeVideoSendStream* stream = AddSendStream();
2007 webrtc::VideoSendStream::Config config = stream->GetConfig();
2008
2009 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2010
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002011 parameters.codecs.pop_back();
2012 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002013 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002014 ASSERT_TRUE(stream != NULL);
2015 config = stream->GetConfig();
2016 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2017 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002018}
2019
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002020TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002021 cricket::VideoSendParameters parameters;
2022 parameters.codecs.push_back(kVp8Codec720p);
2023 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002024 channel_->SetSend(true);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002025
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002026 FakeVideoSendStream* stream = AddSendStream();
2027
2028 cricket::FakeVideoCapturer capturer;
2029 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
2030 EXPECT_EQ(cricket::CS_RUNNING,
2031 capturer.Start(capturer.GetSupportedFormats()->front()));
2032 EXPECT_TRUE(capturer.CaptureFrame());
2033
2034 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002035 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
2036 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
2037
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002038 parameters.codecs.clear();
2039 parameters.codecs.push_back(kVp8Codec360p);
2040 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002041 streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002042 EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
2043 EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002044 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002045}
2046
pbos@webrtc.org00873182014-11-25 14:03:34 +00002047TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
2048 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2049 200000);
2050}
2051
pbos@webrtc.orga5f6fb52015-03-23 22:29:39 +00002052TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
2053 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
2054 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
2055 ASSERT_EQ(1u, streams.size());
2056 EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
2057}
2058
pbos@webrtc.org00873182014-11-25 14:03:34 +00002059TEST_F(WebRtcVideoChannel2Test,
2060 SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
2061 SetSendCodecsShouldWorkForBitrates(
2062 "", 0, "", -1, "", -1);
2063}
2064
2065TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
2066 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002067}
2068
2069TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002070 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300";
2071 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200";
2072 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002073}
2074
pbos@webrtc.org00873182014-11-25 14:03:34 +00002075TEST_F(WebRtcVideoChannel2Test,
2076 SetMaxSendBandwidthShouldPreserveOtherBitrates) {
2077 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2078 200000);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002079 send_parameters_.max_bandwidth_bps = 300000;
2080 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002081 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002082 << "Setting max bitrate should keep previous min bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002083 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002084 << "Setting max bitrate should not reset start bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002085 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002086}
2087
2088TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002089 send_parameters_.max_bandwidth_bps = 300000;
2090 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002091 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002092 // <= 0 means disable (infinite) max bitrate.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002093 send_parameters_.max_bandwidth_bps = 0;
2094 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002095 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002096 << "Setting zero max bitrate did not reset start bitrate.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002097}
2098
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002099TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002100 cricket::VideoSendParameters parameters;
2101 parameters.codecs.push_back(kVp8Codec720p);
2102 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002103 channel_->SetSend(true);
2104
2105 FakeVideoSendStream* stream = AddSendStream();
2106
2107 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2108 int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
2109 EXPECT_GT(initial_max_bitrate_bps, 0);
2110
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002111 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2112 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002113 streams = stream->GetVideoStreams();
2114 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
2115}
2116
2117TEST_F(WebRtcVideoChannel2Test,
2118 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002119 cricket::VideoSendParameters parameters;
2120 parameters.codecs.push_back(kVp8Codec720p);
2121 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002122 channel_->SetSend(true);
2123
2124 FakeVideoSendStream* stream = AddSendStream(
2125 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2126
2127 // Send a frame to make sure this scales up to >1 stream (simulcast).
2128 cricket::FakeVideoCapturer capturer;
2129 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &capturer));
2130 EXPECT_EQ(cricket::CS_RUNNING,
2131 capturer.Start(capturer.GetSupportedFormats()->front()));
2132 EXPECT_TRUE(capturer.CaptureFrame());
2133
2134 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2135 ASSERT_GT(streams.size(), 1u)
2136 << "Without simulcast this test doesn't make sense.";
pbosbe16f792015-10-16 12:49:39 -07002137 int initial_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002138 EXPECT_GT(initial_max_bitrate_bps, 0);
2139
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002140 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2141 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002142 streams = stream->GetVideoStreams();
pbosbe16f792015-10-16 12:49:39 -07002143 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002144 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
2145
2146 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], nullptr));
2147}
2148
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002149TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
2150 static const char* kMaxQuantization = "21";
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002151 cricket::VideoSendParameters parameters;
2152 parameters.codecs.push_back(kVp8Codec);
2153 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
2154 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002155 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
2156 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002157
2158 VideoCodec codec;
2159 EXPECT_TRUE(channel_->GetSendCodec(&codec));
2160 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
2161}
2162
2163TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002164 cricket::VideoSendParameters parameters;
2165 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002166
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002167 parameters.codecs[0].width = 0;
2168 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002169 << "Codec set though codec width is zero.";
2170
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002171 parameters.codecs[0].width = kVp8Codec.width;
2172 parameters.codecs[0].height = 0;
2173 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002174 << "Codec set though codec height is zero.";
2175}
2176
2177TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
2178 // TODO(pbos): Should we only allow the dynamic range?
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002179 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002180 cricket::VideoSendParameters parameters;
2181 parameters.codecs.push_back(kVp8Codec);
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002182 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002183 parameters.codecs[0].id = kIncorrectPayloads[i];
2184 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002185 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002186 }
2187}
2188
2189TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002190 cricket::VideoSendParameters parameters;
2191 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002192 for (int payload_type = 0; payload_type <= 127; ++payload_type) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002193 parameters.codecs[0].id = payload_type;
2194 EXPECT_TRUE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002195 << "Payload type '" << payload_type << "' rejected.";
2196 }
2197}
2198
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002199TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002200 cricket::VideoRecvParameters parameters;
2201 parameters.codecs.push_back(kVp8Codec);
2202 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002203}
2204
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002205// Test that we set our inbound RTX codecs properly.
2206TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002207 cricket::VideoRecvParameters parameters;
2208 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002209 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002210 parameters.codecs.push_back(rtx_codec);
2211 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002212 << "RTX codec without associated payload should be rejected.";
2213
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002214 parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1);
2215 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002216 << "RTX codec with invalid associated payload type should be rejected.";
2217
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002218 parameters.codecs[1].SetParam("apt", kVp8Codec.id);
2219 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002220
2221 cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0);
2222 rtx_codec2.SetParam("apt", rtx_codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002223 parameters.codecs.push_back(rtx_codec2);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002224
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002225 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) <<
2226 "RTX codec with another RTX as associated payload type should be "
2227 "rejected.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002228}
2229
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002230TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002231 cricket::VideoRecvParameters parameters;
2232 parameters.codecs.push_back(kVp8Codec);
2233 parameters.codecs[0].id = 99;
2234 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002235}
2236
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002237TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002238 cricket::VideoRecvParameters parameters;
2239 parameters.codecs = engine_.codecs();
2240 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002241
2242 FakeVideoReceiveStream* stream = AddRecvStream();
2243 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002244 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
2245 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002246}
2247
2248TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002249 cricket::VideoRecvParameters parameters;
2250 parameters.codecs.push_back(kVp8Codec);
2251 parameters.codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
2252 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002253}
2254
2255// TODO(pbos): Enable VP9 through external codec support
2256TEST_F(WebRtcVideoChannel2Test,
2257 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002258 cricket::VideoRecvParameters parameters;
2259 parameters.codecs.push_back(kVp8Codec);
2260 parameters.codecs.push_back(kVp9Codec);
2261 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002262}
2263
2264TEST_F(WebRtcVideoChannel2Test,
2265 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002266 cricket::VideoRecvParameters parameters;
2267 parameters.codecs.push_back(kVp8Codec);
2268 parameters.codecs.push_back(kVp9Codec);
2269 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002270 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
2271}
2272
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002273TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002274 cricket::VideoSendParameters send_parameters;
2275 send_parameters.codecs.push_back(kVp8Codec);
2276 send_parameters.codecs.push_back(kUlpfecCodec);
2277 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002278
2279 FakeVideoReceiveStream* stream = AddRecvStream();
2280 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
2281
2282 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2283
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002284 cricket::VideoRecvParameters recv_parameters;
2285 recv_parameters.codecs.push_back(kVp8Codec);
2286 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002287 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002288 ASSERT_TRUE(stream != NULL);
2289 config = stream->GetConfig();
2290 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2291 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002292}
2293
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002294TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002295 cricket::VideoRecvParameters parameters;
2296 parameters.codecs.push_back(kVp8Codec);
2297 parameters.codecs.push_back(kRedCodec);
2298 parameters.codecs[1].id = parameters.codecs[0].id;
2299 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002300}
2301
2302TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002303 cricket::VideoRecvParameters parameters;
2304 parameters.codecs.push_back(kVp8Codec);
2305 parameters.codecs.push_back(kVp9Codec);
2306 parameters.codecs[1].id = parameters.codecs[0].id;
2307 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002308}
2309
2310TEST_F(WebRtcVideoChannel2Test,
2311 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002312 cricket::VideoRecvParameters parameters;
2313 parameters.codecs.push_back(kVp8Codec);
2314 parameters.codecs.push_back(kVp8Codec);
2315 parameters.codecs[1].id += 1;
2316 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002317}
2318
deadbeef874ca3a2015-08-20 17:19:20 -07002319// Test that setting the same codecs but with a different order and preference
2320// doesn't result in the stream being recreated.
2321TEST_F(WebRtcVideoChannel2Test,
2322 SetRecvCodecsDifferentOrderAndPreferenceDoesntRecreateStream) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002323 cricket::VideoRecvParameters parameters1;
2324 parameters1.codecs.push_back(kVp8Codec);
2325 parameters1.codecs.push_back(kRedCodec);
2326 EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
deadbeef874ca3a2015-08-20 17:19:20 -07002327
2328 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2329 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2330
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002331 cricket::VideoRecvParameters parameters2;
2332 parameters2.codecs.push_back(kRedCodec);
2333 parameters2.codecs.push_back(kVp8Codec);
2334 parameters2.codecs[1].preference += 1;
2335 EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
deadbeef874ca3a2015-08-20 17:19:20 -07002336 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2337}
2338
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002339TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
2340 EXPECT_FALSE(AddSendStream()->IsSending());
2341}
2342
pbos@webrtc.org85f42942014-07-22 09:14:58 +00002343TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
2344 EXPECT_TRUE(AddRecvStream()->IsReceiving());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002345}
2346
2347TEST_F(WebRtcVideoChannel2Test, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002348 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002349 EXPECT_FALSE(stream->IsSending());
2350
2351 // false->true
2352 EXPECT_TRUE(channel_->SetSend(true));
2353 EXPECT_TRUE(stream->IsSending());
2354 // true->true
2355 EXPECT_TRUE(channel_->SetSend(true));
2356 EXPECT_TRUE(stream->IsSending());
2357 // true->false
2358 EXPECT_TRUE(channel_->SetSend(false));
2359 EXPECT_FALSE(stream->IsSending());
2360 // false->false
2361 EXPECT_TRUE(channel_->SetSend(false));
2362 EXPECT_FALSE(stream->IsSending());
2363
2364 EXPECT_TRUE(channel_->SetSend(true));
2365 FakeVideoSendStream* new_stream = AddSendStream();
2366 EXPECT_TRUE(new_stream->IsSending())
2367 << "Send stream created after SetSend(true) not sending initially.";
2368}
2369
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002370// This test verifies DSCP settings are properly applied on video media channel.
2371TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
2372 rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
2373 new cricket::FakeNetworkInterface);
2374 channel_->SetInterface(network_interface.get());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002375 cricket::VideoSendParameters parameters = send_parameters_;
2376 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Thatchera9b4c322015-07-16 03:47:28 -07002377 EXPECT_EQ(rtc::DSCP_NO_CHANGE, network_interface->dscp());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002378 parameters.options.dscp.Set(true);
2379 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002380 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2381 // Verify previous value is not modified if dscp option is not set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002382 cricket::VideoSendParameters parameters1 = send_parameters_;
2383 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002384 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002385 parameters1.options.dscp.Set(false);
2386 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002387 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
2388 channel_->SetInterface(NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002389}
2390
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002391TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
Jelena Marusiccd670222015-07-16 09:30:09 +02002392 EXPECT_EQ(webrtc::kNetworkUp, fake_call_->GetNetworkState());
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002393
2394 channel_->OnReadyToSend(false);
Jelena Marusiccd670222015-07-16 09:30:09 +02002395 EXPECT_EQ(webrtc::kNetworkDown, fake_call_->GetNetworkState());
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002396
2397 channel_->OnReadyToSend(true);
Jelena Marusiccd670222015-07-16 09:30:09 +02002398 EXPECT_EQ(webrtc::kNetworkUp, fake_call_->GetNetworkState());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002399}
2400
Peter Boström74d9ed72015-03-26 16:28:31 +01002401TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002402 cricket::VideoSendParameters parameters;
2403 parameters.codecs.push_back(kVp8Codec);
2404 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström74d9ed72015-03-26 16:28:31 +01002405
2406 AddSendStream();
2407
2408 cricket::VideoMediaInfo info;
2409 ASSERT_TRUE(channel_->GetStats(&info));
2410 EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name);
2411}
2412
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002413TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) {
2414 FakeVideoSendStream* stream = AddSendStream();
2415 webrtc::VideoSendStream::Stats stats;
2416 stats.avg_encode_time_ms = 13;
2417 stats.encode_usage_percent = 42;
2418 stream->SetStats(stats);
2419
2420 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002421 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002422 EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms);
2423 EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent);
2424}
2425
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002426TEST_F(WebRtcVideoChannel2Test, GetStatsReportsUpperResolution) {
2427 FakeVideoSendStream* stream = AddSendStream();
2428 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002429 stats.substreams[17].width = 123;
2430 stats.substreams[17].height = 40;
2431 stats.substreams[42].width = 80;
2432 stats.substreams[42].height = 31;
2433 stats.substreams[11].width = 20;
2434 stats.substreams[11].height = 90;
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002435 stream->SetStats(stats);
2436
2437 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002438 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002439 ASSERT_EQ(1u, info.senders.size());
2440 EXPECT_EQ(123, info.senders[0].send_frame_width);
2441 EXPECT_EQ(90, info.senders[0].send_frame_height);
2442}
2443
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002444TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) {
2445 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2446
2447 // Capture format VGA.
2448 cricket::FakeVideoCapturer video_capturer_vga;
2449 const std::vector<cricket::VideoFormat>* formats =
2450 video_capturer_vga.GetSupportedFormats();
2451 cricket::VideoFormat capture_format_vga = (*formats)[1];
2452 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
2453 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_vga));
2454 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2455
2456 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002457 cricket::VideoSendParameters parameters;
2458 parameters.codecs.push_back(send_codec);
2459 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002460 EXPECT_TRUE(channel_->SetSend(true));
2461
2462 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002463 parameters.options.cpu_overuse_detection.Set(true);
2464 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberge5269742015-09-08 05:13:22 -07002465
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002466 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07002467 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002468 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07002469 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
2470 ASSERT_TRUE(overuse_callback != NULL);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002471 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2472
2473 // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
2474 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2475 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002476 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002477 ASSERT_EQ(1U, info.senders.size());
2478 EXPECT_EQ(1, info.senders[0].adapt_changes);
2479 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2480 info.senders[0].adapt_reason);
2481
2482 // Trigger upgrade and verify that we adapt back up to VGA.
2483 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2484 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2485 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002486 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002487 ASSERT_EQ(1U, info.senders.size());
2488 EXPECT_EQ(2, info.senders[0].adapt_changes);
2489 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2490 info.senders[0].adapt_reason);
2491
2492 // No capturer (no adapter). Adapt changes from old adapter should be kept.
2493 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2494 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002495 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002496 ASSERT_EQ(1U, info.senders.size());
2497 EXPECT_EQ(2, info.senders[0].adapt_changes);
2498 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2499 info.senders[0].adapt_reason);
2500
2501 // Set new capturer, capture format HD.
2502 cricket::FakeVideoCapturer video_capturer_hd;
2503 cricket::VideoFormat capture_format_hd = (*formats)[0];
2504 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd));
2505 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_hd));
2506 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2507
2508 // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2.
2509 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2510 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2511 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002512 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002513 ASSERT_EQ(1U, info.senders.size());
2514 EXPECT_EQ(3, info.senders[0].adapt_changes);
2515 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2516 info.senders[0].adapt_reason);
2517
2518 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2519}
2520
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002521TEST_F(WebRtcVideoChannel2Test,
2522 GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
2523 FakeVideoSendStream* stream = AddSendStream();
2524 webrtc::VideoSendStream::Stats stats;
2525 stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
2526 stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
2527 stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
2528
2529 stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5;
2530 stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7;
2531 stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9;
2532
2533 stream->SetStats(stats);
2534
2535 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002536 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002537 EXPECT_EQ(7, info.senders[0].firs_rcvd);
2538 EXPECT_EQ(10, info.senders[0].nacks_rcvd);
2539 EXPECT_EQ(13, info.senders[0].plis_rcvd);
2540}
2541
2542TEST_F(WebRtcVideoChannel2Test,
2543 GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
2544 FakeVideoReceiveStream* stream = AddRecvStream();
2545 webrtc::VideoReceiveStream::Stats stats;
2546 stats.rtcp_packet_type_counts.fir_packets = 2;
2547 stats.rtcp_packet_type_counts.nack_packets = 3;
2548 stats.rtcp_packet_type_counts.pli_packets = 4;
2549 stream->SetStats(stats);
2550
2551 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002552 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002553 EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
2554 info.receivers[0].firs_sent);
2555 EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
2556 info.receivers[0].nacks_sent);
2557 EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
2558 info.receivers[0].plis_sent);
2559}
2560
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002561TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly) {
2562 FakeVideoReceiveStream* stream = AddRecvStream();
2563 webrtc::VideoReceiveStream::Stats stats;
2564 stats.decode_ms = 2;
2565 stats.max_decode_ms = 3;
2566 stats.current_delay_ms = 4;
2567 stats.target_delay_ms = 5;
2568 stats.jitter_buffer_ms = 6;
2569 stats.min_playout_delay_ms = 7;
2570 stats.render_delay_ms = 8;
2571 stream->SetStats(stats);
2572
2573 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002574 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002575 EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms);
2576 EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms);
2577 EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms);
2578 EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms);
2579 EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms);
2580 EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms);
2581 EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
2582}
2583
Peter Boström393347f2015-04-22 14:52:45 +02002584TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesReceivePacketStatsCorrectly) {
2585 FakeVideoReceiveStream* stream = AddRecvStream();
2586 webrtc::VideoReceiveStream::Stats stats;
2587 stats.rtp_stats.transmitted.payload_bytes = 2;
2588 stats.rtp_stats.transmitted.header_bytes = 3;
2589 stats.rtp_stats.transmitted.padding_bytes = 4;
2590 stats.rtp_stats.transmitted.packets = 5;
2591 stats.rtcp_stats.cumulative_lost = 6;
2592 stats.rtcp_stats.fraction_lost = 7;
2593 stream->SetStats(stats);
2594
2595 cricket::VideoMediaInfo info;
2596 ASSERT_TRUE(channel_->GetStats(&info));
2597 EXPECT_EQ(stats.rtp_stats.transmitted.payload_bytes +
2598 stats.rtp_stats.transmitted.header_bytes +
2599 stats.rtp_stats.transmitted.padding_bytes,
2600 info.receivers[0].bytes_rcvd);
2601 EXPECT_EQ(stats.rtp_stats.transmitted.packets,
2602 info.receivers[0].packets_rcvd);
2603 EXPECT_EQ(stats.rtcp_stats.cumulative_lost, info.receivers[0].packets_lost);
2604 EXPECT_EQ(static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8),
2605 info.receivers[0].fraction_lost);
2606}
2607
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002608TEST_F(WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly) {
2609 AddSendStream();
2610 AddSendStream();
2611 webrtc::Call::Stats stats;
2612 stats.rtt_ms = 123;
2613 fake_call_->SetStats(stats);
2614
2615 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002616 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002617 ASSERT_EQ(2u, info.senders.size());
2618 EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms);
2619 EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms);
2620}
2621
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002622TEST_F(WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly) {
2623 FakeVideoSendStream* stream = AddSendStream();
2624 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002625 stats.target_media_bitrate_bps = 156;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002626 stats.media_bitrate_bps = 123;
2627 stats.substreams[17].total_bitrate_bps = 1;
2628 stats.substreams[17].retransmit_bitrate_bps = 2;
2629 stats.substreams[42].total_bitrate_bps = 3;
2630 stats.substreams[42].retransmit_bitrate_bps = 4;
2631 stream->SetStats(stats);
2632
2633 FakeVideoSendStream* stream2 = AddSendStream();
2634 webrtc::VideoSendStream::Stats stats2;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002635 stats2.target_media_bitrate_bps = 200;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002636 stats2.media_bitrate_bps = 321;
2637 stats2.substreams[13].total_bitrate_bps = 5;
2638 stats2.substreams[13].retransmit_bitrate_bps = 6;
2639 stats2.substreams[21].total_bitrate_bps = 7;
2640 stats2.substreams[21].retransmit_bitrate_bps = 8;
2641 stream2->SetStats(stats2);
2642
2643 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002644 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002645 ASSERT_EQ(2u, info.senders.size());
2646 // Assuming stream and stream2 corresponds to senders[0] and [1] respectively
2647 // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
2648 EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
2649 EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002650 EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
2651 info.bw_estimations[0].target_enc_bitrate);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002652 EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
2653 info.bw_estimations[0].actual_enc_bitrate);
2654 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
2655 << "Bandwidth stats should take all streams into account.";
2656 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
2657 << "Bandwidth stats should take all streams into account.";
2658}
2659
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002660TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002661 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002662
Peter Boström0c4e06b2015-10-07 12:23:21 +02002663 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2664 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002665
2666 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
2667 const size_t kDataLength = 12;
2668 uint8_t data[kDataLength];
2669 memset(data, 0, sizeof(data));
2670 rtc::SetBE32(&data[8], ssrcs[0]);
2671 rtc::Buffer packet(data, kDataLength);
2672 rtc::PacketTime packet_time;
2673 channel_->OnPacketReceived(&packet, packet_time);
2674
2675 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
2676 << "No default receive stream created.";
2677 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2678 EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size())
2679 << "Default receive stream should not have configured RTX";
2680
2681 EXPECT_TRUE(channel_->AddRecvStream(
2682 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
2683 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
2684 << "AddRecvStream should've reconfigured, not added a new receiver.";
2685 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2686 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
2687 EXPECT_EQ(rtx_ssrcs[0],
2688 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
2689}
2690
Peter Boströmd4362cd2015-03-25 14:17:23 +01002691TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002692 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd4362cd2015-03-25 14:17:23 +01002693
Peter Boström0c4e06b2015-10-07 12:23:21 +02002694 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2695 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd4362cd2015-03-25 14:17:23 +01002696
2697 StreamParams sp =
2698 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
2699 sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
2700
2701 EXPECT_FALSE(channel_->AddSendStream(sp));
2702 EXPECT_FALSE(channel_->AddRecvStream(sp));
2703}
2704
Peter Boströmd6f4c252015-03-26 16:23:04 +01002705TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002706 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01002707
Peter Boström0c4e06b2015-10-07 12:23:21 +02002708 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2709 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd6f4c252015-03-26 16:23:04 +01002710
2711 StreamParams sp =
2712 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
2713
2714 EXPECT_TRUE(channel_->AddSendStream(sp));
2715 EXPECT_TRUE(channel_->AddRecvStream(sp));
2716
2717 // The RTX SSRC is already used in previous streams, using it should fail.
2718 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
2719 EXPECT_FALSE(channel_->AddSendStream(sp));
2720 EXPECT_FALSE(channel_->AddRecvStream(sp));
2721
2722 // After removing the original stream this should be fine to add (makes sure
2723 // that RTX ssrcs are not forever taken).
2724 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
2725 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
2726 EXPECT_TRUE(channel_->AddSendStream(sp));
2727 EXPECT_TRUE(channel_->AddRecvStream(sp));
2728}
2729
2730TEST_F(WebRtcVideoChannel2Test,
2731 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02002732 static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3};
2733 static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002734 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01002735
Peter Boströmd6f4c252015-03-26 16:23:04 +01002736 StreamParams sp =
2737 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
2738
2739 EXPECT_TRUE(channel_->AddSendStream(sp));
2740 EXPECT_TRUE(channel_->AddRecvStream(sp));
2741
2742 // One of the SSRCs is already used in previous streams, using it should fail.
2743 sp = cricket::CreateSimStreamParams("cname",
2744 MAKE_VECTOR(kOverlappingStreamSsrcs));
2745 EXPECT_FALSE(channel_->AddSendStream(sp));
2746 EXPECT_FALSE(channel_->AddRecvStream(sp));
2747
2748 // After removing the original stream this should be fine to add (makes sure
2749 // that RTX ssrcs are not forever taken).
Peter Boström3548dd22015-05-22 18:48:36 +02002750 EXPECT_TRUE(channel_->RemoveSendStream(kFirstStreamSsrcs[0]));
2751 EXPECT_TRUE(channel_->RemoveRecvStream(kFirstStreamSsrcs[0]));
Peter Boströmd6f4c252015-03-26 16:23:04 +01002752 EXPECT_TRUE(channel_->AddSendStream(sp));
2753 EXPECT_TRUE(channel_->AddRecvStream(sp));
2754}
2755
Peter Boström259bd202015-05-28 13:39:50 +02002756TEST_F(WebRtcVideoChannel2Test, ReportsSsrcGroupsInStats) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002757 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström259bd202015-05-28 13:39:50 +02002758
2759 static const uint32_t kSenderSsrcs[] = {4, 7, 10};
2760 static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11};
2761
2762 StreamParams sender_sp = cricket::CreateSimWithRtxStreamParams(
2763 "cname", MAKE_VECTOR(kSenderSsrcs), MAKE_VECTOR(kSenderRtxSsrcs));
2764
2765 EXPECT_TRUE(channel_->AddSendStream(sender_sp));
2766
2767 static const uint32_t kReceiverSsrcs[] = {3};
2768 static const uint32_t kReceiverRtxSsrcs[] = {2};
2769
2770 StreamParams receiver_sp = cricket::CreateSimWithRtxStreamParams(
2771 "cname", MAKE_VECTOR(kReceiverSsrcs), MAKE_VECTOR(kReceiverRtxSsrcs));
2772 EXPECT_TRUE(channel_->AddRecvStream(receiver_sp));
2773
2774 cricket::VideoMediaInfo info;
2775 ASSERT_TRUE(channel_->GetStats(&info));
2776
2777 ASSERT_EQ(1u, info.senders.size());
2778 ASSERT_EQ(1u, info.receivers.size());
2779
2780 EXPECT_NE(sender_sp.ssrc_groups, receiver_sp.ssrc_groups);
2781 EXPECT_EQ(sender_sp.ssrc_groups, info.senders[0].ssrc_groups);
2782 EXPECT_EQ(receiver_sp.ssrc_groups, info.receivers[0].ssrc_groups);
2783}
2784
pbosf42376c2015-08-28 07:35:32 -07002785TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) {
2786 FakeVideoReceiveStream* stream = AddRecvStream();
2787 webrtc::VideoReceiveStream::Stats stats;
2788 cricket::VideoMediaInfo info;
2789
2790 // Report no codec name before receiving.
2791 stream->SetStats(stats);
2792 ASSERT_TRUE(channel_->GetStats(&info));
2793 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
2794
2795 // Report VP8 if we're receiving it.
2796 stats.current_payload_type = kDefaultVp8PlType;
2797 stream->SetStats(stats);
2798 ASSERT_TRUE(channel_->GetStats(&info));
2799 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str());
2800
2801 // Report no codec name for unknown playload types.
2802 stats.current_payload_type = 3;
2803 stream->SetStats(stats);
2804 ASSERT_TRUE(channel_->GetStats(&info));
2805 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
2806}
2807
noahricd10a68e2015-07-10 11:27:55 -07002808void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket(
2809 uint8_t payload_type,
2810 bool expect_created_receive_stream) {
noahricd10a68e2015-07-10 11:27:55 -07002811 // Add a RED RTX codec.
2812 VideoCodec red_rtx_codec =
2813 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002814 recv_parameters_.codecs.push_back(red_rtx_codec);
2815 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
noahricd10a68e2015-07-10 11:27:55 -07002816
2817 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
2818 const size_t kDataLength = 12;
2819 uint8_t data[kDataLength];
2820 memset(data, 0, sizeof(data));
2821
2822 rtc::Set8(data, 1, payload_type);
2823 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
2824 rtc::Buffer packet(data, kDataLength);
2825 rtc::PacketTime packet_time;
2826 channel_->OnPacketReceived(&packet, packet_time);
2827
2828 if (expect_created_receive_stream) {
2829 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
2830 << "Should have created a receive stream for payload type: "
2831 << payload_type;
2832 } else {
2833 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size())
2834 << "Shouldn't have created a receive stream for payload type: "
2835 << payload_type;
2836 }
2837}
2838
2839TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) {
2840 TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true);
2841}
2842
2843TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) {
2844 TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true);
2845}
2846
2847TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) {
2848 TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false);
2849}
2850
2851TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
2852 TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false);
2853}
2854
2855TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
2856 TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false);
2857}
2858
Peter Boström3548dd22015-05-22 18:48:36 +02002859void WebRtcVideoChannel2Test::TestReceiverLocalSsrcConfiguration(
2860 bool receiver_first) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002861 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström3548dd22015-05-22 18:48:36 +02002862
2863 const uint32_t kSenderSsrc = 0xC0FFEE;
Peter Boströmdfa28152015-10-21 17:21:10 +02002864 const uint32_t kSecondSenderSsrc = 0xBADCAFE;
Peter Boström3548dd22015-05-22 18:48:36 +02002865 const uint32_t kReceiverSsrc = 0x4711;
Peter Boströmdfa28152015-10-21 17:21:10 +02002866 const uint32_t kExpectedDefaultReceiverSsrc = 1;
Peter Boström3548dd22015-05-22 18:48:36 +02002867
2868 if (receiver_first) {
2869 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
2870 std::vector<FakeVideoReceiveStream*> receive_streams =
2871 fake_call_->GetVideoReceiveStreams();
2872 ASSERT_EQ(1u, receive_streams.size());
Peter Boströmdfa28152015-10-21 17:21:10 +02002873 // Default local SSRC when we have no sender.
2874 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
2875 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02002876 }
2877 AddSendStream(StreamParams::CreateLegacy(kSenderSsrc));
2878 if (!receiver_first)
2879 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
2880 std::vector<FakeVideoReceiveStream*> receive_streams =
2881 fake_call_->GetVideoReceiveStreams();
2882 ASSERT_EQ(1u, receive_streams.size());
2883 EXPECT_EQ(kSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boströmdfa28152015-10-21 17:21:10 +02002884
2885 // Removing first sender should fall back to another (in this case the second)
2886 // local send stream's SSRC.
2887 AddSendStream(StreamParams::CreateLegacy(kSecondSenderSsrc));
2888 ASSERT_TRUE(channel_->RemoveSendStream(kSenderSsrc));
2889 receive_streams =
2890 fake_call_->GetVideoReceiveStreams();
2891 ASSERT_EQ(1u, receive_streams.size());
2892 EXPECT_EQ(kSecondSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
2893
2894 // Removing the last sender should fall back to default local SSRC.
2895 ASSERT_TRUE(channel_->RemoveSendStream(kSecondSenderSsrc));
2896 receive_streams =
2897 fake_call_->GetVideoReceiveStreams();
2898 ASSERT_EQ(1u, receive_streams.size());
2899 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
2900 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02002901}
2902
2903TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrc) {
2904 TestReceiverLocalSsrcConfiguration(false);
2905}
2906
2907TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) {
2908 TestReceiverLocalSsrcConfiguration(true);
2909}
2910
Fredrik Solenberg709ed672015-09-15 12:26:33 +02002911class WebRtcVideoEngine2SimulcastTest : public testing::Test {};
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002912
stefan658910c2015-09-03 05:48:32 -07002913// Test that if we add a stream with RTX SSRC's, SSRC's get set correctly.
2914TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestStreamWithRtx) {
2915 // TODO(pbos): Implement.
2916 FAIL() << "Not implemented.";
2917}
2918
2919// Test that if we get too few ssrcs are given in AddSendStream(),
2920// only supported sub-streams will be added.
2921TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TooFewSimulcastSsrcs) {
2922 // TODO(pbos): Implement.
2923 FAIL() << "Not implemented.";
2924}
2925
2926// Test that even more than enough ssrcs are given in AddSendStream(),
2927// only supported sub-streams will be added.
2928TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_MoreThanEnoughSimulcastSscrs) {
2929 // TODO(pbos): Implement.
2930 FAIL() << "Not implemented.";
2931}
2932
2933// Test that SetSendStreamFormat works well with simulcast.
2934TEST_F(WebRtcVideoEngine2SimulcastTest,
2935 DISABLED_SetSendStreamFormatWithSimulcast) {
2936 // TODO(pbos): Implement.
2937 FAIL() << "Not implemented.";
2938}
2939
2940// Test that simulcast send codec is reset on new video frame size.
2941TEST_F(WebRtcVideoEngine2SimulcastTest,
2942 DISABLED_ResetSimulcastSendCodecOnNewFrameSize) {
2943 // TODO(pbos): Implement.
2944 FAIL() << "Not implemented.";
2945}
2946
2947// Test that simulcast send codec is reset on new portait mode video frame.
2948TEST_F(WebRtcVideoEngine2SimulcastTest,
2949 DISABLED_ResetSimulcastSendCodecOnNewPortaitFrame) {
2950 // TODO(pbos): Implement.
2951 FAIL() << "Not implemented.";
2952}
2953
2954TEST_F(WebRtcVideoEngine2SimulcastTest,
2955 DISABLED_SetBandwidthInConferenceWithSimulcast) {
2956 // TODO(pbos): Implement.
2957 FAIL() << "Not implemented.";
2958}
2959
2960// Test that sending screencast frames in conference mode changes
2961// bitrate.
2962TEST_F(WebRtcVideoEngine2SimulcastTest,
2963 DISABLED_SetBandwidthScreencastInConference) {
2964 // TODO(pbos): Implement.
2965 FAIL() << "Not implemented.";
2966}
2967
2968// Test AddSendStream with simulcast rejects bad StreamParams.
2969TEST_F(WebRtcVideoEngine2SimulcastTest,
2970 DISABLED_AddSendStreamWithBadStreamParams) {
2971 // TODO(pbos): Implement.
2972 FAIL() << "Not implemented.";
2973}
2974
2975// Test AddSendStream with simulcast sets ssrc and cname correctly.
2976TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_AddSendStreamWithSimulcast) {
2977 // TODO(pbos): Implement.
2978 FAIL() << "Not implemented.";
2979}
2980
2981// Test RemoveSendStream with simulcast.
2982TEST_F(WebRtcVideoEngine2SimulcastTest,
2983 DISABLED_RemoveSendStreamWithSimulcast) {
2984 // TODO(pbos): Implement.
2985 FAIL() << "Not implemented.";
2986}
2987
2988// Test AddSendStream after send codec has already been set will reset
2989// send codec with simulcast settings.
2990TEST_F(WebRtcVideoEngine2SimulcastTest,
2991 DISABLED_AddSimulcastStreamAfterSetSendCodec) {
2992 // TODO(pbos): Implement.
2993 FAIL() << "Not implemented.";
2994}
2995
2996TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_GetStatsWithMultipleSsrcs) {
2997 // TODO(pbos): Implement.
2998 FAIL() << "Not implemented.";
2999}
3000
3001// Test receiving channel(s) local ssrc is set to the same as the first
3002// simulcast sending ssrc.
3003TEST_F(WebRtcVideoEngine2SimulcastTest,
3004 DISABLED_AddSimulcastStreamAfterCreatingRecvChannels) {
3005 // TODO(pbos): Implement.
3006 FAIL() << "Not implemented.";
3007}
3008
3009// Test 1:1 call never turn on simulcast.
3010TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_NoSimulcastWith1on1) {
3011 // TODO(pbos): Implement.
3012 FAIL() << "Not implemented.";
3013}
3014
3015// Test SetOptions with OPT_CONFERENCE flag.
3016TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_SetOptionsWithConferenceMode) {
3017 // TODO(pbos): Implement.
3018 FAIL() << "Not implemented.";
3019}
3020
3021// Test that two different streams can have different formats.
3022TEST_F(WebRtcVideoEngine2SimulcastTest,
3023 DISABLED_MultipleSendStreamsDifferentFormats) {
3024 // TODO(pbos): Implement.
3025 FAIL() << "Not implemented.";
3026}
3027
3028TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToOutputFormat) {
3029 // TODO(pbos): Implement.
3030 FAIL() << "Not implemented.";
3031}
3032
3033TEST_F(WebRtcVideoEngine2SimulcastTest,
3034 DISABLED_TestAdaptWithCpuOveruseObserver) {
3035 // TODO(pbos): Implement.
3036 FAIL() << "Not implemented.";
3037}
3038
3039// Test that codec is not reset for every frame sent in non-conference and
3040// non-screencast mode.
3041TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_DontResetCodecOnSendFrame) {
3042 // TODO(pbos): Implement.
3043 FAIL() << "Not implemented.";
3044}
3045
3046TEST_F(WebRtcVideoEngine2SimulcastTest,
3047 DISABLED_UseSimulcastAdapterOnVp8OnlyFactory) {
3048 // TODO(pbos): Implement.
3049 FAIL() << "Not implemented.";
3050}
3051
3052TEST_F(WebRtcVideoEngine2SimulcastTest,
3053 DISABLED_DontUseSimulcastAdapterOnNonVp8Factory) {
3054 // TODO(pbos): Implement.
3055 FAIL() << "Not implemented.";
3056}
3057
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003058class WebRtcVideoChannel2SimulcastTest : public testing::Test {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003059 public:
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003060 WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {}
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003061
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00003062 void SetUp() override {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +02003063 engine_.Init();
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003064 channel_.reset(engine_.CreateChannel(&fake_call_, VideoOptions()));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003065 last_ssrc_ = 123;
3066 }
3067
3068 protected:
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003069 void VerifySimulcastSettings(const VideoCodec& codec,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003070 size_t num_configured_streams,
pbosbe16f792015-10-16 12:49:39 -07003071 size_t expected_num_streams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003072 cricket::VideoSendParameters parameters;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003073 parameters.codecs.push_back(codec);
3074 ASSERT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003075
Peter Boström0c4e06b2015-10-07 12:23:21 +02003076 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
henrikg91d6ede2015-09-17 00:24:34 -07003077 RTC_DCHECK(num_configured_streams <= ssrcs.size());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003078 ssrcs.resize(num_configured_streams);
3079
3080 FakeVideoSendStream* stream =
3081 AddSendStream(CreateSimStreamParams("cname", ssrcs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003082 // Send a full-size frame to trigger a stream reconfiguration to use all
3083 // expected simulcast layers.
3084 cricket::FakeVideoCapturer capturer;
3085 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer));
3086 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
3087 codec.width, codec.height,
3088 cricket::VideoFormat::FpsToInterval(30),
3089 cricket::FOURCC_I420)));
3090 channel_->SetSend(true);
3091 EXPECT_TRUE(capturer.CaptureFrame());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003092
3093 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
3094 ASSERT_EQ(expected_num_streams, video_streams.size());
3095
3096 std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
pbosbe16f792015-10-16 12:49:39 -07003097 num_configured_streams, codec.width, codec.height, 0, kDefaultQpMax,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003098 codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
3099
3100 ASSERT_EQ(expected_streams.size(), video_streams.size());
3101
3102 size_t num_streams = video_streams.size();
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003103 int total_max_bitrate_bps = 0;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003104 for (size_t i = 0; i < num_streams; ++i) {
3105 EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
3106 EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
3107
3108 EXPECT_GT(video_streams[i].max_framerate, 0);
3109 EXPECT_EQ(expected_streams[i].max_framerate,
3110 video_streams[i].max_framerate);
3111
3112 EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
3113 EXPECT_EQ(expected_streams[i].min_bitrate_bps,
3114 video_streams[i].min_bitrate_bps);
3115
3116 EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
3117 EXPECT_EQ(expected_streams[i].target_bitrate_bps,
3118 video_streams[i].target_bitrate_bps);
3119
3120 EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
3121 EXPECT_EQ(expected_streams[i].max_bitrate_bps,
3122 video_streams[i].max_bitrate_bps);
3123
3124 EXPECT_GT(video_streams[i].max_qp, 0);
3125 EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
3126
3127 EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty());
3128 EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps,
3129 video_streams[i].temporal_layer_thresholds_bps);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003130
3131 if (i == num_streams - 1) {
3132 total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
3133 } else {
3134 total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
3135 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003136 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003137 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003138 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003139 ASSERT_EQ(1u, info.senders.size());
3140 EXPECT_EQ(total_max_bitrate_bps, info.senders[0].preferred_bitrate);
3141
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003142 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003143 }
3144
3145 FakeVideoSendStream* AddSendStream() {
3146 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
3147 }
3148
3149 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
3150 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003151 fake_call_.GetVideoSendStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003152 EXPECT_TRUE(channel_->AddSendStream(sp));
3153 std::vector<FakeVideoSendStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003154 fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003155 EXPECT_EQ(num_streams + 1, streams.size());
3156 return streams[streams.size() - 1];
3157 }
3158
3159 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003160 return fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003161 }
3162
3163 FakeVideoReceiveStream* AddRecvStream() {
3164 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
3165 }
3166
3167 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
3168 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003169 fake_call_.GetVideoReceiveStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003170 EXPECT_TRUE(channel_->AddRecvStream(sp));
3171 std::vector<FakeVideoReceiveStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003172 fake_call_.GetVideoReceiveStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003173 EXPECT_EQ(num_streams + 1, streams.size());
3174 return streams[streams.size() - 1];
3175 }
3176
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003177 FakeCall fake_call_;
3178 WebRtcVideoEngine2 engine_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003179 rtc::scoped_ptr<VideoMediaChannel> channel_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02003180 uint32_t last_ssrc_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003181};
3182
3183TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003184 VerifySimulcastSettings(kVp8Codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003185}
3186
3187TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003188 VerifySimulcastSettings(kVp8Codec720p, 3, 3);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003189}
3190
3191// Test that we normalize send codec format size in simulcast.
3192TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
3193 cricket::VideoCodec codec(kVp8Codec270p);
3194 codec.width += 1;
3195 codec.height += 1;
pbosbe16f792015-10-16 12:49:39 -07003196 VerifySimulcastSettings(codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003197}
3198
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003199TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x800) {
3200 // TODO(pbos): Implement.
3201 FAIL() << "Not implemented.";
3202}
3203
3204TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x720) {
3205 // TODO(pbos): Implement.
3206 FAIL() << "Not implemented.";
3207}
3208
3209TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x540) {
3210 // TODO(pbos): Implement.
3211 FAIL() << "Not implemented.";
3212}
3213
3214TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x600) {
3215 // TODO(pbos): Implement.
3216 FAIL() << "Not implemented.";
3217}
3218
3219TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x400) {
3220 // TODO(pbos): Implement.
3221 FAIL() << "Not implemented.";
3222}
3223
3224TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x360) {
3225 // TODO(pbos): Implement.
3226 FAIL() << "Not implemented.";
3227}
3228
3229TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_480x300) {
3230 // TODO(pbos): Implement.
3231 FAIL() << "Not implemented.";
3232}
3233
Peter Boström54be3e02015-05-25 15:04:24 +02003234TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_480x270) {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003235 // TODO(pbos): Implement.
3236 FAIL() << "Not implemented.";
3237}
3238
3239TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x200) {
3240 // TODO(pbos): Implement.
3241 FAIL() << "Not implemented.";
3242}
3243
3244TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x180) {
3245 // TODO(pbos): Implement.
3246 FAIL() << "Not implemented.";
3247}
3248
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003249// Test simulcast streams are decodeable with expected sizes.
3250TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastStreams) {
3251 // TODO(pbos): Implement.
3252 FAIL() << "Not implemented.";
3253}
3254
3255// Simulcast and resolution resizing should be turned off when screencasting
3256// but not otherwise.
3257TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_ScreencastRendering) {
3258 // TODO(pbos): Implement.
3259 FAIL() << "Not implemented.";
3260}
3261
3262// Ensures that the correct settings are applied to the codec when single
3263// temporal layer screencasting is enabled, and that the correct simulcast
3264// settings are reapplied when disabling screencasting.
3265TEST_F(WebRtcVideoChannel2SimulcastTest,
3266 DISABLED_OneTemporalLayerScreencastSettings) {
3267 // TODO(pbos): Implement.
3268 FAIL() << "Not implemented.";
3269}
3270
3271// Ensures that the correct settings are applied to the codec when two temporal
3272// layer screencasting is enabled, and that the correct simulcast settings are
3273// reapplied when disabling screencasting.
3274TEST_F(WebRtcVideoChannel2SimulcastTest,
3275 DISABLED_TwoTemporalLayerScreencastSettings) {
3276 // TODO(pbos): Implement.
3277 FAIL() << "Not implemented.";
3278}
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00003279
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003280} // namespace cricket