blob: 177ab9f22368fd705601cc29d59300b516d6662d [file] [log] [blame]
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001/*
kjellander1afca732016-02-07 20:46:45 -08002 * Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003 *
kjellander1afca732016-02-07 20:46:45 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00009 */
10
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +000011#include <algorithm>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000012#include <map>
kwiberg686a8ef2016-02-26 03:00:35 -080013#include <memory>
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000014#include <vector>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000015
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +000016#include "webrtc/base/arraysize.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000017#include "webrtc/base/gunit.h"
18#include "webrtc/base/stringutils.h"
kjellandera96e2d72016-02-04 23:52:28 -080019#include "webrtc/media/base/testutils.h"
20#include "webrtc/media/base/videoengine_unittest.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010021#include "webrtc/media/engine/fakewebrtccall.h"
22#include "webrtc/media/engine/fakewebrtcvideoengine.h"
23#include "webrtc/media/engine/simulcast.h"
24#include "webrtc/media/engine/webrtcvideochannelfactory.h"
25#include "webrtc/media/engine/webrtcvideoengine2.h"
26#include "webrtc/media/engine/webrtcvoiceengine.h"
stefanc1aeaf02015-10-15 07:26:07 -070027#include "webrtc/test/field_trial.h"
pbos@webrtc.org42684be2014-10-03 11:25:45 +000028#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000029
isheriff6f8d6862016-05-26 11:24:55 -070030using webrtc::RtpExtension;
31
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000032namespace {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000033static const int kDefaultQpMax = 56;
34static const int kDefaultFramerate = 30;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000035
deadbeef67cf2c12016-04-13 10:07:16 -070036static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30);
37static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30);
38static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000039
deadbeef67cf2c12016-04-13 10:07:16 -070040static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30);
41static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30);
42static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000043
deadbeef67cf2c12016-04-13 10:07:16 -070044static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0);
45static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000046
noahricd10a68e2015-07-10 11:27:55 -070047static const uint8_t kRedRtxPayloadType = 125;
48
Peter Boström0c4e06b2015-10-07 12:23:21 +020049static const uint32_t kSsrcs1[] = {1};
50static const uint32_t kSsrcs3[] = {1, 2, 3};
51static const uint32_t kRtxSsrcs1[] = {4};
52static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
pbos@webrtc.org3c107582014-07-20 15:27:35 +000053static const char kUnsupportedExtensionName[] =
54 "urn:ietf:params:rtp-hdrext:unsupported";
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000055
56void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
57 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
58 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
59 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
60 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
61 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
62 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
63 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
stefan43edf0f2015-11-20 18:05:48 -080064 cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty)));
65 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000066 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
67}
68
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -070069static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000070 int width,
71 int height) {
72 video_frame->CreateEmptyFrame(
73 width, height, width, (width + 1) / 2, (width + 1) / 2);
nissec9c142f2016-05-17 04:05:47 -070074 memset(video_frame->video_frame_buffer()->MutableDataY(), 16,
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000075 video_frame->allocated_size(webrtc::kYPlane));
nissec9c142f2016-05-17 04:05:47 -070076 memset(video_frame->video_frame_buffer()->MutableDataU(), 128,
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000077 video_frame->allocated_size(webrtc::kUPlane));
nissec9c142f2016-05-17 04:05:47 -070078 memset(video_frame->video_frame_buffer()->MutableDataV(), 128,
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000079 video_frame->allocated_size(webrtc::kVPlane));
80}
81
Shao Changbine62202f2015-04-21 20:24:50 +080082void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
83 const std::map<int, int>& rtx_types) {
84 std::map<int, int>::const_iterator it;
85 it = rtx_types.find(config.encoder_settings.payload_type);
86 EXPECT_TRUE(it != rtx_types.end() &&
87 it->second == config.rtp.rtx.payload_type);
88
89 if (config.rtp.fec.red_rtx_payload_type != -1) {
90 it = rtx_types.find(config.rtp.fec.red_payload_type);
91 EXPECT_TRUE(it != rtx_types.end() &&
92 it->second == config.rtp.fec.red_rtx_payload_type);
93 }
94}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000095} // namespace
96
97namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000098class WebRtcVideoEngine2Test : public ::testing::Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000099 public:
stefanc1aeaf02015-10-15 07:26:07 -0700100 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {}
101 explicit WebRtcVideoEngine2Test(const char* field_trials)
102 : WebRtcVideoEngine2Test(nullptr, field_trials) {}
103 WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine,
104 const char* field_trials)
105 : override_field_trials_(field_trials),
106 call_(webrtc::Call::Create(webrtc::Call::Config())),
solenbergff976312016-03-30 23:28:51 -0700107 voice_engine_(nullptr),
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200108 engine_() {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000109 std::vector<VideoCodec> engine_codecs = engine_.codecs();
henrikg91d6ede2015-09-17 00:24:34 -0700110 RTC_DCHECK(!engine_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000111 bool codec_set = false;
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000112 for (size_t i = 0; i < engine_codecs.size(); ++i) {
113 if (engine_codecs[i].name == "red") {
114 default_red_codec_ = engine_codecs[i];
115 } else if (engine_codecs[i].name == "ulpfec") {
116 default_ulpfec_codec_ = engine_codecs[i];
117 } else if (engine_codecs[i].name == "rtx") {
Shao Changbine62202f2015-04-21 20:24:50 +0800118 int associated_payload_type;
119 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
120 &associated_payload_type)) {
121 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id;
122 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000123 } else if (!codec_set) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000124 default_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000125 codec_set = true;
126 }
127 }
128
henrikg91d6ede2015-09-17 00:24:34 -0700129 RTC_DCHECK(codec_set);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000130 }
131
132 protected:
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000133 VideoMediaChannel* SetUpForExternalEncoderFactory(
134 cricket::WebRtcVideoEncoderFactory* encoder_factory,
135 const std::vector<VideoCodec>& codecs);
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000136
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000137 VideoMediaChannel* SetUpForExternalDecoderFactory(
138 cricket::WebRtcVideoDecoderFactory* decoder_factory,
139 const std::vector<VideoCodec>& codecs);
140
Peter Boströme4499152016-02-05 11:13:28 +0100141 void TestExtendedEncoderOveruse(bool use_external_encoder);
142
stefanc1aeaf02015-10-15 07:26:07 -0700143 webrtc::test::ScopedFieldTrials override_field_trials_;
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000144 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
145 // initialized when the constructor is called.
kwiberg686a8ef2016-02-26 03:00:35 -0800146 std::unique_ptr<webrtc::Call> call_;
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000147 WebRtcVoiceEngine voice_engine_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000148 WebRtcVideoEngine2 engine_;
149 VideoCodec default_codec_;
150 VideoCodec default_red_codec_;
151 VideoCodec default_ulpfec_codec_;
Shao Changbine62202f2015-04-21 20:24:50 +0800152 std::map<int, int> default_apt_rtx_types_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000153};
154
Peter Boström12996152016-05-14 02:03:18 +0200155TEST_F(WebRtcVideoEngine2Test, AnnouncesVp9AccordingToBuildFlags) {
156 bool claims_vp9_support = false;
157 for (const cricket::VideoCodec& codec : engine_.codecs()) {
158 if (codec.name == "VP9") {
159 claims_vp9_support = true;
160 break;
161 }
162 }
163#if defined(RTC_DISABLE_VP9)
164 EXPECT_FALSE(claims_vp9_support);
165#else
166 EXPECT_TRUE(claims_vp9_support);
167#endif // defined(RTC_DISABLE_VP9)
168}
169
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000170TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
171 std::vector<VideoCodec> engine_codecs = engine_.codecs();
172 for (size_t i = 0; i < engine_codecs.size(); ++i) {
173 if (engine_codecs[i].name != kRtxCodecName)
174 continue;
175 int associated_payload_type;
176 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000177 &associated_payload_type));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000178 EXPECT_EQ(default_codec_.id, associated_payload_type);
179 return;
180 }
181 FAIL() << "No RTX codec found among default codecs.";
182}
183
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000184TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100185 RtpCapabilities capabilities = engine_.GetCapabilities();
186 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700187 for (const RtpExtension& extension : capabilities.header_extensions) {
188 if (extension.uri == RtpExtension::kTimestampOffsetUri) {
189 EXPECT_EQ(RtpExtension::kTimestampOffsetDefaultId, extension.id);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000190 return;
191 }
192 }
193 FAIL() << "Timestamp offset extension not in header-extension list.";
194}
195
196TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100197 RtpCapabilities capabilities = engine_.GetCapabilities();
198 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700199 for (const RtpExtension& extension : capabilities.header_extensions) {
200 if (extension.uri == RtpExtension::kAbsSendTimeUri) {
201 EXPECT_EQ(RtpExtension::kAbsSendTimeDefaultId, extension.id);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000202 return;
203 }
204 }
205 FAIL() << "Absolute Sender Time extension not in header-extension list.";
206}
207
stefanc1aeaf02015-10-15 07:26:07 -0700208class WebRtcVideoEngine2WithSendSideBweTest : public WebRtcVideoEngine2Test {
209 public:
210 WebRtcVideoEngine2WithSendSideBweTest()
211 : WebRtcVideoEngine2Test("WebRTC-SendSideBwe/Enabled/") {}
212};
213
214TEST_F(WebRtcVideoEngine2WithSendSideBweTest,
215 SupportsTransportSequenceNumberHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100216 RtpCapabilities capabilities = engine_.GetCapabilities();
217 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700218 for (const RtpExtension& extension : capabilities.header_extensions) {
219 if (extension.uri == RtpExtension::kTransportSequenceNumberUri) {
220 EXPECT_EQ(RtpExtension::kTransportSequenceNumberDefaultId, extension.id);
stefanc1aeaf02015-10-15 07:26:07 -0700221 return;
222 }
223 }
224 FAIL() << "Transport sequence number extension not in header-extension list.";
225}
226
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700227TEST_F(WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension) {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100228 RtpCapabilities capabilities = engine_.GetCapabilities();
229 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -0700230 for (const RtpExtension& extension : capabilities.header_extensions) {
231 if (extension.uri == RtpExtension::kVideoRotationUri) {
232 EXPECT_EQ(RtpExtension::kVideoRotationDefaultId, extension.id);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700233 return;
234 }
235 }
236 FAIL() << "Video Rotation extension not in header-extension list.";
237}
238
239TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
240 // Allocate the capturer first to prevent early destruction before channel's
241 // dtor is called.
242 cricket::FakeVideoCapturer capturer;
243
244 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
245 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200246 cricket::VideoSendParameters parameters;
247 parameters.codecs.push_back(kVp8Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700248
kwiberg686a8ef2016-02-26 03:00:35 -0800249 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200250 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700251 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
252
253 // Add CVO extension.
254 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200255 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700256 RtpExtension(RtpExtension::kVideoRotationUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200257 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700258
259 // Set capturer.
nisse2ded9b12016-04-08 02:23:55 -0700260 channel->SetSource(kSsrc, &capturer);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700261
262 // Verify capturer has turned off applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700263 EXPECT_FALSE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700264
265 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200266 parameters.extensions.clear();
267 EXPECT_TRUE(channel->SetSendParameters(parameters));
nisse47ac4622016-05-25 08:47:01 -0700268 EXPECT_TRUE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700269}
270
perkj91e1c152016-03-02 05:34:00 -0800271TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) {
272 // Allocate the capturer first to prevent early destruction before channel's
273 // dtor is called.
274 cricket::FakeVideoCapturer capturer;
275
276 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
277 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
278 cricket::VideoSendParameters parameters;
279 parameters.codecs.push_back(kVp8Codec);
280
281 std::unique_ptr<VideoMediaChannel> channel(
282 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
283 // Add CVO extension.
284 const int id = 1;
285 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700286 RtpExtension(RtpExtension::kVideoRotationUri, id));
perkj91e1c152016-03-02 05:34:00 -0800287 EXPECT_TRUE(channel->SetSendParameters(parameters));
288 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
289
290 // Set capturer.
nisse2ded9b12016-04-08 02:23:55 -0700291 channel->SetSource(kSsrc, &capturer);
perkj91e1c152016-03-02 05:34:00 -0800292
293 // Verify capturer has turned off applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700294 EXPECT_FALSE(capturer.apply_rotation());
perkj91e1c152016-03-02 05:34:00 -0800295}
296
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700297TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
298 cricket::FakeVideoCapturer capturer;
299
300 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
301 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
perkjcaafdba2016-03-20 07:34:29 -0700302 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200303 cricket::VideoSendParameters parameters;
304 parameters.codecs.push_back(kVp8Codec);
perkjcaafdba2016-03-20 07:34:29 -0700305 parameters.codecs.push_back(kVp9Codec);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700306
kwiberg686a8ef2016-02-26 03:00:35 -0800307 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200308 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700309 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
310
311 // Set capturer.
nisse2ded9b12016-04-08 02:23:55 -0700312 channel->SetSource(kSsrc, &capturer);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700313
perkjcaafdba2016-03-20 07:34:29 -0700314 // Verify capturer has turned on applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700315 EXPECT_TRUE(capturer.apply_rotation());
perkjcaafdba2016-03-20 07:34:29 -0700316
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700317 // Add CVO extension.
318 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200319 parameters.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700320 RtpExtension(RtpExtension::kVideoRotationUri, id));
perkjcaafdba2016-03-20 07:34:29 -0700321 // Also remove the first codec to trigger a codec change as well.
322 parameters.codecs.erase(parameters.codecs.begin());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200323 EXPECT_TRUE(channel->SetSendParameters(parameters));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700324
325 // Verify capturer has turned off applying rotation.
nisse47ac4622016-05-25 08:47:01 -0700326 EXPECT_FALSE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700327
328 // Verify removing header extension turns on applying rotation.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200329 parameters.extensions.clear();
330 EXPECT_TRUE(channel->SetSendParameters(parameters));
nisse47ac4622016-05-25 08:47:01 -0700331 EXPECT_TRUE(capturer.apply_rotation());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700332}
333
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000334TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200335 engine_.Init();
kwiberg686a8ef2016-02-26 03:00:35 -0800336 std::unique_ptr<VideoMediaChannel> channel(
nisse51542be2016-02-12 02:27:06 -0800337 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000338
339 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
340
341 EXPECT_FALSE(channel->SetSend(true))
342 << "Channel should not start without codecs.";
343 EXPECT_TRUE(channel->SetSend(false))
344 << "Channel should be stoppable even without set codecs.";
345}
346
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000347TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200348 engine_.Init();
kwiberg686a8ef2016-02-26 03:00:35 -0800349 std::unique_ptr<VideoMediaChannel> channel(
nisse51542be2016-02-12 02:27:06 -0800350 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000351 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
352 VideoMediaInfo info;
353 channel->GetStats(&info);
354}
355
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000356TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
357 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
358 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200359 cricket::VideoSendParameters parameters;
360 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000361
kwiberg686a8ef2016-02-26 03:00:35 -0800362 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200363 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000364
365 EXPECT_TRUE(
366 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pbos14fe7082016-04-20 06:35:56 -0700367 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000368 ASSERT_EQ(1u, encoder_factory.encoders().size());
369 EXPECT_TRUE(channel->SetSend(true));
370
371 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -0700372 channel->SetSource(kSsrc, &capturer);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000373 EXPECT_EQ(cricket::CS_RUNNING,
374 capturer.Start(capturer.GetSupportedFormats()->front()));
375 EXPECT_TRUE(capturer.CaptureFrame());
pbos14fe7082016-04-20 06:35:56 -0700376 // Sending one frame will have reallocated the encoder since input size
377 // changes from a small default to the actual frame width/height. Wait for
378 // that to happen then for the frame to be sent.
379 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000380 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
381 kTimeout);
382
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000383 int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
384 EXPECT_EQ(num_created_encoders, 2);
385
386 // Setting codecs of the same type should not reallocate any encoders
387 // (expecting a no-op).
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200388 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000389 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000390
391 // Remove stream previously added to free the external encoder instance.
392 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
393 EXPECT_EQ(0u, encoder_factory.encoders().size());
394}
395
Peter Boströme4499152016-02-05 11:13:28 +0100396void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse(
397 bool use_external_encoder) {
398 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
399 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
400 cricket::VideoSendParameters parameters;
401 parameters.codecs.push_back(kVp8Codec);
kwiberg686a8ef2016-02-26 03:00:35 -0800402 std::unique_ptr<VideoMediaChannel> channel;
Peter Boströme4499152016-02-05 11:13:28 +0100403 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
404 call_.reset(fake_call);
405 if (use_external_encoder) {
406 channel.reset(
407 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
408 } else {
409 engine_.Init();
nisse51542be2016-02-12 02:27:06 -0800410 channel.reset(
411 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
Peter Boströme4499152016-02-05 11:13:28 +0100412 }
413 ASSERT_TRUE(
414 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
415 EXPECT_TRUE(channel->SetSendParameters(parameters));
416 EXPECT_TRUE(channel->SetSend(true));
417 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
418
419 EXPECT_EQ(use_external_encoder,
420 stream->GetConfig().encoder_settings.full_overuse_time);
421 // Remove stream previously added to free the external encoder instance.
422 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
423}
424
425TEST_F(WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders) {
426 TestExtendedEncoderOveruse(true);
427}
428
429TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) {
430 TestExtendedEncoderOveruse(false);
431}
432
Peter Boström12996152016-05-14 02:03:18 +0200433#if !defined(RTC_DISABLE_VP9)
Peter Boström53eda3d2015-03-27 15:53:18 +0100434TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
435 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
436 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
437 std::vector<cricket::VideoCodec> codecs;
438 codecs.push_back(kVp9Codec);
439
kwiberg686a8ef2016-02-26 03:00:35 -0800440 std::unique_ptr<VideoMediaChannel> channel(
Peter Boström53eda3d2015-03-27 15:53:18 +0100441 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
442
443 EXPECT_TRUE(
444 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
445}
Peter Boström12996152016-05-14 02:03:18 +0200446#endif // !defined(RTC_DISABLE_VP9)
Peter Boström53eda3d2015-03-27 15:53:18 +0100447
qiangchenc27d89f2015-07-16 10:27:16 -0700448TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
449 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
450 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
451 std::vector<cricket::VideoCodec> codecs;
452 codecs.push_back(kVp8Codec);
453
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200454 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
455 call_.reset(fake_call);
kwiberg686a8ef2016-02-26 03:00:35 -0800456 std::unique_ptr<VideoMediaChannel> channel(
qiangchenc27d89f2015-07-16 10:27:16 -0700457 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
458
459 EXPECT_TRUE(
460 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
461
462 FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -0700463 channel->SetSource(kSsrc, &capturer);
qiangchenc27d89f2015-07-16 10:27:16 -0700464 capturer.Start(cricket::VideoFormat(1280, 720,
465 cricket::VideoFormat::FpsToInterval(60),
466 cricket::FOURCC_I420));
467 channel->SetSend(true);
468
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200469 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
qiangchenc27d89f2015-07-16 10:27:16 -0700470
471 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700472 int64_t last_timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700473 for (int i = 0; i < 10; i++) {
474 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700475 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700476 int64_t interval = timestamp - last_timestamp;
477
478 // Precision changes from nanosecond to millisecond.
479 // Allow error to be no more than 1.
480 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(60) / 1E6, interval, 1);
481
482 last_timestamp = timestamp;
483 }
484
485 capturer.Start(cricket::VideoFormat(1280, 720,
486 cricket::VideoFormat::FpsToInterval(30),
487 cricket::FOURCC_I420));
488
489 EXPECT_TRUE(capturer.CaptureFrame());
490 last_timestamp = stream->GetLastTimestamp();
491 for (int i = 0; i < 10; i++) {
492 EXPECT_TRUE(capturer.CaptureFrame());
pbos1cb121d2015-09-14 11:38:38 -0700493 int64_t timestamp = stream->GetLastTimestamp();
qiangchenc27d89f2015-07-16 10:27:16 -0700494 int64_t interval = timestamp - last_timestamp;
495
496 // Precision changes from nanosecond to millisecond.
497 // Allow error to be no more than 1.
498 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1);
499
500 last_timestamp = timestamp;
501 }
502
503 // Remove stream previously added to free the external encoder instance.
504 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
505}
506
pbos1cb121d2015-09-14 11:38:38 -0700507TEST_F(WebRtcVideoEngine2Test,
508 ProducesIncreasingTimestampsWithResetInputSources) {
509 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
510 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
511 std::vector<cricket::VideoCodec> codecs;
512 codecs.push_back(kVp8Codec);
513
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200514 FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
515 call_.reset(fake_call);
kwiberg686a8ef2016-02-26 03:00:35 -0800516 std::unique_ptr<VideoMediaChannel> channel(
pbos1cb121d2015-09-14 11:38:38 -0700517 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
518
519 EXPECT_TRUE(
520 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
521 channel->SetSend(true);
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200522 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
pbos1cb121d2015-09-14 11:38:38 -0700523
524 FakeVideoCapturer capturer1;
nisse2ded9b12016-04-08 02:23:55 -0700525 channel->SetSource(kSsrc, &capturer1);
pbos1cb121d2015-09-14 11:38:38 -0700526
527 cricket::CapturedFrame frame;
528 frame.width = 1280;
529 frame.height = 720;
530 frame.fourcc = cricket::FOURCC_I420;
nissed73c99c2016-02-12 01:01:11 -0800531 frame.data_size = frame.width * frame.height +
532 2 * ((frame.width + 1) / 2) * ((frame.height + 1) / 2);
kwiberg686a8ef2016-02-26 03:00:35 -0800533 std::unique_ptr<char[]> data(new char[frame.data_size]);
pbos1cb121d2015-09-14 11:38:38 -0700534 frame.data = data.get();
535 memset(frame.data, 1, frame.data_size);
nisseb17712f2016-04-14 02:29:29 -0700536 int64_t initial_timestamp = rtc::TimeNanos();
537 frame.time_stamp = initial_timestamp;
pbos1cb121d2015-09-14 11:38:38 -0700538
539 // Deliver initial frame.
540 capturer1.SignalCapturedFrame(&frame);
541 // Deliver next frame 1 second later.
542 frame.time_stamp += rtc::kNumNanosecsPerSec;
543 rtc::Thread::Current()->SleepMs(1000);
544 capturer1.SignalCapturedFrame(&frame);
545
546 int64_t capturer1_last_timestamp = stream->GetLastTimestamp();
547 // Reset input source, should still be continuous even though input-frame
548 // timestamp is less than before.
549 FakeVideoCapturer capturer2;
nisse2ded9b12016-04-08 02:23:55 -0700550 channel->SetSource(kSsrc, &capturer2);
pbos1cb121d2015-09-14 11:38:38 -0700551
552 rtc::Thread::Current()->SleepMs(1);
553 // Deliver with a timestamp (10 seconds) before the previous initial one,
554 // these should not be related at all anymore and it should still work fine.
nisseb17712f2016-04-14 02:29:29 -0700555 frame.time_stamp = initial_timestamp - 10 * rtc::kNumNanosecsPerSec;
pbos1cb121d2015-09-14 11:38:38 -0700556 capturer2.SignalCapturedFrame(&frame);
557
558 // New timestamp should be at least 1ms in the future and not old.
559 EXPECT_GT(stream->GetLastTimestamp(), capturer1_last_timestamp);
560
561 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
562}
563
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000564VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
565 cricket::WebRtcVideoEncoderFactory* encoder_factory,
566 const std::vector<VideoCodec>& codecs) {
567 engine_.SetExternalEncoderFactory(encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200568 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000569
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000570 VideoMediaChannel* channel =
nisse51542be2016-02-12 02:27:06 -0800571 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200572 cricket::VideoSendParameters parameters;
573 parameters.codecs = codecs;
574 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000575
576 return channel;
577}
578
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000579VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
580 cricket::WebRtcVideoDecoderFactory* decoder_factory,
581 const std::vector<VideoCodec>& codecs) {
582 engine_.SetExternalDecoderFactory(decoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200583 engine_.Init();
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000584
585 VideoMediaChannel* channel =
nisse51542be2016-02-12 02:27:06 -0800586 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200587 cricket::VideoRecvParameters parameters;
588 parameters.codecs = codecs;
589 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000590
591 return channel;
592}
593
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000594TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
595 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
596 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
597 std::vector<cricket::VideoCodec> codecs;
598 codecs.push_back(kVp8Codec);
599
kwiberg686a8ef2016-02-26 03:00:35 -0800600 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000601 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
602
Peter Boström0c4e06b2015-10-07 12:23:21 +0200603 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000604
605 EXPECT_TRUE(
606 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
607 EXPECT_TRUE(channel->SetSend(true));
608
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000609 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -0700610 channel->SetSource(ssrcs.front(), &capturer);
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000611 EXPECT_EQ(cricket::CS_RUNNING,
612 capturer.Start(capturer.GetSupportedFormats()->front()));
613 EXPECT_TRUE(capturer.CaptureFrame());
614
pbos14fe7082016-04-20 06:35:56 -0700615 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000616
617 // Verify that encoders are configured for simulcast through adapter
618 // (increasing resolution and only configured to send one stream each).
619 int prev_width = -1;
620 for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
pbos14fe7082016-04-20 06:35:56 -0700621 ASSERT_TRUE(encoder_factory.encoders()[i]->WaitForInitEncode());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000622 webrtc::VideoCodec codec_settings =
623 encoder_factory.encoders()[i]->GetCodecSettings();
624 EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
625 EXPECT_GT(codec_settings.width, prev_width);
626 prev_width = codec_settings.width;
627 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000628
nisse2ded9b12016-04-08 02:23:55 -0700629 channel->SetSource(ssrcs.front(), NULL);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000630
631 channel.reset();
632 ASSERT_EQ(0u, encoder_factory.encoders().size());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000633}
634
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000635TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
636 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
637 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
638 std::vector<cricket::VideoCodec> codecs;
639 codecs.push_back(kH264Codec);
640
kwiberg686a8ef2016-02-26 03:00:35 -0800641 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000642 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
643
644 EXPECT_TRUE(
645 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
646 ASSERT_EQ(1u, encoder_factory.encoders().size());
647
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200648 cricket::VideoSendParameters parameters;
649 parameters.codecs.push_back(kVp8Codec);
650 EXPECT_TRUE(channel->SetSendParameters(parameters));
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000651 ASSERT_EQ(0u, encoder_factory.encoders().size());
652}
653
654TEST_F(WebRtcVideoEngine2Test,
655 DontUseExternalEncoderFactoryForUnsupportedCodecs) {
656 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
657 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
658 std::vector<cricket::VideoCodec> codecs;
659 codecs.push_back(kVp8Codec);
660
kwiberg686a8ef2016-02-26 03:00:35 -0800661 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000662 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
663
664 EXPECT_TRUE(
665 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000666 // Make sure DestroyVideoEncoder was called on the factory.
667 ASSERT_EQ(0u, encoder_factory.encoders().size());
668}
669
670TEST_F(WebRtcVideoEngine2Test,
671 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
672 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
673 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
674 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
675
676 std::vector<cricket::VideoCodec> codecs;
677 codecs.push_back(kVp8Codec);
678
kwiberg686a8ef2016-02-26 03:00:35 -0800679 std::unique_ptr<VideoMediaChannel> channel(
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000680 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
681
Peter Boström0c4e06b2015-10-07 12:23:21 +0200682 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000683
684 EXPECT_TRUE(
685 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
686 EXPECT_TRUE(channel->SetSend(true));
687
688 // Send a fake frame, or else the media engine will configure the simulcast
689 // encoder adapter at a low-enough size that it'll only create a single
690 // encoder layer.
691 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -0700692 channel->SetSource(ssrcs.front(), &capturer);
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000693 EXPECT_EQ(cricket::CS_RUNNING,
694 capturer.Start(capturer.GetSupportedFormats()->front()));
695 EXPECT_TRUE(capturer.CaptureFrame());
696
pbos14fe7082016-04-20 06:35:56 -0700697 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
698 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000699 EXPECT_EQ(webrtc::kVideoCodecVP8,
700 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
701
702 channel.reset();
703 // Make sure DestroyVideoEncoder was called on the factory.
704 EXPECT_EQ(0u, encoder_factory.encoders().size());
705}
706
707TEST_F(WebRtcVideoEngine2Test,
708 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
709 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
710 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
711 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
712
713 std::vector<cricket::VideoCodec> codecs;
714 codecs.push_back(kH264Codec);
715
kwiberg686a8ef2016-02-26 03:00:35 -0800716 std::unique_ptr<VideoMediaChannel> channel(
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000717 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
718
719 EXPECT_TRUE(
720 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
721 ASSERT_EQ(1u, encoder_factory.encoders().size());
pbos14fe7082016-04-20 06:35:56 -0700722 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000723 EXPECT_EQ(webrtc::kVideoCodecH264,
724 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
725
726 channel.reset();
727 // Make sure DestroyVideoEncoder was called on the factory.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000728 ASSERT_EQ(0u, encoder_factory.encoders().size());
729}
730
noahricfdac5162015-08-27 01:59:29 -0700731TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) {
732 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
733 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
734 std::vector<cricket::VideoCodec> codecs;
735 codecs.push_back(kH264Codec);
736
kwiberg686a8ef2016-02-26 03:00:35 -0800737 std::unique_ptr<VideoMediaChannel> channel(
noahricfdac5162015-08-27 01:59:29 -0700738 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
739
Peter Boström0c4e06b2015-10-07 12:23:21 +0200740 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
noahricfdac5162015-08-27 01:59:29 -0700741 EXPECT_TRUE(
742 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
Peter Boströmce23bee2016-02-02 14:14:30 +0100743
744 // Send a frame of 720p. This should trigger a "real" encoder initialization.
noahricfdac5162015-08-27 01:59:29 -0700745 cricket::VideoFormat format(
746 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
Peter Boströmce23bee2016-02-02 14:14:30 +0100747 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -0700748 channel->SetSource(ssrcs[0], &capturer);
Peter Boströmce23bee2016-02-02 14:14:30 +0100749 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
750 EXPECT_TRUE(capturer.CaptureFrame());
751
noahricfdac5162015-08-27 01:59:29 -0700752 ASSERT_EQ(1u, encoder_factory.encoders().size());
753 FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0];
pbos14fe7082016-04-20 06:35:56 -0700754 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
noahricfdac5162015-08-27 01:59:29 -0700755 EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
756 EXPECT_EQ(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
nisse2ded9b12016-04-08 02:23:55 -0700757 channel->SetSource(ssrcs[0], nullptr);
noahricfdac5162015-08-27 01:59:29 -0700758}
759
hbosbab934b2016-01-27 01:36:03 -0800760// Test that external codecs are added to the end of the supported codec list.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000761TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) {
762 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
hbosbab934b2016-01-27 01:36:03 -0800763 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecUnknown,
764 "FakeExternalCodec");
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000765 engine_.SetExternalEncoderFactory(&encoder_factory);
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200766 engine_.Init();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000767
768 std::vector<cricket::VideoCodec> codecs(engine_.codecs());
769 ASSERT_GE(codecs.size(), 2u);
770 cricket::VideoCodec internal_codec = codecs.front();
771 cricket::VideoCodec external_codec = codecs.back();
772
773 // The external codec will appear at last.
774 EXPECT_EQ("VP8", internal_codec.name);
hbosbab934b2016-01-27 01:36:03 -0800775 EXPECT_EQ("FakeExternalCodec", external_codec.name);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000776}
777
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000778TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
779 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
780 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200781 cricket::VideoRecvParameters parameters;
782 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000783
kwiberg686a8ef2016-02-26 03:00:35 -0800784 std::unique_ptr<VideoMediaChannel> channel(
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200785 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000786
787 EXPECT_TRUE(
788 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
789 ASSERT_EQ(1u, decoder_factory.decoders().size());
790
791 // Setting codecs of the same type should not reallocate the decoder.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200792 EXPECT_TRUE(channel->SetRecvParameters(parameters));
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000793 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
794
795 // Remove stream previously added to free the external decoder instance.
796 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
797 EXPECT_EQ(0u, decoder_factory.decoders().size());
798}
799
800// Verifies that we can set up decoders that are not internally supported.
801TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
802 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
803 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
804 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
805 // codecs.
806 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
807 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
808 engine_.SetExternalEncoderFactory(&encoder_factory);
809 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
810 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
811 std::vector<cricket::VideoCodec> codecs;
812 codecs.push_back(kH264Codec);
813
kwiberg686a8ef2016-02-26 03:00:35 -0800814 std::unique_ptr<VideoMediaChannel> channel(
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000815 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
816
817 EXPECT_TRUE(
818 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
819 ASSERT_EQ(1u, decoder_factory.decoders().size());
820}
821
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000822class WebRtcVideoChannel2BaseTest
823 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
824 protected:
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000825 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000826
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000827 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000828};
829
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000830#define WEBRTC_BASE_TEST(test) \
831 TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); }
832
833#define WEBRTC_DISABLED_BASE_TEST(test) \
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000834 TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); }
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000835
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000836WEBRTC_BASE_TEST(SetSend);
837WEBRTC_BASE_TEST(SetSendWithoutCodecs);
838WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000839
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000840WEBRTC_BASE_TEST(GetStats);
841WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams);
842WEBRTC_BASE_TEST(GetStatsMultipleSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000843
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000844WEBRTC_BASE_TEST(SetSendBandwidth);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000845
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000846WEBRTC_BASE_TEST(SetSendSsrc);
847WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000848
nisse08582ff2016-02-04 01:24:52 -0800849WEBRTC_BASE_TEST(SetSink);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000850
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000851WEBRTC_BASE_TEST(AddRemoveSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000852
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000853WEBRTC_BASE_TEST(SimulateConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000854
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000855WEBRTC_BASE_TEST(AddRemoveCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000856
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000857WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000858
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000859WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000860
861// TODO(pbos): Figure out why this fails so often.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000862WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000863
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000864WEBRTC_BASE_TEST(RejectEmptyStreamParams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000865
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000866WEBRTC_BASE_TEST(AdaptResolution16x10);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000867
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000868WEBRTC_BASE_TEST(AdaptResolution4x3);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000869
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000870// TODO(juberti): Restore this test once we support sending 0 fps.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000871WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000872// TODO(juberti): Understand why we get decode errors on this test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000873WEBRTC_DISABLED_BASE_TEST(AdaptFramerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000874
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +0000875WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames);
876
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +0000877WEBRTC_BASE_TEST(MultipleSendStreams);
878
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000879TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
deadbeef67cf2c12016-04-13 10:07:16 -0700880 SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000881}
882
883TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
deadbeef67cf2c12016-04-13 10:07:16 -0700884 SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000885}
886
887TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
deadbeef67cf2c12016-04-13 10:07:16 -0700888 SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30));
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000889}
890
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000891TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
Peter Boströmd1f584b2016-04-20 16:31:53 +0200892 // Set a high bitrate to not be downscaled by VP8 due to low initial start
893 // bitrates. This currently happens at <250k, and two streams sharing 300k
894 // initially will use QVGA instead of VGA.
895 // TODO(pbos): Set up the quality scaler so that both senders reliably start
896 // at QVGA, then verify that instead.
897 cricket::VideoCodec codec = kVp8Codec;
898 codec.params[kCodecParamStartBitrate] = "1000000";
899 Base::TwoStreamsSendAndReceive(codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000900}
901
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200902class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000903 public:
stefanc1aeaf02015-10-15 07:26:07 -0700904 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {}
905 explicit WebRtcVideoChannel2Test(const char* field_trials)
906 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000907 void SetUp() override {
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200908 fake_call_.reset(new FakeCall(webrtc::Call::Config()));
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200909 engine_.Init();
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200910 channel_.reset(
nisse51542be2016-02-12 02:27:06 -0800911 engine_.CreateChannel(fake_call_.get(), MediaConfig(), VideoOptions()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000912 last_ssrc_ = 123;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200913 send_parameters_.codecs = engine_.codecs();
914 recv_parameters_.codecs = engine_.codecs();
915 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000916 }
917
918 protected:
919 FakeVideoSendStream* AddSendStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000920 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000921 }
922
923 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000924 size_t num_streams = fake_call_->GetVideoSendStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000925 EXPECT_TRUE(channel_->AddSendStream(sp));
926 std::vector<FakeVideoSendStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000927 fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000928 EXPECT_EQ(num_streams + 1, streams.size());
929 return streams[streams.size() - 1];
930 }
931
932 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000933 return fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000934 }
935
936 FakeVideoReceiveStream* AddRecvStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000937 return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000938 }
939
940 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000941 size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000942 EXPECT_TRUE(channel_->AddRecvStream(sp));
943 std::vector<FakeVideoReceiveStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000944 fake_call_->GetVideoReceiveStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000945 EXPECT_EQ(num_streams + 1, streams.size());
946 return streams[streams.size() - 1];
947 }
948
pbos@webrtc.org00873182014-11-25 14:03:34 +0000949 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
950 int expected_min_bitrate_bps,
951 const char* start_bitrate_kbps,
952 int expected_start_bitrate_bps,
953 const char* max_bitrate_kbps,
954 int expected_max_bitrate_bps) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200955 auto& codecs = send_parameters_.codecs;
956 codecs.clear();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000957 codecs.push_back(kVp8Codec);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000958 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
959 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
960 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200961 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000962
pbos@webrtc.org00873182014-11-25 14:03:34 +0000963 EXPECT_EQ(expected_min_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100964 fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000965 EXPECT_EQ(expected_start_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100966 fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000967 EXPECT_EQ(expected_max_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +0100968 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000969 }
970
isheriff6f8d6862016-05-26 11:24:55 -0700971 void TestSetSendRtpHeaderExtensions(const std::string& ext_uri) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000972 // Enable extension.
973 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200974 cricket::VideoSendParameters parameters = send_parameters_;
isheriff6f8d6862016-05-26 11:24:55 -0700975 parameters.extensions.push_back(RtpExtension(ext_uri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200976 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000977 FakeVideoSendStream* send_stream =
978 AddSendStream(cricket::StreamParams::CreateLegacy(123));
979
980 // Verify the send extension id.
981 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
982 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -0700983 EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000984 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200985 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000986 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
987 // receivers.
988 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
989 ->GetConfig()
990 .rtp.extensions.empty());
991
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000992 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200993 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200994 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
995 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000996 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
997
998 // Verify that adding receive RTP header extensions adds them for existing
999 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001000 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001001 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001002 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1003 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07001004 EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001005 }
1006
isheriff6f8d6862016-05-26 11:24:55 -07001007 void TestSetRecvRtpHeaderExtensions(const std::string& ext_uri) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001008 // Enable extension.
1009 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001010 cricket::VideoRecvParameters parameters = recv_parameters_;
isheriff6f8d6862016-05-26 11:24:55 -07001011 parameters.extensions.push_back(RtpExtension(ext_uri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001012 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001013
1014 FakeVideoReceiveStream* recv_stream =
1015 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1016
1017 // Verify the recv extension id.
1018 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1019 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07001020 EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001021 // Verify call with same set of extensions returns true.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001022 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001023
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001024 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
1025 // senders.
1026 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
1027 ->GetConfig()
1028 .rtp.extensions.empty());
1029
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001030 // Verify that existing RTP header extensions can be removed.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001031 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001032 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
1033 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001034 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
1035
1036 // Verify that adding receive RTP header extensions adds them for existing
1037 // streams.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001038 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001039 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001040 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1041 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
isheriff6f8d6862016-05-26 11:24:55 -07001042 EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001043 }
1044
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001045 void TestExtensionFilter(const std::vector<std::string>& extensions,
1046 const std::string& expected_extension) {
1047 cricket::VideoSendParameters parameters = send_parameters_;
1048 int expected_id = -1;
1049 int id = 1;
1050 for (const std::string& extension : extensions) {
1051 if (extension == expected_extension)
1052 expected_id = id;
isheriff6f8d6862016-05-26 11:24:55 -07001053 parameters.extensions.push_back(RtpExtension(extension, id++));
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001054 }
1055 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1056 FakeVideoSendStream* send_stream =
1057 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1058
1059 // Verify that only one of them has been set, and that it is the one with
1060 // highest priority (transport sequence number).
1061 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1062 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
1063 EXPECT_EQ(expected_extension,
isheriff6f8d6862016-05-26 11:24:55 -07001064 send_stream->GetConfig().rtp.extensions[0].uri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001065 }
1066
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02001067 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
Peter Boström3548dd22015-05-22 18:48:36 +02001068 void TestReceiverLocalSsrcConfiguration(bool receiver_first);
noahricd10a68e2015-07-10 11:27:55 -07001069 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
1070 bool expect_created_receive_stream);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001071
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001072 FakeVideoSendStream* SetDenoisingOption(
nisse05103312016-03-16 02:22:50 -07001073 uint32_t ssrc,
nisse0db023a2016-03-01 04:29:59 -08001074 cricket::FakeVideoCapturer* capturer,
1075 bool enabled) {
nisse05103312016-03-16 02:22:50 -07001076 cricket::VideoOptions options;
1077 options.video_noise_reduction = rtc::Optional<bool>(enabled);
1078 channel_->SetVideoSend(ssrc, true, &options);
nisse0db023a2016-03-01 04:29:59 -08001079 // Options only take effect on the next frame.
1080 EXPECT_TRUE(capturer->CaptureFrame());
1081
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001082 return fake_call_->GetVideoSendStreams().back();
1083 }
1084
Peter Boström2feafdb2015-09-09 14:32:14 +02001085 FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
1086 const int kRtxSsrcOffset = 0xDEADBEEF;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001087 last_ssrc_ += 3;
Peter Boström2feafdb2015-09-09 14:32:14 +02001088 std::vector<uint32_t> ssrcs;
1089 std::vector<uint32_t> rtx_ssrcs;
1090 uint32_t num_streams = enabled ? 3 : 1;
1091 for (uint32_t i = 0; i < num_streams; ++i) {
1092 uint32_t ssrc = last_ssrc_ + i;
1093 ssrcs.push_back(ssrc);
1094 if (with_rtx) {
1095 rtx_ssrcs.push_back(ssrc + kRtxSsrcOffset);
1096 }
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001097 }
Peter Boström2feafdb2015-09-09 14:32:14 +02001098 if (with_rtx) {
1099 return AddSendStream(
1100 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1101 }
1102 return AddSendStream(CreateSimStreamParams("cname", ssrcs));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001103 }
1104
skvladdc1c62c2016-03-16 19:07:43 -07001105 int GetMaxEncoderBitrate(cricket::FakeVideoCapturer& capturer) {
1106 EXPECT_TRUE(capturer.CaptureFrame());
1107
1108 std::vector<FakeVideoSendStream*> streams =
1109 fake_call_->GetVideoSendStreams();
1110 EXPECT_TRUE(streams.size() > 0);
1111 FakeVideoSendStream* stream = streams[streams.size() - 1];
1112
1113 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig();
1114 EXPECT_EQ(1, encoder_config.streams.size());
1115 return encoder_config.streams[0].max_bitrate_bps;
1116 }
1117
1118 void SetAndExpectMaxBitrate(cricket::FakeVideoCapturer& capturer,
1119 int global_max,
1120 int stream_max,
1121 int expected_encoder_bitrate) {
1122 VideoSendParameters limited_send_params = send_parameters_;
1123 limited_send_params.max_bandwidth_bps = global_max;
1124 EXPECT_TRUE(channel_->SetSendParameters(limited_send_params));
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001125 webrtc::RtpParameters parameters =
1126 channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07001127 EXPECT_EQ(1UL, parameters.encodings.size());
1128 parameters.encodings[0].max_bitrate_bps = stream_max;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001129 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07001130 // Read back the parameteres and verify they have the correct value
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001131 parameters = channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07001132 EXPECT_EQ(1UL, parameters.encodings.size());
1133 EXPECT_EQ(stream_max, parameters.encodings[0].max_bitrate_bps);
1134 // Verify that the new value propagated down to the encoder
1135 EXPECT_EQ(expected_encoder_bitrate, GetMaxEncoderBitrate(capturer));
1136 }
1137
kwiberg686a8ef2016-02-26 03:00:35 -08001138 std::unique_ptr<FakeCall> fake_call_;
1139 std::unique_ptr<VideoMediaChannel> channel_;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001140 cricket::VideoSendParameters send_parameters_;
1141 cricket::VideoRecvParameters recv_parameters_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001142 uint32_t last_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001143};
1144
pbos8fc7fa72015-07-15 08:02:58 -07001145TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001146 const uint32_t kVideoSsrc = 123;
pbos8fc7fa72015-07-15 08:02:58 -07001147 const std::string kSyncLabel = "AvSyncLabel";
1148
1149 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
1150 sp.sync_label = kSyncLabel;
1151 EXPECT_TRUE(channel_->AddRecvStream(sp));
1152
1153 EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size());
1154 EXPECT_EQ(kSyncLabel,
1155 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
1156 << "SyncGroup should be set based on sync_label";
1157}
1158
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001159TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001160 cricket::VideoSendParameters parameters;
1161 parameters.codecs = engine_.codecs();
1162 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001163 EXPECT_TRUE(channel_->SetSend(true));
nisse4b4dc862016-02-17 05:25:36 -08001164 parameters.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001165 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001166
1167 // Send side.
Peter Boström0c4e06b2015-10-07 12:23:21 +02001168 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
1169 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001170 FakeVideoSendStream* send_stream = AddSendStream(
1171 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1172
1173 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
1174 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
1175 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
1176
1177 // Receiver side.
1178 FakeVideoReceiveStream* recv_stream = AddRecvStream(
1179 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
Peter Boströmd8b01092016-05-12 16:44:36 +02001180 EXPECT_FALSE(recv_stream->GetConfig().rtp.rtx.empty());
1181 EXPECT_EQ(recv_stream->GetConfig().decoders.size(),
1182 recv_stream->GetConfig().rtp.rtx.size())
1183 << "RTX should be mapped for all decoders/payload types.";
1184 for (const auto& kv : recv_stream->GetConfig().rtp.rtx) {
1185 EXPECT_EQ(rtx_ssrcs[0], kv.second.ssrc);
1186 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001187}
1188
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001189TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
1190 // Setup one channel with an associated RTX stream.
1191 cricket::StreamParams params =
1192 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1193 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
1194 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001195 EXPECT_EQ(kRtxSsrcs1[0],
1196 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001197}
1198
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001199TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
1200 // Setup one channel without an associated RTX stream.
1201 cricket::StreamParams params =
1202 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1203 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1204 ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001205}
1206
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001207TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
1208 FakeVideoSendStream* send_stream =
1209 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1210 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1211
1212 FakeVideoReceiveStream* recv_stream =
1213 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1214 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001215}
1216
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001217// Test support for RTP timestamp offset header extension.
1218TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001219 TestSetSendRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001220}
isheriff6f8d6862016-05-26 11:24:55 -07001221
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001222TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001223 TestSetRecvRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001224}
1225
1226// Test support for absolute send time header extension.
1227TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001228 TestSetSendRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001229}
isheriff6f8d6862016-05-26 11:24:55 -07001230
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001231TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001232 TestSetRecvRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001233}
1234
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001235TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksTransportSeqNum) {
1236 // Enable three redundant extensions.
1237 std::vector<std::string> extensions;
isheriff6f8d6862016-05-26 11:24:55 -07001238 extensions.push_back(RtpExtension::kAbsSendTimeUri);
1239 extensions.push_back(RtpExtension::kTimestampOffsetUri);
1240 extensions.push_back(RtpExtension::kTransportSequenceNumberUri);
1241 TestExtensionFilter(extensions, RtpExtension::kTransportSequenceNumberUri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001242}
1243
1244TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksAbsSendTime) {
1245 // Enable two redundant extensions.
1246 std::vector<std::string> extensions;
isheriff6f8d6862016-05-26 11:24:55 -07001247 extensions.push_back(RtpExtension::kAbsSendTimeUri);
1248 extensions.push_back(RtpExtension::kTimestampOffsetUri);
1249 TestExtensionFilter(extensions, RtpExtension::kAbsSendTimeUri);
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001250}
1251
stefanc1aeaf02015-10-15 07:26:07 -07001252class WebRtcVideoChannel2WithSendSideBweTest : public WebRtcVideoChannel2Test {
1253 public:
1254 WebRtcVideoChannel2WithSendSideBweTest()
1255 : WebRtcVideoChannel2Test("WebRTC-SendSideBwe/Enabled/") {}
1256};
1257
1258// Test support for transport sequence number header extension.
1259TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
1260 SendTransportSequenceNumberHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001261 TestSetSendRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
stefanc1aeaf02015-10-15 07:26:07 -07001262}
1263TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
1264 RecvTransportSequenceNumberHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001265 TestSetRecvRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
stefanc1aeaf02015-10-15 07:26:07 -07001266}
1267
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001268// Test support for video rotation header extension.
1269TEST_F(WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001270 TestSetSendRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001271}
1272TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07001273 TestSetRecvRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001274}
1275
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001276TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001277 const int kAbsSendTimeId = 1;
1278 const int kVideoRotationId = 2;
isheriff6f8d6862016-05-26 11:24:55 -07001279 send_parameters_.extensions.push_back(
1280 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
1281 send_parameters_.extensions.push_back(
1282 RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001283
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001284 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001285 FakeVideoSendStream* send_stream =
1286 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1287
1288 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
Stefan Holmerbbaf3632015-10-29 18:53:23 +01001289 ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001290
1291 // Setting the same extensions (even if in different order) shouldn't
1292 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001293 std::reverse(send_parameters_.extensions.begin(),
1294 send_parameters_.extensions.end());
1295 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001296
1297 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1298
1299 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001300 send_parameters_.extensions.resize(1);
1301 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001302
1303 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
1304}
1305
1306TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
1307 const int kTOffsetId = 1;
1308 const int kAbsSendTimeId = 2;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001309 const int kVideoRotationId = 3;
isheriff6f8d6862016-05-26 11:24:55 -07001310 recv_parameters_.extensions.push_back(
1311 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
1312 recv_parameters_.extensions.push_back(
1313 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
1314 recv_parameters_.extensions.push_back(
1315 RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001316
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001317 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
Peter Boström54be3e02015-05-25 15:04:24 +02001318 FakeVideoReceiveStream* recv_stream =
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001319 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1320
1321 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
Peter Boström54be3e02015-05-25 15:04:24 +02001322 ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001323
1324 // Setting the same extensions (even if in different order) shouldn't
1325 // reallocate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001326 std::reverse(recv_parameters_.extensions.begin(),
1327 recv_parameters_.extensions.end());
1328 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001329
1330 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
1331
1332 // Setting different extensions should recreate the stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001333 recv_parameters_.extensions.resize(1);
1334 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001335
1336 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
1337}
1338
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001339TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001340 SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001341 const int kUnsupportedId = 1;
1342 const int kTOffsetId = 2;
1343
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001344 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001345 RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001346 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001347 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001348 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001349 FakeVideoSendStream* send_stream =
1350 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1351
1352 // Only timestamp offset extension is set to send stream,
1353 // unsupported rtp extension is ignored.
1354 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -07001355 EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
1356 send_stream->GetConfig().rtp.extensions[0].uri.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001357}
1358
1359TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001360 SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001361 const int kUnsupportedId = 1;
1362 const int kTOffsetId = 2;
1363
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001364 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001365 RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001366 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001367 RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001368 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001369 FakeVideoReceiveStream* recv_stream =
1370 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1371
1372 // Only timestamp offset extension is set to receive stream,
1373 // unsupported rtp extension is ignored.
1374 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -07001375 EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
1376 recv_stream->GetConfig().rtp.extensions[0].uri.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001377}
1378
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001379TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001380 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001381 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
isheriff6f8d6862016-05-26 11:24:55 -07001382 send_parameters_.extensions.push_back(
1383 RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001384 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001385 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1386 }
1387}
1388
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001389TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001390 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001391 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
isheriff6f8d6862016-05-26 11:24:55 -07001392 recv_parameters_.extensions.push_back(
1393 RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001394 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_))
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001395 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1396 }
1397}
1398
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001399TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001400 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001401 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001402 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001403 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001404 RtpExtension(RtpExtension::kAbsSendTimeUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001405 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001406
1407 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001408 send_parameters_.extensions.clear();
1409 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001410 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001411 send_parameters_.extensions.push_back(send_parameters_.extensions.back());
1412 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001413}
1414
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001415TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001416 const int id = 1;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001417 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001418 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001419 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001420 RtpExtension(RtpExtension::kAbsSendTimeUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001421 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001422
1423 // Duplicate entries are also not supported.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001424 recv_parameters_.extensions.clear();
1425 recv_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07001426 RtpExtension(RtpExtension::kTimestampOffsetUri, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001427 recv_parameters_.extensions.push_back(recv_parameters_.extensions.back());
1428 EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001429}
1430
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001431TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
1432 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001433 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001434}
1435
Peter Boströmd7da1202015-06-05 14:09:38 +02001436TEST_F(WebRtcVideoChannel2Test, RtcpIsCompoundByDefault) {
1437 FakeVideoReceiveStream* stream = AddRecvStream();
pbosda903ea2015-10-02 02:36:56 -07001438 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
Peter Boströmd7da1202015-06-05 14:09:38 +02001439}
1440
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001441TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
1442 FakeVideoReceiveStream* stream = AddRecvStream();
1443 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001444}
1445
stefan43edf0f2015-11-20 18:05:48 -08001446TEST_F(WebRtcVideoChannel2Test, TransportCcIsEnabledByDefault) {
1447 FakeVideoReceiveStream* stream = AddRecvStream();
1448 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1449}
1450
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001451TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1452 FakeVideoReceiveStream* stream = AddRecvStream();
1453 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1454
Peter Boström126c03e2015-05-11 12:48:12 +02001455 // Verify that REMB is turned off when send(!) codecs without REMB are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001456 cricket::VideoSendParameters parameters;
1457 parameters.codecs.push_back(kVp8Codec);
1458 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1459 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001460 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001461 EXPECT_FALSE(stream->GetConfig().rtp.remb);
1462
1463 // Verify that REMB is turned on when setting default codecs since the
1464 // default codecs have REMB enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001465 parameters.codecs = engine_.codecs();
1466 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001467 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001468 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001469}
1470
stefan43edf0f2015-11-20 18:05:48 -08001471TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) {
1472 FakeVideoReceiveStream* stream = AddRecvStream();
1473 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1474
1475 // Verify that transport cc feedback is turned off when send(!) codecs without
1476 // transport cc feedback are set.
1477 cricket::VideoSendParameters parameters;
1478 parameters.codecs.push_back(kVp8Codec);
1479 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1480 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1481 stream = fake_call_->GetVideoReceiveStreams()[0];
1482 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc);
1483
1484 // Verify that transport cc feedback is turned on when setting default codecs
1485 // since the default codecs have transport cc feedback enabled.
1486 parameters.codecs = engine_.codecs();
1487 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1488 stream = fake_call_->GetVideoReceiveStreams()[0];
1489 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1490}
1491
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001492TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
1493 VerifyCodecHasDefaultFeedbackParams(default_codec_);
1494
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001495 cricket::VideoSendParameters parameters;
1496 parameters.codecs = engine_.codecs();
1497 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org19864742014-05-30 07:35:47 +00001498 EXPECT_TRUE(channel_->SetSend(true));
1499
1500 // Send side.
1501 FakeVideoSendStream* send_stream =
1502 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1503 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1504
1505 // Receiver side.
1506 FakeVideoReceiveStream* recv_stream =
1507 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1508 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1509
1510 // Nack history size should match between sender and receiver.
1511 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
1512 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001513}
1514
Peter Boström67c9df72015-05-11 14:34:58 +02001515TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
Peter Boström67c9df72015-05-11 14:34:58 +02001516 FakeVideoSendStream* send_stream = AddSendStream();
Peter Boström3548dd22015-05-22 18:48:36 +02001517 FakeVideoReceiveStream* recv_stream = AddRecvStream();
Peter Boström67c9df72015-05-11 14:34:58 +02001518
1519 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1520 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1521
1522 // Verify that NACK is turned off when send(!) codecs without NACK are set.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001523 cricket::VideoSendParameters parameters;
1524 parameters.codecs.push_back(kVp8Codec);
1525 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1526 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001527 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1528 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1529 send_stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001530 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1531
Peter Boström67c9df72015-05-11 14:34:58 +02001532 // Verify that NACK is turned on when setting default codecs since the
1533 // default codecs have NACK enabled.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001534 parameters.codecs = engine_.codecs();
1535 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström67c9df72015-05-11 14:34:58 +02001536 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1537 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1538 send_stream = fake_call_->GetVideoSendStreams()[0];
1539 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001540}
1541
Peter Boströme7ba0862016-03-12 00:02:28 +01001542// This test verifies that new frame sizes reconfigures encoders even though not
1543// (yet) sending. The purpose of this is to permit encoding as quickly as
1544// possible once we start sending. Likely the frames being input are from the
1545// same source that will be sent later, which just means that we're ready
1546// earlier.
1547TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) {
1548 cricket::VideoSendParameters parameters;
1549 parameters.codecs.push_back(kVp8Codec720p);
1550 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1551 channel_->SetSend(false);
1552
1553 FakeVideoSendStream* stream = AddSendStream();
1554
1555 // No frames entered, using default dimensions.
1556 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
1557 EXPECT_EQ(176u, streams[0].width);
1558 EXPECT_EQ(144u, streams[0].height);
1559
1560 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07001561 channel_->SetSource(last_ssrc_, &capturer);
Peter Boströme7ba0862016-03-12 00:02:28 +01001562 EXPECT_EQ(cricket::CS_RUNNING,
1563 capturer.Start(capturer.GetSupportedFormats()->front()));
1564 EXPECT_TRUE(capturer.CaptureFrame());
1565
1566 // Frame entered, should be reconfigured to new dimensions.
1567 streams = stream->GetVideoStreams();
1568 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
1569 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
1570 // No frames should have been actually put in there though.
1571 EXPECT_EQ(0, stream->GetNumberOfSwappedFrames());
1572
nisse2ded9b12016-04-08 02:23:55 -07001573 channel_->SetSource(last_ssrc_, NULL);
Peter Boströme7ba0862016-03-12 00:02:28 +01001574}
1575
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001576TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1577 static const int kScreenshareMinBitrateKbps = 800;
1578 cricket::VideoCodec codec = kVp8Codec360p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001579 cricket::VideoSendParameters parameters;
1580 parameters.codecs.push_back(codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001581 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001582 AddSendStream();
1583
nisse05103312016-03-16 02:22:50 -07001584 VideoOptions min_bitrate_options;
1585 min_bitrate_options.screencast_min_bitrate_kbps =
1586 rtc::Optional<int>(kScreenshareMinBitrateKbps);
1587 channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options);
1588
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001589 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07001590 channel_->SetSource(last_ssrc_, &capturer);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001591 cricket::VideoFormat capture_format_hd =
1592 capturer.GetSupportedFormats()->front();
1593 EXPECT_EQ(1280, capture_format_hd.width);
1594 EXPECT_EQ(720, capture_format_hd.height);
1595 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1596
1597 EXPECT_TRUE(channel_->SetSend(true));
1598
1599 EXPECT_TRUE(capturer.CaptureFrame());
1600 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1601 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1602
1603 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1604
1605 // Verify non-screencast settings.
1606 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001607 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001608 encoder_config.content_type);
1609 EXPECT_EQ(codec.width, encoder_config.streams.front().width);
1610 EXPECT_EQ(codec.height, encoder_config.streams.front().height);
1611 EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
1612 << "Non-screenshare shouldn't use min-transmit bitrate.";
1613
nisse2ded9b12016-04-08 02:23:55 -07001614 channel_->SetSource(last_ssrc_, nullptr);
perkj2d5f0912016-02-29 00:04:41 -08001615 // Removing a capturer triggers a black frame to be sent.
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001616 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
nisse2ded9b12016-04-08 02:23:55 -07001617 channel_->SetSource(last_ssrc_, &capturer);
nisse05103312016-03-16 02:22:50 -07001618 VideoOptions screencast_options;
1619 screencast_options.is_screencast = rtc::Optional<bool>(true);
1620 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &screencast_options));
perkj2d5f0912016-02-29 00:04:41 -08001621 EXPECT_TRUE(capturer.CaptureFrame());
Niels Möller60653ba2016-03-02 11:41:36 +01001622 // Send stream not recreated after option change.
1623 ASSERT_EQ(send_stream, fake_call_->GetVideoSendStreams().front());
perkj2d5f0912016-02-29 00:04:41 -08001624 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001625
1626 // Verify screencast settings.
1627 encoder_config = send_stream->GetEncoderConfig();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001628 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001629 encoder_config.content_type);
1630 EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
1631 encoder_config.min_transmit_bitrate_bps);
1632
1633 EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width);
1634 EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001635 EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
1636
nisse2ded9b12016-04-08 02:23:55 -07001637 channel_->SetSource(last_ssrc_, NULL);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001638}
1639
Niels Möller60653ba2016-03-02 11:41:36 +01001640TEST_F(WebRtcVideoChannel2Test, NoRecreateStreamForScreencast) {
1641 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
1642 ASSERT_TRUE(
1643 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
1644 EXPECT_TRUE(channel_->SetSend(true));
1645
1646 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07001647 channel_->SetSource(kSsrc, &capturer);
Niels Möller60653ba2016-03-02 11:41:36 +01001648 EXPECT_EQ(cricket::CS_RUNNING,
1649 capturer.Start(capturer.GetSupportedFormats()->front()));
1650 EXPECT_TRUE(capturer.CaptureFrame());
1651
1652 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1653 FakeVideoSendStream* stream = fake_call_->GetVideoSendStreams().front();
1654 webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig();
1655 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
1656 encoder_config.content_type);
1657
1658 EXPECT_EQ(1, stream->GetNumberOfSwappedFrames());
1659
1660 /* Switch to screencast source. We expect a reconfigure of the
1661 * encoder, but no change of the send stream. */
1662 struct VideoOptions video_options;
1663 video_options.is_screencast = rtc::Optional<bool>(true);
1664 channel_->SetVideoSend(kSsrc, true, &video_options);
1665
1666 EXPECT_TRUE(capturer.CaptureFrame());
1667 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1668 ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front());
1669 EXPECT_EQ(2, stream->GetNumberOfSwappedFrames());
1670
1671 encoder_config = stream->GetEncoderConfig();
1672 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
1673 encoder_config.content_type);
1674
1675 /* Switch back. */
1676 video_options.is_screencast = rtc::Optional<bool>(false);
1677 channel_->SetVideoSend(kSsrc, true, &video_options);
1678
1679 EXPECT_TRUE(capturer.CaptureFrame());
1680 ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1681 ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front());
1682 EXPECT_EQ(3, stream->GetNumberOfSwappedFrames());
1683
1684 encoder_config = stream->GetEncoderConfig();
1685 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
1686 encoder_config.content_type);
1687
nisse2ded9b12016-04-08 02:23:55 -07001688 channel_->SetSource(kSsrc, NULL);
Niels Möller60653ba2016-03-02 11:41:36 +01001689}
1690
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001691TEST_F(WebRtcVideoChannel2Test,
1692 ConferenceModeScreencastConfiguresTemporalLayer) {
Erik SprĂ¥ng2c4c9142015-06-24 11:24:44 +02001693 static const int kConferenceScreencastTemporalBitrateBps =
1694 ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
nisse4b4dc862016-02-17 05:25:36 -08001695 send_parameters_.conference_mode = true;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001696 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001697
1698 AddSendStream();
nisse05103312016-03-16 02:22:50 -07001699 VideoOptions options;
1700 options.is_screencast = rtc::Optional<bool>(true);
1701 channel_->SetVideoSend(last_ssrc_, true, &options);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001702 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07001703 channel_->SetSource(last_ssrc_, &capturer);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001704 cricket::VideoFormat capture_format_hd =
1705 capturer.GetSupportedFormats()->front();
1706 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1707
1708 EXPECT_TRUE(channel_->SetSend(true));
1709
1710 EXPECT_TRUE(capturer.CaptureFrame());
1711 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1712 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1713
1714 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1715
1716 // Verify screencast settings.
1717 encoder_config = send_stream->GetEncoderConfig();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001718 EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001719 encoder_config.content_type);
1720 ASSERT_EQ(1u, encoder_config.streams.size());
1721 ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size());
1722 EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
1723 encoder_config.streams[0].temporal_layer_thresholds_bps[0]);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001724
nisse2ded9b12016-04-08 02:23:55 -07001725 channel_->SetSource(last_ssrc_, NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001726}
1727
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001728TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
1729 FakeVideoSendStream* stream = AddSendStream();
1730 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1731}
1732
nisse0db023a2016-03-01 04:29:59 -08001733TEST_F(WebRtcVideoChannel2Test, SetMediaConfigSuspendBelowMinBitrate) {
1734 MediaConfig media_config = MediaConfig();
1735 media_config.video.suspend_below_min_bitrate = true;
1736
1737 channel_.reset(
1738 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1739
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001740 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001741
1742 FakeVideoSendStream* stream = AddSendStream();
1743 EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
1744
nisse0db023a2016-03-01 04:29:59 -08001745 media_config.video.suspend_below_min_bitrate = false;
1746 channel_.reset(
1747 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1748
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001749 channel_->SetSendParameters(send_parameters_);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001750
nisse0db023a2016-03-01 04:29:59 -08001751 stream = AddSendStream();
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001752 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1753}
1754
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001755TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1756 FakeVideoSendStream* stream = AddSendStream();
1757 webrtc::VideoCodecVP8 vp8_settings;
1758 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1759 EXPECT_TRUE(vp8_settings.denoisingOn);
1760}
1761
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001762TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001763 cricket::VideoSendParameters parameters;
1764 parameters.codecs.push_back(kVp8Codec720p);
1765 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001766
Peter Boström2feafdb2015-09-09 14:32:14 +02001767 // Single-stream settings should apply with RTX as well (verifies that we
1768 // check number of regular SSRCs and not StreamParams::ssrcs which contains
1769 // both RTX and regular SSRCs).
1770 FakeVideoSendStream* stream = SetUpSimulcast(false, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001771
1772 cricket::FakeVideoCapturer capturer;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001773 EXPECT_EQ(cricket::CS_RUNNING,
1774 capturer.Start(capturer.GetSupportedFormats()->front()));
nisse2ded9b12016-04-08 02:23:55 -07001775 channel_->SetSource(last_ssrc_, &capturer);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001776 channel_->SetSend(true);
1777
1778 EXPECT_TRUE(capturer.CaptureFrame());
1779
pbos4cba4eb2015-10-26 11:18:18 -07001780 webrtc::VideoCodecVP8 vp8_settings;
1781 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1782 EXPECT_TRUE(vp8_settings.denoisingOn)
1783 << "VP8 denoising should be on by default.";
1784
nisse05103312016-03-16 02:22:50 -07001785 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001786
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001787 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1788 EXPECT_FALSE(vp8_settings.denoisingOn);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001789 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1790 EXPECT_TRUE(vp8_settings.frameDroppingOn);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001791
nisse05103312016-03-16 02:22:50 -07001792 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001793
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001794 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1795 EXPECT_TRUE(vp8_settings.denoisingOn);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001796 EXPECT_TRUE(vp8_settings.automaticResizeOn);
1797 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1798
nisse2ded9b12016-04-08 02:23:55 -07001799 channel_->SetSource(last_ssrc_, NULL);
Peter Boström2feafdb2015-09-09 14:32:14 +02001800 stream = SetUpSimulcast(true, false);
nisse2ded9b12016-04-08 02:23:55 -07001801 channel_->SetSource(last_ssrc_, &capturer);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001802 channel_->SetSend(true);
1803 EXPECT_TRUE(capturer.CaptureFrame());
1804
1805 EXPECT_EQ(3, stream->GetVideoStreams().size());
1806 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1807 // Autmatic resize off when using simulcast.
1808 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1809 EXPECT_TRUE(vp8_settings.frameDroppingOn);
1810
1811 // In screen-share mode, denoising is forced off and simulcast disabled.
nisse05103312016-03-16 02:22:50 -07001812 VideoOptions options;
1813 options.is_screencast = rtc::Optional<bool>(true);
1814 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
Niels Möller60653ba2016-03-02 11:41:36 +01001815
nisse05103312016-03-16 02:22:50 -07001816 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001817
1818 EXPECT_EQ(1, stream->GetVideoStreams().size());
1819 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1820 EXPECT_FALSE(vp8_settings.denoisingOn);
1821 // Resizing and frame dropping always off for screen sharing.
1822 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1823 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1824
nisse05103312016-03-16 02:22:50 -07001825 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001826
1827 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1828 EXPECT_FALSE(vp8_settings.denoisingOn);
1829 EXPECT_FALSE(vp8_settings.automaticResizeOn);
1830 EXPECT_FALSE(vp8_settings.frameDroppingOn);
1831
nisse2ded9b12016-04-08 02:23:55 -07001832 channel_->SetSource(last_ssrc_, NULL);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001833}
1834
deadbeef119760a2016-04-04 11:43:27 -07001835// Test that setting the same options doesn't result in the encoder being
1836// reconfigured.
1837TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) {
1838 VideoOptions options;
1839 cricket::FakeVideoCapturer capturer;
1840
1841 FakeVideoSendStream* send_stream = AddSendStream();
nisse2ded9b12016-04-08 02:23:55 -07001842 channel_->SetSource(last_ssrc_, &capturer);
deadbeef119760a2016-04-04 11:43:27 -07001843 EXPECT_EQ(cricket::CS_RUNNING,
1844 capturer.Start(capturer.GetSupportedFormats()->front()));
1845 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
1846 EXPECT_TRUE(capturer.CaptureFrame());
1847 // Expect 2 reconfigurations at this point, from the initial configuration
1848 // and from the dimensions of the first frame.
1849 EXPECT_EQ(2, send_stream->num_encoder_reconfigurations());
1850
1851 // Set the options one more time and expect no additional reconfigurations.
1852 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
1853 EXPECT_TRUE(capturer.CaptureFrame());
1854 EXPECT_EQ(2, send_stream->num_encoder_reconfigurations());
1855
nisse2ded9b12016-04-08 02:23:55 -07001856 channel_->SetSource(last_ssrc_, nullptr);
deadbeef119760a2016-04-04 11:43:27 -07001857}
1858
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001859class Vp9SettingsTest : public WebRtcVideoChannel2Test {
1860 public:
asaperssonc5dabdd2016-03-21 04:15:50 -07001861 Vp9SettingsTest() : Vp9SettingsTest("") {}
1862 explicit Vp9SettingsTest(const char* field_trials)
1863 : WebRtcVideoChannel2Test(field_trials) {
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001864 encoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
1865 }
1866 virtual ~Vp9SettingsTest() {}
1867
1868 protected:
1869 void SetUp() override {
1870 engine_.SetExternalEncoderFactory(&encoder_factory_);
1871
1872 WebRtcVideoChannel2Test::SetUp();
1873 }
1874
1875 void TearDown() override {
1876 // Remove references to encoder_factory_ since this will be destroyed
1877 // before channel_ and engine_.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001878 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001879 }
1880
1881 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
1882};
1883
1884TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001885 cricket::VideoSendParameters parameters;
1886 parameters.codecs.push_back(kVp9Codec);
1887 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001888
Peter Boström2feafdb2015-09-09 14:32:14 +02001889 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001890
1891 cricket::FakeVideoCapturer capturer;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001892 EXPECT_EQ(cricket::CS_RUNNING,
1893 capturer.Start(capturer.GetSupportedFormats()->front()));
nisse2ded9b12016-04-08 02:23:55 -07001894 channel_->SetSource(last_ssrc_, &capturer);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001895 channel_->SetSend(true);
1896
1897 EXPECT_TRUE(capturer.CaptureFrame());
1898
pbos4cba4eb2015-10-26 11:18:18 -07001899 webrtc::VideoCodecVP9 vp9_settings;
1900 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1901 EXPECT_FALSE(vp9_settings.denoisingOn)
1902 << "VP9 denoising should be off by default.";
1903
nisse05103312016-03-16 02:22:50 -07001904 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001905
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001906 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1907 EXPECT_FALSE(vp9_settings.denoisingOn);
1908 // Frame dropping always on for real time video.
1909 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1910
nisse05103312016-03-16 02:22:50 -07001911 stream = SetDenoisingOption(last_ssrc_, &capturer, true);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001912
1913 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1914 EXPECT_TRUE(vp9_settings.denoisingOn);
1915 EXPECT_TRUE(vp9_settings.frameDroppingOn);
1916
1917 // In screen-share mode, denoising is forced off.
nisse05103312016-03-16 02:22:50 -07001918 VideoOptions options;
1919 options.is_screencast = rtc::Optional<bool>(true);
1920 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
perkj2d5f0912016-02-29 00:04:41 -08001921
nisse05103312016-03-16 02:22:50 -07001922 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001923
1924 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1925 EXPECT_FALSE(vp9_settings.denoisingOn);
1926 // Frame dropping always off for screen sharing.
1927 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1928
nisse05103312016-03-16 02:22:50 -07001929 stream = SetDenoisingOption(last_ssrc_, &capturer, false);
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001930
1931 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1932 EXPECT_FALSE(vp9_settings.denoisingOn);
1933 EXPECT_FALSE(vp9_settings.frameDroppingOn);
1934
nisse2ded9b12016-04-08 02:23:55 -07001935 channel_->SetSource(last_ssrc_, NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001936}
1937
asaperssonc5dabdd2016-03-21 04:15:50 -07001938class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest {
1939 public:
1940 Vp9SettingsTestWithFieldTrial(const char* field_trials)
1941 : Vp9SettingsTest(field_trials) {}
1942
1943 protected:
1944 void VerifySettings(int num_spatial_layers, int num_temporal_layers) {
1945 cricket::VideoSendParameters parameters;
1946 parameters.codecs.push_back(kVp9Codec);
1947 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1948
1949 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
1950
1951 cricket::FakeVideoCapturer capturer;
1952 EXPECT_EQ(cricket::CS_RUNNING,
1953 capturer.Start(capturer.GetSupportedFormats()->front()));
nisse2ded9b12016-04-08 02:23:55 -07001954 channel_->SetSource(last_ssrc_, &capturer);
asaperssonc5dabdd2016-03-21 04:15:50 -07001955 channel_->SetSend(true);
1956
1957 EXPECT_TRUE(capturer.CaptureFrame());
1958
1959 webrtc::VideoCodecVP9 vp9_settings;
1960 ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
1961 EXPECT_EQ(num_spatial_layers, vp9_settings.numberOfSpatialLayers);
1962 EXPECT_EQ(num_temporal_layers, vp9_settings.numberOfTemporalLayers);
1963
nisse2ded9b12016-04-08 02:23:55 -07001964 channel_->SetSource(last_ssrc_, NULL);
asaperssonc5dabdd2016-03-21 04:15:50 -07001965 }
1966};
1967
1968class Vp9SettingsTestWithNoFlag : public Vp9SettingsTestWithFieldTrial {
1969 public:
1970 Vp9SettingsTestWithNoFlag() : Vp9SettingsTestWithFieldTrial("") {}
1971};
1972
1973TEST_F(Vp9SettingsTestWithNoFlag, VerifySettings) {
1974 const int kNumSpatialLayers = 1;
1975 const int kNumTemporalLayers = 1;
1976 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1977}
1978
1979class Vp9SettingsTestWithInvalidFlag : public Vp9SettingsTestWithFieldTrial {
1980 public:
1981 Vp9SettingsTestWithInvalidFlag()
1982 : Vp9SettingsTestWithFieldTrial("WebRTC-SupportVP9SVC/Default/") {}
1983};
1984
1985TEST_F(Vp9SettingsTestWithInvalidFlag, VerifySettings) {
1986 const int kNumSpatialLayers = 1;
1987 const int kNumTemporalLayers = 1;
1988 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
1989}
1990
1991class Vp9SettingsTestWith2SL3TLFlag : public Vp9SettingsTestWithFieldTrial {
1992 public:
1993 Vp9SettingsTestWith2SL3TLFlag()
1994 : Vp9SettingsTestWithFieldTrial(
1995 "WebRTC-SupportVP9SVC/EnabledByFlag_2SL3TL/") {}
1996};
1997
1998TEST_F(Vp9SettingsTestWith2SL3TLFlag, VerifySettings) {
1999 const int kNumSpatialLayers = 2;
2000 const int kNumTemporalLayers = 3;
2001 VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
2002}
2003
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002004TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) {
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02002005 TestCpuAdaptation(true, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002006}
2007
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002008TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02002009 TestCpuAdaptation(false, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002010}
2011
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02002012TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
2013 TestCpuAdaptation(true, true);
2014}
2015
perkj2d5f0912016-02-29 00:04:41 -08002016TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) {
2017 cricket::VideoCodec codec = kVp8Codec720p;
2018 cricket::VideoSendParameters parameters;
2019 parameters.codecs.push_back(codec);
2020
2021 MediaConfig media_config = MediaConfig();
2022 channel_.reset(
2023 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2024 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2025
2026 AddSendStream();
2027
2028 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07002029 channel_->SetSource(last_ssrc_, &capturer);
perkj2d5f0912016-02-29 00:04:41 -08002030 ASSERT_EQ(cricket::CS_RUNNING,
2031 capturer.Start(capturer.GetSupportedFormats()->front()));
2032 ASSERT_TRUE(channel_->SetSend(true));
2033
2034 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2035 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
2036 webrtc::LoadObserver* overuse_callback =
2037 send_stream->GetConfig().overuse_callback;
2038 ASSERT_TRUE(overuse_callback != NULL);
2039
2040 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2041 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2042 EXPECT_EQ(1280, send_stream->GetLastWidth());
2043 EXPECT_EQ(720, send_stream->GetLastHeight());
2044
2045 // Trigger overuse.
2046 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2047 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2048 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
2049 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2050 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2051
2052 // Trigger overuse again.
2053 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2054 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2055 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
2056 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth());
2057 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight());
2058
Per766ad3b2016-04-05 15:23:49 +02002059 // Trigger overuse again. This should not decrease the resolution since we
2060 // should only adapt the resolution down max two steps.
2061 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2062 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2063 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
2064 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth());
2065 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight());
2066
perkj2d5f0912016-02-29 00:04:41 -08002067 // Change input resolution.
2068 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
Per766ad3b2016-04-05 15:23:49 +02002069 EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames());
perkj2d5f0912016-02-29 00:04:41 -08002070 EXPECT_EQ(1284 / 2, send_stream->GetLastWidth());
2071 EXPECT_EQ(724 / 2, send_stream->GetLastHeight());
2072
2073 // Trigger underuse which should go back up in resolution.
2074 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2075 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
Per766ad3b2016-04-05 15:23:49 +02002076 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames());
perkj2d5f0912016-02-29 00:04:41 -08002077 EXPECT_EQ(1284 * 3 / 4, send_stream->GetLastWidth());
2078 EXPECT_EQ(724 * 3 / 4, send_stream->GetLastHeight());
2079
2080 // Trigger underuse which should go back up in resolution.
2081 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2082 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
Per766ad3b2016-04-05 15:23:49 +02002083 EXPECT_EQ(7, send_stream->GetNumberOfSwappedFrames());
perkj2d5f0912016-02-29 00:04:41 -08002084 EXPECT_EQ(1284, send_stream->GetLastWidth());
2085 EXPECT_EQ(724, send_stream->GetLastHeight());
2086
nisse2ded9b12016-04-08 02:23:55 -07002087 channel_->SetSource(last_ssrc_, NULL);
perkj2d5f0912016-02-29 00:04:41 -08002088}
2089
Per766ad3b2016-04-05 15:23:49 +02002090TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) {
2091 cricket::VideoCodec codec = kVp8Codec720p;
2092 cricket::VideoSendParameters parameters;
2093 parameters.codecs.push_back(codec);
2094
2095 MediaConfig media_config = MediaConfig();
2096 channel_.reset(
2097 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2098 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2099
2100 AddSendStream();
2101
2102 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07002103 channel_->SetSource(last_ssrc_, &capturer);
Per766ad3b2016-04-05 15:23:49 +02002104 ASSERT_EQ(cricket::CS_RUNNING,
2105 capturer.Start(capturer.GetSupportedFormats()->front()));
2106 ASSERT_TRUE(channel_->SetSend(true));
2107 cricket::VideoOptions camera_options;
2108 channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options);
2109
2110 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2111 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
2112 webrtc::LoadObserver* overuse_callback =
2113 send_stream->GetConfig().overuse_callback;
2114 ASSERT_TRUE(overuse_callback != NULL);
2115
2116 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2117 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2118 EXPECT_EQ(1280, send_stream->GetLastWidth());
2119 EXPECT_EQ(720, send_stream->GetLastHeight());
2120
2121 // Trigger overuse.
2122 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2123 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2124 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
2125 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2126 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2127
2128 // Switch to screen share. Expect no CPU adaptation.
2129 cricket::FakeVideoCapturer screen_share(true);
2130 ASSERT_EQ(cricket::CS_RUNNING,
2131 screen_share.Start(screen_share.GetSupportedFormats()->front()));
nisse2ded9b12016-04-08 02:23:55 -07002132 channel_->SetSource(last_ssrc_, &screen_share);
Per766ad3b2016-04-05 15:23:49 +02002133 cricket::VideoOptions screenshare_options;
2134 screenshare_options.is_screencast = rtc::Optional<bool>(true);
2135 channel_->SetVideoSend(last_ssrc_, true /* enable */, &screenshare_options);
2136 EXPECT_TRUE(screen_share.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
2137 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
2138 EXPECT_EQ(1284, send_stream->GetLastWidth());
2139 EXPECT_EQ(724, send_stream->GetLastHeight());
2140
2141 // Switch back to the normal capturer. Expect the frame to be CPU adapted.
nisse2ded9b12016-04-08 02:23:55 -07002142 channel_->SetSource(last_ssrc_, &capturer);
Per766ad3b2016-04-05 15:23:49 +02002143 channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options);
2144 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2145 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
2146 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2147 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2148
nisse2ded9b12016-04-08 02:23:55 -07002149 channel_->SetSource(last_ssrc_, NULL);
Per766ad3b2016-04-05 15:23:49 +02002150}
2151
Erik SprĂ¥ngefbde372015-04-29 16:21:28 +02002152void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
2153 bool is_screenshare) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002154 cricket::VideoCodec codec = kVp8Codec720p;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002155 cricket::VideoSendParameters parameters;
2156 parameters.codecs.push_back(codec);
nisse51542be2016-02-12 02:27:06 -08002157
2158 MediaConfig media_config = MediaConfig();
Peter Boströme4328002015-04-14 22:45:29 +02002159 if (!enable_overuse) {
nisse0db023a2016-03-01 04:29:59 -08002160 media_config.video.enable_cpu_overuse_detection = false;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002161 }
nisse51542be2016-02-12 02:27:06 -08002162 channel_.reset(
2163 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2164
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002165 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002166
2167 AddSendStream();
2168
nisse05103312016-03-16 02:22:50 -07002169 VideoOptions options;
2170 options.is_screencast = rtc::Optional<bool>(is_screenshare);
2171 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
2172
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002173 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07002174 channel_->SetSource(last_ssrc_, &capturer);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002175 EXPECT_EQ(cricket::CS_RUNNING,
2176 capturer.Start(capturer.GetSupportedFormats()->front()));
2177
2178 EXPECT_TRUE(channel_->SetSend(true));
2179
2180 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07002181 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
2182 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002183 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07002184 send_stream->GetConfig().overuse_callback;
perkj2d5f0912016-02-29 00:04:41 -08002185
2186 if (!enable_overuse) {
2187 ASSERT_TRUE(overuse_callback == NULL);
2188
2189 EXPECT_TRUE(capturer.CaptureFrame());
2190 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
2191
2192 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2193 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
2194
nisse2ded9b12016-04-08 02:23:55 -07002195 channel_->SetSource(last_ssrc_, NULL);
perkj2d5f0912016-02-29 00:04:41 -08002196 return;
2197 }
2198
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002199 ASSERT_TRUE(overuse_callback != NULL);
perkj2d5f0912016-02-29 00:04:41 -08002200 EXPECT_TRUE(capturer.CaptureFrame());
2201 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002202 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2203
2204 EXPECT_TRUE(capturer.CaptureFrame());
perkj2d5f0912016-02-29 00:04:41 -08002205 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002206
perkj2d5f0912016-02-29 00:04:41 -08002207 if (is_screenshare) {
2208 // Do not adapt screen share.
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002209 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2210 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
perkj2d5f0912016-02-29 00:04:41 -08002211 } else {
2212 EXPECT_LT(send_stream->GetLastWidth(), codec.width);
2213 EXPECT_LT(send_stream->GetLastHeight(), codec.height);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002214 }
2215
2216 // Trigger underuse which should go back to normal resolution.
2217 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2218 EXPECT_TRUE(capturer.CaptureFrame());
perkj2d5f0912016-02-29 00:04:41 -08002219 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002220
2221 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
2222 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
2223
nisse2ded9b12016-04-08 02:23:55 -07002224 channel_->SetSource(last_ssrc_, NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002225}
2226
magjedb09b6602015-10-01 03:02:44 -07002227TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly) {
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002228 // Start at last timestamp to verify that wraparounds are estimated correctly.
2229 static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
2230 static const int64_t kInitialNtpTimeMs = 1247891230;
2231 static const int kFrameOffsetMs = 20;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002232 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002233
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002234 FakeVideoReceiveStream* stream = AddRecvStream();
2235 cricket::FakeVideoRenderer renderer;
nisse08582ff2016-02-04 01:24:52 -08002236 EXPECT_TRUE(channel_->SetSink(last_ssrc_, &renderer));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002237
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07002238 webrtc::VideoFrame video_frame;
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002239 CreateBlackFrame(&video_frame, 4, 4);
2240 video_frame.set_timestamp(kInitialTimestamp);
2241 // Initial NTP time is not available on the first frame, but should still be
2242 // able to be estimated.
nisseeb83a1a2016-03-21 01:27:56 -07002243 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002244
2245 EXPECT_EQ(1, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002246
2247 // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which
2248 // triggers a constant-overflow warning, hence we're calculating it explicitly
2249 // here.
2250 video_frame.set_timestamp(kFrameOffsetMs * 90 - 1);
2251 video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs);
nisseeb83a1a2016-03-21 01:27:56 -07002252 stream->InjectFrame(video_frame);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002253
2254 EXPECT_EQ(2, renderer.num_rendered_frames());
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002255
2256 // Verify that NTP time has been correctly deduced.
2257 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002258 ASSERT_TRUE(channel_->GetStats(&info));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002259 ASSERT_EQ(1u, info.receivers.size());
2260 EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002261}
2262
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002263TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002264 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002265
2266 VideoCodec codec;
2267 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00002268 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002269
2270 // Using a RTX setup to verify that the default RTX payload type is good.
Peter Boström0c4e06b2015-10-07 12:23:21 +02002271 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2272 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002273 FakeVideoSendStream* stream = AddSendStream(
2274 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
2275 webrtc::VideoSendStream::Config config = stream->GetConfig();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002276
2277 // Make sure NACK and FEC are enabled on the correct payload types.
2278 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
2279 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
2280 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002281
2282 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
2283 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
Shao Changbine62202f2015-04-21 20:24:50 +08002284 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002285 // TODO(juberti): Check RTCP, PLI, TMMBR.
2286}
2287
2288TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002289 cricket::VideoSendParameters parameters;
2290 parameters.codecs.push_back(kVp8Codec);
2291 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002292
2293 FakeVideoSendStream* stream = AddSendStream();
2294 webrtc::VideoSendStream::Config config = stream->GetConfig();
2295
2296 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
2297 EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
2298}
2299
2300TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002301 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002302 cricket::VideoSendParameters parameters;
deadbeef67cf2c12016-04-13 10:07:16 -07002303 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002304 parameters.codecs.push_back(rtx_codec);
2305 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002306 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002307}
2308
2309TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002310 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002311 cricket::VideoSendParameters parameters;
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002312 cricket::VideoCodec rtx_codec =
2313 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002314 parameters.codecs.push_back(kVp8Codec);
2315 parameters.codecs.push_back(rtx_codec);
2316 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002317
2318 cricket::VideoCodec rtx_codec2 =
2319 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002320 parameters.codecs.pop_back();
2321 parameters.codecs.push_back(rtx_codec2);
2322 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002323 << "RTX without matching video codec should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002324}
2325
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002326TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002327 cricket::VideoSendParameters parameters;
2328 parameters.codecs.push_back(kVp8Codec);
2329 parameters.codecs.push_back(kUlpfecCodec);
2330 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002331
2332 FakeVideoSendStream* stream = AddSendStream();
2333 webrtc::VideoSendStream::Config config = stream->GetConfig();
2334
2335 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2336
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002337 parameters.codecs.pop_back();
2338 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002339 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002340 ASSERT_TRUE(stream != NULL);
2341 config = stream->GetConfig();
2342 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2343 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002344}
2345
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002346TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002347 cricket::VideoSendParameters parameters;
2348 parameters.codecs.push_back(kVp8Codec720p);
2349 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002350 channel_->SetSend(true);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002351
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002352 FakeVideoSendStream* stream = AddSendStream();
2353
2354 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07002355 channel_->SetSource(last_ssrc_, &capturer);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002356 EXPECT_EQ(cricket::CS_RUNNING,
2357 capturer.Start(capturer.GetSupportedFormats()->front()));
2358 EXPECT_TRUE(capturer.CaptureFrame());
2359
2360 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002361 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
2362 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
2363
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002364 parameters.codecs.clear();
2365 parameters.codecs.push_back(kVp8Codec360p);
2366 ASSERT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002367 streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00002368 EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
2369 EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
nisse2ded9b12016-04-08 02:23:55 -07002370 channel_->SetSource(last_ssrc_, NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002371}
2372
pbos@webrtc.org00873182014-11-25 14:03:34 +00002373TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
2374 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2375 200000);
2376}
2377
pbos@webrtc.orga5f6fb52015-03-23 22:29:39 +00002378TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
2379 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
2380 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
2381 ASSERT_EQ(1u, streams.size());
2382 EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
2383}
2384
pbos@webrtc.org00873182014-11-25 14:03:34 +00002385TEST_F(WebRtcVideoChannel2Test,
2386 SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
2387 SetSendCodecsShouldWorkForBitrates(
2388 "", 0, "", -1, "", -1);
2389}
2390
2391TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
2392 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002393}
2394
2395TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002396 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300";
2397 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200";
2398 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002399}
2400
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -07002401// Test that when both the codec-specific bitrate params and max_bandwidth_bps
2402// are present in the same send parameters, the settings are combined correctly.
2403TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitratesAndMaxSendBandwidth) {
2404 send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "100";
2405 send_parameters_.codecs[0].params[kCodecParamStartBitrate] = "200";
2406 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "300";
2407 send_parameters_.max_bandwidth_bps = 400000;
2408 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2409 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2410 EXPECT_EQ(200000, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2411 // We expect max_bandwidth_bps to take priority, if set.
2412 EXPECT_EQ(400000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2413
2414 // Decrease max_bandwidth_bps.
2415 send_parameters_.max_bandwidth_bps = 350000;
2416 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2417 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2418 // Since the codec isn't changing, start_bitrate_bps should be -1.
2419 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2420 EXPECT_EQ(350000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2421
2422 // Now try again with the values flipped around.
2423 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "400";
2424 send_parameters_.max_bandwidth_bps = 300000;
2425 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2426 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2427 EXPECT_EQ(200000, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2428 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2429
2430 // If we change the codec max, max_bandwidth_bps should still apply.
2431 send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "350";
2432 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2433 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
2434 EXPECT_EQ(200000, fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
2435 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2436}
2437
pbos@webrtc.org00873182014-11-25 14:03:34 +00002438TEST_F(WebRtcVideoChannel2Test,
2439 SetMaxSendBandwidthShouldPreserveOtherBitrates) {
2440 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
2441 200000);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002442 send_parameters_.max_bandwidth_bps = 300000;
2443 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002444 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002445 << "Setting max bitrate should keep previous min bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002446 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002447 << "Setting max bitrate should not reset start bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01002448 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002449}
2450
2451TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002452 send_parameters_.max_bandwidth_bps = 300000;
2453 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002454 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00002455 // <= 0 means disable (infinite) max bitrate.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002456 send_parameters_.max_bandwidth_bps = 0;
2457 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Stefan Holmere5904162015-03-26 11:11:06 +01002458 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00002459 << "Setting zero max bitrate did not reset start bitrate.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002460}
2461
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002462TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002463 cricket::VideoSendParameters parameters;
2464 parameters.codecs.push_back(kVp8Codec720p);
2465 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002466 channel_->SetSend(true);
2467
2468 FakeVideoSendStream* stream = AddSendStream();
2469
Peter Boström3afc8c42016-01-27 16:45:21 +01002470 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07002471 channel_->SetSource(last_ssrc_, &capturer);
Peter Boström3afc8c42016-01-27 16:45:21 +01002472 EXPECT_EQ(cricket::CS_RUNNING,
2473 capturer.Start(capturer.GetSupportedFormats()->front()));
2474
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002475 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2476 int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
2477 EXPECT_GT(initial_max_bitrate_bps, 0);
2478
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002479 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2480 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01002481 // Insert a frame to update the encoder config.
2482 EXPECT_TRUE(capturer.CaptureFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002483 streams = stream->GetVideoStreams();
2484 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
nisse2ded9b12016-04-08 02:23:55 -07002485 channel_->SetSource(last_ssrc_, nullptr);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002486}
2487
2488TEST_F(WebRtcVideoChannel2Test,
2489 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002490 cricket::VideoSendParameters parameters;
2491 parameters.codecs.push_back(kVp8Codec720p);
2492 ASSERT_TRUE(channel_->SetSendParameters(parameters));
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002493 channel_->SetSend(true);
2494
2495 FakeVideoSendStream* stream = AddSendStream(
2496 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2497
2498 // Send a frame to make sure this scales up to >1 stream (simulcast).
2499 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07002500 channel_->SetSource(kSsrcs3[0], &capturer);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002501 EXPECT_EQ(cricket::CS_RUNNING,
2502 capturer.Start(capturer.GetSupportedFormats()->front()));
2503 EXPECT_TRUE(capturer.CaptureFrame());
2504
2505 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2506 ASSERT_GT(streams.size(), 1u)
2507 << "Without simulcast this test doesn't make sense.";
pbosbe16f792015-10-16 12:49:39 -07002508 int initial_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002509 EXPECT_GT(initial_max_bitrate_bps, 0);
2510
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002511 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2512 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström3afc8c42016-01-27 16:45:21 +01002513 // Insert a frame to update the encoder config.
2514 EXPECT_TRUE(capturer.CaptureFrame());
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002515 streams = stream->GetVideoStreams();
pbosbe16f792015-10-16 12:49:39 -07002516 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002517 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
2518
nisse2ded9b12016-04-08 02:23:55 -07002519 channel_->SetSource(kSsrcs3[0], nullptr);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002520}
2521
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002522TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
2523 static const char* kMaxQuantization = "21";
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002524 cricket::VideoSendParameters parameters;
2525 parameters.codecs.push_back(kVp8Codec);
2526 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
2527 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002528 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
2529 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002530
2531 VideoCodec codec;
2532 EXPECT_TRUE(channel_->GetSendCodec(&codec));
2533 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
2534}
2535
2536TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002537 cricket::VideoSendParameters parameters;
2538 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002539
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002540 parameters.codecs[0].width = 0;
2541 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002542 << "Codec set though codec width is zero.";
2543
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002544 parameters.codecs[0].width = kVp8Codec.width;
2545 parameters.codecs[0].height = 0;
2546 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002547 << "Codec set though codec height is zero.";
2548}
2549
2550TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
2551 // TODO(pbos): Should we only allow the dynamic range?
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002552 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002553 cricket::VideoSendParameters parameters;
2554 parameters.codecs.push_back(kVp8Codec);
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002555 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002556 parameters.codecs[0].id = kIncorrectPayloads[i];
2557 EXPECT_FALSE(channel_->SetSendParameters(parameters))
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002558 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002559 }
2560}
2561
2562TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002563 cricket::VideoSendParameters parameters;
2564 parameters.codecs.push_back(kVp8Codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002565 for (int payload_type = 0; payload_type <= 127; ++payload_type) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002566 parameters.codecs[0].id = payload_type;
2567 EXPECT_TRUE(channel_->SetSendParameters(parameters))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002568 << "Payload type '" << payload_type << "' rejected.";
2569 }
2570}
2571
deadbeef67cf2c12016-04-13 10:07:16 -07002572// Test that setting the a different set of codecs but with an identical front
2573// codec doesn't result in the stream being recreated.
2574// This may happen when a subsequent negotiation includes fewer codecs, as a
2575// result of one of the codecs being rejected.
2576TEST_F(WebRtcVideoChannel2Test,
2577 SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) {
2578 cricket::VideoSendParameters parameters1;
2579 parameters1.codecs.push_back(kVp8Codec);
2580 parameters1.codecs.push_back(kVp9Codec);
2581 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
2582
2583 AddSendStream();
2584 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
2585
2586 cricket::VideoSendParameters parameters2;
2587 parameters2.codecs.push_back(kVp8Codec);
2588 EXPECT_TRUE(channel_->SetSendParameters(parameters2));
2589 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
2590}
2591
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002592TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002593 cricket::VideoRecvParameters parameters;
2594 parameters.codecs.push_back(kVp8Codec);
2595 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002596}
2597
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002598// Test that we set our inbound RTX codecs properly.
2599TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002600 cricket::VideoRecvParameters parameters;
2601 parameters.codecs.push_back(kVp8Codec);
deadbeef67cf2c12016-04-13 10:07:16 -07002602 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002603 parameters.codecs.push_back(rtx_codec);
2604 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002605 << "RTX codec without associated payload should be rejected.";
2606
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002607 parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1);
2608 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002609 << "RTX codec with invalid associated payload type should be rejected.";
2610
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002611 parameters.codecs[1].SetParam("apt", kVp8Codec.id);
2612 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002613
deadbeef67cf2c12016-04-13 10:07:16 -07002614 cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002615 rtx_codec2.SetParam("apt", rtx_codec.id);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002616 parameters.codecs.push_back(rtx_codec2);
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002617
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002618 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) <<
2619 "RTX codec with another RTX as associated payload type should be "
2620 "rejected.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002621}
2622
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002623TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002624 cricket::VideoRecvParameters parameters;
2625 parameters.codecs.push_back(kVp8Codec);
2626 parameters.codecs[0].id = 99;
2627 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002628}
2629
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002630TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002631 cricket::VideoRecvParameters parameters;
2632 parameters.codecs = engine_.codecs();
2633 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002634
2635 FakeVideoReceiveStream* stream = AddRecvStream();
2636 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002637 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
2638 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002639}
2640
2641TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002642 cricket::VideoRecvParameters parameters;
2643 parameters.codecs.push_back(kVp8Codec);
deadbeef67cf2c12016-04-13 10:07:16 -07002644 parameters.codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002645 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002646}
2647
2648// TODO(pbos): Enable VP9 through external codec support
2649TEST_F(WebRtcVideoChannel2Test,
2650 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002651 cricket::VideoRecvParameters parameters;
2652 parameters.codecs.push_back(kVp8Codec);
2653 parameters.codecs.push_back(kVp9Codec);
2654 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002655}
2656
2657TEST_F(WebRtcVideoChannel2Test,
2658 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002659 cricket::VideoRecvParameters parameters;
2660 parameters.codecs.push_back(kVp8Codec);
2661 parameters.codecs.push_back(kVp9Codec);
2662 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002663 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
2664}
2665
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002666TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002667 cricket::VideoSendParameters send_parameters;
2668 send_parameters.codecs.push_back(kVp8Codec);
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002669 send_parameters.codecs.push_back(kRedCodec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002670 send_parameters.codecs.push_back(kUlpfecCodec);
2671 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002672
2673 FakeVideoReceiveStream* stream = AddRecvStream();
2674 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
2675
2676 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2677
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002678 cricket::VideoRecvParameters recv_parameters;
2679 recv_parameters.codecs.push_back(kVp8Codec);
2680 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002681 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002682 ASSERT_TRUE(stream != NULL);
2683 config = stream->GetConfig();
2684 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2685 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002686}
2687
Stefan Holmer2b1f6512016-05-17 16:33:30 +02002688TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithoutFecDisablesReceivingFec) {
2689 FakeVideoReceiveStream* stream = AddRecvStream();
2690 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
2691
2692 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2693
2694 cricket::VideoRecvParameters recv_parameters;
2695 recv_parameters.codecs.push_back(kVp8Codec);
2696 recv_parameters.codecs.push_back(kRedCodec);
2697 recv_parameters.codecs.push_back(kUlpfecCodec);
2698 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
2699 stream = fake_call_->GetVideoReceiveStreams()[0];
2700 ASSERT_TRUE(stream != NULL);
2701 config = stream->GetConfig();
2702 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type)
2703 << "FEC should be enabled on the recieve stream.";
2704
2705 cricket::VideoSendParameters send_parameters;
2706 send_parameters.codecs.push_back(kVp8Codec);
2707 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
2708 stream = fake_call_->GetVideoReceiveStreams()[0];
2709 config = stream->GetConfig();
2710 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2711 << "FEC should have been disabled when we know the other side won't do "
2712 "FEC.";
2713
2714 send_parameters.codecs.push_back(kRedCodec);
2715 send_parameters.codecs.push_back(kUlpfecCodec);
2716 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
2717 stream = fake_call_->GetVideoReceiveStreams()[0];
2718 config = stream->GetConfig();
2719 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type)
2720 << "FEC should be enabled on the recieve stream.";
2721}
2722
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002723TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002724 cricket::VideoRecvParameters parameters;
2725 parameters.codecs.push_back(kVp8Codec);
2726 parameters.codecs.push_back(kRedCodec);
2727 parameters.codecs[1].id = parameters.codecs[0].id;
2728 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002729}
2730
2731TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002732 cricket::VideoRecvParameters parameters;
2733 parameters.codecs.push_back(kVp8Codec);
2734 parameters.codecs.push_back(kVp9Codec);
2735 parameters.codecs[1].id = parameters.codecs[0].id;
2736 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002737}
2738
2739TEST_F(WebRtcVideoChannel2Test,
2740 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002741 cricket::VideoRecvParameters parameters;
2742 parameters.codecs.push_back(kVp8Codec);
2743 parameters.codecs.push_back(kVp8Codec);
2744 parameters.codecs[1].id += 1;
2745 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002746}
2747
deadbeef67cf2c12016-04-13 10:07:16 -07002748// Test that setting the same codecs but with a different order
deadbeef874ca3a2015-08-20 17:19:20 -07002749// doesn't result in the stream being recreated.
2750TEST_F(WebRtcVideoChannel2Test,
deadbeef67cf2c12016-04-13 10:07:16 -07002751 SetRecvCodecsDifferentOrderDoesntRecreateStream) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002752 cricket::VideoRecvParameters parameters1;
2753 parameters1.codecs.push_back(kVp8Codec);
2754 parameters1.codecs.push_back(kRedCodec);
2755 EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
deadbeef874ca3a2015-08-20 17:19:20 -07002756
2757 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2758 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2759
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002760 cricket::VideoRecvParameters parameters2;
2761 parameters2.codecs.push_back(kRedCodec);
2762 parameters2.codecs.push_back(kVp8Codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002763 EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
deadbeef874ca3a2015-08-20 17:19:20 -07002764 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2765}
2766
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002767TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
2768 EXPECT_FALSE(AddSendStream()->IsSending());
2769}
2770
pbos@webrtc.org85f42942014-07-22 09:14:58 +00002771TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
2772 EXPECT_TRUE(AddRecvStream()->IsReceiving());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002773}
2774
2775TEST_F(WebRtcVideoChannel2Test, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002776 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002777 EXPECT_FALSE(stream->IsSending());
2778
2779 // false->true
2780 EXPECT_TRUE(channel_->SetSend(true));
2781 EXPECT_TRUE(stream->IsSending());
2782 // true->true
2783 EXPECT_TRUE(channel_->SetSend(true));
2784 EXPECT_TRUE(stream->IsSending());
2785 // true->false
2786 EXPECT_TRUE(channel_->SetSend(false));
2787 EXPECT_FALSE(stream->IsSending());
2788 // false->false
2789 EXPECT_TRUE(channel_->SetSend(false));
2790 EXPECT_FALSE(stream->IsSending());
2791
2792 EXPECT_TRUE(channel_->SetSend(true));
2793 FakeVideoSendStream* new_stream = AddSendStream();
2794 EXPECT_TRUE(new_stream->IsSending())
2795 << "Send stream created after SetSend(true) not sending initially.";
2796}
2797
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002798// This test verifies DSCP settings are properly applied on video media channel.
2799TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
kwiberg686a8ef2016-02-26 03:00:35 -08002800 std::unique_ptr<cricket::FakeNetworkInterface> network_interface(
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002801 new cricket::FakeNetworkInterface);
nisse51542be2016-02-12 02:27:06 -08002802 MediaConfig config;
kwiberg686a8ef2016-02-26 03:00:35 -08002803 std::unique_ptr<VideoMediaChannel> channel;
nisse51542be2016-02-12 02:27:06 -08002804
2805 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2806 channel->SetInterface(network_interface.get());
2807 // Default value when DSCP is disabled should be DSCP_DEFAULT.
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002808 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
nisse51542be2016-02-12 02:27:06 -08002809
2810 config.enable_dscp = true;
2811 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2812 channel->SetInterface(network_interface.get());
2813 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2814
2815 // Verify that setting the option to false resets the
2816 // DiffServCodePoint.
2817 config.enable_dscp = false;
2818 channel.reset(engine_.CreateChannel(call_.get(), config, VideoOptions()));
2819 channel->SetInterface(network_interface.get());
2820 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002821}
2822
deadbeef13871492015-12-09 12:37:51 -08002823// This test verifies that the RTCP reduced size mode is properly applied to
2824// send video streams.
2825TEST_F(WebRtcVideoChannel2Test, TestSetSendRtcpReducedSize) {
2826 // Create stream, expecting that default mode is "compound".
2827 FakeVideoSendStream* stream1 = AddSendStream();
2828 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
2829
2830 // Now enable reduced size mode.
2831 send_parameters_.rtcp.reduced_size = true;
2832 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2833 stream1 = fake_call_->GetVideoSendStreams()[0];
2834 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
2835
2836 // Create a new stream and ensure it picks up the reduced size mode.
2837 FakeVideoSendStream* stream2 = AddSendStream();
2838 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
2839}
2840
2841// This test verifies that the RTCP reduced size mode is properly applied to
2842// receive video streams.
2843TEST_F(WebRtcVideoChannel2Test, TestSetRecvRtcpReducedSize) {
2844 // Create stream, expecting that default mode is "compound".
2845 FakeVideoReceiveStream* stream1 = AddRecvStream();
2846 EXPECT_EQ(webrtc::RtcpMode::kCompound, stream1->GetConfig().rtp.rtcp_mode);
2847
2848 // Now enable reduced size mode.
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002849 // TODO(deadbeef): Once "recv_parameters" becomes "receiver_parameters",
2850 // the reduced_size flag should come from that.
2851 send_parameters_.rtcp.reduced_size = true;
2852 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
deadbeef13871492015-12-09 12:37:51 -08002853 stream1 = fake_call_->GetVideoReceiveStreams()[0];
2854 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode);
2855
2856 // Create a new stream and ensure it picks up the reduced size mode.
2857 FakeVideoReceiveStream* stream2 = AddRecvStream();
2858 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream2->GetConfig().rtp.rtcp_mode);
2859}
2860
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002861TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
skvlad7a43d252016-03-22 15:32:27 -07002862 EXPECT_EQ(webrtc::kNetworkUp,
2863 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2864 EXPECT_EQ(webrtc::kNetworkUp,
2865 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002866
2867 channel_->OnReadyToSend(false);
skvlad7a43d252016-03-22 15:32:27 -07002868 EXPECT_EQ(webrtc::kNetworkDown,
2869 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2870 EXPECT_EQ(webrtc::kNetworkUp,
2871 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002872
2873 channel_->OnReadyToSend(true);
skvlad7a43d252016-03-22 15:32:27 -07002874 EXPECT_EQ(webrtc::kNetworkUp,
2875 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2876 EXPECT_EQ(webrtc::kNetworkUp,
2877 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002878}
2879
Peter Boström74d9ed72015-03-26 16:28:31 +01002880TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002881 cricket::VideoSendParameters parameters;
2882 parameters.codecs.push_back(kVp8Codec);
2883 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Peter Boström74d9ed72015-03-26 16:28:31 +01002884
2885 AddSendStream();
2886
2887 cricket::VideoMediaInfo info;
2888 ASSERT_TRUE(channel_->GetStats(&info));
2889 EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name);
2890}
2891
Peter Boströmb7d9a972015-12-18 16:01:11 +01002892TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) {
2893 FakeVideoSendStream* stream = AddSendStream();
2894 webrtc::VideoSendStream::Stats stats;
2895 stats.encoder_implementation_name = "encoder_implementation_name";
2896 stream->SetStats(stats);
2897
2898 cricket::VideoMediaInfo info;
2899 ASSERT_TRUE(channel_->GetStats(&info));
2900 EXPECT_EQ(stats.encoder_implementation_name,
2901 info.senders[0].encoder_implementation_name);
2902}
2903
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002904TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) {
2905 FakeVideoSendStream* stream = AddSendStream();
2906 webrtc::VideoSendStream::Stats stats;
2907 stats.avg_encode_time_ms = 13;
2908 stats.encode_usage_percent = 42;
2909 stream->SetStats(stats);
2910
2911 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002912 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002913 EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms);
2914 EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent);
2915}
2916
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002917TEST_F(WebRtcVideoChannel2Test, GetStatsReportsUpperResolution) {
2918 FakeVideoSendStream* stream = AddSendStream();
2919 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002920 stats.substreams[17].width = 123;
2921 stats.substreams[17].height = 40;
2922 stats.substreams[42].width = 80;
2923 stats.substreams[42].height = 31;
2924 stats.substreams[11].width = 20;
2925 stats.substreams[11].height = 90;
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002926 stream->SetStats(stats);
2927
2928 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002929 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002930 ASSERT_EQ(1u, info.senders.size());
2931 EXPECT_EQ(123, info.senders[0].send_frame_width);
2932 EXPECT_EQ(90, info.senders[0].send_frame_height);
2933}
2934
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002935TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) {
2936 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2937
2938 // Capture format VGA.
2939 cricket::FakeVideoCapturer video_capturer_vga;
2940 const std::vector<cricket::VideoFormat>* formats =
2941 video_capturer_vga.GetSupportedFormats();
2942 cricket::VideoFormat capture_format_vga = (*formats)[1];
2943 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
nisse2ded9b12016-04-08 02:23:55 -07002944 channel_->SetSource(kSsrcs3[0], &video_capturer_vga);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002945 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2946
deadbeef67cf2c12016-04-13 10:07:16 -07002947 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002948 cricket::VideoSendParameters parameters;
2949 parameters.codecs.push_back(send_codec);
2950 EXPECT_TRUE(channel_->SetSendParameters(parameters));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002951 EXPECT_TRUE(channel_->SetSend(true));
2952
2953 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
solenberge5269742015-09-08 05:13:22 -07002954
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002955 // Trigger overuse.
solenberge5269742015-09-08 05:13:22 -07002956 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002957 webrtc::LoadObserver* overuse_callback =
solenberge5269742015-09-08 05:13:22 -07002958 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
2959 ASSERT_TRUE(overuse_callback != NULL);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002960 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2961
2962 // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
2963 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2964 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002965 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002966 ASSERT_EQ(1U, info.senders.size());
2967 EXPECT_EQ(1, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02002968 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002969
2970 // Trigger upgrade and verify that we adapt back up to VGA.
2971 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2972 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2973 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002974 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002975 ASSERT_EQ(1U, info.senders.size());
2976 EXPECT_EQ(2, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02002977 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002978 info.senders[0].adapt_reason);
2979
2980 // No capturer (no adapter). Adapt changes from old adapter should be kept.
nisse2ded9b12016-04-08 02:23:55 -07002981 channel_->SetSource(kSsrcs3[0], NULL);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002982 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002983 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002984 ASSERT_EQ(1U, info.senders.size());
2985 EXPECT_EQ(2, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02002986 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002987 info.senders[0].adapt_reason);
2988
2989 // Set new capturer, capture format HD.
2990 cricket::FakeVideoCapturer video_capturer_hd;
2991 cricket::VideoFormat capture_format_hd = (*formats)[0];
2992 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd));
nisse2ded9b12016-04-08 02:23:55 -07002993 channel_->SetSource(kSsrcs3[0], &video_capturer_hd);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002994 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2995
2996 // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2.
2997 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2998 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2999 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003000 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00003001 ASSERT_EQ(1U, info.senders.size());
3002 EXPECT_EQ(3, info.senders[0].adapt_changes);
Per766ad3b2016-04-05 15:23:49 +02003003 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00003004
nisse2ded9b12016-04-08 02:23:55 -07003005 channel_->SetSource(kSsrcs3[0], NULL);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00003006}
3007
asapersson17821db2015-12-14 02:08:12 -08003008TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationAndBandwidthStats) {
3009 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
3010
3011 // Capture format VGA.
3012 cricket::FakeVideoCapturer video_capturer_vga;
3013 const std::vector<cricket::VideoFormat>* formats =
3014 video_capturer_vga.GetSupportedFormats();
3015 cricket::VideoFormat capture_format_vga = (*formats)[1];
3016 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
nisse2ded9b12016-04-08 02:23:55 -07003017 channel_->SetSource(kSsrcs3[0], &video_capturer_vga);
asapersson17821db2015-12-14 02:08:12 -08003018 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
3019
deadbeef67cf2c12016-04-13 10:07:16 -07003020 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30);
asapersson17821db2015-12-14 02:08:12 -08003021 cricket::VideoSendParameters parameters;
3022 parameters.codecs.push_back(send_codec);
3023 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3024 EXPECT_TRUE(channel_->SetSend(true));
3025
3026 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
asapersson17821db2015-12-14 02:08:12 -08003027
3028 // Trigger overuse -> adapt CPU.
3029 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
3030 webrtc::LoadObserver* overuse_callback =
3031 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
3032 ASSERT_TRUE(overuse_callback != NULL);
3033 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
3034 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
3035 cricket::VideoMediaInfo info;
3036 EXPECT_TRUE(channel_->GetStats(&info));
3037 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003038 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
asapersson17821db2015-12-14 02:08:12 -08003039
3040 // Set bandwidth limitation stats for the stream -> adapt CPU + BW.
3041 webrtc::VideoSendStream::Stats stats;
3042 stats.bw_limited_resolution = true;
3043 fake_call_->GetVideoSendStreams().front()->SetStats(stats);
3044 info.Clear();
3045 EXPECT_TRUE(channel_->GetStats(&info));
3046 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003047 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU |
3048 WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08003049 info.senders[0].adapt_reason);
3050
3051 // Trigger upgrade -> adapt BW.
3052 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
3053 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
3054 info.Clear();
3055 EXPECT_TRUE(channel_->GetStats(&info));
3056 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003057 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08003058 info.senders[0].adapt_reason);
3059
3060 // Reset bandwidth limitation state -> adapt NONE.
3061 stats.bw_limited_resolution = false;
3062 fake_call_->GetVideoSendStreams().front()->SetStats(stats);
3063 info.Clear();
3064 EXPECT_TRUE(channel_->GetStats(&info));
3065 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003066 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
asapersson17821db2015-12-14 02:08:12 -08003067 info.senders[0].adapt_reason);
3068
nisse2ded9b12016-04-08 02:23:55 -07003069 channel_->SetSource(kSsrcs3[0], NULL);
asapersson17821db2015-12-14 02:08:12 -08003070}
3071
3072TEST_F(WebRtcVideoChannel2Test,
3073 GetStatsTranslatesBandwidthLimitedResolutionCorrectly) {
3074 FakeVideoSendStream* stream = AddSendStream();
3075 webrtc::VideoSendStream::Stats stats;
3076 stats.bw_limited_resolution = true;
3077 stream->SetStats(stats);
3078
3079 cricket::VideoMediaInfo info;
3080 EXPECT_TRUE(channel_->GetStats(&info));
3081 ASSERT_EQ(1U, info.senders.size());
Per766ad3b2016-04-05 15:23:49 +02003082 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
asapersson17821db2015-12-14 02:08:12 -08003083 info.senders[0].adapt_reason);
3084}
3085
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00003086TEST_F(WebRtcVideoChannel2Test,
3087 GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
3088 FakeVideoSendStream* stream = AddSendStream();
3089 webrtc::VideoSendStream::Stats stats;
3090 stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
3091 stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
3092 stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
3093
3094 stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5;
3095 stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7;
3096 stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9;
3097
3098 stream->SetStats(stats);
3099
3100 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003101 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00003102 EXPECT_EQ(7, info.senders[0].firs_rcvd);
3103 EXPECT_EQ(10, info.senders[0].nacks_rcvd);
3104 EXPECT_EQ(13, info.senders[0].plis_rcvd);
3105}
3106
3107TEST_F(WebRtcVideoChannel2Test,
3108 GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
3109 FakeVideoReceiveStream* stream = AddRecvStream();
3110 webrtc::VideoReceiveStream::Stats stats;
3111 stats.rtcp_packet_type_counts.fir_packets = 2;
3112 stats.rtcp_packet_type_counts.nack_packets = 3;
3113 stats.rtcp_packet_type_counts.pli_packets = 4;
3114 stream->SetStats(stats);
3115
3116 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003117 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00003118 EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
3119 info.receivers[0].firs_sent);
3120 EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
3121 info.receivers[0].nacks_sent);
3122 EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
3123 info.receivers[0].plis_sent);
3124}
3125
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003126TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly) {
3127 FakeVideoReceiveStream* stream = AddRecvStream();
3128 webrtc::VideoReceiveStream::Stats stats;
Peter Boströmb7d9a972015-12-18 16:01:11 +01003129 stats.decoder_implementation_name = "decoder_implementation_name";
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003130 stats.decode_ms = 2;
3131 stats.max_decode_ms = 3;
3132 stats.current_delay_ms = 4;
3133 stats.target_delay_ms = 5;
3134 stats.jitter_buffer_ms = 6;
3135 stats.min_playout_delay_ms = 7;
3136 stats.render_delay_ms = 8;
3137 stream->SetStats(stats);
3138
3139 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003140 ASSERT_TRUE(channel_->GetStats(&info));
Peter Boströmb7d9a972015-12-18 16:01:11 +01003141 EXPECT_EQ(stats.decoder_implementation_name,
3142 info.receivers[0].decoder_implementation_name);
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00003143 EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms);
3144 EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms);
3145 EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms);
3146 EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms);
3147 EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms);
3148 EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms);
3149 EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
3150}
3151
Peter Boström393347f2015-04-22 14:52:45 +02003152TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesReceivePacketStatsCorrectly) {
3153 FakeVideoReceiveStream* stream = AddRecvStream();
3154 webrtc::VideoReceiveStream::Stats stats;
3155 stats.rtp_stats.transmitted.payload_bytes = 2;
3156 stats.rtp_stats.transmitted.header_bytes = 3;
3157 stats.rtp_stats.transmitted.padding_bytes = 4;
3158 stats.rtp_stats.transmitted.packets = 5;
3159 stats.rtcp_stats.cumulative_lost = 6;
3160 stats.rtcp_stats.fraction_lost = 7;
3161 stream->SetStats(stats);
3162
3163 cricket::VideoMediaInfo info;
3164 ASSERT_TRUE(channel_->GetStats(&info));
3165 EXPECT_EQ(stats.rtp_stats.transmitted.payload_bytes +
3166 stats.rtp_stats.transmitted.header_bytes +
3167 stats.rtp_stats.transmitted.padding_bytes,
3168 info.receivers[0].bytes_rcvd);
3169 EXPECT_EQ(stats.rtp_stats.transmitted.packets,
3170 info.receivers[0].packets_rcvd);
3171 EXPECT_EQ(stats.rtcp_stats.cumulative_lost, info.receivers[0].packets_lost);
3172 EXPECT_EQ(static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8),
3173 info.receivers[0].fraction_lost);
3174}
3175
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00003176TEST_F(WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly) {
3177 AddSendStream();
3178 AddSendStream();
3179 webrtc::Call::Stats stats;
3180 stats.rtt_ms = 123;
3181 fake_call_->SetStats(stats);
3182
3183 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003184 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00003185 ASSERT_EQ(2u, info.senders.size());
3186 EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms);
3187 EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms);
3188}
3189
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003190TEST_F(WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly) {
3191 FakeVideoSendStream* stream = AddSendStream();
3192 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003193 stats.target_media_bitrate_bps = 156;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003194 stats.media_bitrate_bps = 123;
3195 stats.substreams[17].total_bitrate_bps = 1;
3196 stats.substreams[17].retransmit_bitrate_bps = 2;
3197 stats.substreams[42].total_bitrate_bps = 3;
3198 stats.substreams[42].retransmit_bitrate_bps = 4;
3199 stream->SetStats(stats);
3200
3201 FakeVideoSendStream* stream2 = AddSendStream();
3202 webrtc::VideoSendStream::Stats stats2;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003203 stats2.target_media_bitrate_bps = 200;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003204 stats2.media_bitrate_bps = 321;
3205 stats2.substreams[13].total_bitrate_bps = 5;
3206 stats2.substreams[13].retransmit_bitrate_bps = 6;
3207 stats2.substreams[21].total_bitrate_bps = 7;
3208 stats2.substreams[21].retransmit_bitrate_bps = 8;
3209 stream2->SetStats(stats2);
3210
3211 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003212 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003213 ASSERT_EQ(2u, info.senders.size());
3214 // Assuming stream and stream2 corresponds to senders[0] and [1] respectively
3215 // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
3216 EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
3217 EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
pbos@webrtc.org891d4832015-02-26 13:15:22 +00003218 EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
3219 info.bw_estimations[0].target_enc_bitrate);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003220 EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
3221 info.bw_estimations[0].actual_enc_bitrate);
3222 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
3223 << "Bandwidth stats should take all streams into account.";
3224 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
3225 << "Bandwidth stats should take all streams into account.";
3226}
3227
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003228TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003229 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003230
Peter Boström0c4e06b2015-10-07 12:23:21 +02003231 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3232 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003233
3234 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
3235 const size_t kDataLength = 12;
3236 uint8_t data[kDataLength];
3237 memset(data, 0, sizeof(data));
3238 rtc::SetBE32(&data[8], ssrcs[0]);
jbaucheec21bd2016-03-20 06:15:43 -07003239 rtc::CopyOnWriteBuffer packet(data, kDataLength);
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003240 rtc::PacketTime packet_time;
3241 channel_->OnPacketReceived(&packet, packet_time);
3242
3243 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3244 << "No default receive stream created.";
3245 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
Peter Boströmd8b01092016-05-12 16:44:36 +02003246 EXPECT_TRUE(recv_stream->GetConfig().rtp.rtx.empty())
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003247 << "Default receive stream should not have configured RTX";
3248
3249 EXPECT_TRUE(channel_->AddRecvStream(
3250 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
3251 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3252 << "AddRecvStream should've reconfigured, not added a new receiver.";
3253 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
Peter Boströmd8b01092016-05-12 16:44:36 +02003254 EXPECT_FALSE(recv_stream->GetConfig().rtp.rtx.empty());
3255 EXPECT_EQ(recv_stream->GetConfig().decoders.size(),
3256 recv_stream->GetConfig().rtp.rtx.size())
3257 << "RTX should be mapped for all decoders/payload types.";
3258 for (const auto& kv : recv_stream->GetConfig().rtp.rtx) {
3259 EXPECT_EQ(rtx_ssrcs[0], kv.second.ssrc);
3260 }
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00003261}
3262
Peter Boströmd4362cd2015-03-25 14:17:23 +01003263TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003264 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd4362cd2015-03-25 14:17:23 +01003265
Peter Boström0c4e06b2015-10-07 12:23:21 +02003266 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3267 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd4362cd2015-03-25 14:17:23 +01003268
3269 StreamParams sp =
3270 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
3271 sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
3272
3273 EXPECT_FALSE(channel_->AddSendStream(sp));
3274 EXPECT_FALSE(channel_->AddRecvStream(sp));
3275}
3276
Peter Boströmd6f4c252015-03-26 16:23:04 +01003277TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003278 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003279
Peter Boström0c4e06b2015-10-07 12:23:21 +02003280 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
3281 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
Peter Boströmd6f4c252015-03-26 16:23:04 +01003282
3283 StreamParams sp =
3284 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
3285
3286 EXPECT_TRUE(channel_->AddSendStream(sp));
3287 EXPECT_TRUE(channel_->AddRecvStream(sp));
3288
3289 // The RTX SSRC is already used in previous streams, using it should fail.
3290 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
3291 EXPECT_FALSE(channel_->AddSendStream(sp));
3292 EXPECT_FALSE(channel_->AddRecvStream(sp));
3293
3294 // After removing the original stream this should be fine to add (makes sure
3295 // that RTX ssrcs are not forever taken).
3296 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
3297 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
3298 EXPECT_TRUE(channel_->AddSendStream(sp));
3299 EXPECT_TRUE(channel_->AddRecvStream(sp));
3300}
3301
3302TEST_F(WebRtcVideoChannel2Test,
3303 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02003304 static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3};
3305 static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5};
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003306 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003307
Peter Boströmd6f4c252015-03-26 16:23:04 +01003308 StreamParams sp =
3309 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
3310
3311 EXPECT_TRUE(channel_->AddSendStream(sp));
3312 EXPECT_TRUE(channel_->AddRecvStream(sp));
3313
3314 // One of the SSRCs is already used in previous streams, using it should fail.
3315 sp = cricket::CreateSimStreamParams("cname",
3316 MAKE_VECTOR(kOverlappingStreamSsrcs));
3317 EXPECT_FALSE(channel_->AddSendStream(sp));
3318 EXPECT_FALSE(channel_->AddRecvStream(sp));
3319
3320 // After removing the original stream this should be fine to add (makes sure
3321 // that RTX ssrcs are not forever taken).
Peter Boström3548dd22015-05-22 18:48:36 +02003322 EXPECT_TRUE(channel_->RemoveSendStream(kFirstStreamSsrcs[0]));
3323 EXPECT_TRUE(channel_->RemoveRecvStream(kFirstStreamSsrcs[0]));
Peter Boströmd6f4c252015-03-26 16:23:04 +01003324 EXPECT_TRUE(channel_->AddSendStream(sp));
3325 EXPECT_TRUE(channel_->AddRecvStream(sp));
3326}
3327
Peter Boström259bd202015-05-28 13:39:50 +02003328TEST_F(WebRtcVideoChannel2Test, ReportsSsrcGroupsInStats) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003329 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström259bd202015-05-28 13:39:50 +02003330
3331 static const uint32_t kSenderSsrcs[] = {4, 7, 10};
3332 static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11};
3333
3334 StreamParams sender_sp = cricket::CreateSimWithRtxStreamParams(
3335 "cname", MAKE_VECTOR(kSenderSsrcs), MAKE_VECTOR(kSenderRtxSsrcs));
3336
3337 EXPECT_TRUE(channel_->AddSendStream(sender_sp));
3338
3339 static const uint32_t kReceiverSsrcs[] = {3};
3340 static const uint32_t kReceiverRtxSsrcs[] = {2};
3341
3342 StreamParams receiver_sp = cricket::CreateSimWithRtxStreamParams(
3343 "cname", MAKE_VECTOR(kReceiverSsrcs), MAKE_VECTOR(kReceiverRtxSsrcs));
3344 EXPECT_TRUE(channel_->AddRecvStream(receiver_sp));
3345
3346 cricket::VideoMediaInfo info;
3347 ASSERT_TRUE(channel_->GetStats(&info));
3348
3349 ASSERT_EQ(1u, info.senders.size());
3350 ASSERT_EQ(1u, info.receivers.size());
3351
3352 EXPECT_NE(sender_sp.ssrc_groups, receiver_sp.ssrc_groups);
3353 EXPECT_EQ(sender_sp.ssrc_groups, info.senders[0].ssrc_groups);
3354 EXPECT_EQ(receiver_sp.ssrc_groups, info.receivers[0].ssrc_groups);
3355}
3356
pbosf42376c2015-08-28 07:35:32 -07003357TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) {
3358 FakeVideoReceiveStream* stream = AddRecvStream();
3359 webrtc::VideoReceiveStream::Stats stats;
3360 cricket::VideoMediaInfo info;
3361
3362 // Report no codec name before receiving.
3363 stream->SetStats(stats);
3364 ASSERT_TRUE(channel_->GetStats(&info));
3365 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3366
3367 // Report VP8 if we're receiving it.
3368 stats.current_payload_type = kDefaultVp8PlType;
3369 stream->SetStats(stats);
3370 ASSERT_TRUE(channel_->GetStats(&info));
3371 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str());
3372
3373 // Report no codec name for unknown playload types.
3374 stats.current_payload_type = 3;
3375 stream->SetStats(stats);
3376 ASSERT_TRUE(channel_->GetStats(&info));
3377 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3378}
3379
noahricd10a68e2015-07-10 11:27:55 -07003380void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket(
3381 uint8_t payload_type,
3382 bool expect_created_receive_stream) {
noahricd10a68e2015-07-10 11:27:55 -07003383 // Add a RED RTX codec.
3384 VideoCodec red_rtx_codec =
3385 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003386 recv_parameters_.codecs.push_back(red_rtx_codec);
3387 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
noahricd10a68e2015-07-10 11:27:55 -07003388
3389 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
3390 const size_t kDataLength = 12;
3391 uint8_t data[kDataLength];
3392 memset(data, 0, sizeof(data));
3393
3394 rtc::Set8(data, 1, payload_type);
3395 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
jbaucheec21bd2016-03-20 06:15:43 -07003396 rtc::CopyOnWriteBuffer packet(data, kDataLength);
noahricd10a68e2015-07-10 11:27:55 -07003397 rtc::PacketTime packet_time;
3398 channel_->OnPacketReceived(&packet, packet_time);
3399
3400 if (expect_created_receive_stream) {
3401 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3402 << "Should have created a receive stream for payload type: "
3403 << payload_type;
3404 } else {
3405 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size())
3406 << "Shouldn't have created a receive stream for payload type: "
3407 << payload_type;
3408 }
3409}
3410
3411TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) {
3412 TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true);
3413}
3414
3415TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) {
3416 TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true);
3417}
3418
3419TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) {
3420 TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false);
3421}
3422
3423TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
3424 TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false);
3425}
3426
3427TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
3428 TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false);
3429}
3430
skvladdc1c62c2016-03-16 19:07:43 -07003431TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) {
3432 AddSendStream();
3433
3434 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07003435 channel_->SetSource(last_ssrc_, &capturer);
skvladdc1c62c2016-03-16 19:07:43 -07003436 cricket::VideoFormat capture_format_hd =
3437 capturer.GetSupportedFormats()->front();
3438 EXPECT_EQ(1280, capture_format_hd.width);
3439 EXPECT_EQ(720, capture_format_hd.height);
3440 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
3441 EXPECT_TRUE(channel_->SetSend(true));
3442
3443 int default_encoder_bitrate = GetMaxEncoderBitrate(capturer);
3444 EXPECT_TRUE(default_encoder_bitrate > 1000);
3445
3446 // TODO(skvlad): Resolve the inconsistency between the interpretation
3447 // of the global bitrate limit for audio and video:
3448 // - Audio: max_bandwidth_bps = 0 - fail the operation,
3449 // max_bandwidth_bps = -1 - remove the bandwidth limit
3450 // - Video: max_bandwidth_bps = 0 - remove the bandwidth limit,
3451 // max_bandwidth_bps = -1 - do not change the previously set
3452 // limit.
3453
3454 SetAndExpectMaxBitrate(capturer, 1000, 0, 1000);
3455 SetAndExpectMaxBitrate(capturer, 1000, 800, 800);
3456 SetAndExpectMaxBitrate(capturer, 600, 800, 600);
3457 SetAndExpectMaxBitrate(capturer, 0, 800, 800);
3458 SetAndExpectMaxBitrate(capturer, 0, 0, default_encoder_bitrate);
3459
nisse2ded9b12016-04-08 02:23:55 -07003460 channel_->SetSource(last_ssrc_, NULL);
skvladdc1c62c2016-03-16 19:07:43 -07003461}
3462
3463TEST_F(WebRtcVideoChannel2Test, CannotSetMaxBitrateForNonexistentStream) {
3464 webrtc::RtpParameters nonexistent_parameters =
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003465 channel_->GetRtpSendParameters(last_ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -07003466 EXPECT_EQ(0, nonexistent_parameters.encodings.size());
3467
3468 nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003469 EXPECT_FALSE(
3470 channel_->SetRtpSendParameters(last_ssrc_, nonexistent_parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003471}
3472
3473TEST_F(WebRtcVideoChannel2Test,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003474 CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) {
skvladdc1c62c2016-03-16 19:07:43 -07003475 // This test verifies that setting RtpParameters succeeds only if
3476 // the structure contains exactly one encoding.
deadbeefdbe2b872016-03-22 15:42:00 -07003477 // TODO(skvlad): Update this test when we start supporting setting parameters
skvladdc1c62c2016-03-16 19:07:43 -07003478 // for each encoding individually.
3479
3480 AddSendStream();
3481 // Setting RtpParameters with no encoding is expected to fail.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003482 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
3483 parameters.encodings.clear();
3484 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003485 // Setting RtpParameters with exactly one encoding should succeed.
3486 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003487 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003488 // Two or more encodings should result in failure.
3489 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003490 EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07003491}
3492
deadbeefdbe2b872016-03-22 15:42:00 -07003493// Test that a stream will not be sending if its encoding is made
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003494// inactive through SetRtpSendParameters.
deadbeefdbe2b872016-03-22 15:42:00 -07003495// TODO(deadbeef): Update this test when we start supporting setting parameters
3496// for each encoding individually.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003497TEST_F(WebRtcVideoChannel2Test, SetRtpSendParametersEncodingsActive) {
deadbeefdbe2b872016-03-22 15:42:00 -07003498 FakeVideoSendStream* stream = AddSendStream();
3499 EXPECT_TRUE(channel_->SetSend(true));
3500 EXPECT_TRUE(stream->IsSending());
3501
3502 // Get current parameters and change "active" to false.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003503 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
deadbeefdbe2b872016-03-22 15:42:00 -07003504 ASSERT_EQ(1u, parameters.encodings.size());
3505 ASSERT_TRUE(parameters.encodings[0].active);
3506 parameters.encodings[0].active = false;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003507 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
deadbeefdbe2b872016-03-22 15:42:00 -07003508 EXPECT_FALSE(stream->IsSending());
3509
3510 // Now change it back to active and verify we resume sending.
3511 parameters.encodings[0].active = true;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003512 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
deadbeefdbe2b872016-03-22 15:42:00 -07003513 EXPECT_TRUE(stream->IsSending());
3514}
3515
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003516// Test that GetRtpSendParameters returns the currently configured codecs.
3517TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003518 AddSendStream();
3519 cricket::VideoSendParameters parameters;
3520 parameters.codecs.push_back(kVp8Codec);
3521 parameters.codecs.push_back(kVp9Codec);
3522 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3523
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003524 webrtc::RtpParameters rtp_parameters =
3525 channel_->GetRtpSendParameters(last_ssrc_);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003526 ASSERT_EQ(2u, rtp_parameters.codecs.size());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003527 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]);
3528 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003529}
3530
3531// Test that if we set/get parameters multiple times, we get the same results.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003532TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003533 AddSendStream();
3534 cricket::VideoSendParameters parameters;
3535 parameters.codecs.push_back(kVp8Codec);
3536 parameters.codecs.push_back(kVp9Codec);
3537 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3538
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003539 webrtc::RtpParameters initial_params =
3540 channel_->GetRtpSendParameters(last_ssrc_);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003541
3542 // We should be able to set the params we just got.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003543 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, initial_params));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003544
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07003545 // ... And this shouldn't change the params returned by GetRtpSendParameters.
3546 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(last_ssrc_));
3547}
3548
3549// Test that GetRtpReceiveParameters returns the currently configured codecs.
3550TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) {
3551 AddRecvStream();
3552 cricket::VideoRecvParameters parameters;
3553 parameters.codecs.push_back(kVp8Codec);
3554 parameters.codecs.push_back(kVp9Codec);
3555 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
3556
3557 webrtc::RtpParameters rtp_parameters =
3558 channel_->GetRtpReceiveParameters(last_ssrc_);
3559 ASSERT_EQ(2u, rtp_parameters.codecs.size());
3560 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]);
3561 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]);
3562}
3563
3564// Test that if we set/get parameters multiple times, we get the same results.
3565TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) {
3566 AddRecvStream();
3567 cricket::VideoRecvParameters parameters;
3568 parameters.codecs.push_back(kVp8Codec);
3569 parameters.codecs.push_back(kVp9Codec);
3570 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
3571
3572 webrtc::RtpParameters initial_params =
3573 channel_->GetRtpReceiveParameters(last_ssrc_);
3574
3575 // We should be able to set the params we just got.
3576 EXPECT_TRUE(channel_->SetRtpReceiveParameters(last_ssrc_, initial_params));
3577
3578 // ... And this shouldn't change the params returned by
3579 // GetRtpReceiveParameters.
3580 EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(last_ssrc_));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07003581}
3582
Peter Boström3548dd22015-05-22 18:48:36 +02003583void WebRtcVideoChannel2Test::TestReceiverLocalSsrcConfiguration(
3584 bool receiver_first) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003585 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Peter Boström3548dd22015-05-22 18:48:36 +02003586
3587 const uint32_t kSenderSsrc = 0xC0FFEE;
Peter Boströmdfa28152015-10-21 17:21:10 +02003588 const uint32_t kSecondSenderSsrc = 0xBADCAFE;
Peter Boström3548dd22015-05-22 18:48:36 +02003589 const uint32_t kReceiverSsrc = 0x4711;
Peter Boströmdfa28152015-10-21 17:21:10 +02003590 const uint32_t kExpectedDefaultReceiverSsrc = 1;
Peter Boström3548dd22015-05-22 18:48:36 +02003591
3592 if (receiver_first) {
3593 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
3594 std::vector<FakeVideoReceiveStream*> receive_streams =
3595 fake_call_->GetVideoReceiveStreams();
3596 ASSERT_EQ(1u, receive_streams.size());
Peter Boströmdfa28152015-10-21 17:21:10 +02003597 // Default local SSRC when we have no sender.
3598 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
3599 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02003600 }
3601 AddSendStream(StreamParams::CreateLegacy(kSenderSsrc));
3602 if (!receiver_first)
3603 AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
3604 std::vector<FakeVideoReceiveStream*> receive_streams =
3605 fake_call_->GetVideoReceiveStreams();
3606 ASSERT_EQ(1u, receive_streams.size());
3607 EXPECT_EQ(kSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boströmdfa28152015-10-21 17:21:10 +02003608
3609 // Removing first sender should fall back to another (in this case the second)
3610 // local send stream's SSRC.
3611 AddSendStream(StreamParams::CreateLegacy(kSecondSenderSsrc));
3612 ASSERT_TRUE(channel_->RemoveSendStream(kSenderSsrc));
3613 receive_streams =
3614 fake_call_->GetVideoReceiveStreams();
3615 ASSERT_EQ(1u, receive_streams.size());
3616 EXPECT_EQ(kSecondSenderSsrc, receive_streams[0]->GetConfig().rtp.local_ssrc);
3617
3618 // Removing the last sender should fall back to default local SSRC.
3619 ASSERT_TRUE(channel_->RemoveSendStream(kSecondSenderSsrc));
3620 receive_streams =
3621 fake_call_->GetVideoReceiveStreams();
3622 ASSERT_EQ(1u, receive_streams.size());
3623 EXPECT_EQ(kExpectedDefaultReceiverSsrc,
3624 receive_streams[0]->GetConfig().rtp.local_ssrc);
Peter Boström3548dd22015-05-22 18:48:36 +02003625}
3626
3627TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrc) {
3628 TestReceiverLocalSsrcConfiguration(false);
3629}
3630
3631TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) {
3632 TestReceiverLocalSsrcConfiguration(true);
3633}
3634
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003635class WebRtcVideoChannel2SimulcastTest : public testing::Test {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003636 public:
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003637 WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {}
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003638
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00003639 void SetUp() override {
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +02003640 engine_.Init();
nisse51542be2016-02-12 02:27:06 -08003641 channel_.reset(
3642 engine_.CreateChannel(&fake_call_, MediaConfig(), VideoOptions()));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003643 last_ssrc_ = 123;
3644 }
3645
3646 protected:
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003647 void VerifySimulcastSettings(const VideoCodec& codec,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003648 size_t num_configured_streams,
pbosbe16f792015-10-16 12:49:39 -07003649 size_t expected_num_streams) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003650 cricket::VideoSendParameters parameters;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003651 parameters.codecs.push_back(codec);
3652 ASSERT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003653
Peter Boström0c4e06b2015-10-07 12:23:21 +02003654 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
henrikg91d6ede2015-09-17 00:24:34 -07003655 RTC_DCHECK(num_configured_streams <= ssrcs.size());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003656 ssrcs.resize(num_configured_streams);
3657
3658 FakeVideoSendStream* stream =
3659 AddSendStream(CreateSimStreamParams("cname", ssrcs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003660 // Send a full-size frame to trigger a stream reconfiguration to use all
3661 // expected simulcast layers.
3662 cricket::FakeVideoCapturer capturer;
nisse2ded9b12016-04-08 02:23:55 -07003663 channel_->SetSource(ssrcs.front(), &capturer);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00003664 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
3665 codec.width, codec.height,
3666 cricket::VideoFormat::FpsToInterval(30),
3667 cricket::FOURCC_I420)));
3668 channel_->SetSend(true);
3669 EXPECT_TRUE(capturer.CaptureFrame());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003670
3671 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
3672 ASSERT_EQ(expected_num_streams, video_streams.size());
3673
3674 std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
pbosbe16f792015-10-16 12:49:39 -07003675 num_configured_streams, codec.width, codec.height, 0, kDefaultQpMax,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003676 codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
3677
3678 ASSERT_EQ(expected_streams.size(), video_streams.size());
3679
3680 size_t num_streams = video_streams.size();
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003681 int total_max_bitrate_bps = 0;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003682 for (size_t i = 0; i < num_streams; ++i) {
3683 EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
3684 EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
3685
3686 EXPECT_GT(video_streams[i].max_framerate, 0);
3687 EXPECT_EQ(expected_streams[i].max_framerate,
3688 video_streams[i].max_framerate);
3689
3690 EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
3691 EXPECT_EQ(expected_streams[i].min_bitrate_bps,
3692 video_streams[i].min_bitrate_bps);
3693
3694 EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
3695 EXPECT_EQ(expected_streams[i].target_bitrate_bps,
3696 video_streams[i].target_bitrate_bps);
3697
3698 EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
3699 EXPECT_EQ(expected_streams[i].max_bitrate_bps,
3700 video_streams[i].max_bitrate_bps);
3701
3702 EXPECT_GT(video_streams[i].max_qp, 0);
3703 EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
3704
3705 EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty());
3706 EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps,
3707 video_streams[i].temporal_layer_thresholds_bps);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003708
3709 if (i == num_streams - 1) {
3710 total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
3711 } else {
3712 total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
3713 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003714 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003715 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00003716 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00003717 ASSERT_EQ(1u, info.senders.size());
3718 EXPECT_EQ(total_max_bitrate_bps, info.senders[0].preferred_bitrate);
3719
nisse2ded9b12016-04-08 02:23:55 -07003720 channel_->SetSource(ssrcs.front(), NULL);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003721 }
3722
3723 FakeVideoSendStream* AddSendStream() {
3724 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
3725 }
3726
3727 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
3728 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003729 fake_call_.GetVideoSendStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003730 EXPECT_TRUE(channel_->AddSendStream(sp));
3731 std::vector<FakeVideoSendStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003732 fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003733 EXPECT_EQ(num_streams + 1, streams.size());
3734 return streams[streams.size() - 1];
3735 }
3736
3737 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003738 return fake_call_.GetVideoSendStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003739 }
3740
3741 FakeVideoReceiveStream* AddRecvStream() {
3742 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
3743 }
3744
3745 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
3746 size_t num_streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003747 fake_call_.GetVideoReceiveStreams().size();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003748 EXPECT_TRUE(channel_->AddRecvStream(sp));
3749 std::vector<FakeVideoReceiveStream*> streams =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003750 fake_call_.GetVideoReceiveStreams();
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003751 EXPECT_EQ(num_streams + 1, streams.size());
3752 return streams[streams.size() - 1];
3753 }
3754
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003755 FakeCall fake_call_;
3756 WebRtcVideoEngine2 engine_;
kwiberg686a8ef2016-02-26 03:00:35 -08003757 std::unique_ptr<VideoMediaChannel> channel_;
Peter Boström0c4e06b2015-10-07 12:23:21 +02003758 uint32_t last_ssrc_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003759};
3760
3761TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003762 VerifySimulcastSettings(kVp8Codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003763}
3764
3765TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
pbosbe16f792015-10-16 12:49:39 -07003766 VerifySimulcastSettings(kVp8Codec720p, 3, 3);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003767}
3768
3769// Test that we normalize send codec format size in simulcast.
3770TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
3771 cricket::VideoCodec codec(kVp8Codec270p);
3772 codec.width += 1;
3773 codec.height += 1;
pbosbe16f792015-10-16 12:49:39 -07003774 VerifySimulcastSettings(codec, 2, 2);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00003775}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003776} // namespace cricket