blob: 73228793490ac55991e1276160a2971194ebba17 [file] [log] [blame]
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001/*
2 * libjingle
3 * Copyright 2004 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +000028#include <algorithm>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000029#include <map>
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000030#include <vector>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000031
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000032#include "talk/media/base/testutils.h"
33#include "talk/media/base/videoengine_unittest.h"
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000034#include "talk/media/webrtc/fakewebrtcvideoengine.h"
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000035#include "talk/media/webrtc/simulcast.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000036#include "talk/media/webrtc/webrtcvideochannelfactory.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000037#include "talk/media/webrtc/webrtcvideoengine2.h"
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000038#include "talk/media/webrtc/webrtcvideoengine2_unittest.h"
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +000039#include "talk/media/webrtc/webrtcvoiceengine.h"
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +000040#include "webrtc/base/arraysize.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000041#include "webrtc/base/gunit.h"
42#include "webrtc/base/stringutils.h"
pbos@webrtc.org42684be2014-10-03 11:25:45 +000043#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000044
45namespace {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000046static const int kDefaultQpMax = 56;
47static const int kDefaultFramerate = 30;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000048
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000049static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0);
50static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30, 0);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000051static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30, 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000052
53static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0);
54static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000055static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0);
56
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000057static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0);
58static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0);
59
60static const uint32 kSsrcs1[] = {1};
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000061static const uint32 kSsrcs3[] = {1, 2, 3};
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000062static const uint32 kRtxSsrcs1[] = {4};
pbos@webrtc.org3c107582014-07-20 15:27:35 +000063static const char kUnsupportedExtensionName[] =
64 "urn:ietf:params:rtp-hdrext:unsupported";
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000065
66void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
67 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
68 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
69 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
70 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
71 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
72 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
73 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
74 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
75}
76
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000077static void CreateBlackFrame(webrtc::I420VideoFrame* video_frame,
78 int width,
79 int height) {
80 video_frame->CreateEmptyFrame(
81 width, height, width, (width + 1) / 2, (width + 1) / 2);
82 memset(video_frame->buffer(webrtc::kYPlane), 16,
83 video_frame->allocated_size(webrtc::kYPlane));
84 memset(video_frame->buffer(webrtc::kUPlane), 128,
85 video_frame->allocated_size(webrtc::kUPlane));
86 memset(video_frame->buffer(webrtc::kVPlane), 128,
87 video_frame->allocated_size(webrtc::kVPlane));
88}
89
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000090} // namespace
91
92namespace cricket {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000093FakeVideoSendStream::FakeVideoSendStream(
94 const webrtc::VideoSendStream::Config& config,
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +000095 const webrtc::VideoEncoderConfig& encoder_config)
pbos@webrtc.org42684be2014-10-03 11:25:45 +000096 : sending_(false),
97 config_(config),
98 codec_settings_set_(false),
99 num_swapped_frames_(0) {
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000100 assert(config.encoder_settings.encoder != NULL);
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000101 ReconfigureVideoEncoder(encoder_config);
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000102}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000103
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000104webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() const {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000105 return config_;
106}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000107
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000108webrtc::VideoEncoderConfig FakeVideoSendStream::GetEncoderConfig() const {
109 return encoder_config_;
110}
111
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000112std::vector<webrtc::VideoStream> FakeVideoSendStream::GetVideoStreams() {
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000113 return encoder_config_.streams;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000114}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000115
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000116bool FakeVideoSendStream::IsSending() const {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000117 return sending_;
118}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000119
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000120bool FakeVideoSendStream::GetVp8Settings(
121 webrtc::VideoCodecVP8* settings) const {
122 if (!codec_settings_set_) {
123 return false;
124 }
125
126 *settings = vp8_settings_;
127 return true;
128}
129
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000130int FakeVideoSendStream::GetNumberOfSwappedFrames() const {
131 return num_swapped_frames_;
132}
133
134int FakeVideoSendStream::GetLastWidth() const {
135 return last_frame_.width();
136}
137
138int FakeVideoSendStream::GetLastHeight() const {
139 return last_frame_.height();
140}
141
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +0000142void FakeVideoSendStream::IncomingCapturedFrame(
143 const webrtc::I420VideoFrame& frame) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000144 ++num_swapped_frames_;
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +0000145 last_frame_.ShallowCopy(frame);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000146}
pbos@webrtc.org273a4142014-12-01 15:23:21 +0000147
148void FakeVideoSendStream::SetStats(
149 const webrtc::VideoSendStream::Stats& stats) {
150 stats_ = stats;
151}
152
153webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() {
154 return stats_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000155}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000156
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000157bool FakeVideoSendStream::ReconfigureVideoEncoder(
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000158 const webrtc::VideoEncoderConfig& config) {
159 encoder_config_ = config;
160 if (config.encoder_specific_settings != NULL) {
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000161 assert(config_.encoder_settings.payload_name == "VP8");
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000162 vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>(
163 config.encoder_specific_settings);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000164 }
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000165 codec_settings_set_ = config.encoder_specific_settings != NULL;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000166 return true;
167}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000168
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000169webrtc::VideoSendStreamInput* FakeVideoSendStream::Input() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000170 return this;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000171}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000172
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000173void FakeVideoSendStream::Start() {
174 sending_ = true;
175}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000176
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000177void FakeVideoSendStream::Stop() {
178 sending_ = false;
179}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000180
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000181FakeVideoReceiveStream::FakeVideoReceiveStream(
182 const webrtc::VideoReceiveStream::Config& config)
183 : config_(config), receiving_(false) {
184}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000185
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000186webrtc::VideoReceiveStream::Config FakeVideoReceiveStream::GetConfig() {
187 return config_;
188}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000189
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000190bool FakeVideoReceiveStream::IsReceiving() const {
191 return receiving_;
192}
193
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +0000194void FakeVideoReceiveStream::InjectFrame(const webrtc::I420VideoFrame& frame,
195 int time_to_render_ms) {
196 config_.renderer->RenderFrame(frame, time_to_render_ms);
197}
198
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000199webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const {
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +0000200 return stats_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000201}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000202
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000203void FakeVideoReceiveStream::Start() {
204 receiving_ = true;
205}
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000206
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000207void FakeVideoReceiveStream::Stop() {
208 receiving_ = false;
209}
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000210
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +0000211void FakeVideoReceiveStream::SetStats(
212 const webrtc::VideoReceiveStream::Stats& stats) {
213 stats_ = stats;
214}
215
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000216FakeCall::FakeCall(const webrtc::Call::Config& config)
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000217 : config_(config),
218 network_state_(kNetworkUp),
219 num_created_send_streams_(0),
220 num_created_receive_streams_(0) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000221}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000222
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000223FakeCall::~FakeCall() {
224 EXPECT_EQ(0u, video_send_streams_.size());
225 EXPECT_EQ(0u, video_receive_streams_.size());
226}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000227
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000228webrtc::Call::Config FakeCall::GetConfig() const {
229 return config_;
230}
231
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000232std::vector<FakeVideoSendStream*> FakeCall::GetVideoSendStreams() {
233 return video_send_streams_;
234}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000235
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000236std::vector<FakeVideoReceiveStream*> FakeCall::GetVideoReceiveStreams() {
237 return video_receive_streams_;
238}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000239
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000240webrtc::Call::NetworkState FakeCall::GetNetworkState() const {
241 return network_state_;
242}
243
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000244webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
245 const webrtc::VideoSendStream::Config& config,
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000246 const webrtc::VideoEncoderConfig& encoder_config) {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000247 FakeVideoSendStream* fake_stream =
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000248 new FakeVideoSendStream(config, encoder_config);
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000249 video_send_streams_.push_back(fake_stream);
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000250 ++num_created_send_streams_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000251 return fake_stream;
252}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000253
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000254void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
255 FakeVideoSendStream* fake_stream =
256 static_cast<FakeVideoSendStream*>(send_stream);
257 for (size_t i = 0; i < video_send_streams_.size(); ++i) {
258 if (video_send_streams_[i] == fake_stream) {
259 delete video_send_streams_[i];
260 video_send_streams_.erase(video_send_streams_.begin() + i);
261 return;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000262 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000263 }
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000264 ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter.";
265}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000266
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000267webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
268 const webrtc::VideoReceiveStream::Config& config) {
269 video_receive_streams_.push_back(new FakeVideoReceiveStream(config));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000270 ++num_created_receive_streams_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000271 return video_receive_streams_[video_receive_streams_.size() - 1];
272}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000273
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000274void FakeCall::DestroyVideoReceiveStream(
275 webrtc::VideoReceiveStream* receive_stream) {
276 FakeVideoReceiveStream* fake_stream =
277 static_cast<FakeVideoReceiveStream*>(receive_stream);
278 for (size_t i = 0; i < video_receive_streams_.size(); ++i) {
279 if (video_receive_streams_[i] == fake_stream) {
280 delete video_receive_streams_[i];
281 video_receive_streams_.erase(video_receive_streams_.begin() + i);
282 return;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000283 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000284 }
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000285 ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter.";
286}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000287
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000288webrtc::PacketReceiver* FakeCall::Receiver() {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000289 return this;
290}
291
292FakeCall::DeliveryStatus FakeCall::DeliverPacket(const uint8_t* packet,
293 size_t length) {
294 CHECK(length >= 12);
295 uint32_t ssrc;
296 if (!GetRtpSsrc(packet, length, &ssrc))
297 return DELIVERY_PACKET_ERROR;
298
299 for (auto& receiver: video_receive_streams_) {
300 if (receiver->GetConfig().rtp.remote_ssrc == ssrc)
301 return DELIVERY_OK;
302 }
303 return DELIVERY_UNKNOWN_SSRC;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000304}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000305
pbos@webrtc.org2b19f062014-12-11 13:26:09 +0000306void FakeCall::SetStats(const webrtc::Call::Stats& stats) {
307 stats_ = stats;
308}
309
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000310int FakeCall::GetNumCreatedSendStreams() const {
311 return num_created_send_streams_;
312}
313
314int FakeCall::GetNumCreatedReceiveStreams() const {
315 return num_created_receive_streams_;
316}
317
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000318webrtc::Call::Stats FakeCall::GetStats() const {
pbos@webrtc.org2b19f062014-12-11 13:26:09 +0000319 return stats_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000320}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000321
pbos@webrtc.org00873182014-11-25 14:03:34 +0000322void FakeCall::SetBitrateConfig(
323 const webrtc::Call::Config::BitrateConfig& bitrate_config) {
Stefan Holmere5904162015-03-26 11:11:06 +0100324 config_.bitrate_config = bitrate_config;
pbos@webrtc.org00873182014-11-25 14:03:34 +0000325}
326
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000327void FakeCall::SignalNetworkState(webrtc::Call::NetworkState state) {
328 network_state_ = state;
329}
330
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000331class WebRtcVideoEngine2Test : public ::testing::Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000332 public:
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000333 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test(nullptr) {}
334 WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine)
335 : engine_(voice_engine) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000336 std::vector<VideoCodec> engine_codecs = engine_.codecs();
337 assert(!engine_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000338 bool codec_set = false;
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000339 for (size_t i = 0; i < engine_codecs.size(); ++i) {
340 if (engine_codecs[i].name == "red") {
341 default_red_codec_ = engine_codecs[i];
342 } else if (engine_codecs[i].name == "ulpfec") {
343 default_ulpfec_codec_ = engine_codecs[i];
344 } else if (engine_codecs[i].name == "rtx") {
andrew@webrtc.org8f27fcc2015-01-09 20:22:46 +0000345 default_rtx_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000346 } else if (!codec_set) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000347 default_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000348 codec_set = true;
349 }
350 }
351
352 assert(codec_set);
353 }
354
355 protected:
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000356 class FakeCallFactory : public WebRtcCallFactory {
357 public:
358 FakeCallFactory() : fake_call_(NULL) {}
359 FakeCall* GetCall() { return fake_call_; }
360
361 private:
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000362 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000363 assert(fake_call_ == NULL);
364 fake_call_ = new FakeCall(config);
365 return fake_call_;
366 }
367
368 FakeCall* fake_call_;
369 };
370
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000371 VideoMediaChannel* SetUpForExternalEncoderFactory(
372 cricket::WebRtcVideoEncoderFactory* encoder_factory,
373 const std::vector<VideoCodec>& codecs);
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000374
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000375 VideoMediaChannel* SetUpForExternalDecoderFactory(
376 cricket::WebRtcVideoDecoderFactory* decoder_factory,
377 const std::vector<VideoCodec>& codecs);
378
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000379 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
380 // initialized when the constructor is called.
381 WebRtcVoiceEngine voice_engine_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000382 WebRtcVideoEngine2 engine_;
383 VideoCodec default_codec_;
384 VideoCodec default_red_codec_;
385 VideoCodec default_ulpfec_codec_;
andrew@webrtc.org8f27fcc2015-01-09 20:22:46 +0000386 VideoCodec default_rtx_codec_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000387};
388
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000389class WebRtcVideoEngine2VoiceTest : public WebRtcVideoEngine2Test {
390 public:
391 WebRtcVideoEngine2VoiceTest() : WebRtcVideoEngine2Test(&voice_engine_) {}
392};
393
394TEST_F(WebRtcVideoEngine2VoiceTest, ConfiguresAvSyncForFirstReceiveChannel) {
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000395 FakeCallFactory call_factory;
396 engine_.SetCallFactory(&call_factory);
397
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000398 voice_engine_.Init(rtc::Thread::Current());
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000399 engine_.Init(rtc::Thread::Current());
400
401 rtc::scoped_ptr<VoiceMediaChannel> voice_channel(
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000402 voice_engine_.CreateChannel());
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000403 ASSERT_TRUE(voice_channel.get() != NULL);
404 WebRtcVoiceMediaChannel* webrtc_voice_channel =
405 static_cast<WebRtcVoiceMediaChannel*>(voice_channel.get());
406 ASSERT_NE(webrtc_voice_channel->voe_channel(), -1);
407 rtc::scoped_ptr<VideoMediaChannel> channel(
408 engine_.CreateChannel(cricket::VideoOptions(), voice_channel.get()));
409
410 FakeCall* fake_call = call_factory.GetCall();
411 ASSERT_TRUE(fake_call != NULL);
412
413 webrtc::Call::Config call_config = fake_call->GetConfig();
414
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000415 ASSERT_TRUE(voice_engine_.voe()->engine() != NULL);
416 ASSERT_EQ(voice_engine_.voe()->engine(), call_config.voice_engine);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000417
418 EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc)));
419 EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc + 1)));
420 std::vector<FakeVideoReceiveStream*> receive_streams =
421 fake_call->GetVideoReceiveStreams();
422
423 ASSERT_EQ(2u, receive_streams.size());
424 EXPECT_EQ(webrtc_voice_channel->voe_channel(),
425 receive_streams[0]->GetConfig().audio_channel_id);
426 EXPECT_EQ(-1, receive_streams[1]->GetConfig().audio_channel_id)
427 << "AV sync should only be set up for the first receive channel.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000428}
429
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000430TEST_F(WebRtcVideoEngine2Test, FindCodec) {
431 const std::vector<cricket::VideoCodec>& c = engine_.codecs();
andrew@webrtc.org8f27fcc2015-01-09 20:22:46 +0000432 EXPECT_EQ(4U, c.size());
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000433
434 cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0);
435 EXPECT_TRUE(engine_.FindCodec(vp8));
436
437 cricket::VideoCodec vp8_ci(104, "vp8", 320, 200, 30, 0);
438 EXPECT_TRUE(engine_.FindCodec(vp8));
439
440 cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50);
441 EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref));
442
443 cricket::VideoCodec vp8_diff_id(95, "VP8", 320, 200, 30, 0);
444 EXPECT_FALSE(engine_.FindCodec(vp8_diff_id));
445 vp8_diff_id.id = 97;
446 EXPECT_TRUE(engine_.FindCodec(vp8_diff_id));
447
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000448 // FindCodec ignores the codec size.
449 // Test that FindCodec can accept uncommon codec size.
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000450 cricket::VideoCodec vp8_diff_res(104, "VP8", 320, 111, 30, 0);
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000451 EXPECT_TRUE(engine_.FindCodec(vp8_diff_res));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000452
453 // PeerConnection doesn't negotiate the resolution at this point.
454 // Test that FindCodec can handle the case when width/height is 0.
455 cricket::VideoCodec vp8_zero_res(104, "VP8", 0, 0, 30, 0);
456 EXPECT_TRUE(engine_.FindCodec(vp8_zero_res));
457
458 cricket::VideoCodec red(101, "RED", 0, 0, 30, 0);
459 EXPECT_TRUE(engine_.FindCodec(red));
460
461 cricket::VideoCodec red_ci(101, "red", 0, 0, 30, 0);
462 EXPECT_TRUE(engine_.FindCodec(red));
463
464 cricket::VideoCodec fec(102, "ULPFEC", 0, 0, 30, 0);
465 EXPECT_TRUE(engine_.FindCodec(fec));
466
467 cricket::VideoCodec fec_ci(102, "ulpfec", 0, 0, 30, 0);
468 EXPECT_TRUE(engine_.FindCodec(fec));
469
470 cricket::VideoCodec rtx(96, "rtx", 0, 0, 30, 0);
471 EXPECT_TRUE(engine_.FindCodec(rtx));
472}
473
pbos@webrtc.org2a72c652015-02-26 16:01:24 +0000474TEST_F(WebRtcVideoEngine2Test, SetDefaultEncoderConfigPreservesFeedbackParams) {
475 cricket::VideoCodec max_settings(
476 engine_.codecs()[0].id, engine_.codecs()[0].name,
477 engine_.codecs()[0].width / 2, engine_.codecs()[0].height / 2, 30, 0);
478 // This codec shouldn't have NACK by default or the test is pointless.
479 EXPECT_FALSE(max_settings.HasFeedbackParam(
480 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
481 // The engine should by default have it however.
482 EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam(
483 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
484
485 // Set constrained max codec settings.
486 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
487 cricket::VideoEncoderConfig(max_settings)));
488
489 // Verify that feedback parameters are retained.
490 EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam(
491 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
492}
493
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000494TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
495 std::vector<VideoCodec> engine_codecs = engine_.codecs();
496 for (size_t i = 0; i < engine_codecs.size(); ++i) {
497 if (engine_codecs[i].name != kRtxCodecName)
498 continue;
499 int associated_payload_type;
500 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000501 &associated_payload_type));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000502 EXPECT_EQ(default_codec_.id, associated_payload_type);
503 return;
504 }
505 FAIL() << "No RTX codec found among default codecs.";
506}
507
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000508TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
509 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
510 ASSERT_FALSE(extensions.empty());
511 for (size_t i = 0; i < extensions.size(); ++i) {
512 if (extensions[i].uri == kRtpTimestampOffsetHeaderExtension) {
513 EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extensions[i].id);
514 return;
515 }
516 }
517 FAIL() << "Timestamp offset extension not in header-extension list.";
518}
519
520TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
521 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
522 ASSERT_FALSE(extensions.empty());
523 for (size_t i = 0; i < extensions.size(); ++i) {
524 if (extensions[i].uri == kRtpAbsoluteSenderTimeHeaderExtension) {
525 EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId,
526 extensions[i].id);
527 return;
528 }
529 }
530 FAIL() << "Absolute Sender Time extension not in header-extension list.";
531}
532
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000533TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000534 engine_.Init(rtc::Thread::Current());
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000535 rtc::scoped_ptr<VideoMediaChannel> channel(
536 engine_.CreateChannel(cricket::VideoOptions(), NULL));
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000537
538 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
539
540 EXPECT_FALSE(channel->SetSend(true))
541 << "Channel should not start without codecs.";
542 EXPECT_TRUE(channel->SetSend(false))
543 << "Channel should be stoppable even without set codecs.";
544}
545
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000546TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000547 engine_.Init(rtc::Thread::Current());
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000548 rtc::scoped_ptr<VideoMediaChannel> channel(
549 engine_.CreateChannel(cricket::VideoOptions(), NULL));
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000550 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
551 VideoMediaInfo info;
552 channel->GetStats(&info);
553}
554
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000555TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
556 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
557 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
558 std::vector<cricket::VideoCodec> codecs;
559 codecs.push_back(kVp8Codec);
560
561 rtc::scoped_ptr<VideoMediaChannel> channel(
562 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
563
564 EXPECT_TRUE(
565 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
566 ASSERT_EQ(1u, encoder_factory.encoders().size());
567 EXPECT_TRUE(channel->SetSend(true));
568
569 cricket::FakeVideoCapturer capturer;
570 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
571 EXPECT_EQ(cricket::CS_RUNNING,
572 capturer.Start(capturer.GetSupportedFormats()->front()));
573 EXPECT_TRUE(capturer.CaptureFrame());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000574 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
575 kTimeout);
576
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000577 // Sending one frame will have reallocated the encoder since input size
578 // changes from a small default to the actual frame width/height.
579 int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
580 EXPECT_EQ(num_created_encoders, 2);
581
582 // Setting codecs of the same type should not reallocate any encoders
583 // (expecting a no-op).
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000584 EXPECT_TRUE(channel->SetSendCodecs(codecs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000585 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000586
587 // Remove stream previously added to free the external encoder instance.
588 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
589 EXPECT_EQ(0u, encoder_factory.encoders().size());
590}
591
592VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
593 cricket::WebRtcVideoEncoderFactory* encoder_factory,
594 const std::vector<VideoCodec>& codecs) {
595 engine_.SetExternalEncoderFactory(encoder_factory);
596 engine_.Init(rtc::Thread::Current());
597
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000598 VideoMediaChannel* channel =
599 engine_.CreateChannel(cricket::VideoOptions(), NULL);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000600 EXPECT_TRUE(channel->SetSendCodecs(codecs));
601
602 return channel;
603}
604
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000605VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
606 cricket::WebRtcVideoDecoderFactory* decoder_factory,
607 const std::vector<VideoCodec>& codecs) {
608 engine_.SetExternalDecoderFactory(decoder_factory);
609 engine_.Init(rtc::Thread::Current());
610
611 VideoMediaChannel* channel =
612 engine_.CreateChannel(cricket::VideoOptions(), NULL);
613 EXPECT_TRUE(channel->SetRecvCodecs(codecs));
614
615 return channel;
616}
617
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000618TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
619 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
620 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
621 std::vector<cricket::VideoCodec> codecs;
622 codecs.push_back(kVp8Codec);
623
624 rtc::scoped_ptr<VideoMediaChannel> channel(
625 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
626
627 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
628
629 EXPECT_TRUE(
630 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
631 EXPECT_TRUE(channel->SetSend(true));
632
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000633 cricket::FakeVideoCapturer capturer;
634 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
635 EXPECT_EQ(cricket::CS_RUNNING,
636 capturer.Start(capturer.GetSupportedFormats()->front()));
637 EXPECT_TRUE(capturer.CaptureFrame());
638
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000639 EXPECT_GT(encoder_factory.encoders().size(), 1u);
640
641 // Verify that encoders are configured for simulcast through adapter
642 // (increasing resolution and only configured to send one stream each).
643 int prev_width = -1;
644 for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
645 webrtc::VideoCodec codec_settings =
646 encoder_factory.encoders()[i]->GetCodecSettings();
647 EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
648 EXPECT_GT(codec_settings.width, prev_width);
649 prev_width = codec_settings.width;
650 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000651
652 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), NULL));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000653
654 channel.reset();
655 ASSERT_EQ(0u, encoder_factory.encoders().size());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000656}
657
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000658TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
659 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
660 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
661 std::vector<cricket::VideoCodec> codecs;
662 codecs.push_back(kH264Codec);
663
664 rtc::scoped_ptr<VideoMediaChannel> channel(
665 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
666
667 EXPECT_TRUE(
668 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
669 ASSERT_EQ(1u, encoder_factory.encoders().size());
670
671 codecs.clear();
672 codecs.push_back(kVp8Codec);
673 EXPECT_TRUE(channel->SetSendCodecs(codecs));
674
675 ASSERT_EQ(0u, encoder_factory.encoders().size());
676}
677
678TEST_F(WebRtcVideoEngine2Test,
679 DontUseExternalEncoderFactoryForUnsupportedCodecs) {
680 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
681 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
682 std::vector<cricket::VideoCodec> codecs;
683 codecs.push_back(kVp8Codec);
684
685 rtc::scoped_ptr<VideoMediaChannel> channel(
686 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
687
688 EXPECT_TRUE(
689 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000690 // Make sure DestroyVideoEncoder was called on the factory.
691 ASSERT_EQ(0u, encoder_factory.encoders().size());
692}
693
694TEST_F(WebRtcVideoEngine2Test,
695 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
696 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
697 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
698 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
699
700 std::vector<cricket::VideoCodec> codecs;
701 codecs.push_back(kVp8Codec);
702
703 rtc::scoped_ptr<VideoMediaChannel> channel(
704 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
705
706 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
707
708 EXPECT_TRUE(
709 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
710 EXPECT_TRUE(channel->SetSend(true));
711
712 // Send a fake frame, or else the media engine will configure the simulcast
713 // encoder adapter at a low-enough size that it'll only create a single
714 // encoder layer.
715 cricket::FakeVideoCapturer capturer;
716 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
717 EXPECT_EQ(cricket::CS_RUNNING,
718 capturer.Start(capturer.GetSupportedFormats()->front()));
719 EXPECT_TRUE(capturer.CaptureFrame());
720
721 ASSERT_GT(encoder_factory.encoders().size(), 1u);
722 EXPECT_EQ(webrtc::kVideoCodecVP8,
723 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
724
725 channel.reset();
726 // Make sure DestroyVideoEncoder was called on the factory.
727 EXPECT_EQ(0u, encoder_factory.encoders().size());
728}
729
730TEST_F(WebRtcVideoEngine2Test,
731 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
732 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
733 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
734 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
735
736 std::vector<cricket::VideoCodec> codecs;
737 codecs.push_back(kH264Codec);
738
739 rtc::scoped_ptr<VideoMediaChannel> channel(
740 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
741
742 EXPECT_TRUE(
743 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
744 ASSERT_EQ(1u, encoder_factory.encoders().size());
745 EXPECT_EQ(webrtc::kVideoCodecH264,
746 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
747
748 channel.reset();
749 // Make sure DestroyVideoEncoder was called on the factory.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000750 ASSERT_EQ(0u, encoder_factory.encoders().size());
751}
752
753// Test external codec with be added to the end of the supported codec list.
754TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) {
755 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
756 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
757 engine_.SetExternalEncoderFactory(&encoder_factory);
758
759 engine_.Init(rtc::Thread::Current());
760
761 std::vector<cricket::VideoCodec> codecs(engine_.codecs());
762 ASSERT_GE(codecs.size(), 2u);
763 cricket::VideoCodec internal_codec = codecs.front();
764 cricket::VideoCodec external_codec = codecs.back();
765
766 // The external codec will appear at last.
767 EXPECT_EQ("VP8", internal_codec.name);
768 EXPECT_EQ("H264", external_codec.name);
769}
770
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000771TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
772 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
773 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
774 std::vector<cricket::VideoCodec> codecs;
775 codecs.push_back(kVp8Codec);
776
777 rtc::scoped_ptr<VideoMediaChannel> channel(
778 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
779
780 EXPECT_TRUE(
781 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
782 ASSERT_EQ(1u, decoder_factory.decoders().size());
783
784 // Setting codecs of the same type should not reallocate the decoder.
785 EXPECT_TRUE(channel->SetRecvCodecs(codecs));
786 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
787
788 // Remove stream previously added to free the external decoder instance.
789 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
790 EXPECT_EQ(0u, decoder_factory.decoders().size());
791}
792
793// Verifies that we can set up decoders that are not internally supported.
794TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
795 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
796 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
797 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
798 // codecs.
799 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
800 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
801 engine_.SetExternalEncoderFactory(&encoder_factory);
802 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
803 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
804 std::vector<cricket::VideoCodec> codecs;
805 codecs.push_back(kH264Codec);
806
807 rtc::scoped_ptr<VideoMediaChannel> channel(
808 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
809
810 EXPECT_TRUE(
811 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
812 ASSERT_EQ(1u, decoder_factory.decoders().size());
813}
814
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000815class WebRtcVideoEngine2BaseTest
816 : public VideoEngineTest<cricket::WebRtcVideoEngine2> {
817 protected:
818 typedef VideoEngineTest<cricket::WebRtcVideoEngine2> Base;
819};
820
821#define WEBRTC_ENGINE_BASE_TEST(test) \
822 TEST_F(WebRtcVideoEngine2BaseTest, test) { Base::test##Body(); }
823
824WEBRTC_ENGINE_BASE_TEST(ConstrainNewCodec2);
825
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000826class WebRtcVideoChannel2BaseTest
827 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
828 protected:
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000829 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000830
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000831 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000832};
833
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000834#define WEBRTC_BASE_TEST(test) \
835 TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); }
836
837#define WEBRTC_DISABLED_BASE_TEST(test) \
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000838 TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); }
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000839
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000840// TODO(pbos): Fix WebRtcVideoEngine2BaseTest, where we want CheckCoInitialize.
841#if 0
842// TODO(juberti): Figure out why ViE is munging the COM refcount.
843#ifdef WIN32
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000844WEBRTC_DISABLED_BASE_TEST(CheckCoInitialize) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000845 Base::CheckCoInitialize();
846}
847#endif
848#endif
849
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000850WEBRTC_BASE_TEST(SetSend);
851WEBRTC_BASE_TEST(SetSendWithoutCodecs);
852WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000853
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000854WEBRTC_BASE_TEST(GetStats);
855WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams);
856WEBRTC_BASE_TEST(GetStatsMultipleSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000857
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000858WEBRTC_BASE_TEST(SetSendBandwidth);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000859
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000860WEBRTC_BASE_TEST(SetSendSsrc);
861WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000862
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000863WEBRTC_BASE_TEST(SetRenderer);
864WEBRTC_BASE_TEST(AddRemoveRecvStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000865
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000866WEBRTC_DISABLED_BASE_TEST(AddRemoveRecvStreamAndRender);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000867
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000868WEBRTC_BASE_TEST(AddRemoveRecvStreamsNoConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000869
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000870WEBRTC_BASE_TEST(AddRemoveSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000871
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000872WEBRTC_BASE_TEST(SimulateConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000873
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000874WEBRTC_BASE_TEST(AddRemoveCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000875
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000876WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000877
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000878WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000879
880// TODO(pbos): Figure out why this fails so often.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000881WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000882
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000883WEBRTC_BASE_TEST(RejectEmptyStreamParams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000884
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000885WEBRTC_BASE_TEST(AdaptResolution16x10);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000886
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000887WEBRTC_BASE_TEST(AdaptResolution4x3);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000888
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000889// TODO(juberti): Restore this test once we support sending 0 fps.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000890WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000891// TODO(juberti): Understand why we get decode errors on this test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000892WEBRTC_DISABLED_BASE_TEST(AdaptFramerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000893
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +0000894WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames);
895
896WEBRTC_BASE_TEST(MuteStream);
897
898WEBRTC_BASE_TEST(MultipleSendStreams);
899
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000900WEBRTC_BASE_TEST(SetSendStreamFormat0x0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000901
902// TODO(zhurunz): Fix the flakey test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000903WEBRTC_DISABLED_BASE_TEST(SetSendStreamFormat);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000904
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000905TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
906 SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30, 0));
907}
908
909TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
910 SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30, 0));
911}
912
913TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
914 SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30, 0));
915}
916
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000917TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
918 Base::TwoStreamsSendAndReceive(kVp8Codec);
919}
920
921TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsReUseFirstStream) {
922 Base::TwoStreamsReUseFirstStream(kVp8Codec);
923}
924
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000925WEBRTC_BASE_TEST(SendManyResizeOnce);
926
927// TODO(pbos): Enable and figure out why this fails (or should work).
928TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_SendVp8HdAndReceiveAdaptedVp8Vga) {
929 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
930 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
931 channel_->UpdateAspectRatio(1280, 720);
932 video_capturer_.reset(new cricket::FakeVideoCapturer);
933 const std::vector<cricket::VideoFormat>* formats =
934 video_capturer_->GetSupportedFormats();
935 cricket::VideoFormat capture_format_hd = (*formats)[0];
936 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format_hd));
937 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
938
939 // Capture format HD -> adapt (OnOutputFormatRequest VGA) -> VGA.
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000940 cricket::VideoCodec codec = kVp8Codec720p;
pbos@webrtc.org9359cb32014-07-23 15:44:48 +0000941 EXPECT_TRUE(SetOneCodec(codec));
942 codec.width /= 2;
943 codec.height /= 2;
944 EXPECT_TRUE(SetSend(true));
945 EXPECT_TRUE(channel_->SetRender(true));
946 EXPECT_EQ(0, renderer_.num_rendered_frames());
947 EXPECT_TRUE(SendFrame());
948 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
949}
950
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000951class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test,
952 public WebRtcCallFactory {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000953 public:
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000954 WebRtcVideoChannel2Test() : fake_call_(NULL) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000955 void SetUp() override {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000956 engine_.SetCallFactory(this);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000957 engine_.Init(rtc::Thread::Current());
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000958 channel_.reset(engine_.CreateChannel(cricket::VideoOptions(), NULL));
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000959 ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000960 last_ssrc_ = 123;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000961 ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000962 }
963
964 protected:
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000965 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000966 assert(fake_call_ == NULL);
967 fake_call_ = new FakeCall(config);
968 return fake_call_;
969 }
970
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000971 FakeVideoSendStream* AddSendStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000972 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000973 }
974
975 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000976 size_t num_streams = fake_call_->GetVideoSendStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000977 EXPECT_TRUE(channel_->AddSendStream(sp));
978 std::vector<FakeVideoSendStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000979 fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000980 EXPECT_EQ(num_streams + 1, streams.size());
981 return streams[streams.size() - 1];
982 }
983
984 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000985 return fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000986 }
987
988 FakeVideoReceiveStream* AddRecvStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000989 return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000990 }
991
992 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000993 size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000994 EXPECT_TRUE(channel_->AddRecvStream(sp));
995 std::vector<FakeVideoReceiveStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000996 fake_call_->GetVideoReceiveStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000997 EXPECT_EQ(num_streams + 1, streams.size());
998 return streams[streams.size() - 1];
999 }
1000
pbos@webrtc.org00873182014-11-25 14:03:34 +00001001 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
1002 int expected_min_bitrate_bps,
1003 const char* start_bitrate_kbps,
1004 int expected_start_bitrate_bps,
1005 const char* max_bitrate_kbps,
1006 int expected_max_bitrate_bps) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001007 std::vector<VideoCodec> codecs;
1008 codecs.push_back(kVp8Codec);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001009 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
1010 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
1011 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001012 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1013
pbos@webrtc.org00873182014-11-25 14:03:34 +00001014 EXPECT_EQ(expected_min_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +01001015 fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001016 EXPECT_EQ(expected_start_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +01001017 fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001018 EXPECT_EQ(expected_max_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +01001019 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001020 }
1021
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001022 void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
1023 const std::string& webrtc_ext) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001024 FakeCall* call = fake_call_;
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001025 // Enable extension.
1026 const int id = 1;
1027 std::vector<cricket::RtpHeaderExtension> extensions;
1028 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
1029 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1030
1031 FakeVideoSendStream* send_stream =
1032 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1033
1034 // Verify the send extension id.
1035 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1036 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
1037 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
1038 // Verify call with same set of extensions returns true.
1039 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1040 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
1041 // receivers.
1042 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
1043 ->GetConfig()
1044 .rtp.extensions.empty());
1045
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001046 // Verify that existing RTP header extensions can be removed.
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001047 std::vector<cricket::RtpHeaderExtension> empty_extensions;
1048 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001049 ASSERT_EQ(1u, call->GetVideoSendStreams().size());
1050 send_stream = call->GetVideoSendStreams()[0];
1051 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1052
1053 // Verify that adding receive RTP header extensions adds them for existing
1054 // streams.
1055 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1056 send_stream = call->GetVideoSendStreams()[0];
1057 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1058 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
1059 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001060 }
1061
1062 void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
1063 const std::string& webrtc_ext) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001064 FakeCall* call = fake_call_;
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001065 // Enable extension.
1066 const int id = 1;
1067 std::vector<cricket::RtpHeaderExtension> extensions;
1068 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
1069 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1070
1071 FakeVideoReceiveStream* recv_stream =
1072 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1073
1074 // Verify the recv extension id.
1075 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1076 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
1077 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
1078 // Verify call with same set of extensions returns true.
1079 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001080
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001081 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
1082 // senders.
1083 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
1084 ->GetConfig()
1085 .rtp.extensions.empty());
1086
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001087 // Verify that existing RTP header extensions can be removed.
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001088 std::vector<cricket::RtpHeaderExtension> empty_extensions;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001089 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions));
1090 ASSERT_EQ(1u, call->GetVideoReceiveStreams().size());
1091 recv_stream = call->GetVideoReceiveStreams()[0];
1092 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
1093
1094 // Verify that adding receive RTP header extensions adds them for existing
1095 // streams.
1096 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1097 recv_stream = call->GetVideoReceiveStreams()[0];
1098 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1099 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
1100 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001101 }
1102
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001103 void TestCpuAdaptation(bool enable_overuse);
1104
1105 FakeCall* fake_call_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001106 rtc::scoped_ptr<VideoMediaChannel> channel_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001107 uint32 last_ssrc_;
1108};
1109
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001110TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001111 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
1112 EXPECT_TRUE(channel_->SetSend(true));
1113 cricket::VideoOptions options;
1114 options.conference_mode.Set(true);
1115 EXPECT_TRUE(channel_->SetOptions(options));
1116
1117 // Send side.
1118 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1119 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1120 FakeVideoSendStream* send_stream = AddSendStream(
1121 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1122
1123 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
1124 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
1125 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
1126
1127 // Receiver side.
1128 FakeVideoReceiveStream* recv_stream = AddRecvStream(
1129 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1130 ASSERT_GT(recv_stream->GetConfig().rtp.rtx.size(), 0u)
1131 << "No SSRCs for RTX configured by AddRecvStream.";
1132 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size())
1133 << "This test only works with one receive codec. Please update the test.";
1134 EXPECT_EQ(rtx_ssrcs[0],
1135 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
1136 // TODO(pbos): Make sure we set the RTX for correct payloads etc.
1137}
1138
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001139TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
1140 // Setup one channel with an associated RTX stream.
1141 cricket::StreamParams params =
1142 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1143 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
1144 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1145 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
1146 EXPECT_EQ(kRtxSsrcs1[0],
1147 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001148}
1149
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001150TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
1151 // Setup one channel without an associated RTX stream.
1152 cricket::StreamParams params =
1153 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1154 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1155 ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001156}
1157
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001158TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
1159 FakeVideoSendStream* send_stream =
1160 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1161 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1162
1163 FakeVideoReceiveStream* recv_stream =
1164 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1165 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001166}
1167
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001168// Test support for RTP timestamp offset header extension.
1169TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
1170 TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1171 webrtc::RtpExtension::kTOffset);
1172}
1173TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
1174 TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1175 webrtc::RtpExtension::kTOffset);
1176}
1177
1178// Test support for absolute send time header extension.
1179TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
1180 TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1181 webrtc::RtpExtension::kAbsSendTime);
1182}
1183TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
1184 TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1185 webrtc::RtpExtension::kAbsSendTime);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001186}
1187
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001188TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
1189 const int kTOffsetId = 1;
1190 const int kAbsSendTimeId = 2;
1191 std::vector<cricket::RtpHeaderExtension> extensions;
1192 extensions.push_back(cricket::RtpHeaderExtension(
1193 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
1194 extensions.push_back(cricket::RtpHeaderExtension(
1195 kRtpTimestampOffsetHeaderExtension, kTOffsetId));
1196
1197 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1198 FakeVideoSendStream* send_stream =
1199 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1200
1201 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1202 ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
1203
1204 // Setting the same extensions (even if in different order) shouldn't
1205 // reallocate the stream.
1206 std::reverse(extensions.begin(), extensions.end());
1207 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1208
1209 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1210
1211 // Setting different extensions should recreate the stream.
1212 extensions.resize(1);
1213 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1214
1215 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
1216}
1217
1218TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
1219 const int kTOffsetId = 1;
1220 const int kAbsSendTimeId = 2;
1221 std::vector<cricket::RtpHeaderExtension> extensions;
1222 extensions.push_back(cricket::RtpHeaderExtension(
1223 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
1224 extensions.push_back(cricket::RtpHeaderExtension(
1225 kRtpTimestampOffsetHeaderExtension, kTOffsetId));
1226
1227 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1228 FakeVideoReceiveStream* send_stream =
1229 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1230
1231 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
1232 ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
1233
1234 // Setting the same extensions (even if in different order) shouldn't
1235 // reallocate the stream.
1236 std::reverse(extensions.begin(), extensions.end());
1237 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1238
1239 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
1240
1241 // Setting different extensions should recreate the stream.
1242 extensions.resize(1);
1243 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1244
1245 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
1246}
1247
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001248TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001249 SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001250 const int kUnsupportedId = 1;
1251 const int kTOffsetId = 2;
1252
1253 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001254 extensions.push_back(
1255 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
1256 extensions.push_back(
1257 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001258 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1259 FakeVideoSendStream* send_stream =
1260 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1261
1262 // Only timestamp offset extension is set to send stream,
1263 // unsupported rtp extension is ignored.
1264 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1265 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001266 send_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001267}
1268
1269TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001270 SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001271 const int kUnsupportedId = 1;
1272 const int kTOffsetId = 2;
1273
1274 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001275 extensions.push_back(
1276 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
1277 extensions.push_back(
1278 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001279 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1280 FakeVideoReceiveStream* recv_stream =
1281 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1282
1283 // Only timestamp offset extension is set to receive stream,
1284 // unsupported rtp extension is ignored.
1285 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1286 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001287 recv_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001288}
1289
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001290TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001291 const int kIncorrectIds[] = {-2, -1, 15, 16};
1292 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001293 std::vector<cricket::RtpHeaderExtension> extensions;
1294 extensions.push_back(cricket::RtpHeaderExtension(
1295 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
1296 EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions))
1297 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1298 }
1299}
1300
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001301TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001302 const int kIncorrectIds[] = {-2, -1, 15, 16};
1303 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001304 std::vector<cricket::RtpHeaderExtension> extensions;
1305 extensions.push_back(cricket::RtpHeaderExtension(
1306 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
1307 EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions))
1308 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1309 }
1310}
1311
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001312TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001313 const int id = 1;
1314 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001315 extensions.push_back(
1316 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1317 extensions.push_back(
1318 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001319 EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
1320
1321 // Duplicate entries are also not supported.
1322 extensions.clear();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001323 extensions.push_back(
1324 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001325 extensions.push_back(extensions.back());
1326 EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
1327}
1328
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001329TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001330 const int id = 1;
1331 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001332 extensions.push_back(
1333 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1334 extensions.push_back(
1335 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001336 EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
1337
1338 // Duplicate entries are also not supported.
1339 extensions.clear();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001340 extensions.push_back(
1341 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001342 extensions.push_back(extensions.back());
1343 EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
1344}
1345
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001346TEST_F(WebRtcVideoChannel2Test, DISABLED_LeakyBucketTest) {
1347 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1348}
1349
1350TEST_F(WebRtcVideoChannel2Test, DISABLED_BufferedModeLatency) {
1351 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1352}
1353
1354TEST_F(WebRtcVideoChannel2Test, DISABLED_AdditiveVideoOptions) {
1355 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1356}
1357
1358TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
1359 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001360 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001361}
1362
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001363TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
1364 FakeVideoReceiveStream* stream = AddRecvStream();
1365 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001366}
1367
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001368TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1369 FakeVideoReceiveStream* stream = AddRecvStream();
1370 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1371
1372 // Verify that REMB is turned off when codecs without REMB are set.
1373 std::vector<VideoCodec> codecs;
1374 codecs.push_back(kVp8Codec);
1375 EXPECT_TRUE(codecs[0].feedback_params.params().empty());
1376 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001377 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001378 EXPECT_FALSE(stream->GetConfig().rtp.remb);
1379
1380 // Verify that REMB is turned on when setting default codecs since the
1381 // default codecs have REMB enabled.
1382 EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001383 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001384 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001385}
1386
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001387TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
1388 VerifyCodecHasDefaultFeedbackParams(default_codec_);
1389
pbos@webrtc.org19864742014-05-30 07:35:47 +00001390 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
1391 EXPECT_TRUE(channel_->SetSend(true));
1392
1393 // Send side.
1394 FakeVideoSendStream* send_stream =
1395 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1396 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1397
1398 // Receiver side.
1399 FakeVideoReceiveStream* recv_stream =
1400 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1401 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1402
1403 // Nack history size should match between sender and receiver.
1404 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
1405 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001406}
1407
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001408TEST_F(WebRtcVideoChannel2Test, NackCanBeDisabled) {
1409 std::vector<VideoCodec> codecs;
1410 codecs.push_back(kVp8Codec);
1411
1412 // Send side.
1413 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1414 FakeVideoSendStream* send_stream =
1415 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1416 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1417
1418 // Receiver side.
1419 ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
1420 FakeVideoReceiveStream* recv_stream =
1421 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1422 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1423}
1424
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001425TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInterop) {
1426 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1427}
1428
1429TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInteropReversed) {
1430 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1431}
1432
1433TEST_F(WebRtcVideoChannel2Test, DISABLED_HybridNackFecConference) {
1434 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1435}
1436
1437TEST_F(WebRtcVideoChannel2Test, DISABLED_AddRemoveRecvStreamConference) {
1438 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1439}
1440
1441TEST_F(WebRtcVideoChannel2Test, DISABLED_SetRender) {
1442 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1443}
1444
1445TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAuto) {
1446 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1447}
1448
1449TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAutoCapped) {
1450 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1451}
1452
1453TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthFixed) {
1454 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1455}
1456
1457TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthInConference) {
1458 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1459}
1460
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001461TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1462 static const int kScreenshareMinBitrateKbps = 800;
1463 cricket::VideoCodec codec = kVp8Codec360p;
1464 std::vector<cricket::VideoCodec> codecs;
1465 codecs.push_back(codec);
1466 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1467 VideoOptions options;
1468 options.screencast_min_bitrate.Set(kScreenshareMinBitrateKbps);
1469 channel_->SetOptions(options);
1470
1471 AddSendStream();
1472
1473 cricket::FakeVideoCapturer capturer;
1474 capturer.SetScreencast(false);
1475 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1476 cricket::VideoFormat capture_format_hd =
1477 capturer.GetSupportedFormats()->front();
1478 EXPECT_EQ(1280, capture_format_hd.width);
1479 EXPECT_EQ(720, capture_format_hd.height);
1480 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1481
1482 EXPECT_TRUE(channel_->SetSend(true));
1483
1484 EXPECT_TRUE(capturer.CaptureFrame());
1485 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1486 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1487
1488 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1489
1490 // Verify non-screencast settings.
1491 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1492 EXPECT_EQ(webrtc::VideoEncoderConfig::kRealtimeVideo,
1493 encoder_config.content_type);
1494 EXPECT_EQ(codec.width, encoder_config.streams.front().width);
1495 EXPECT_EQ(codec.height, encoder_config.streams.front().height);
1496 EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
1497 << "Non-screenshare shouldn't use min-transmit bitrate.";
1498
1499 capturer.SetScreencast(true);
1500 EXPECT_TRUE(capturer.CaptureFrame());
1501
1502 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1503
1504 // Verify screencast settings.
1505 encoder_config = send_stream->GetEncoderConfig();
1506 EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare,
1507 encoder_config.content_type);
1508 EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
1509 encoder_config.min_transmit_bitrate_bps);
1510
1511 EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width);
1512 EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001513 EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
1514
1515 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1516}
1517
1518TEST_F(WebRtcVideoChannel2Test,
1519 ConferenceModeScreencastConfiguresTemporalLayer) {
1520 static const int kConferenceScreencastTemporalBitrateBps = 100000;
1521 VideoOptions options;
1522 options.conference_mode.Set(true);
1523 channel_->SetOptions(options);
1524
1525 AddSendStream();
1526
1527 cricket::FakeVideoCapturer capturer;
1528 capturer.SetScreencast(true);
1529 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1530 cricket::VideoFormat capture_format_hd =
1531 capturer.GetSupportedFormats()->front();
1532 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1533
1534 EXPECT_TRUE(channel_->SetSend(true));
1535
1536 EXPECT_TRUE(capturer.CaptureFrame());
1537 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1538 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1539
1540 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1541
1542 // Verify screencast settings.
1543 encoder_config = send_stream->GetEncoderConfig();
1544 EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare,
1545 encoder_config.content_type);
1546 ASSERT_EQ(1u, encoder_config.streams.size());
1547 ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size());
1548 EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
1549 encoder_config.streams[0].temporal_layer_thresholds_bps[0]);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001550
1551 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001552}
1553
1554TEST_F(WebRtcVideoChannel2Test, DISABLED_SetSendSsrcAndCname) {
1555 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1556}
1557
1558TEST_F(WebRtcVideoChannel2Test,
1559 DISABLED_SetSendSsrcAfterCreatingReceiveChannel) {
1560 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1561}
1562
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001563TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
1564 FakeVideoSendStream* stream = AddSendStream();
1565 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1566}
1567
1568TEST_F(WebRtcVideoChannel2Test, SetOptionsWithSuspendBelowMinBitrate) {
1569 VideoOptions options;
1570 options.suspend_below_min_bitrate.Set(true);
1571 channel_->SetOptions(options);
1572
1573 FakeVideoSendStream* stream = AddSendStream();
1574 EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
1575
1576 options.suspend_below_min_bitrate.Set(false);
1577 channel_->SetOptions(options);
1578
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001579 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001580 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1581}
1582
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001583TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1584 FakeVideoSendStream* stream = AddSendStream();
1585 webrtc::VideoCodecVP8 vp8_settings;
1586 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1587 EXPECT_TRUE(vp8_settings.denoisingOn);
1588}
1589
1590TEST_F(WebRtcVideoChannel2Test, SetOptionsWithDenoising) {
1591 VideoOptions options;
1592 options.video_noise_reduction.Set(false);
1593 channel_->SetOptions(options);
1594
1595 FakeVideoSendStream* stream = AddSendStream();
1596 webrtc::VideoCodecVP8 vp8_settings;
1597 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1598 EXPECT_FALSE(vp8_settings.denoisingOn);
1599
1600 options.video_noise_reduction.Set(true);
1601 channel_->SetOptions(options);
1602
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001603 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001604 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1605 EXPECT_TRUE(vp8_settings.denoisingOn);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001606}
1607
1608TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) {
1609 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1610}
1611
pbos@webrtc.org8aed9452014-07-26 10:16:49 +00001612TEST_F(WebRtcVideoChannel2Test, DISABLED_SendReceiveBitratesStats) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001613 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1614}
1615
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001616TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) {
1617 TestCpuAdaptation(true);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001618}
1619
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001620TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
1621 TestCpuAdaptation(false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001622}
1623
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001624void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001625 cricket::VideoCodec codec = kVp8Codec720p;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001626 std::vector<cricket::VideoCodec> codecs;
1627 codecs.push_back(codec);
1628 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1629
1630 if (enable_overuse) {
1631 VideoOptions options;
1632 options.cpu_overuse_detection.Set(true);
1633 channel_->SetOptions(options);
1634 }
1635
1636 AddSendStream();
1637
1638 cricket::FakeVideoCapturer capturer;
1639 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1640 EXPECT_EQ(cricket::CS_RUNNING,
1641 capturer.Start(capturer.GetSupportedFormats()->front()));
1642
1643 EXPECT_TRUE(channel_->SetSend(true));
1644
1645 // Trigger overuse.
1646 webrtc::LoadObserver* overuse_callback =
1647 fake_call_->GetConfig().overuse_callback;
1648 ASSERT_TRUE(overuse_callback != NULL);
1649 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
1650
1651 EXPECT_TRUE(capturer.CaptureFrame());
1652 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1653 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1654
1655 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1656
1657 if (enable_overuse) {
1658 EXPECT_LT(send_stream->GetLastWidth(), codec.width);
1659 EXPECT_LT(send_stream->GetLastHeight(), codec.height);
1660 } else {
1661 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1662 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1663 }
1664
1665 // Trigger underuse which should go back to normal resolution.
1666 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
1667 EXPECT_TRUE(capturer.CaptureFrame());
1668
1669 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1670
1671 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1672 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1673
1674 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001675}
1676
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001677TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeAndElapsedTimeCorrectly) {
1678 // Start at last timestamp to verify that wraparounds are estimated correctly.
1679 static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
1680 static const int64_t kInitialNtpTimeMs = 1247891230;
1681 static const int kFrameOffsetMs = 20;
1682 EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001683
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001684 FakeVideoReceiveStream* stream = AddRecvStream();
1685 cricket::FakeVideoRenderer renderer;
1686 EXPECT_TRUE(channel_->SetRenderer(last_ssrc_, &renderer));
1687 EXPECT_TRUE(channel_->SetRender(true));
1688
1689 webrtc::I420VideoFrame video_frame;
1690 CreateBlackFrame(&video_frame, 4, 4);
1691 video_frame.set_timestamp(kInitialTimestamp);
1692 // Initial NTP time is not available on the first frame, but should still be
1693 // able to be estimated.
1694 stream->InjectFrame(video_frame, 0);
1695
1696 EXPECT_EQ(1, renderer.num_rendered_frames());
1697 EXPECT_EQ(0, renderer.last_frame_elapsed_time_ns());
1698
1699 // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which
1700 // triggers a constant-overflow warning, hence we're calculating it explicitly
1701 // here.
1702 video_frame.set_timestamp(kFrameOffsetMs * 90 - 1);
1703 video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs);
1704 stream->InjectFrame(video_frame, 0);
1705
1706 EXPECT_EQ(2, renderer.num_rendered_frames());
1707 EXPECT_EQ(kFrameOffsetMs * rtc::kNumNanosecsPerMillisec,
1708 renderer.last_frame_elapsed_time_ns());
1709
1710 // Verify that NTP time has been correctly deduced.
1711 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001712 ASSERT_TRUE(channel_->GetStats(&info));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001713 ASSERT_EQ(1u, info.receivers.size());
1714 EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001715}
1716
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001717TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001718 ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001719
1720 VideoCodec codec;
1721 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001722 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001723
1724 // Using a RTX setup to verify that the default RTX payload type is good.
1725 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1726 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1727 FakeVideoSendStream* stream = AddSendStream(
1728 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1729 webrtc::VideoSendStream::Config config = stream->GetConfig();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001730
1731 // Make sure NACK and FEC are enabled on the correct payload types.
1732 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
1733 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
1734 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001735
1736 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
1737 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00001738 EXPECT_EQ(default_rtx_codec_.id, config.rtp.rtx.payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001739 // TODO(juberti): Check RTCP, PLI, TMMBR.
1740}
1741
1742TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
1743 std::vector<VideoCodec> codecs;
1744 codecs.push_back(kVp8Codec);
1745 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1746
1747 FakeVideoSendStream* stream = AddSendStream();
1748 webrtc::VideoSendStream::Config config = stream->GetConfig();
1749
1750 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
1751 EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
1752}
1753
1754TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001755 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
1756 std::vector<VideoCodec> codecs;
1757 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
1758 codecs.push_back(rtx_codec);
1759 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1760 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001761}
1762
1763TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001764 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
1765 std::vector<VideoCodec> codecs;
1766 cricket::VideoCodec rtx_codec =
1767 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
1768 codecs.push_back(kVp8Codec);
1769 codecs.push_back(rtx_codec);
1770 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1771
1772 cricket::VideoCodec rtx_codec2 =
1773 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
1774 codecs.pop_back();
1775 codecs.push_back(rtx_codec2);
1776 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1777 << "RTX without matching video codec should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001778}
1779
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001780TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
1781 std::vector<VideoCodec> codecs;
1782 codecs.push_back(kVp8Codec);
1783 codecs.push_back(kUlpfecCodec);
1784 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1785
1786 FakeVideoSendStream* stream = AddSendStream();
1787 webrtc::VideoSendStream::Config config = stream->GetConfig();
1788
1789 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
1790
1791 codecs.pop_back();
1792 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001793 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001794 ASSERT_TRUE(stream != NULL);
1795 config = stream->GetConfig();
1796 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
1797 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001798}
1799
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001800TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
1801 std::vector<VideoCodec> codecs;
1802 codecs.push_back(kVp8Codec720p);
1803 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001804 channel_->SetSend(true);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001805
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001806 FakeVideoSendStream* stream = AddSendStream();
1807
1808 cricket::FakeVideoCapturer capturer;
1809 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1810 EXPECT_EQ(cricket::CS_RUNNING,
1811 capturer.Start(capturer.GetSupportedFormats()->front()));
1812 EXPECT_TRUE(capturer.CaptureFrame());
1813
1814 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001815 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
1816 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
1817
1818 codecs.clear();
1819 codecs.push_back(kVp8Codec360p);
1820 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001821 streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001822 EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
1823 EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001824 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001825}
1826
pbos@webrtc.org00873182014-11-25 14:03:34 +00001827TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
1828 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
1829 200000);
1830}
1831
pbos@webrtc.orga5f6fb52015-03-23 22:29:39 +00001832TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
1833 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
1834 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
1835 ASSERT_EQ(1u, streams.size());
1836 EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
1837}
1838
pbos@webrtc.org00873182014-11-25 14:03:34 +00001839TEST_F(WebRtcVideoChannel2Test,
1840 SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
1841 SetSendCodecsShouldWorkForBitrates(
1842 "", 0, "", -1, "", -1);
1843}
1844
1845TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
1846 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001847}
1848
1849TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001850 std::vector<VideoCodec> video_codecs = engine_.codecs();
pbos@webrtc.org88ef6322014-11-04 15:29:29 +00001851 video_codecs[0].params[kCodecParamMinBitrate] = "300";
1852 video_codecs[0].params[kCodecParamMaxBitrate] = "200";
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001853 EXPECT_FALSE(channel_->SetSendCodecs(video_codecs));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001854}
1855
pbos@webrtc.org00873182014-11-25 14:03:34 +00001856TEST_F(WebRtcVideoChannel2Test,
1857 SetMaxSendBandwidthShouldPreserveOtherBitrates) {
1858 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
1859 200000);
1860 channel_->SetMaxSendBandwidth(300000);
Stefan Holmere5904162015-03-26 11:11:06 +01001861 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00001862 << "Setting max bitrate should keep previous min bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01001863 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00001864 << "Setting max bitrate should not reset start bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01001865 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001866}
1867
1868TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
1869 channel_->SetMaxSendBandwidth(300000);
Stefan Holmere5904162015-03-26 11:11:06 +01001870 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001871 // <= 0 means disable (infinite) max bitrate.
1872 channel_->SetMaxSendBandwidth(0);
Stefan Holmere5904162015-03-26 11:11:06 +01001873 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00001874 << "Setting zero max bitrate did not reset start bitrate.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001875}
1876
1877TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
1878 static const char* kMaxQuantization = "21";
1879 std::vector<VideoCodec> codecs;
1880 codecs.push_back(kVp8Codec);
1881 codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
1882 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001883 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
1884 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001885
1886 VideoCodec codec;
1887 EXPECT_TRUE(channel_->GetSendCodec(&codec));
1888 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
1889}
1890
1891TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
1892 std::vector<cricket::VideoCodec> codecs;
1893 codecs.push_back(kVp8Codec);
1894
1895 codecs[0].width = 0;
1896 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1897 << "Codec set though codec width is zero.";
1898
1899 codecs[0].width = kVp8Codec.width;
1900 codecs[0].height = 0;
1901 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1902 << "Codec set though codec height is zero.";
1903}
1904
1905TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
1906 // TODO(pbos): Should we only allow the dynamic range?
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001907 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001908 std::vector<cricket::VideoCodec> codecs;
1909 codecs.push_back(kVp8Codec);
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001910 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00001911 codecs[0].id = kIncorrectPayloads[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001912 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00001913 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001914 }
1915}
1916
1917TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
1918 std::vector<cricket::VideoCodec> codecs;
1919 codecs.push_back(kVp8Codec);
1920 for (int payload_type = 0; payload_type <= 127; ++payload_type) {
1921 codecs[0].id = payload_type;
1922 EXPECT_TRUE(channel_->SetSendCodecs(codecs))
1923 << "Payload type '" << payload_type << "' rejected.";
1924 }
1925}
1926
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001927TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
1928 std::vector<cricket::VideoCodec> codecs;
1929 codecs.push_back(kVp8Codec);
1930 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1931}
1932
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001933// Test that we set our inbound RTX codecs properly.
1934TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
1935 std::vector<cricket::VideoCodec> codecs;
1936 codecs.push_back(kVp8Codec);
1937 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
1938 codecs.push_back(rtx_codec);
1939 EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
1940 << "RTX codec without associated payload should be rejected.";
1941
1942 codecs[1].SetParam("apt", kVp8Codec.id + 1);
1943 EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
1944 << "RTX codec with invalid associated payload type should be rejected.";
1945
1946 codecs[1].SetParam("apt", kVp8Codec.id);
1947 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1948
1949 cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0);
1950 rtx_codec2.SetParam("apt", rtx_codec.id);
1951 codecs.push_back(rtx_codec2);
1952
1953 EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) << "RTX codec with another RTX "
1954 "as associated payload type "
1955 "should be rejected.";
1956}
1957
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001958TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
1959 std::vector<cricket::VideoCodec> codecs;
1960 codecs.push_back(kVp8Codec);
1961 codecs[0].id = 99;
1962 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1963}
1964
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00001965TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001966 EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00001967
1968 FakeVideoReceiveStream* stream = AddRecvStream();
1969 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00001970 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
1971 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001972}
1973
1974TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
1975 std::vector<VideoCodec> codecs;
1976 codecs.push_back(kVp8Codec);
1977 codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
1978 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
1979}
1980
1981// TODO(pbos): Enable VP9 through external codec support
1982TEST_F(WebRtcVideoChannel2Test,
1983 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
1984 std::vector<VideoCodec> codecs;
1985 codecs.push_back(kVp8Codec);
1986 codecs.push_back(kVp9Codec);
1987 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1988}
1989
1990TEST_F(WebRtcVideoChannel2Test,
1991 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
1992 std::vector<VideoCodec> codecs;
1993 codecs.push_back(kVp8Codec);
1994 codecs.push_back(kVp9Codec);
1995 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1996 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
1997}
1998
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001999TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
2000 std::vector<VideoCodec> codecs;
2001 codecs.push_back(kVp8Codec);
2002 codecs.push_back(kUlpfecCodec);
2003 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
2004
2005 FakeVideoReceiveStream* stream = AddRecvStream();
2006 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
2007
2008 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2009
2010 codecs.pop_back();
2011 ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002012 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002013 ASSERT_TRUE(stream != NULL);
2014 config = stream->GetConfig();
2015 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2016 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002017}
2018
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002019TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
2020 std::vector<VideoCodec> codecs;
2021 codecs.push_back(kVp8Codec);
2022 codecs.push_back(kRedCodec);
2023 codecs[1].id = codecs[0].id;
2024 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
2025}
2026
2027TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
2028 std::vector<VideoCodec> codecs;
2029 codecs.push_back(kVp8Codec);
2030 codecs.push_back(kVp9Codec);
2031 codecs[1].id = codecs[0].id;
2032 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
2033}
2034
2035TEST_F(WebRtcVideoChannel2Test,
2036 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
2037 std::vector<VideoCodec> codecs;
2038 codecs.push_back(kVp8Codec);
2039 codecs.push_back(kVp8Codec);
2040 codecs[1].id += 1;
2041 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2042}
2043
2044TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
2045 EXPECT_FALSE(AddSendStream()->IsSending());
2046}
2047
pbos@webrtc.org85f42942014-07-22 09:14:58 +00002048TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
2049 EXPECT_TRUE(AddRecvStream()->IsReceiving());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002050}
2051
2052TEST_F(WebRtcVideoChannel2Test, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002053 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002054 EXPECT_FALSE(stream->IsSending());
2055
2056 // false->true
2057 EXPECT_TRUE(channel_->SetSend(true));
2058 EXPECT_TRUE(stream->IsSending());
2059 // true->true
2060 EXPECT_TRUE(channel_->SetSend(true));
2061 EXPECT_TRUE(stream->IsSending());
2062 // true->false
2063 EXPECT_TRUE(channel_->SetSend(false));
2064 EXPECT_FALSE(stream->IsSending());
2065 // false->false
2066 EXPECT_TRUE(channel_->SetSend(false));
2067 EXPECT_FALSE(stream->IsSending());
2068
2069 EXPECT_TRUE(channel_->SetSend(true));
2070 FakeVideoSendStream* new_stream = AddSendStream();
2071 EXPECT_TRUE(new_stream->IsSending())
2072 << "Send stream created after SetSend(true) not sending initially.";
2073}
2074
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002075// This test verifies DSCP settings are properly applied on video media channel.
2076TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
2077 rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
2078 new cricket::FakeNetworkInterface);
2079 channel_->SetInterface(network_interface.get());
2080 cricket::VideoOptions options;
2081 options.dscp.Set(true);
2082 EXPECT_TRUE(channel_->SetOptions(options));
2083 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2084 // Verify previous value is not modified if dscp option is not set.
2085 cricket::VideoOptions options1;
2086 EXPECT_TRUE(channel_->SetOptions(options1));
2087 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2088 options.dscp.Set(false);
2089 EXPECT_TRUE(channel_->SetOptions(options));
2090 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
2091 channel_->SetInterface(NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002092}
2093
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002094TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002095 EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState());
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002096
2097 channel_->OnReadyToSend(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002098 EXPECT_EQ(webrtc::Call::kNetworkDown, fake_call_->GetNetworkState());
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002099
2100 channel_->OnReadyToSend(true);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002101 EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002102}
2103
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002104TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) {
2105 FakeVideoSendStream* stream = AddSendStream();
2106 webrtc::VideoSendStream::Stats stats;
2107 stats.avg_encode_time_ms = 13;
2108 stats.encode_usage_percent = 42;
2109 stream->SetStats(stats);
2110
2111 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002112 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002113 EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms);
2114 EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent);
2115}
2116
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002117TEST_F(WebRtcVideoChannel2Test, GetStatsReportsUpperResolution) {
2118 FakeVideoSendStream* stream = AddSendStream();
2119 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002120 stats.substreams[17].width = 123;
2121 stats.substreams[17].height = 40;
2122 stats.substreams[42].width = 80;
2123 stats.substreams[42].height = 31;
2124 stats.substreams[11].width = 20;
2125 stats.substreams[11].height = 90;
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002126 stream->SetStats(stats);
2127
2128 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002129 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002130 ASSERT_EQ(1u, info.senders.size());
2131 EXPECT_EQ(123, info.senders[0].send_frame_width);
2132 EXPECT_EQ(90, info.senders[0].send_frame_height);
2133}
2134
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002135TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) {
2136 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2137
2138 // Capture format VGA.
2139 cricket::FakeVideoCapturer video_capturer_vga;
2140 const std::vector<cricket::VideoFormat>* formats =
2141 video_capturer_vga.GetSupportedFormats();
2142 cricket::VideoFormat capture_format_vga = (*formats)[1];
2143 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
2144 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_vga));
2145 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2146
2147 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30, 0);
2148 std::vector<cricket::VideoCodec> codecs;
2149 codecs.push_back(send_codec);
2150 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
2151 EXPECT_TRUE(channel_->SetSend(true));
2152
2153 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
2154 cricket::VideoOptions options;
2155 options.cpu_overuse_detection.Set(true);
2156 EXPECT_TRUE(channel_->SetOptions(options));
2157 // Trigger overuse.
2158 webrtc::LoadObserver* overuse_callback =
2159 fake_call_->GetConfig().overuse_callback;
2160 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2161
2162 // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
2163 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2164 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002165 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002166 ASSERT_EQ(1U, info.senders.size());
2167 EXPECT_EQ(1, info.senders[0].adapt_changes);
2168 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2169 info.senders[0].adapt_reason);
2170
2171 // Trigger upgrade and verify that we adapt back up to VGA.
2172 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2173 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2174 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002175 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002176 ASSERT_EQ(1U, info.senders.size());
2177 EXPECT_EQ(2, info.senders[0].adapt_changes);
2178 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2179 info.senders[0].adapt_reason);
2180
2181 // No capturer (no adapter). Adapt changes from old adapter should be kept.
2182 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2183 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002184 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002185 ASSERT_EQ(1U, info.senders.size());
2186 EXPECT_EQ(2, info.senders[0].adapt_changes);
2187 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2188 info.senders[0].adapt_reason);
2189
2190 // Set new capturer, capture format HD.
2191 cricket::FakeVideoCapturer video_capturer_hd;
2192 cricket::VideoFormat capture_format_hd = (*formats)[0];
2193 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd));
2194 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_hd));
2195 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2196
2197 // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2.
2198 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2199 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2200 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002201 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002202 ASSERT_EQ(1U, info.senders.size());
2203 EXPECT_EQ(3, info.senders[0].adapt_changes);
2204 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2205 info.senders[0].adapt_reason);
2206
2207 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2208}
2209
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002210TEST_F(WebRtcVideoChannel2Test,
2211 GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
2212 FakeVideoSendStream* stream = AddSendStream();
2213 webrtc::VideoSendStream::Stats stats;
2214 stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
2215 stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
2216 stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
2217
2218 stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5;
2219 stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7;
2220 stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9;
2221
2222 stream->SetStats(stats);
2223
2224 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002225 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002226 EXPECT_EQ(7, info.senders[0].firs_rcvd);
2227 EXPECT_EQ(10, info.senders[0].nacks_rcvd);
2228 EXPECT_EQ(13, info.senders[0].plis_rcvd);
2229}
2230
2231TEST_F(WebRtcVideoChannel2Test,
2232 GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
2233 FakeVideoReceiveStream* stream = AddRecvStream();
2234 webrtc::VideoReceiveStream::Stats stats;
2235 stats.rtcp_packet_type_counts.fir_packets = 2;
2236 stats.rtcp_packet_type_counts.nack_packets = 3;
2237 stats.rtcp_packet_type_counts.pli_packets = 4;
2238 stream->SetStats(stats);
2239
2240 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002241 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002242 EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
2243 info.receivers[0].firs_sent);
2244 EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
2245 info.receivers[0].nacks_sent);
2246 EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
2247 info.receivers[0].plis_sent);
2248}
2249
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002250TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly) {
2251 FakeVideoReceiveStream* stream = AddRecvStream();
2252 webrtc::VideoReceiveStream::Stats stats;
2253 stats.decode_ms = 2;
2254 stats.max_decode_ms = 3;
2255 stats.current_delay_ms = 4;
2256 stats.target_delay_ms = 5;
2257 stats.jitter_buffer_ms = 6;
2258 stats.min_playout_delay_ms = 7;
2259 stats.render_delay_ms = 8;
2260 stream->SetStats(stats);
2261
2262 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002263 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002264 EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms);
2265 EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms);
2266 EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms);
2267 EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms);
2268 EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms);
2269 EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms);
2270 EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
2271}
2272
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002273TEST_F(WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly) {
2274 AddSendStream();
2275 AddSendStream();
2276 webrtc::Call::Stats stats;
2277 stats.rtt_ms = 123;
2278 fake_call_->SetStats(stats);
2279
2280 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002281 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002282 ASSERT_EQ(2u, info.senders.size());
2283 EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms);
2284 EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms);
2285}
2286
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002287TEST_F(WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly) {
2288 FakeVideoSendStream* stream = AddSendStream();
2289 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002290 stats.target_media_bitrate_bps = 156;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002291 stats.media_bitrate_bps = 123;
2292 stats.substreams[17].total_bitrate_bps = 1;
2293 stats.substreams[17].retransmit_bitrate_bps = 2;
2294 stats.substreams[42].total_bitrate_bps = 3;
2295 stats.substreams[42].retransmit_bitrate_bps = 4;
2296 stream->SetStats(stats);
2297
2298 FakeVideoSendStream* stream2 = AddSendStream();
2299 webrtc::VideoSendStream::Stats stats2;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002300 stats2.target_media_bitrate_bps = 200;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002301 stats2.media_bitrate_bps = 321;
2302 stats2.substreams[13].total_bitrate_bps = 5;
2303 stats2.substreams[13].retransmit_bitrate_bps = 6;
2304 stats2.substreams[21].total_bitrate_bps = 7;
2305 stats2.substreams[21].retransmit_bitrate_bps = 8;
2306 stream2->SetStats(stats2);
2307
2308 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002309 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002310 ASSERT_EQ(2u, info.senders.size());
2311 // Assuming stream and stream2 corresponds to senders[0] and [1] respectively
2312 // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
2313 EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
2314 EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002315 EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
2316 info.bw_estimations[0].target_enc_bitrate);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002317 EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
2318 info.bw_estimations[0].actual_enc_bitrate);
2319 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
2320 << "Bandwidth stats should take all streams into account.";
2321 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
2322 << "Bandwidth stats should take all streams into account.";
2323}
2324
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002325TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
2326 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2327
2328 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
2329 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
2330
2331 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
2332 const size_t kDataLength = 12;
2333 uint8_t data[kDataLength];
2334 memset(data, 0, sizeof(data));
2335 rtc::SetBE32(&data[8], ssrcs[0]);
2336 rtc::Buffer packet(data, kDataLength);
2337 rtc::PacketTime packet_time;
2338 channel_->OnPacketReceived(&packet, packet_time);
2339
2340 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
2341 << "No default receive stream created.";
2342 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2343 EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size())
2344 << "Default receive stream should not have configured RTX";
2345
2346 EXPECT_TRUE(channel_->AddRecvStream(
2347 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
2348 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
2349 << "AddRecvStream should've reconfigured, not added a new receiver.";
2350 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2351 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
2352 EXPECT_EQ(rtx_ssrcs[0],
2353 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
2354}
2355
Peter Boströmd4362cd2015-03-25 14:17:23 +01002356TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
2357 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2358
2359 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
2360 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
2361
2362 StreamParams sp =
2363 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
2364 sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
2365
2366 EXPECT_FALSE(channel_->AddSendStream(sp));
2367 EXPECT_FALSE(channel_->AddRecvStream(sp));
2368}
2369
Peter Boströmd6f4c252015-03-26 16:23:04 +01002370TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
2371 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2372
2373 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
2374 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
2375
2376 StreamParams sp =
2377 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
2378
2379 EXPECT_TRUE(channel_->AddSendStream(sp));
2380 EXPECT_TRUE(channel_->AddRecvStream(sp));
2381
2382 // The RTX SSRC is already used in previous streams, using it should fail.
2383 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
2384 EXPECT_FALSE(channel_->AddSendStream(sp));
2385 EXPECT_FALSE(channel_->AddRecvStream(sp));
2386
2387 // After removing the original stream this should be fine to add (makes sure
2388 // that RTX ssrcs are not forever taken).
2389 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
2390 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
2391 EXPECT_TRUE(channel_->AddSendStream(sp));
2392 EXPECT_TRUE(channel_->AddRecvStream(sp));
2393}
2394
2395TEST_F(WebRtcVideoChannel2Test,
2396 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
2397 static const uint32 kFirstStreamSsrcs[] = {1, 2, 3};
2398 static const uint32 kOverlappingStreamSsrcs[] = {4, 3, 5};
2399 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2400
2401 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
2402
2403 StreamParams sp =
2404 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
2405
2406 EXPECT_TRUE(channel_->AddSendStream(sp));
2407 EXPECT_TRUE(channel_->AddRecvStream(sp));
2408
2409 // One of the SSRCs is already used in previous streams, using it should fail.
2410 sp = cricket::CreateSimStreamParams("cname",
2411 MAKE_VECTOR(kOverlappingStreamSsrcs));
2412 EXPECT_FALSE(channel_->AddSendStream(sp));
2413 EXPECT_FALSE(channel_->AddRecvStream(sp));
2414
2415 // After removing the original stream this should be fine to add (makes sure
2416 // that RTX ssrcs are not forever taken).
2417 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
2418 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
2419 EXPECT_TRUE(channel_->AddSendStream(sp));
2420 EXPECT_TRUE(channel_->AddRecvStream(sp));
2421}
2422
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002423class WebRtcVideoEngine2SimulcastTest : public testing::Test {
2424 public:
Peter Boströmd4362cd2015-03-25 14:17:23 +01002425 WebRtcVideoEngine2SimulcastTest() : engine_(nullptr) {}
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002426
2427 protected:
2428 WebRtcVideoEngine2 engine_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002429};
2430
2431class WebRtcVideoChannel2SimulcastTest : public WebRtcVideoEngine2SimulcastTest,
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002432 public WebRtcCallFactory {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002433 public:
2434 WebRtcVideoChannel2SimulcastTest() : fake_call_(NULL) {}
2435
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00002436 void SetUp() override {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002437 engine_.SetCallFactory(this);
2438 engine_.Init(rtc::Thread::Current());
2439 channel_.reset(engine_.CreateChannel(VideoOptions(), NULL));
2440 ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory.";
2441 last_ssrc_ = 123;
2442 }
2443
2444 protected:
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00002445 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002446 assert(fake_call_ == NULL);
2447 fake_call_ = new FakeCall(config);
2448 return fake_call_;
2449 }
2450
2451 void VerifySimulcastSettings(const VideoCodec& codec,
2452 VideoOptions::HighestBitrate bitrate_mode,
2453 size_t num_configured_streams,
2454 size_t expected_num_streams,
2455 SimulcastBitrateMode simulcast_bitrate_mode) {
2456 cricket::VideoOptions options;
2457 options.video_highest_bitrate.Set(bitrate_mode);
2458 EXPECT_TRUE(channel_->SetOptions(options));
2459
2460 std::vector<VideoCodec> codecs;
2461 codecs.push_back(codec);
2462 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
2463
2464 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
2465 assert(num_configured_streams <= ssrcs.size());
2466 ssrcs.resize(num_configured_streams);
2467
2468 FakeVideoSendStream* stream =
2469 AddSendStream(CreateSimStreamParams("cname", ssrcs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002470 // Send a full-size frame to trigger a stream reconfiguration to use all
2471 // expected simulcast layers.
2472 cricket::FakeVideoCapturer capturer;
2473 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer));
2474 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
2475 codec.width, codec.height,
2476 cricket::VideoFormat::FpsToInterval(30),
2477 cricket::FOURCC_I420)));
2478 channel_->SetSend(true);
2479 EXPECT_TRUE(capturer.CaptureFrame());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002480
2481 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
2482 ASSERT_EQ(expected_num_streams, video_streams.size());
2483
2484 std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
2485 num_configured_streams,
2486 simulcast_bitrate_mode,
2487 codec.width,
2488 codec.height,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002489 0,
2490 kDefaultQpMax,
2491 codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
2492
2493 ASSERT_EQ(expected_streams.size(), video_streams.size());
2494
2495 size_t num_streams = video_streams.size();
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002496 int total_max_bitrate_bps = 0;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002497 for (size_t i = 0; i < num_streams; ++i) {
2498 EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
2499 EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
2500
2501 EXPECT_GT(video_streams[i].max_framerate, 0);
2502 EXPECT_EQ(expected_streams[i].max_framerate,
2503 video_streams[i].max_framerate);
2504
2505 EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
2506 EXPECT_EQ(expected_streams[i].min_bitrate_bps,
2507 video_streams[i].min_bitrate_bps);
2508
2509 EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
2510 EXPECT_EQ(expected_streams[i].target_bitrate_bps,
2511 video_streams[i].target_bitrate_bps);
2512
2513 EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
2514 EXPECT_EQ(expected_streams[i].max_bitrate_bps,
2515 video_streams[i].max_bitrate_bps);
2516
2517 EXPECT_GT(video_streams[i].max_qp, 0);
2518 EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
2519
2520 EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty());
2521 EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps,
2522 video_streams[i].temporal_layer_thresholds_bps);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002523
2524 if (i == num_streams - 1) {
2525 total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
2526 } else {
2527 total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
2528 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002529 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002530 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002531 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002532 ASSERT_EQ(1u, info.senders.size());
2533 EXPECT_EQ(total_max_bitrate_bps, info.senders[0].preferred_bitrate);
2534
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002535 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002536 }
2537
2538 FakeVideoSendStream* AddSendStream() {
2539 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
2540 }
2541
2542 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
2543 size_t num_streams =
2544 fake_call_->GetVideoSendStreams().size();
2545 EXPECT_TRUE(channel_->AddSendStream(sp));
2546 std::vector<FakeVideoSendStream*> streams =
2547 fake_call_->GetVideoSendStreams();
2548 EXPECT_EQ(num_streams + 1, streams.size());
2549 return streams[streams.size() - 1];
2550 }
2551
2552 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
2553 return fake_call_->GetVideoSendStreams();
2554 }
2555
2556 FakeVideoReceiveStream* AddRecvStream() {
2557 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
2558 }
2559
2560 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
2561 size_t num_streams =
2562 fake_call_->GetVideoReceiveStreams().size();
2563 EXPECT_TRUE(channel_->AddRecvStream(sp));
2564 std::vector<FakeVideoReceiveStream*> streams =
2565 fake_call_->GetVideoReceiveStreams();
2566 EXPECT_EQ(num_streams + 1, streams.size());
2567 return streams[streams.size() - 1];
2568 }
2569
2570 FakeCall* fake_call_;
2571 rtc::scoped_ptr<VideoMediaChannel> channel_;
2572 uint32 last_ssrc_;
2573};
2574
2575TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
2576 VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
2577}
2578
2579TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
2580 VerifySimulcastSettings(
2581 kVp8Codec720p, VideoOptions::NORMAL, 3, 3, SBM_NORMAL);
2582}
2583
2584TEST_F(WebRtcVideoChannel2SimulcastTest,
2585 SetSendCodecsWith2SimulcastStreamsHighBitrateMode) {
2586 VerifySimulcastSettings(kVp8Codec, VideoOptions::HIGH, 2, 2, SBM_HIGH);
2587}
2588
2589TEST_F(WebRtcVideoChannel2SimulcastTest,
2590 SetSendCodecsWith3SimulcastStreamsHighBitrateMode) {
2591 VerifySimulcastSettings(kVp8Codec720p, VideoOptions::HIGH, 3, 3, SBM_HIGH);
2592}
2593
2594TEST_F(WebRtcVideoChannel2SimulcastTest,
2595 SetSendCodecsWith2SimulcastStreamsVeryHighBitrateMode) {
2596 VerifySimulcastSettings(
2597 kVp8Codec, VideoOptions::VERY_HIGH, 2, 2, SBM_VERY_HIGH);
2598}
2599
2600TEST_F(WebRtcVideoChannel2SimulcastTest,
2601 SetSendCodecsWith3SimulcastStreamsVeryHighBitrateMode) {
2602 VerifySimulcastSettings(
2603 kVp8Codec720p, VideoOptions::VERY_HIGH, 3, 3, SBM_VERY_HIGH);
2604}
2605
2606// Test that we normalize send codec format size in simulcast.
2607TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
2608 cricket::VideoCodec codec(kVp8Codec270p);
2609 codec.width += 1;
2610 codec.height += 1;
2611 VerifySimulcastSettings(codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
2612}
2613
2614// Test that if we add a stream with RTX SSRC's, SSRC's get set correctly.
2615TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestStreamWithRtx) {
2616 // TODO(pbos): Implement.
2617 FAIL() << "Not implemented.";
2618}
2619
2620// Test that if we get too few ssrcs are given in AddSendStream(),
2621// only supported sub-streams will be added.
2622TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TooFewSimulcastSsrcs) {
2623 // TODO(pbos): Implement.
2624 FAIL() << "Not implemented.";
2625}
2626
2627// Test that even more than enough ssrcs are given in AddSendStream(),
2628// only supported sub-streams will be added.
2629TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_MoreThanEnoughSimulcastSscrs) {
2630 // TODO(pbos): Implement.
2631 FAIL() << "Not implemented.";
2632}
2633
2634// Test that SetSendStreamFormat works well with simulcast.
2635TEST_F(WebRtcVideoEngine2SimulcastTest,
2636 DISABLED_SetSendStreamFormatWithSimulcast) {
2637 // TODO(pbos): Implement.
2638 FAIL() << "Not implemented.";
2639}
2640
2641// Test that simulcast send codec is reset on new video frame size.
2642TEST_F(WebRtcVideoEngine2SimulcastTest,
2643 DISABLED_ResetSimulcastSendCodecOnNewFrameSize) {
2644 // TODO(pbos): Implement.
2645 FAIL() << "Not implemented.";
2646}
2647
2648// Test that simulcast send codec is reset on new portait mode video frame.
2649TEST_F(WebRtcVideoEngine2SimulcastTest,
2650 DISABLED_ResetSimulcastSendCodecOnNewPortaitFrame) {
2651 // TODO(pbos): Implement.
2652 FAIL() << "Not implemented.";
2653}
2654
2655TEST_F(WebRtcVideoEngine2SimulcastTest,
2656 DISABLED_SetBandwidthInConferenceWithSimulcast) {
2657 // TODO(pbos): Implement.
2658 FAIL() << "Not implemented.";
2659}
2660
2661// Test that sending screencast frames in conference mode changes
2662// bitrate.
2663TEST_F(WebRtcVideoEngine2SimulcastTest,
2664 DISABLED_SetBandwidthScreencastInConference) {
2665 // TODO(pbos): Implement.
2666 FAIL() << "Not implemented.";
2667}
2668
2669// Test AddSendStream with simulcast rejects bad StreamParams.
2670TEST_F(WebRtcVideoEngine2SimulcastTest,
2671 DISABLED_AddSendStreamWithBadStreamParams) {
2672 // TODO(pbos): Implement.
2673 FAIL() << "Not implemented.";
2674}
2675
2676// Test AddSendStream with simulcast sets ssrc and cname correctly.
2677TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_AddSendStreamWithSimulcast) {
2678 // TODO(pbos): Implement.
2679 FAIL() << "Not implemented.";
2680}
2681
2682// Test RemoveSendStream with simulcast.
2683TEST_F(WebRtcVideoEngine2SimulcastTest,
2684 DISABLED_RemoveSendStreamWithSimulcast) {
2685 // TODO(pbos): Implement.
2686 FAIL() << "Not implemented.";
2687}
2688
2689// Test AddSendStream after send codec has already been set will reset
2690// send codec with simulcast settings.
2691TEST_F(WebRtcVideoEngine2SimulcastTest,
2692 DISABLED_AddSimulcastStreamAfterSetSendCodec) {
2693 // TODO(pbos): Implement.
2694 FAIL() << "Not implemented.";
2695}
2696
2697TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_GetStatsWithMultipleSsrcs) {
2698 // TODO(pbos): Implement.
2699 FAIL() << "Not implemented.";
2700}
2701
2702// Test receiving channel(s) local ssrc is set to the same as the first
2703// simulcast sending ssrc.
2704TEST_F(WebRtcVideoEngine2SimulcastTest,
2705 DISABLED_AddSimulcastStreamAfterCreatingRecvChannels) {
2706 // TODO(pbos): Implement.
2707 FAIL() << "Not implemented.";
2708}
2709
2710// Test 1:1 call never turn on simulcast.
2711TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_NoSimulcastWith1on1) {
2712 // TODO(pbos): Implement.
2713 FAIL() << "Not implemented.";
2714}
2715
2716// Test SetOptions with OPT_CONFERENCE flag.
2717TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_SetOptionsWithConferenceMode) {
2718 // TODO(pbos): Implement.
2719 FAIL() << "Not implemented.";
2720}
2721
2722// Test that two different streams can have different formats.
2723TEST_F(WebRtcVideoEngine2SimulcastTest,
2724 DISABLED_MultipleSendStreamsDifferentFormats) {
2725 // TODO(pbos): Implement.
2726 FAIL() << "Not implemented.";
2727}
2728
2729TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToOutputFormat) {
2730 // TODO(pbos): Implement.
2731 FAIL() << "Not implemented.";
2732}
2733
2734TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToCpuLoad) {
2735 // TODO(pbos): Implement.
2736 FAIL() << "Not implemented.";
2737}
2738
2739TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToCpuLoadDisabled) {
2740 // TODO(pbos): Implement.
2741 FAIL() << "Not implemented.";
2742}
2743
2744TEST_F(WebRtcVideoEngine2SimulcastTest,
2745 DISABLED_TestAdaptWithCpuOveruseObserver) {
2746 // TODO(pbos): Implement.
2747 FAIL() << "Not implemented.";
2748}
2749
2750// Test that codec is not reset for every frame sent in non-conference and
2751// non-screencast mode.
2752TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_DontResetCodecOnSendFrame) {
2753 // TODO(pbos): Implement.
2754 FAIL() << "Not implemented.";
2755}
2756
2757TEST_F(WebRtcVideoEngine2SimulcastTest,
2758 DISABLED_UseSimulcastAdapterOnVp8OnlyFactory) {
2759 // TODO(pbos): Implement.
2760 FAIL() << "Not implemented.";
2761}
2762
2763TEST_F(WebRtcVideoEngine2SimulcastTest,
2764 DISABLED_DontUseSimulcastAdapterOnNoneVp8Factory) {
2765 // TODO(pbos): Implement.
2766 FAIL() << "Not implemented.";
2767}
2768
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002769TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x800) {
2770 // TODO(pbos): Implement.
2771 FAIL() << "Not implemented.";
2772}
2773
2774TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x720) {
2775 // TODO(pbos): Implement.
2776 FAIL() << "Not implemented.";
2777}
2778
2779TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x540) {
2780 // TODO(pbos): Implement.
2781 FAIL() << "Not implemented.";
2782}
2783
2784TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x600) {
2785 // TODO(pbos): Implement.
2786 FAIL() << "Not implemented.";
2787}
2788
2789TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x400) {
2790 // TODO(pbos): Implement.
2791 FAIL() << "Not implemented.";
2792}
2793
2794TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x360) {
2795 // TODO(pbos): Implement.
2796 FAIL() << "Not implemented.";
2797}
2798
2799TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_480x300) {
2800 // TODO(pbos): Implement.
2801 FAIL() << "Not implemented.";
2802}
2803
2804TEST_F(WebRtcVideoChannel2SimulcastTest,
2805 DISABLED_DISABLED_SimulcastSend_480x270) {
2806 // TODO(pbos): Implement.
2807 FAIL() << "Not implemented.";
2808}
2809
2810TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x200) {
2811 // TODO(pbos): Implement.
2812 FAIL() << "Not implemented.";
2813}
2814
2815TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x180) {
2816 // TODO(pbos): Implement.
2817 FAIL() << "Not implemented.";
2818}
2819
2820// Test reset send codec with simulcast.
2821// Disabled per b/6773425
2822TEST_F(WebRtcVideoChannel2SimulcastTest,
2823 DISABLED_DISABLED_SimulcastResetSendCodec) {
2824 // TODO(pbos): Implement.
2825 FAIL() << "Not implemented.";
2826}
2827
2828// Test simulcast streams are decodeable with expected sizes.
2829TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastStreams) {
2830 // TODO(pbos): Implement.
2831 FAIL() << "Not implemented.";
2832}
2833
2834// Simulcast and resolution resizing should be turned off when screencasting
2835// but not otherwise.
2836TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_ScreencastRendering) {
2837 // TODO(pbos): Implement.
2838 FAIL() << "Not implemented.";
2839}
2840
2841// Ensures that the correct settings are applied to the codec when single
2842// temporal layer screencasting is enabled, and that the correct simulcast
2843// settings are reapplied when disabling screencasting.
2844TEST_F(WebRtcVideoChannel2SimulcastTest,
2845 DISABLED_OneTemporalLayerScreencastSettings) {
2846 // TODO(pbos): Implement.
2847 FAIL() << "Not implemented.";
2848}
2849
2850// Ensures that the correct settings are applied to the codec when two temporal
2851// layer screencasting is enabled, and that the correct simulcast settings are
2852// reapplied when disabling screencasting.
2853TEST_F(WebRtcVideoChannel2SimulcastTest,
2854 DISABLED_TwoTemporalLayerScreencastSettings) {
2855 // TODO(pbos): Implement.
2856 FAIL() << "Not implemented.";
2857}
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002858
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002859} // namespace cricket