blob: ca5d0dda96eec361229a2014893d439fe9af5683 [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"
Shao Changbine62202f2015-04-21 20:24:50 +080037#include "talk/media/webrtc/webrtcvideoengine.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000038#include "talk/media/webrtc/webrtcvideoengine2.h"
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000039#include "talk/media/webrtc/webrtcvideoengine2_unittest.h"
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +000040#include "talk/media/webrtc/webrtcvoiceengine.h"
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +000041#include "webrtc/base/arraysize.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000042#include "webrtc/base/gunit.h"
43#include "webrtc/base/stringutils.h"
pbos@webrtc.org42684be2014-10-03 11:25:45 +000044#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000045
46namespace {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000047static const int kDefaultQpMax = 56;
48static const int kDefaultFramerate = 30;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000049
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000050static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0);
51static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30, 0);
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000052static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30, 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000053
54static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0);
55static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000056static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0);
57
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000058static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0);
59static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0);
60
61static const uint32 kSsrcs1[] = {1};
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000062static const uint32 kSsrcs3[] = {1, 2, 3};
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000063static const uint32 kRtxSsrcs1[] = {4};
pbos@webrtc.org3c107582014-07-20 15:27:35 +000064static const char kUnsupportedExtensionName[] =
65 "urn:ietf:params:rtp-hdrext:unsupported";
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000066
67void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
68 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
69 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
70 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
71 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
72 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
73 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
74 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
75 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
76}
77
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +000078static void CreateBlackFrame(webrtc::I420VideoFrame* video_frame,
79 int width,
80 int height) {
81 video_frame->CreateEmptyFrame(
82 width, height, width, (width + 1) / 2, (width + 1) / 2);
83 memset(video_frame->buffer(webrtc::kYPlane), 16,
84 video_frame->allocated_size(webrtc::kYPlane));
85 memset(video_frame->buffer(webrtc::kUPlane), 128,
86 video_frame->allocated_size(webrtc::kUPlane));
87 memset(video_frame->buffer(webrtc::kVPlane), 128,
88 video_frame->allocated_size(webrtc::kVPlane));
89}
90
Shao Changbine62202f2015-04-21 20:24:50 +080091void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
92 const std::map<int, int>& rtx_types) {
93 std::map<int, int>::const_iterator it;
94 it = rtx_types.find(config.encoder_settings.payload_type);
95 EXPECT_TRUE(it != rtx_types.end() &&
96 it->second == config.rtp.rtx.payload_type);
97
98 if (config.rtp.fec.red_rtx_payload_type != -1) {
99 it = rtx_types.find(config.rtp.fec.red_payload_type);
100 EXPECT_TRUE(it != rtx_types.end() &&
101 it->second == config.rtp.fec.red_rtx_payload_type);
102 }
103}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000104} // namespace
105
106namespace cricket {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000107FakeVideoSendStream::FakeVideoSendStream(
108 const webrtc::VideoSendStream::Config& config,
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000109 const webrtc::VideoEncoderConfig& encoder_config)
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000110 : sending_(false),
111 config_(config),
112 codec_settings_set_(false),
113 num_swapped_frames_(0) {
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000114 assert(config.encoder_settings.encoder != NULL);
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000115 ReconfigureVideoEncoder(encoder_config);
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000116}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000117
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000118webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() const {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000119 return config_;
120}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000121
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000122webrtc::VideoEncoderConfig FakeVideoSendStream::GetEncoderConfig() const {
123 return encoder_config_;
124}
125
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000126std::vector<webrtc::VideoStream> FakeVideoSendStream::GetVideoStreams() {
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000127 return encoder_config_.streams;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000128}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000129
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000130bool FakeVideoSendStream::IsSending() const {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000131 return sending_;
132}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000133
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000134bool FakeVideoSendStream::GetVp8Settings(
135 webrtc::VideoCodecVP8* settings) const {
136 if (!codec_settings_set_) {
137 return false;
138 }
139
140 *settings = vp8_settings_;
141 return true;
142}
143
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000144int FakeVideoSendStream::GetNumberOfSwappedFrames() const {
145 return num_swapped_frames_;
146}
147
148int FakeVideoSendStream::GetLastWidth() const {
149 return last_frame_.width();
150}
151
152int FakeVideoSendStream::GetLastHeight() const {
153 return last_frame_.height();
154}
155
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +0000156void FakeVideoSendStream::IncomingCapturedFrame(
157 const webrtc::I420VideoFrame& frame) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000158 ++num_swapped_frames_;
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +0000159 last_frame_.ShallowCopy(frame);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000160}
pbos@webrtc.org273a4142014-12-01 15:23:21 +0000161
162void FakeVideoSendStream::SetStats(
163 const webrtc::VideoSendStream::Stats& stats) {
164 stats_ = stats;
165}
166
167webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() {
168 return stats_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000169}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000170
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000171bool FakeVideoSendStream::ReconfigureVideoEncoder(
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000172 const webrtc::VideoEncoderConfig& config) {
173 encoder_config_ = config;
174 if (config.encoder_specific_settings != NULL) {
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000175 assert(config_.encoder_settings.payload_name == "VP8");
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000176 vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>(
177 config.encoder_specific_settings);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000178 }
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000179 codec_settings_set_ = config.encoder_specific_settings != NULL;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000180 return true;
181}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000182
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000183webrtc::VideoSendStreamInput* FakeVideoSendStream::Input() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000184 return this;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000185}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000186
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000187void FakeVideoSendStream::Start() {
188 sending_ = true;
189}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000190
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000191void FakeVideoSendStream::Stop() {
192 sending_ = false;
193}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000194
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000195FakeVideoReceiveStream::FakeVideoReceiveStream(
196 const webrtc::VideoReceiveStream::Config& config)
197 : config_(config), receiving_(false) {
198}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000199
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000200webrtc::VideoReceiveStream::Config FakeVideoReceiveStream::GetConfig() {
201 return config_;
202}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000203
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000204bool FakeVideoReceiveStream::IsReceiving() const {
205 return receiving_;
206}
207
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +0000208void FakeVideoReceiveStream::InjectFrame(const webrtc::I420VideoFrame& frame,
209 int time_to_render_ms) {
210 config_.renderer->RenderFrame(frame, time_to_render_ms);
211}
212
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000213webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const {
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +0000214 return stats_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000215}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000216
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000217void FakeVideoReceiveStream::Start() {
218 receiving_ = true;
219}
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000220
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000221void FakeVideoReceiveStream::Stop() {
222 receiving_ = false;
223}
pbos@webrtc.org85f42942014-07-22 09:14:58 +0000224
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +0000225void FakeVideoReceiveStream::SetStats(
226 const webrtc::VideoReceiveStream::Stats& stats) {
227 stats_ = stats;
228}
229
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000230FakeCall::FakeCall(const webrtc::Call::Config& config)
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000231 : config_(config),
232 network_state_(kNetworkUp),
233 num_created_send_streams_(0),
234 num_created_receive_streams_(0) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000235}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000236
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000237FakeCall::~FakeCall() {
238 EXPECT_EQ(0u, video_send_streams_.size());
239 EXPECT_EQ(0u, video_receive_streams_.size());
240}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000241
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000242webrtc::Call::Config FakeCall::GetConfig() const {
243 return config_;
244}
245
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000246std::vector<FakeVideoSendStream*> FakeCall::GetVideoSendStreams() {
247 return video_send_streams_;
248}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000249
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000250std::vector<FakeVideoReceiveStream*> FakeCall::GetVideoReceiveStreams() {
251 return video_receive_streams_;
252}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000253
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000254webrtc::Call::NetworkState FakeCall::GetNetworkState() const {
255 return network_state_;
256}
257
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000258webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
259 const webrtc::VideoSendStream::Config& config,
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000260 const webrtc::VideoEncoderConfig& encoder_config) {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000261 FakeVideoSendStream* fake_stream =
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000262 new FakeVideoSendStream(config, encoder_config);
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000263 video_send_streams_.push_back(fake_stream);
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000264 ++num_created_send_streams_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000265 return fake_stream;
266}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000267
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000268void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
269 FakeVideoSendStream* fake_stream =
270 static_cast<FakeVideoSendStream*>(send_stream);
271 for (size_t i = 0; i < video_send_streams_.size(); ++i) {
272 if (video_send_streams_[i] == fake_stream) {
273 delete video_send_streams_[i];
274 video_send_streams_.erase(video_send_streams_.begin() + i);
275 return;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000276 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000277 }
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000278 ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter.";
279}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000280
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000281webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
282 const webrtc::VideoReceiveStream::Config& config) {
283 video_receive_streams_.push_back(new FakeVideoReceiveStream(config));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000284 ++num_created_receive_streams_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000285 return video_receive_streams_[video_receive_streams_.size() - 1];
286}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000287
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000288void FakeCall::DestroyVideoReceiveStream(
289 webrtc::VideoReceiveStream* receive_stream) {
290 FakeVideoReceiveStream* fake_stream =
291 static_cast<FakeVideoReceiveStream*>(receive_stream);
292 for (size_t i = 0; i < video_receive_streams_.size(); ++i) {
293 if (video_receive_streams_[i] == fake_stream) {
294 delete video_receive_streams_[i];
295 video_receive_streams_.erase(video_receive_streams_.begin() + i);
296 return;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000297 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000298 }
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000299 ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter.";
300}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000301
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000302webrtc::PacketReceiver* FakeCall::Receiver() {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000303 return this;
304}
305
306FakeCall::DeliveryStatus FakeCall::DeliverPacket(const uint8_t* packet,
307 size_t length) {
308 CHECK(length >= 12);
309 uint32_t ssrc;
310 if (!GetRtpSsrc(packet, length, &ssrc))
311 return DELIVERY_PACKET_ERROR;
312
313 for (auto& receiver: video_receive_streams_) {
314 if (receiver->GetConfig().rtp.remote_ssrc == ssrc)
315 return DELIVERY_OK;
316 }
317 return DELIVERY_UNKNOWN_SSRC;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000318}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000319
pbos@webrtc.org2b19f062014-12-11 13:26:09 +0000320void FakeCall::SetStats(const webrtc::Call::Stats& stats) {
321 stats_ = stats;
322}
323
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000324int FakeCall::GetNumCreatedSendStreams() const {
325 return num_created_send_streams_;
326}
327
328int FakeCall::GetNumCreatedReceiveStreams() const {
329 return num_created_receive_streams_;
330}
331
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000332webrtc::Call::Stats FakeCall::GetStats() const {
pbos@webrtc.org2b19f062014-12-11 13:26:09 +0000333 return stats_;
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000334}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000335
pbos@webrtc.org00873182014-11-25 14:03:34 +0000336void FakeCall::SetBitrateConfig(
337 const webrtc::Call::Config::BitrateConfig& bitrate_config) {
Stefan Holmere5904162015-03-26 11:11:06 +0100338 config_.bitrate_config = bitrate_config;
pbos@webrtc.org00873182014-11-25 14:03:34 +0000339}
340
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000341void FakeCall::SignalNetworkState(webrtc::Call::NetworkState state) {
342 network_state_ = state;
343}
344
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000345class WebRtcVideoEngine2Test : public ::testing::Test {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000346 public:
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000347 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test(nullptr) {}
348 WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine)
349 : engine_(voice_engine) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000350 std::vector<VideoCodec> engine_codecs = engine_.codecs();
351 assert(!engine_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000352 bool codec_set = false;
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000353 for (size_t i = 0; i < engine_codecs.size(); ++i) {
354 if (engine_codecs[i].name == "red") {
355 default_red_codec_ = engine_codecs[i];
356 } else if (engine_codecs[i].name == "ulpfec") {
357 default_ulpfec_codec_ = engine_codecs[i];
358 } else if (engine_codecs[i].name == "rtx") {
Shao Changbine62202f2015-04-21 20:24:50 +0800359 int associated_payload_type;
360 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
361 &associated_payload_type)) {
362 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id;
363 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000364 } else if (!codec_set) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000365 default_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000366 codec_set = true;
367 }
368 }
369
370 assert(codec_set);
371 }
372
373 protected:
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000374 class FakeCallFactory : public WebRtcCallFactory {
375 public:
376 FakeCallFactory() : fake_call_(NULL) {}
377 FakeCall* GetCall() { return fake_call_; }
378
379 private:
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000380 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000381 assert(fake_call_ == NULL);
382 fake_call_ = new FakeCall(config);
383 return fake_call_;
384 }
385
386 FakeCall* fake_call_;
387 };
388
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000389 VideoMediaChannel* SetUpForExternalEncoderFactory(
390 cricket::WebRtcVideoEncoderFactory* encoder_factory,
391 const std::vector<VideoCodec>& codecs);
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000392
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000393 VideoMediaChannel* SetUpForExternalDecoderFactory(
394 cricket::WebRtcVideoDecoderFactory* decoder_factory,
395 const std::vector<VideoCodec>& codecs);
396
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000397 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
398 // initialized when the constructor is called.
399 WebRtcVoiceEngine voice_engine_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000400 WebRtcVideoEngine2 engine_;
401 VideoCodec default_codec_;
402 VideoCodec default_red_codec_;
403 VideoCodec default_ulpfec_codec_;
Shao Changbine62202f2015-04-21 20:24:50 +0800404 std::map<int, int> default_apt_rtx_types_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000405};
406
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000407class WebRtcVideoEngine2VoiceTest : public WebRtcVideoEngine2Test {
408 public:
409 WebRtcVideoEngine2VoiceTest() : WebRtcVideoEngine2Test(&voice_engine_) {}
410};
411
412TEST_F(WebRtcVideoEngine2VoiceTest, ConfiguresAvSyncForFirstReceiveChannel) {
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000413 FakeCallFactory call_factory;
414 engine_.SetCallFactory(&call_factory);
415
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000416 voice_engine_.Init(rtc::Thread::Current());
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000417 engine_.Init(rtc::Thread::Current());
418
419 rtc::scoped_ptr<VoiceMediaChannel> voice_channel(
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000420 voice_engine_.CreateChannel());
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000421 ASSERT_TRUE(voice_channel.get() != NULL);
422 WebRtcVoiceMediaChannel* webrtc_voice_channel =
423 static_cast<WebRtcVoiceMediaChannel*>(voice_channel.get());
424 ASSERT_NE(webrtc_voice_channel->voe_channel(), -1);
425 rtc::scoped_ptr<VideoMediaChannel> channel(
426 engine_.CreateChannel(cricket::VideoOptions(), voice_channel.get()));
427
428 FakeCall* fake_call = call_factory.GetCall();
429 ASSERT_TRUE(fake_call != NULL);
430
431 webrtc::Call::Config call_config = fake_call->GetConfig();
432
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000433 ASSERT_TRUE(voice_engine_.voe()->engine() != NULL);
434 ASSERT_EQ(voice_engine_.voe()->engine(), call_config.voice_engine);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000435
436 EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc)));
437 EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc + 1)));
438 std::vector<FakeVideoReceiveStream*> receive_streams =
439 fake_call->GetVideoReceiveStreams();
440
441 ASSERT_EQ(2u, receive_streams.size());
442 EXPECT_EQ(webrtc_voice_channel->voe_channel(),
443 receive_streams[0]->GetConfig().audio_channel_id);
444 EXPECT_EQ(-1, receive_streams[1]->GetConfig().audio_channel_id)
445 << "AV sync should only be set up for the first receive channel.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000446}
447
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000448TEST_F(WebRtcVideoEngine2Test, FindCodec) {
449 const std::vector<cricket::VideoCodec>& c = engine_.codecs();
Shao Changbine62202f2015-04-21 20:24:50 +0800450 EXPECT_EQ(cricket::DefaultVideoCodecList().size(), c.size());
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000451
452 cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0);
453 EXPECT_TRUE(engine_.FindCodec(vp8));
454
455 cricket::VideoCodec vp8_ci(104, "vp8", 320, 200, 30, 0);
456 EXPECT_TRUE(engine_.FindCodec(vp8));
457
458 cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50);
459 EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref));
460
461 cricket::VideoCodec vp8_diff_id(95, "VP8", 320, 200, 30, 0);
462 EXPECT_FALSE(engine_.FindCodec(vp8_diff_id));
463 vp8_diff_id.id = 97;
464 EXPECT_TRUE(engine_.FindCodec(vp8_diff_id));
465
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000466 // FindCodec ignores the codec size.
467 // Test that FindCodec can accept uncommon codec size.
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000468 cricket::VideoCodec vp8_diff_res(104, "VP8", 320, 111, 30, 0);
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000469 EXPECT_TRUE(engine_.FindCodec(vp8_diff_res));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000470
471 // PeerConnection doesn't negotiate the resolution at this point.
472 // Test that FindCodec can handle the case when width/height is 0.
473 cricket::VideoCodec vp8_zero_res(104, "VP8", 0, 0, 30, 0);
474 EXPECT_TRUE(engine_.FindCodec(vp8_zero_res));
475
476 cricket::VideoCodec red(101, "RED", 0, 0, 30, 0);
477 EXPECT_TRUE(engine_.FindCodec(red));
478
479 cricket::VideoCodec red_ci(101, "red", 0, 0, 30, 0);
480 EXPECT_TRUE(engine_.FindCodec(red));
481
482 cricket::VideoCodec fec(102, "ULPFEC", 0, 0, 30, 0);
483 EXPECT_TRUE(engine_.FindCodec(fec));
484
485 cricket::VideoCodec fec_ci(102, "ulpfec", 0, 0, 30, 0);
486 EXPECT_TRUE(engine_.FindCodec(fec));
487
488 cricket::VideoCodec rtx(96, "rtx", 0, 0, 30, 0);
489 EXPECT_TRUE(engine_.FindCodec(rtx));
490}
491
pbos@webrtc.org2a72c652015-02-26 16:01:24 +0000492TEST_F(WebRtcVideoEngine2Test, SetDefaultEncoderConfigPreservesFeedbackParams) {
493 cricket::VideoCodec max_settings(
494 engine_.codecs()[0].id, engine_.codecs()[0].name,
495 engine_.codecs()[0].width / 2, engine_.codecs()[0].height / 2, 30, 0);
496 // This codec shouldn't have NACK by default or the test is pointless.
497 EXPECT_FALSE(max_settings.HasFeedbackParam(
498 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
499 // The engine should by default have it however.
500 EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam(
501 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
502
503 // Set constrained max codec settings.
504 EXPECT_TRUE(engine_.SetDefaultEncoderConfig(
505 cricket::VideoEncoderConfig(max_settings)));
506
507 // Verify that feedback parameters are retained.
508 EXPECT_TRUE(engine_.codecs()[0].HasFeedbackParam(
509 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)));
510}
511
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000512TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
513 std::vector<VideoCodec> engine_codecs = engine_.codecs();
514 for (size_t i = 0; i < engine_codecs.size(); ++i) {
515 if (engine_codecs[i].name != kRtxCodecName)
516 continue;
517 int associated_payload_type;
518 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000519 &associated_payload_type));
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000520 EXPECT_EQ(default_codec_.id, associated_payload_type);
521 return;
522 }
523 FAIL() << "No RTX codec found among default codecs.";
524}
525
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000526TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
527 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
528 ASSERT_FALSE(extensions.empty());
529 for (size_t i = 0; i < extensions.size(); ++i) {
530 if (extensions[i].uri == kRtpTimestampOffsetHeaderExtension) {
531 EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extensions[i].id);
532 return;
533 }
534 }
535 FAIL() << "Timestamp offset extension not in header-extension list.";
536}
537
538TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
539 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
540 ASSERT_FALSE(extensions.empty());
541 for (size_t i = 0; i < extensions.size(); ++i) {
542 if (extensions[i].uri == kRtpAbsoluteSenderTimeHeaderExtension) {
543 EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId,
544 extensions[i].id);
545 return;
546 }
547 }
548 FAIL() << "Absolute Sender Time extension not in header-extension list.";
549}
550
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700551TEST_F(WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension) {
552 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
553 ASSERT_FALSE(extensions.empty());
554 for (size_t i = 0; i < extensions.size(); ++i) {
555 if (extensions[i].uri == kRtpVideoRotationHeaderExtension) {
556 EXPECT_EQ(kRtpVideoRotationHeaderExtensionDefaultId, extensions[i].id);
557 return;
558 }
559 }
560 FAIL() << "Video Rotation extension not in header-extension list.";
561}
562
563TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
564 // Allocate the capturer first to prevent early destruction before channel's
565 // dtor is called.
566 cricket::FakeVideoCapturer capturer;
567
568 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
569 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
570 std::vector<cricket::VideoCodec> codecs;
571 codecs.push_back(kVp8Codec);
572
573 rtc::scoped_ptr<VideoMediaChannel> channel(
574 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
575 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
576
577 // Add CVO extension.
578 const int id = 1;
579 std::vector<cricket::RtpHeaderExtension> extensions;
580 extensions.push_back(
581 cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
582 EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
583
584 // Set capturer.
585 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
586
587 // Verify capturer has turned off applying rotation.
588 EXPECT_FALSE(capturer.GetApplyRotation());
589
590 // Verify removing header extension turns on applying rotation.
591 extensions.clear();
592 EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
593 EXPECT_TRUE(capturer.GetApplyRotation());
594}
595
596TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
597 cricket::FakeVideoCapturer capturer;
598
599 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
600 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
601 std::vector<cricket::VideoCodec> codecs;
602 codecs.push_back(kVp8Codec);
603
604 rtc::scoped_ptr<VideoMediaChannel> channel(
605 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
606 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
607
608 // Set capturer.
609 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
610
611 // Add CVO extension.
612 const int id = 1;
613 std::vector<cricket::RtpHeaderExtension> extensions;
614 extensions.push_back(
615 cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
616 EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
617
618 // Verify capturer has turned off applying rotation.
619 EXPECT_FALSE(capturer.GetApplyRotation());
620
621 // Verify removing header extension turns on applying rotation.
622 extensions.clear();
623 EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
624 EXPECT_TRUE(capturer.GetApplyRotation());
625}
626
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000627TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000628 engine_.Init(rtc::Thread::Current());
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000629 rtc::scoped_ptr<VideoMediaChannel> channel(
630 engine_.CreateChannel(cricket::VideoOptions(), NULL));
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000631
632 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
633
634 EXPECT_FALSE(channel->SetSend(true))
635 << "Channel should not start without codecs.";
636 EXPECT_TRUE(channel->SetSend(false))
637 << "Channel should be stoppable even without set codecs.";
638}
639
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000640TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000641 engine_.Init(rtc::Thread::Current());
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000642 rtc::scoped_ptr<VideoMediaChannel> channel(
643 engine_.CreateChannel(cricket::VideoOptions(), NULL));
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +0000644 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
645 VideoMediaInfo info;
646 channel->GetStats(&info);
647}
648
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000649TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
650 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
651 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
652 std::vector<cricket::VideoCodec> codecs;
653 codecs.push_back(kVp8Codec);
654
655 rtc::scoped_ptr<VideoMediaChannel> channel(
656 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
657
658 EXPECT_TRUE(
659 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
660 ASSERT_EQ(1u, encoder_factory.encoders().size());
661 EXPECT_TRUE(channel->SetSend(true));
662
663 cricket::FakeVideoCapturer capturer;
664 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
665 EXPECT_EQ(cricket::CS_RUNNING,
666 capturer.Start(capturer.GetSupportedFormats()->front()));
667 EXPECT_TRUE(capturer.CaptureFrame());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000668 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
669 kTimeout);
670
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000671 // Sending one frame will have reallocated the encoder since input size
672 // changes from a small default to the actual frame width/height.
673 int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
674 EXPECT_EQ(num_created_encoders, 2);
675
676 // Setting codecs of the same type should not reallocate any encoders
677 // (expecting a no-op).
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000678 EXPECT_TRUE(channel->SetSendCodecs(codecs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000679 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000680
681 // Remove stream previously added to free the external encoder instance.
682 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
683 EXPECT_EQ(0u, encoder_factory.encoders().size());
684}
685
Peter Boström53eda3d2015-03-27 15:53:18 +0100686TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
687 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
688 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
689 std::vector<cricket::VideoCodec> codecs;
690 codecs.push_back(kVp9Codec);
691
692 rtc::scoped_ptr<VideoMediaChannel> channel(
693 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
694
695 EXPECT_TRUE(
696 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
697}
698
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000699VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
700 cricket::WebRtcVideoEncoderFactory* encoder_factory,
701 const std::vector<VideoCodec>& codecs) {
702 engine_.SetExternalEncoderFactory(encoder_factory);
703 engine_.Init(rtc::Thread::Current());
704
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000705 VideoMediaChannel* channel =
706 engine_.CreateChannel(cricket::VideoOptions(), NULL);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000707 EXPECT_TRUE(channel->SetSendCodecs(codecs));
708
709 return channel;
710}
711
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000712VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
713 cricket::WebRtcVideoDecoderFactory* decoder_factory,
714 const std::vector<VideoCodec>& codecs) {
715 engine_.SetExternalDecoderFactory(decoder_factory);
716 engine_.Init(rtc::Thread::Current());
717
718 VideoMediaChannel* channel =
719 engine_.CreateChannel(cricket::VideoOptions(), NULL);
720 EXPECT_TRUE(channel->SetRecvCodecs(codecs));
721
722 return channel;
723}
724
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000725TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
726 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
727 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
728 std::vector<cricket::VideoCodec> codecs;
729 codecs.push_back(kVp8Codec);
730
731 rtc::scoped_ptr<VideoMediaChannel> channel(
732 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
733
734 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
735
736 EXPECT_TRUE(
737 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
738 EXPECT_TRUE(channel->SetSend(true));
739
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000740 cricket::FakeVideoCapturer capturer;
741 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
742 EXPECT_EQ(cricket::CS_RUNNING,
743 capturer.Start(capturer.GetSupportedFormats()->front()));
744 EXPECT_TRUE(capturer.CaptureFrame());
745
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000746 EXPECT_GT(encoder_factory.encoders().size(), 1u);
747
748 // Verify that encoders are configured for simulcast through adapter
749 // (increasing resolution and only configured to send one stream each).
750 int prev_width = -1;
751 for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
752 webrtc::VideoCodec codec_settings =
753 encoder_factory.encoders()[i]->GetCodecSettings();
754 EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
755 EXPECT_GT(codec_settings.width, prev_width);
756 prev_width = codec_settings.width;
757 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +0000758
759 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), NULL));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000760
761 channel.reset();
762 ASSERT_EQ(0u, encoder_factory.encoders().size());
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000763}
764
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000765TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
766 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
767 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
768 std::vector<cricket::VideoCodec> codecs;
769 codecs.push_back(kH264Codec);
770
771 rtc::scoped_ptr<VideoMediaChannel> channel(
772 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
773
774 EXPECT_TRUE(
775 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
776 ASSERT_EQ(1u, encoder_factory.encoders().size());
777
778 codecs.clear();
779 codecs.push_back(kVp8Codec);
780 EXPECT_TRUE(channel->SetSendCodecs(codecs));
781
782 ASSERT_EQ(0u, encoder_factory.encoders().size());
783}
784
785TEST_F(WebRtcVideoEngine2Test,
786 DontUseExternalEncoderFactoryForUnsupportedCodecs) {
787 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
788 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
789 std::vector<cricket::VideoCodec> codecs;
790 codecs.push_back(kVp8Codec);
791
792 rtc::scoped_ptr<VideoMediaChannel> channel(
793 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
794
795 EXPECT_TRUE(
796 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
pthatcher@webrtc.org818c4982015-03-06 02:20:58 +0000797 // Make sure DestroyVideoEncoder was called on the factory.
798 ASSERT_EQ(0u, encoder_factory.encoders().size());
799}
800
801TEST_F(WebRtcVideoEngine2Test,
802 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
803 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
804 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
805 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
806
807 std::vector<cricket::VideoCodec> codecs;
808 codecs.push_back(kVp8Codec);
809
810 rtc::scoped_ptr<VideoMediaChannel> channel(
811 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
812
813 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
814
815 EXPECT_TRUE(
816 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
817 EXPECT_TRUE(channel->SetSend(true));
818
819 // Send a fake frame, or else the media engine will configure the simulcast
820 // encoder adapter at a low-enough size that it'll only create a single
821 // encoder layer.
822 cricket::FakeVideoCapturer capturer;
823 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer));
824 EXPECT_EQ(cricket::CS_RUNNING,
825 capturer.Start(capturer.GetSupportedFormats()->front()));
826 EXPECT_TRUE(capturer.CaptureFrame());
827
828 ASSERT_GT(encoder_factory.encoders().size(), 1u);
829 EXPECT_EQ(webrtc::kVideoCodecVP8,
830 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
831
832 channel.reset();
833 // Make sure DestroyVideoEncoder was called on the factory.
834 EXPECT_EQ(0u, encoder_factory.encoders().size());
835}
836
837TEST_F(WebRtcVideoEngine2Test,
838 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
839 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
840 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
841 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
842
843 std::vector<cricket::VideoCodec> codecs;
844 codecs.push_back(kH264Codec);
845
846 rtc::scoped_ptr<VideoMediaChannel> channel(
847 SetUpForExternalEncoderFactory(&encoder_factory, codecs));
848
849 EXPECT_TRUE(
850 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
851 ASSERT_EQ(1u, encoder_factory.encoders().size());
852 EXPECT_EQ(webrtc::kVideoCodecH264,
853 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
854
855 channel.reset();
856 // Make sure DestroyVideoEncoder was called on the factory.
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000857 ASSERT_EQ(0u, encoder_factory.encoders().size());
858}
859
860// Test external codec with be added to the end of the supported codec list.
861TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) {
862 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
863 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
864 engine_.SetExternalEncoderFactory(&encoder_factory);
865
866 engine_.Init(rtc::Thread::Current());
867
868 std::vector<cricket::VideoCodec> codecs(engine_.codecs());
869 ASSERT_GE(codecs.size(), 2u);
870 cricket::VideoCodec internal_codec = codecs.front();
871 cricket::VideoCodec external_codec = codecs.back();
872
873 // The external codec will appear at last.
874 EXPECT_EQ("VP8", internal_codec.name);
875 EXPECT_EQ("H264", external_codec.name);
876}
877
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000878TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
879 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
880 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
881 std::vector<cricket::VideoCodec> codecs;
882 codecs.push_back(kVp8Codec);
883
884 rtc::scoped_ptr<VideoMediaChannel> channel(
885 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
886
887 EXPECT_TRUE(
888 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
889 ASSERT_EQ(1u, decoder_factory.decoders().size());
890
891 // Setting codecs of the same type should not reallocate the decoder.
892 EXPECT_TRUE(channel->SetRecvCodecs(codecs));
893 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
894
895 // Remove stream previously added to free the external decoder instance.
896 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
897 EXPECT_EQ(0u, decoder_factory.decoders().size());
898}
899
900// Verifies that we can set up decoders that are not internally supported.
901TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
902 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
903 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
904 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
905 // codecs.
906 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
907 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
908 engine_.SetExternalEncoderFactory(&encoder_factory);
909 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
910 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
911 std::vector<cricket::VideoCodec> codecs;
912 codecs.push_back(kH264Codec);
913
914 rtc::scoped_ptr<VideoMediaChannel> channel(
915 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
916
917 EXPECT_TRUE(
918 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
919 ASSERT_EQ(1u, decoder_factory.decoders().size());
920}
921
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000922class WebRtcVideoEngine2BaseTest
923 : public VideoEngineTest<cricket::WebRtcVideoEngine2> {
924 protected:
925 typedef VideoEngineTest<cricket::WebRtcVideoEngine2> Base;
926};
927
928#define WEBRTC_ENGINE_BASE_TEST(test) \
929 TEST_F(WebRtcVideoEngine2BaseTest, test) { Base::test##Body(); }
930
931WEBRTC_ENGINE_BASE_TEST(ConstrainNewCodec2);
932
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000933class WebRtcVideoChannel2BaseTest
934 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
935 protected:
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000936 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000937
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000938 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000939};
940
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000941#define WEBRTC_BASE_TEST(test) \
942 TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); }
943
944#define WEBRTC_DISABLED_BASE_TEST(test) \
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000945 TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); }
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000946
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000947// TODO(pbos): Fix WebRtcVideoEngine2BaseTest, where we want CheckCoInitialize.
948#if 0
949// TODO(juberti): Figure out why ViE is munging the COM refcount.
950#ifdef WIN32
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000951WEBRTC_DISABLED_BASE_TEST(CheckCoInitialize) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000952 Base::CheckCoInitialize();
953}
954#endif
955#endif
956
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000957WEBRTC_BASE_TEST(SetSend);
958WEBRTC_BASE_TEST(SetSendWithoutCodecs);
959WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000960
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000961WEBRTC_BASE_TEST(GetStats);
962WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams);
963WEBRTC_BASE_TEST(GetStatsMultipleSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000964
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000965WEBRTC_BASE_TEST(SetSendBandwidth);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000966
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000967WEBRTC_BASE_TEST(SetSendSsrc);
968WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000969
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000970WEBRTC_BASE_TEST(SetRenderer);
971WEBRTC_BASE_TEST(AddRemoveRecvStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000972
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000973WEBRTC_DISABLED_BASE_TEST(AddRemoveRecvStreamAndRender);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000974
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000975WEBRTC_BASE_TEST(AddRemoveRecvStreamsNoConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000976
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000977WEBRTC_BASE_TEST(AddRemoveSendStreams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000978
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000979WEBRTC_BASE_TEST(SimulateConference);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000980
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000981WEBRTC_BASE_TEST(AddRemoveCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000982
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000983WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000984
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000985WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000986
987// TODO(pbos): Figure out why this fails so often.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000988WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000989
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000990WEBRTC_BASE_TEST(RejectEmptyStreamParams);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000991
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000992WEBRTC_BASE_TEST(AdaptResolution16x10);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000993
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000994WEBRTC_BASE_TEST(AdaptResolution4x3);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000995
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000996// TODO(juberti): Restore this test once we support sending 0 fps.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000997WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000998// TODO(juberti): Understand why we get decode errors on this test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000999WEBRTC_DISABLED_BASE_TEST(AdaptFramerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001000
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001001WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames);
1002
1003WEBRTC_BASE_TEST(MuteStream);
1004
1005WEBRTC_BASE_TEST(MultipleSendStreams);
1006
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +00001007WEBRTC_BASE_TEST(SetSendStreamFormat0x0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001008
1009// TODO(zhurunz): Fix the flakey test.
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +00001010WEBRTC_DISABLED_BASE_TEST(SetSendStreamFormat);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001011
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001012TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
1013 SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30, 0));
1014}
1015
1016TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
1017 SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30, 0));
1018}
1019
1020TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
1021 SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30, 0));
1022}
1023
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001024TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
1025 Base::TwoStreamsSendAndReceive(kVp8Codec);
1026}
1027
1028TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsReUseFirstStream) {
1029 Base::TwoStreamsReUseFirstStream(kVp8Codec);
1030}
1031
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001032WEBRTC_BASE_TEST(SendManyResizeOnce);
1033
1034// TODO(pbos): Enable and figure out why this fails (or should work).
1035TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_SendVp8HdAndReceiveAdaptedVp8Vga) {
1036 EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
1037 EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
1038 channel_->UpdateAspectRatio(1280, 720);
1039 video_capturer_.reset(new cricket::FakeVideoCapturer);
1040 const std::vector<cricket::VideoFormat>* formats =
1041 video_capturer_->GetSupportedFormats();
1042 cricket::VideoFormat capture_format_hd = (*formats)[0];
1043 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format_hd));
1044 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
1045
1046 // Capture format HD -> adapt (OnOutputFormatRequest VGA) -> VGA.
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001047 cricket::VideoCodec codec = kVp8Codec720p;
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001048 EXPECT_TRUE(SetOneCodec(codec));
1049 codec.width /= 2;
1050 codec.height /= 2;
1051 EXPECT_TRUE(SetSend(true));
1052 EXPECT_TRUE(channel_->SetRender(true));
1053 EXPECT_EQ(0, renderer_.num_rendered_frames());
1054 EXPECT_TRUE(SendFrame());
1055 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
1056}
1057
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001058class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test,
1059 public WebRtcCallFactory {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001060 public:
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001061 WebRtcVideoChannel2Test() : fake_call_(NULL) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00001062 void SetUp() override {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001063 engine_.SetCallFactory(this);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001064 engine_.Init(rtc::Thread::Current());
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +00001065 channel_.reset(engine_.CreateChannel(cricket::VideoOptions(), NULL));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001066 ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001067 last_ssrc_ = 123;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001068 ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001069 }
1070
1071 protected:
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00001072 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001073 assert(fake_call_ == NULL);
1074 fake_call_ = new FakeCall(config);
1075 return fake_call_;
1076 }
1077
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001078 FakeVideoSendStream* AddSendStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001079 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001080 }
1081
1082 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001083 size_t num_streams = fake_call_->GetVideoSendStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001084 EXPECT_TRUE(channel_->AddSendStream(sp));
1085 std::vector<FakeVideoSendStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001086 fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001087 EXPECT_EQ(num_streams + 1, streams.size());
1088 return streams[streams.size() - 1];
1089 }
1090
1091 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001092 return fake_call_->GetVideoSendStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001093 }
1094
1095 FakeVideoReceiveStream* AddRecvStream() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001096 return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001097 }
1098
1099 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001100 size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001101 EXPECT_TRUE(channel_->AddRecvStream(sp));
1102 std::vector<FakeVideoReceiveStream*> streams =
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001103 fake_call_->GetVideoReceiveStreams();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001104 EXPECT_EQ(num_streams + 1, streams.size());
1105 return streams[streams.size() - 1];
1106 }
1107
pbos@webrtc.org00873182014-11-25 14:03:34 +00001108 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
1109 int expected_min_bitrate_bps,
1110 const char* start_bitrate_kbps,
1111 int expected_start_bitrate_bps,
1112 const char* max_bitrate_kbps,
1113 int expected_max_bitrate_bps) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001114 std::vector<VideoCodec> codecs;
1115 codecs.push_back(kVp8Codec);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001116 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
1117 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
1118 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001119 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1120
pbos@webrtc.org00873182014-11-25 14:03:34 +00001121 EXPECT_EQ(expected_min_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +01001122 fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001123 EXPECT_EQ(expected_start_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +01001124 fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001125 EXPECT_EQ(expected_max_bitrate_bps,
Stefan Holmere5904162015-03-26 11:11:06 +01001126 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001127 }
1128
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001129 void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
1130 const std::string& webrtc_ext) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001131 FakeCall* call = fake_call_;
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001132 // Enable extension.
1133 const int id = 1;
1134 std::vector<cricket::RtpHeaderExtension> extensions;
1135 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
1136 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1137
1138 FakeVideoSendStream* send_stream =
1139 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1140
1141 // Verify the send extension id.
1142 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1143 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
1144 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
1145 // Verify call with same set of extensions returns true.
1146 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1147 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
1148 // receivers.
1149 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
1150 ->GetConfig()
1151 .rtp.extensions.empty());
1152
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001153 // Verify that existing RTP header extensions can be removed.
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001154 std::vector<cricket::RtpHeaderExtension> empty_extensions;
1155 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001156 ASSERT_EQ(1u, call->GetVideoSendStreams().size());
1157 send_stream = call->GetVideoSendStreams()[0];
1158 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1159
1160 // Verify that adding receive RTP header extensions adds them for existing
1161 // streams.
1162 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1163 send_stream = call->GetVideoSendStreams()[0];
1164 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1165 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
1166 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001167 }
1168
1169 void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
1170 const std::string& webrtc_ext) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001171 FakeCall* call = fake_call_;
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001172 // Enable extension.
1173 const int id = 1;
1174 std::vector<cricket::RtpHeaderExtension> extensions;
1175 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
1176 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1177
1178 FakeVideoReceiveStream* recv_stream =
1179 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1180
1181 // Verify the recv extension id.
1182 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1183 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
1184 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
1185 // Verify call with same set of extensions returns true.
1186 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001187
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001188 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
1189 // senders.
1190 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
1191 ->GetConfig()
1192 .rtp.extensions.empty());
1193
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001194 // Verify that existing RTP header extensions can be removed.
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001195 std::vector<cricket::RtpHeaderExtension> empty_extensions;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001196 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions));
1197 ASSERT_EQ(1u, call->GetVideoReceiveStreams().size());
1198 recv_stream = call->GetVideoReceiveStreams()[0];
1199 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
1200
1201 // Verify that adding receive RTP header extensions adds them for existing
1202 // streams.
1203 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1204 recv_stream = call->GetVideoReceiveStreams()[0];
1205 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1206 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
1207 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001208 }
1209
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001210 void TestCpuAdaptation(bool enable_overuse);
1211
1212 FakeCall* fake_call_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001213 rtc::scoped_ptr<VideoMediaChannel> channel_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001214 uint32 last_ssrc_;
1215};
1216
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001217TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001218 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
1219 EXPECT_TRUE(channel_->SetSend(true));
1220 cricket::VideoOptions options;
1221 options.conference_mode.Set(true);
1222 EXPECT_TRUE(channel_->SetOptions(options));
1223
1224 // Send side.
1225 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1226 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1227 FakeVideoSendStream* send_stream = AddSendStream(
1228 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1229
1230 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
1231 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
1232 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
1233
1234 // Receiver side.
1235 FakeVideoReceiveStream* recv_stream = AddRecvStream(
1236 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1237 ASSERT_GT(recv_stream->GetConfig().rtp.rtx.size(), 0u)
1238 << "No SSRCs for RTX configured by AddRecvStream.";
1239 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size())
1240 << "This test only works with one receive codec. Please update the test.";
1241 EXPECT_EQ(rtx_ssrcs[0],
1242 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
1243 // TODO(pbos): Make sure we set the RTX for correct payloads etc.
1244}
1245
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001246TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
1247 // Setup one channel with an associated RTX stream.
1248 cricket::StreamParams params =
1249 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1250 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
1251 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1252 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
1253 EXPECT_EQ(kRtxSsrcs1[0],
1254 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001255}
1256
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001257TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
1258 // Setup one channel without an associated RTX stream.
1259 cricket::StreamParams params =
1260 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1261 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1262 ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001263}
1264
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001265TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
1266 FakeVideoSendStream* send_stream =
1267 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1268 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1269
1270 FakeVideoReceiveStream* recv_stream =
1271 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1272 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001273}
1274
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001275// Test support for RTP timestamp offset header extension.
1276TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
1277 TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1278 webrtc::RtpExtension::kTOffset);
1279}
1280TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
1281 TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1282 webrtc::RtpExtension::kTOffset);
1283}
1284
1285// Test support for absolute send time header extension.
1286TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
1287 TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1288 webrtc::RtpExtension::kAbsSendTime);
1289}
1290TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
1291 TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1292 webrtc::RtpExtension::kAbsSendTime);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001293}
1294
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001295// Test support for video rotation header extension.
1296TEST_F(WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions) {
1297 TestSetSendRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
1298 webrtc::RtpExtension::kVideoRotation);
1299}
1300TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) {
1301 TestSetRecvRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
1302 webrtc::RtpExtension::kVideoRotation);
1303}
1304
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001305TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
1306 const int kTOffsetId = 1;
1307 const int kAbsSendTimeId = 2;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001308 const int kVideoRotationId = 3;
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001309 std::vector<cricket::RtpHeaderExtension> extensions;
1310 extensions.push_back(cricket::RtpHeaderExtension(
1311 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
1312 extensions.push_back(cricket::RtpHeaderExtension(
1313 kRtpTimestampOffsetHeaderExtension, kTOffsetId));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001314 extensions.push_back(cricket::RtpHeaderExtension(
1315 kRtpVideoRotationHeaderExtension, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001316
1317 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1318 FakeVideoSendStream* send_stream =
1319 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1320
1321 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001322 ASSERT_EQ(3u, send_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001323
1324 // Setting the same extensions (even if in different order) shouldn't
1325 // reallocate the stream.
1326 std::reverse(extensions.begin(), extensions.end());
1327 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1328
1329 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
1330
1331 // Setting different extensions should recreate the stream.
1332 extensions.resize(1);
1333 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1334
1335 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
1336}
1337
1338TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
1339 const int kTOffsetId = 1;
1340 const int kAbsSendTimeId = 2;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001341 const int kVideoRotationId = 3;
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001342 std::vector<cricket::RtpHeaderExtension> extensions;
1343 extensions.push_back(cricket::RtpHeaderExtension(
1344 kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
1345 extensions.push_back(cricket::RtpHeaderExtension(
1346 kRtpTimestampOffsetHeaderExtension, kTOffsetId));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001347 extensions.push_back(cricket::RtpHeaderExtension(
1348 kRtpVideoRotationHeaderExtension, kVideoRotationId));
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001349
1350 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1351 FakeVideoReceiveStream* send_stream =
1352 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1353
1354 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001355 ASSERT_EQ(3u, send_stream->GetConfig().rtp.extensions.size());
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001356
1357 // Setting the same extensions (even if in different order) shouldn't
1358 // reallocate the stream.
1359 std::reverse(extensions.begin(), extensions.end());
1360 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1361
1362 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
1363
1364 // Setting different extensions should recreate the stream.
1365 extensions.resize(1);
1366 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1367
1368 EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
1369}
1370
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001371TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001372 SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001373 const int kUnsupportedId = 1;
1374 const int kTOffsetId = 2;
1375
1376 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001377 extensions.push_back(
1378 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
1379 extensions.push_back(
1380 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001381 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1382 FakeVideoSendStream* send_stream =
1383 AddSendStream(cricket::StreamParams::CreateLegacy(123));
1384
1385 // Only timestamp offset extension is set to send stream,
1386 // unsupported rtp extension is ignored.
1387 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1388 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001389 send_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001390}
1391
1392TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001393 SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001394 const int kUnsupportedId = 1;
1395 const int kTOffsetId = 2;
1396
1397 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001398 extensions.push_back(
1399 cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
1400 extensions.push_back(
1401 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001402 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1403 FakeVideoReceiveStream* recv_stream =
1404 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1405
1406 // Only timestamp offset extension is set to receive stream,
1407 // unsupported rtp extension is ignored.
1408 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1409 EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001410 recv_stream->GetConfig().rtp.extensions[0].name.c_str());
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001411}
1412
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001413TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001414 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001415 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001416 std::vector<cricket::RtpHeaderExtension> extensions;
1417 extensions.push_back(cricket::RtpHeaderExtension(
1418 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
1419 EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions))
1420 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1421 }
1422}
1423
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001424TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
Peter Boström23914fe2015-03-31 15:08:04 +02001425 const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00001426 for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001427 std::vector<cricket::RtpHeaderExtension> extensions;
1428 extensions.push_back(cricket::RtpHeaderExtension(
1429 webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
1430 EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions))
1431 << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1432 }
1433}
1434
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001435TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001436 const int id = 1;
1437 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001438 extensions.push_back(
1439 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1440 extensions.push_back(
1441 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001442 EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
1443
1444 // Duplicate entries are also not supported.
1445 extensions.clear();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001446 extensions.push_back(
1447 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001448 extensions.push_back(extensions.back());
1449 EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
1450}
1451
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001452TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001453 const int id = 1;
1454 std::vector<cricket::RtpHeaderExtension> extensions;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001455 extensions.push_back(
1456 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1457 extensions.push_back(
1458 cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001459 EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
1460
1461 // Duplicate entries are also not supported.
1462 extensions.clear();
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001463 extensions.push_back(
1464 cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001465 extensions.push_back(extensions.back());
1466 EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
1467}
1468
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001469TEST_F(WebRtcVideoChannel2Test, DISABLED_LeakyBucketTest) {
1470 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1471}
1472
1473TEST_F(WebRtcVideoChannel2Test, DISABLED_BufferedModeLatency) {
1474 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1475}
1476
1477TEST_F(WebRtcVideoChannel2Test, DISABLED_AdditiveVideoOptions) {
1478 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1479}
1480
1481TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
1482 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001483 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001484}
1485
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001486TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
1487 FakeVideoReceiveStream* stream = AddRecvStream();
1488 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001489}
1490
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001491TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1492 FakeVideoReceiveStream* stream = AddRecvStream();
1493 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1494
1495 // Verify that REMB is turned off when codecs without REMB are set.
1496 std::vector<VideoCodec> codecs;
1497 codecs.push_back(kVp8Codec);
1498 EXPECT_TRUE(codecs[0].feedback_params.params().empty());
1499 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001500 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001501 EXPECT_FALSE(stream->GetConfig().rtp.remb);
1502
1503 // Verify that REMB is turned on when setting default codecs since the
1504 // default codecs have REMB enabled.
1505 EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001506 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001507 EXPECT_TRUE(stream->GetConfig().rtp.remb);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001508}
1509
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001510TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
1511 VerifyCodecHasDefaultFeedbackParams(default_codec_);
1512
pbos@webrtc.org19864742014-05-30 07:35:47 +00001513 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
1514 EXPECT_TRUE(channel_->SetSend(true));
1515
1516 // Send side.
1517 FakeVideoSendStream* send_stream =
1518 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1519 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1520
1521 // Receiver side.
1522 FakeVideoReceiveStream* recv_stream =
1523 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1524 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1525
1526 // Nack history size should match between sender and receiver.
1527 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
1528 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001529}
1530
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +00001531TEST_F(WebRtcVideoChannel2Test, NackCanBeDisabled) {
1532 std::vector<VideoCodec> codecs;
1533 codecs.push_back(kVp8Codec);
1534
1535 // Send side.
1536 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1537 FakeVideoSendStream* send_stream =
1538 AddSendStream(cricket::StreamParams::CreateLegacy(1));
1539 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1540
1541 // Receiver side.
1542 ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
1543 FakeVideoReceiveStream* recv_stream =
1544 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1545 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1546}
1547
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001548TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInterop) {
1549 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1550}
1551
1552TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInteropReversed) {
1553 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1554}
1555
1556TEST_F(WebRtcVideoChannel2Test, DISABLED_HybridNackFecConference) {
1557 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1558}
1559
1560TEST_F(WebRtcVideoChannel2Test, DISABLED_AddRemoveRecvStreamConference) {
1561 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1562}
1563
1564TEST_F(WebRtcVideoChannel2Test, DISABLED_SetRender) {
1565 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1566}
1567
1568TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAuto) {
1569 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1570}
1571
1572TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAutoCapped) {
1573 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1574}
1575
1576TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthFixed) {
1577 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1578}
1579
1580TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthInConference) {
1581 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1582}
1583
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001584TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1585 static const int kScreenshareMinBitrateKbps = 800;
1586 cricket::VideoCodec codec = kVp8Codec360p;
1587 std::vector<cricket::VideoCodec> codecs;
1588 codecs.push_back(codec);
1589 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1590 VideoOptions options;
1591 options.screencast_min_bitrate.Set(kScreenshareMinBitrateKbps);
1592 channel_->SetOptions(options);
1593
1594 AddSendStream();
1595
1596 cricket::FakeVideoCapturer capturer;
1597 capturer.SetScreencast(false);
1598 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1599 cricket::VideoFormat capture_format_hd =
1600 capturer.GetSupportedFormats()->front();
1601 EXPECT_EQ(1280, capture_format_hd.width);
1602 EXPECT_EQ(720, capture_format_hd.height);
1603 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1604
1605 EXPECT_TRUE(channel_->SetSend(true));
1606
1607 EXPECT_TRUE(capturer.CaptureFrame());
1608 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1609 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1610
1611 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1612
1613 // Verify non-screencast settings.
1614 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1615 EXPECT_EQ(webrtc::VideoEncoderConfig::kRealtimeVideo,
1616 encoder_config.content_type);
1617 EXPECT_EQ(codec.width, encoder_config.streams.front().width);
1618 EXPECT_EQ(codec.height, encoder_config.streams.front().height);
1619 EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
1620 << "Non-screenshare shouldn't use min-transmit bitrate.";
1621
1622 capturer.SetScreencast(true);
1623 EXPECT_TRUE(capturer.CaptureFrame());
1624
1625 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1626
1627 // Verify screencast settings.
1628 encoder_config = send_stream->GetEncoderConfig();
1629 EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare,
1630 encoder_config.content_type);
1631 EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
1632 encoder_config.min_transmit_bitrate_bps);
1633
1634 EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width);
1635 EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001636 EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
1637
1638 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1639}
1640
1641TEST_F(WebRtcVideoChannel2Test,
1642 ConferenceModeScreencastConfiguresTemporalLayer) {
1643 static const int kConferenceScreencastTemporalBitrateBps = 100000;
1644 VideoOptions options;
1645 options.conference_mode.Set(true);
1646 channel_->SetOptions(options);
1647
1648 AddSendStream();
1649
1650 cricket::FakeVideoCapturer capturer;
1651 capturer.SetScreencast(true);
1652 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1653 cricket::VideoFormat capture_format_hd =
1654 capturer.GetSupportedFormats()->front();
1655 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1656
1657 EXPECT_TRUE(channel_->SetSend(true));
1658
1659 EXPECT_TRUE(capturer.CaptureFrame());
1660 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1661 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1662
1663 webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1664
1665 // Verify screencast settings.
1666 encoder_config = send_stream->GetEncoderConfig();
1667 EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare,
1668 encoder_config.content_type);
1669 ASSERT_EQ(1u, encoder_config.streams.size());
1670 ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size());
1671 EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
1672 encoder_config.streams[0].temporal_layer_thresholds_bps[0]);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001673
1674 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001675}
1676
1677TEST_F(WebRtcVideoChannel2Test, DISABLED_SetSendSsrcAndCname) {
1678 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1679}
1680
1681TEST_F(WebRtcVideoChannel2Test,
1682 DISABLED_SetSendSsrcAfterCreatingReceiveChannel) {
1683 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1684}
1685
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001686TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
1687 FakeVideoSendStream* stream = AddSendStream();
1688 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1689}
1690
1691TEST_F(WebRtcVideoChannel2Test, SetOptionsWithSuspendBelowMinBitrate) {
1692 VideoOptions options;
1693 options.suspend_below_min_bitrate.Set(true);
1694 channel_->SetOptions(options);
1695
1696 FakeVideoSendStream* stream = AddSendStream();
1697 EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
1698
1699 options.suspend_below_min_bitrate.Set(false);
1700 channel_->SetOptions(options);
1701
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001702 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001703 EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1704}
1705
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001706TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1707 FakeVideoSendStream* stream = AddSendStream();
1708 webrtc::VideoCodecVP8 vp8_settings;
1709 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1710 EXPECT_TRUE(vp8_settings.denoisingOn);
1711}
1712
1713TEST_F(WebRtcVideoChannel2Test, SetOptionsWithDenoising) {
1714 VideoOptions options;
1715 options.video_noise_reduction.Set(false);
1716 channel_->SetOptions(options);
1717
1718 FakeVideoSendStream* stream = AddSendStream();
1719 webrtc::VideoCodecVP8 vp8_settings;
1720 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1721 EXPECT_FALSE(vp8_settings.denoisingOn);
1722
1723 options.video_noise_reduction.Set(true);
1724 channel_->SetOptions(options);
1725
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001726 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001727 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1728 EXPECT_TRUE(vp8_settings.denoisingOn);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001729}
1730
1731TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) {
1732 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1733}
1734
pbos@webrtc.org8aed9452014-07-26 10:16:49 +00001735TEST_F(WebRtcVideoChannel2Test, DISABLED_SendReceiveBitratesStats) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001736 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1737}
1738
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001739TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) {
1740 TestCpuAdaptation(true);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001741}
1742
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001743TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
1744 TestCpuAdaptation(false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001745}
1746
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001747void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001748 cricket::VideoCodec codec = kVp8Codec720p;
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001749 std::vector<cricket::VideoCodec> codecs;
1750 codecs.push_back(codec);
1751 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1752
Peter Boströme4328002015-04-14 22:45:29 +02001753 if (!enable_overuse) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001754 VideoOptions options;
Peter Boströme4328002015-04-14 22:45:29 +02001755 options.cpu_overuse_detection.Set(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001756 channel_->SetOptions(options);
1757 }
1758
1759 AddSendStream();
1760
1761 cricket::FakeVideoCapturer capturer;
1762 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1763 EXPECT_EQ(cricket::CS_RUNNING,
1764 capturer.Start(capturer.GetSupportedFormats()->front()));
1765
1766 EXPECT_TRUE(channel_->SetSend(true));
1767
1768 // Trigger overuse.
1769 webrtc::LoadObserver* overuse_callback =
1770 fake_call_->GetConfig().overuse_callback;
1771 ASSERT_TRUE(overuse_callback != NULL);
1772 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
1773
1774 EXPECT_TRUE(capturer.CaptureFrame());
1775 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1776 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1777
1778 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1779
1780 if (enable_overuse) {
1781 EXPECT_LT(send_stream->GetLastWidth(), codec.width);
1782 EXPECT_LT(send_stream->GetLastHeight(), codec.height);
1783 } else {
1784 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1785 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1786 }
1787
1788 // Trigger underuse which should go back to normal resolution.
1789 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
1790 EXPECT_TRUE(capturer.CaptureFrame());
1791
1792 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1793
1794 EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1795 EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1796
1797 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001798}
1799
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001800TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeAndElapsedTimeCorrectly) {
1801 // Start at last timestamp to verify that wraparounds are estimated correctly.
1802 static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
1803 static const int64_t kInitialNtpTimeMs = 1247891230;
1804 static const int kFrameOffsetMs = 20;
1805 EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001806
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001807 FakeVideoReceiveStream* stream = AddRecvStream();
1808 cricket::FakeVideoRenderer renderer;
1809 EXPECT_TRUE(channel_->SetRenderer(last_ssrc_, &renderer));
1810 EXPECT_TRUE(channel_->SetRender(true));
1811
1812 webrtc::I420VideoFrame video_frame;
1813 CreateBlackFrame(&video_frame, 4, 4);
1814 video_frame.set_timestamp(kInitialTimestamp);
1815 // Initial NTP time is not available on the first frame, but should still be
1816 // able to be estimated.
1817 stream->InjectFrame(video_frame, 0);
1818
1819 EXPECT_EQ(1, renderer.num_rendered_frames());
1820 EXPECT_EQ(0, renderer.last_frame_elapsed_time_ns());
1821
1822 // This timestamp is kInitialTimestamp (-1) + kFrameOffsetMs * 90, which
1823 // triggers a constant-overflow warning, hence we're calculating it explicitly
1824 // here.
1825 video_frame.set_timestamp(kFrameOffsetMs * 90 - 1);
1826 video_frame.set_ntp_time_ms(kInitialNtpTimeMs + kFrameOffsetMs);
1827 stream->InjectFrame(video_frame, 0);
1828
1829 EXPECT_EQ(2, renderer.num_rendered_frames());
1830 EXPECT_EQ(kFrameOffsetMs * rtc::kNumNanosecsPerMillisec,
1831 renderer.last_frame_elapsed_time_ns());
1832
1833 // Verify that NTP time has been correctly deduced.
1834 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001835 ASSERT_TRUE(channel_->GetStats(&info));
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00001836 ASSERT_EQ(1u, info.receivers.size());
1837 EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001838}
1839
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001840TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001841 ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001842
1843 VideoCodec codec;
1844 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001845 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001846
1847 // Using a RTX setup to verify that the default RTX payload type is good.
1848 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1849 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1850 FakeVideoSendStream* stream = AddSendStream(
1851 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1852 webrtc::VideoSendStream::Config config = stream->GetConfig();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001853
1854 // Make sure NACK and FEC are enabled on the correct payload types.
1855 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
1856 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
1857 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001858
1859 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
1860 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
Shao Changbine62202f2015-04-21 20:24:50 +08001861 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001862 // TODO(juberti): Check RTCP, PLI, TMMBR.
1863}
1864
1865TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
1866 std::vector<VideoCodec> codecs;
1867 codecs.push_back(kVp8Codec);
1868 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1869
1870 FakeVideoSendStream* stream = AddSendStream();
1871 webrtc::VideoSendStream::Config config = stream->GetConfig();
1872
1873 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
1874 EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
1875}
1876
1877TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001878 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
1879 std::vector<VideoCodec> codecs;
1880 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
1881 codecs.push_back(rtx_codec);
1882 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1883 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001884}
1885
1886TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001887 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
1888 std::vector<VideoCodec> codecs;
1889 cricket::VideoCodec rtx_codec =
1890 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
1891 codecs.push_back(kVp8Codec);
1892 codecs.push_back(rtx_codec);
1893 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1894
1895 cricket::VideoCodec rtx_codec2 =
1896 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
1897 codecs.pop_back();
1898 codecs.push_back(rtx_codec2);
1899 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1900 << "RTX without matching video codec should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001901}
1902
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001903TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
1904 std::vector<VideoCodec> codecs;
1905 codecs.push_back(kVp8Codec);
1906 codecs.push_back(kUlpfecCodec);
1907 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1908
1909 FakeVideoSendStream* stream = AddSendStream();
1910 webrtc::VideoSendStream::Config config = stream->GetConfig();
1911
1912 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
1913
1914 codecs.pop_back();
1915 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001916 stream = fake_call_->GetVideoSendStreams()[0];
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001917 ASSERT_TRUE(stream != NULL);
1918 config = stream->GetConfig();
1919 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
1920 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001921}
1922
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001923TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
1924 std::vector<VideoCodec> codecs;
1925 codecs.push_back(kVp8Codec720p);
1926 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001927 channel_->SetSend(true);
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001928
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001929 FakeVideoSendStream* stream = AddSendStream();
1930
1931 cricket::FakeVideoCapturer capturer;
1932 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1933 EXPECT_EQ(cricket::CS_RUNNING,
1934 capturer.Start(capturer.GetSupportedFormats()->front()));
1935 EXPECT_TRUE(capturer.CaptureFrame());
1936
1937 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001938 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
1939 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
1940
1941 codecs.clear();
1942 codecs.push_back(kVp8Codec360p);
1943 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001944 streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001945 EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
1946 EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001947 EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001948}
1949
pbos@webrtc.org00873182014-11-25 14:03:34 +00001950TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
1951 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
1952 200000);
1953}
1954
pbos@webrtc.orga5f6fb52015-03-23 22:29:39 +00001955TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
1956 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
1957 std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
1958 ASSERT_EQ(1u, streams.size());
1959 EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
1960}
1961
pbos@webrtc.org00873182014-11-25 14:03:34 +00001962TEST_F(WebRtcVideoChannel2Test,
1963 SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
1964 SetSendCodecsShouldWorkForBitrates(
1965 "", 0, "", -1, "", -1);
1966}
1967
1968TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
1969 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001970}
1971
1972TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001973 std::vector<VideoCodec> video_codecs = engine_.codecs();
pbos@webrtc.org88ef6322014-11-04 15:29:29 +00001974 video_codecs[0].params[kCodecParamMinBitrate] = "300";
1975 video_codecs[0].params[kCodecParamMaxBitrate] = "200";
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001976 EXPECT_FALSE(channel_->SetSendCodecs(video_codecs));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001977}
1978
pbos@webrtc.org00873182014-11-25 14:03:34 +00001979TEST_F(WebRtcVideoChannel2Test,
1980 SetMaxSendBandwidthShouldPreserveOtherBitrates) {
1981 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
1982 200000);
1983 channel_->SetMaxSendBandwidth(300000);
Stefan Holmere5904162015-03-26 11:11:06 +01001984 EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00001985 << "Setting max bitrate should keep previous min bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01001986 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00001987 << "Setting max bitrate should not reset start bitrate.";
Stefan Holmere5904162015-03-26 11:11:06 +01001988 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001989}
1990
1991TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
1992 channel_->SetMaxSendBandwidth(300000);
Stefan Holmere5904162015-03-26 11:11:06 +01001993 EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +00001994 // <= 0 means disable (infinite) max bitrate.
1995 channel_->SetMaxSendBandwidth(0);
Stefan Holmere5904162015-03-26 11:11:06 +01001996 EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
pbos@webrtc.org00873182014-11-25 14:03:34 +00001997 << "Setting zero max bitrate did not reset start bitrate.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001998}
1999
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002000TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
2001 std::vector<VideoCodec> codecs;
2002 codecs.push_back(kVp8Codec720p);
2003 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
2004 channel_->SetSend(true);
2005
2006 FakeVideoSendStream* stream = AddSendStream();
2007
2008 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2009 int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
2010 EXPECT_GT(initial_max_bitrate_bps, 0);
2011
2012 EXPECT_TRUE(channel_->SetMaxSendBandwidth(initial_max_bitrate_bps * 2));
2013 streams = stream->GetVideoStreams();
2014 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
2015}
2016
2017TEST_F(WebRtcVideoChannel2Test,
2018 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
2019 std::vector<VideoCodec> codecs;
2020 codecs.push_back(kVp8Codec720p);
2021 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
2022 channel_->SetSend(true);
2023
2024 FakeVideoSendStream* stream = AddSendStream(
2025 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2026
2027 // Send a frame to make sure this scales up to >1 stream (simulcast).
2028 cricket::FakeVideoCapturer capturer;
2029 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &capturer));
2030 EXPECT_EQ(cricket::CS_RUNNING,
2031 capturer.Start(capturer.GetSupportedFormats()->front()));
2032 EXPECT_TRUE(capturer.CaptureFrame());
2033
2034 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2035 ASSERT_GT(streams.size(), 1u)
2036 << "Without simulcast this test doesn't make sense.";
2037 int initial_max_bitrate_bps = 0;
2038 for (auto& video_stream : streams)
2039 initial_max_bitrate_bps += video_stream.max_bitrate_bps;
2040 EXPECT_GT(initial_max_bitrate_bps, 0);
2041
2042 EXPECT_TRUE(channel_->SetMaxSendBandwidth(initial_max_bitrate_bps * 2));
2043 streams = stream->GetVideoStreams();
2044 int increased_max_bitrate_bps = 0;
2045 for (auto& video_stream : streams)
2046 increased_max_bitrate_bps += video_stream.max_bitrate_bps;
2047 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
2048
2049 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], nullptr));
2050}
2051
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002052TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
2053 static const char* kMaxQuantization = "21";
2054 std::vector<VideoCodec> codecs;
2055 codecs.push_back(kVp8Codec);
2056 codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
2057 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002058 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
2059 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002060
2061 VideoCodec codec;
2062 EXPECT_TRUE(channel_->GetSendCodec(&codec));
2063 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
2064}
2065
2066TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
2067 std::vector<cricket::VideoCodec> codecs;
2068 codecs.push_back(kVp8Codec);
2069
2070 codecs[0].width = 0;
2071 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
2072 << "Codec set though codec width is zero.";
2073
2074 codecs[0].width = kVp8Codec.width;
2075 codecs[0].height = 0;
2076 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
2077 << "Codec set though codec height is zero.";
2078}
2079
2080TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
2081 // TODO(pbos): Should we only allow the dynamic range?
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002082 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002083 std::vector<cricket::VideoCodec> codecs;
2084 codecs.push_back(kVp8Codec);
pkasting@chromium.orge7a4a122015-01-28 21:36:55 +00002085 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002086 codecs[0].id = kIncorrectPayloads[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002087 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002088 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002089 }
2090}
2091
2092TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
2093 std::vector<cricket::VideoCodec> codecs;
2094 codecs.push_back(kVp8Codec);
2095 for (int payload_type = 0; payload_type <= 127; ++payload_type) {
2096 codecs[0].id = payload_type;
2097 EXPECT_TRUE(channel_->SetSendCodecs(codecs))
2098 << "Payload type '" << payload_type << "' rejected.";
2099 }
2100}
2101
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002102TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
2103 std::vector<cricket::VideoCodec> codecs;
2104 codecs.push_back(kVp8Codec);
2105 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2106}
2107
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002108// Test that we set our inbound RTX codecs properly.
2109TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
2110 std::vector<cricket::VideoCodec> codecs;
2111 codecs.push_back(kVp8Codec);
2112 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
2113 codecs.push_back(rtx_codec);
2114 EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
2115 << "RTX codec without associated payload should be rejected.";
2116
2117 codecs[1].SetParam("apt", kVp8Codec.id + 1);
2118 EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
2119 << "RTX codec with invalid associated payload type should be rejected.";
2120
2121 codecs[1].SetParam("apt", kVp8Codec.id);
2122 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2123
2124 cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0);
2125 rtx_codec2.SetParam("apt", rtx_codec.id);
2126 codecs.push_back(rtx_codec2);
2127
2128 EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) << "RTX codec with another RTX "
2129 "as associated payload type "
2130 "should be rejected.";
2131}
2132
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002133TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
2134 std::vector<cricket::VideoCodec> codecs;
2135 codecs.push_back(kVp8Codec);
2136 codecs[0].id = 99;
2137 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2138}
2139
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002140TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002141 EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00002142
2143 FakeVideoReceiveStream* stream = AddRecvStream();
2144 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002145 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
2146 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002147}
2148
2149TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
2150 std::vector<VideoCodec> codecs;
2151 codecs.push_back(kVp8Codec);
2152 codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
2153 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
2154}
2155
2156// TODO(pbos): Enable VP9 through external codec support
2157TEST_F(WebRtcVideoChannel2Test,
2158 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
2159 std::vector<VideoCodec> codecs;
2160 codecs.push_back(kVp8Codec);
2161 codecs.push_back(kVp9Codec);
2162 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2163}
2164
2165TEST_F(WebRtcVideoChannel2Test,
2166 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
2167 std::vector<VideoCodec> codecs;
2168 codecs.push_back(kVp8Codec);
2169 codecs.push_back(kVp9Codec);
2170 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2171 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
2172}
2173
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002174TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
2175 std::vector<VideoCodec> codecs;
2176 codecs.push_back(kVp8Codec);
2177 codecs.push_back(kUlpfecCodec);
2178 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
2179
2180 FakeVideoReceiveStream* stream = AddRecvStream();
2181 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
2182
2183 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
2184
2185 codecs.pop_back();
2186 ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002187 stream = fake_call_->GetVideoReceiveStreams()[0];
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002188 ASSERT_TRUE(stream != NULL);
2189 config = stream->GetConfig();
2190 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
2191 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00002192}
2193
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002194TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
2195 std::vector<VideoCodec> codecs;
2196 codecs.push_back(kVp8Codec);
2197 codecs.push_back(kRedCodec);
2198 codecs[1].id = codecs[0].id;
2199 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
2200}
2201
2202TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
2203 std::vector<VideoCodec> codecs;
2204 codecs.push_back(kVp8Codec);
2205 codecs.push_back(kVp9Codec);
2206 codecs[1].id = codecs[0].id;
2207 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
2208}
2209
2210TEST_F(WebRtcVideoChannel2Test,
2211 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
2212 std::vector<VideoCodec> codecs;
2213 codecs.push_back(kVp8Codec);
2214 codecs.push_back(kVp8Codec);
2215 codecs[1].id += 1;
2216 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2217}
2218
2219TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
2220 EXPECT_FALSE(AddSendStream()->IsSending());
2221}
2222
pbos@webrtc.org85f42942014-07-22 09:14:58 +00002223TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
2224 EXPECT_TRUE(AddRecvStream()->IsReceiving());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002225}
2226
2227TEST_F(WebRtcVideoChannel2Test, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002228 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002229 EXPECT_FALSE(stream->IsSending());
2230
2231 // false->true
2232 EXPECT_TRUE(channel_->SetSend(true));
2233 EXPECT_TRUE(stream->IsSending());
2234 // true->true
2235 EXPECT_TRUE(channel_->SetSend(true));
2236 EXPECT_TRUE(stream->IsSending());
2237 // true->false
2238 EXPECT_TRUE(channel_->SetSend(false));
2239 EXPECT_FALSE(stream->IsSending());
2240 // false->false
2241 EXPECT_TRUE(channel_->SetSend(false));
2242 EXPECT_FALSE(stream->IsSending());
2243
2244 EXPECT_TRUE(channel_->SetSend(true));
2245 FakeVideoSendStream* new_stream = AddSendStream();
2246 EXPECT_TRUE(new_stream->IsSending())
2247 << "Send stream created after SetSend(true) not sending initially.";
2248}
2249
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00002250// This test verifies DSCP settings are properly applied on video media channel.
2251TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
2252 rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
2253 new cricket::FakeNetworkInterface);
2254 channel_->SetInterface(network_interface.get());
2255 cricket::VideoOptions options;
2256 options.dscp.Set(true);
2257 EXPECT_TRUE(channel_->SetOptions(options));
2258 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2259 // Verify previous value is not modified if dscp option is not set.
2260 cricket::VideoOptions options1;
2261 EXPECT_TRUE(channel_->SetOptions(options1));
2262 EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
2263 options.dscp.Set(false);
2264 EXPECT_TRUE(channel_->SetOptions(options));
2265 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
2266 channel_->SetInterface(NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002267}
2268
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002269TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002270 EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState());
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002271
2272 channel_->OnReadyToSend(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002273 EXPECT_EQ(webrtc::Call::kNetworkDown, fake_call_->GetNetworkState());
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00002274
2275 channel_->OnReadyToSend(true);
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002276 EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002277}
2278
Peter Boström74d9ed72015-03-26 16:28:31 +01002279TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
2280 std::vector<cricket::VideoCodec> codecs;
2281 codecs.push_back(kVp8Codec);
2282 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
2283
2284 AddSendStream();
2285
2286 cricket::VideoMediaInfo info;
2287 ASSERT_TRUE(channel_->GetStats(&info));
2288 EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name);
2289}
2290
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002291TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) {
2292 FakeVideoSendStream* stream = AddSendStream();
2293 webrtc::VideoSendStream::Stats stats;
2294 stats.avg_encode_time_ms = 13;
2295 stats.encode_usage_percent = 42;
2296 stream->SetStats(stats);
2297
2298 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002299 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002300 EXPECT_EQ(stats.avg_encode_time_ms, info.senders[0].avg_encode_ms);
2301 EXPECT_EQ(stats.encode_usage_percent, info.senders[0].encode_usage_percent);
2302}
2303
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002304TEST_F(WebRtcVideoChannel2Test, GetStatsReportsUpperResolution) {
2305 FakeVideoSendStream* stream = AddSendStream();
2306 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002307 stats.substreams[17].width = 123;
2308 stats.substreams[17].height = 40;
2309 stats.substreams[42].width = 80;
2310 stats.substreams[42].height = 31;
2311 stats.substreams[11].width = 20;
2312 stats.substreams[11].height = 90;
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002313 stream->SetStats(stats);
2314
2315 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002316 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002317 ASSERT_EQ(1u, info.senders.size());
2318 EXPECT_EQ(123, info.senders[0].send_frame_width);
2319 EXPECT_EQ(90, info.senders[0].send_frame_height);
2320}
2321
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002322TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) {
2323 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2324
2325 // Capture format VGA.
2326 cricket::FakeVideoCapturer video_capturer_vga;
2327 const std::vector<cricket::VideoFormat>* formats =
2328 video_capturer_vga.GetSupportedFormats();
2329 cricket::VideoFormat capture_format_vga = (*formats)[1];
2330 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
2331 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_vga));
2332 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2333
2334 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30, 0);
2335 std::vector<cricket::VideoCodec> codecs;
2336 codecs.push_back(send_codec);
2337 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
2338 EXPECT_TRUE(channel_->SetSend(true));
2339
2340 // Verify that the CpuOveruseObserver is registered and trigger downgrade.
2341 cricket::VideoOptions options;
2342 options.cpu_overuse_detection.Set(true);
2343 EXPECT_TRUE(channel_->SetOptions(options));
2344 // Trigger overuse.
2345 webrtc::LoadObserver* overuse_callback =
2346 fake_call_->GetConfig().overuse_callback;
2347 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2348
2349 // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
2350 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2351 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002352 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002353 ASSERT_EQ(1U, info.senders.size());
2354 EXPECT_EQ(1, info.senders[0].adapt_changes);
2355 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2356 info.senders[0].adapt_reason);
2357
2358 // Trigger upgrade and verify that we adapt back up to VGA.
2359 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
2360 EXPECT_TRUE(video_capturer_vga.CaptureFrame());
2361 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002362 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002363 ASSERT_EQ(1U, info.senders.size());
2364 EXPECT_EQ(2, info.senders[0].adapt_changes);
2365 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2366 info.senders[0].adapt_reason);
2367
2368 // No capturer (no adapter). Adapt changes from old adapter should be kept.
2369 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2370 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002371 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002372 ASSERT_EQ(1U, info.senders.size());
2373 EXPECT_EQ(2, info.senders[0].adapt_changes);
2374 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
2375 info.senders[0].adapt_reason);
2376
2377 // Set new capturer, capture format HD.
2378 cricket::FakeVideoCapturer video_capturer_hd;
2379 cricket::VideoFormat capture_format_hd = (*formats)[0];
2380 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd));
2381 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_hd));
2382 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2383
2384 // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2.
2385 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
2386 EXPECT_TRUE(video_capturer_hd.CaptureFrame());
2387 info.Clear();
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002388 EXPECT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002389 ASSERT_EQ(1U, info.senders.size());
2390 EXPECT_EQ(3, info.senders[0].adapt_changes);
2391 EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
2392 info.senders[0].adapt_reason);
2393
2394 EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
2395}
2396
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002397TEST_F(WebRtcVideoChannel2Test,
2398 GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
2399 FakeVideoSendStream* stream = AddSendStream();
2400 webrtc::VideoSendStream::Stats stats;
2401 stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
2402 stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
2403 stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
2404
2405 stats.substreams[42].rtcp_packet_type_counts.fir_packets = 5;
2406 stats.substreams[42].rtcp_packet_type_counts.nack_packets = 7;
2407 stats.substreams[42].rtcp_packet_type_counts.pli_packets = 9;
2408
2409 stream->SetStats(stats);
2410
2411 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002412 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002413 EXPECT_EQ(7, info.senders[0].firs_rcvd);
2414 EXPECT_EQ(10, info.senders[0].nacks_rcvd);
2415 EXPECT_EQ(13, info.senders[0].plis_rcvd);
2416}
2417
2418TEST_F(WebRtcVideoChannel2Test,
2419 GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
2420 FakeVideoReceiveStream* stream = AddRecvStream();
2421 webrtc::VideoReceiveStream::Stats stats;
2422 stats.rtcp_packet_type_counts.fir_packets = 2;
2423 stats.rtcp_packet_type_counts.nack_packets = 3;
2424 stats.rtcp_packet_type_counts.pli_packets = 4;
2425 stream->SetStats(stats);
2426
2427 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002428 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002429 EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
2430 info.receivers[0].firs_sent);
2431 EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
2432 info.receivers[0].nacks_sent);
2433 EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
2434 info.receivers[0].plis_sent);
2435}
2436
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002437TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesDecodeStatsCorrectly) {
2438 FakeVideoReceiveStream* stream = AddRecvStream();
2439 webrtc::VideoReceiveStream::Stats stats;
2440 stats.decode_ms = 2;
2441 stats.max_decode_ms = 3;
2442 stats.current_delay_ms = 4;
2443 stats.target_delay_ms = 5;
2444 stats.jitter_buffer_ms = 6;
2445 stats.min_playout_delay_ms = 7;
2446 stats.render_delay_ms = 8;
2447 stream->SetStats(stats);
2448
2449 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002450 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002451 EXPECT_EQ(stats.decode_ms, info.receivers[0].decode_ms);
2452 EXPECT_EQ(stats.max_decode_ms, info.receivers[0].max_decode_ms);
2453 EXPECT_EQ(stats.current_delay_ms, info.receivers[0].current_delay_ms);
2454 EXPECT_EQ(stats.target_delay_ms, info.receivers[0].target_delay_ms);
2455 EXPECT_EQ(stats.jitter_buffer_ms, info.receivers[0].jitter_buffer_ms);
2456 EXPECT_EQ(stats.min_playout_delay_ms, info.receivers[0].min_playout_delay_ms);
2457 EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
2458}
2459
Peter Boström393347f2015-04-22 14:52:45 +02002460TEST_F(WebRtcVideoChannel2Test, GetStatsTranslatesReceivePacketStatsCorrectly) {
2461 FakeVideoReceiveStream* stream = AddRecvStream();
2462 webrtc::VideoReceiveStream::Stats stats;
2463 stats.rtp_stats.transmitted.payload_bytes = 2;
2464 stats.rtp_stats.transmitted.header_bytes = 3;
2465 stats.rtp_stats.transmitted.padding_bytes = 4;
2466 stats.rtp_stats.transmitted.packets = 5;
2467 stats.rtcp_stats.cumulative_lost = 6;
2468 stats.rtcp_stats.fraction_lost = 7;
2469 stream->SetStats(stats);
2470
2471 cricket::VideoMediaInfo info;
2472 ASSERT_TRUE(channel_->GetStats(&info));
2473 EXPECT_EQ(stats.rtp_stats.transmitted.payload_bytes +
2474 stats.rtp_stats.transmitted.header_bytes +
2475 stats.rtp_stats.transmitted.padding_bytes,
2476 info.receivers[0].bytes_rcvd);
2477 EXPECT_EQ(stats.rtp_stats.transmitted.packets,
2478 info.receivers[0].packets_rcvd);
2479 EXPECT_EQ(stats.rtcp_stats.cumulative_lost, info.receivers[0].packets_lost);
2480 EXPECT_EQ(static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8),
2481 info.receivers[0].fraction_lost);
2482}
2483
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002484TEST_F(WebRtcVideoChannel2Test, TranslatesCallStatsCorrectly) {
2485 AddSendStream();
2486 AddSendStream();
2487 webrtc::Call::Stats stats;
2488 stats.rtt_ms = 123;
2489 fake_call_->SetStats(stats);
2490
2491 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002492 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00002493 ASSERT_EQ(2u, info.senders.size());
2494 EXPECT_EQ(stats.rtt_ms, info.senders[0].rtt_ms);
2495 EXPECT_EQ(stats.rtt_ms, info.senders[1].rtt_ms);
2496}
2497
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002498TEST_F(WebRtcVideoChannel2Test, TranslatesSenderBitrateStatsCorrectly) {
2499 FakeVideoSendStream* stream = AddSendStream();
2500 webrtc::VideoSendStream::Stats stats;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002501 stats.target_media_bitrate_bps = 156;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002502 stats.media_bitrate_bps = 123;
2503 stats.substreams[17].total_bitrate_bps = 1;
2504 stats.substreams[17].retransmit_bitrate_bps = 2;
2505 stats.substreams[42].total_bitrate_bps = 3;
2506 stats.substreams[42].retransmit_bitrate_bps = 4;
2507 stream->SetStats(stats);
2508
2509 FakeVideoSendStream* stream2 = AddSendStream();
2510 webrtc::VideoSendStream::Stats stats2;
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002511 stats2.target_media_bitrate_bps = 200;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002512 stats2.media_bitrate_bps = 321;
2513 stats2.substreams[13].total_bitrate_bps = 5;
2514 stats2.substreams[13].retransmit_bitrate_bps = 6;
2515 stats2.substreams[21].total_bitrate_bps = 7;
2516 stats2.substreams[21].retransmit_bitrate_bps = 8;
2517 stream2->SetStats(stats2);
2518
2519 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002520 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002521 ASSERT_EQ(2u, info.senders.size());
2522 // Assuming stream and stream2 corresponds to senders[0] and [1] respectively
2523 // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
2524 EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
2525 EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002526 EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
2527 info.bw_estimations[0].target_enc_bitrate);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002528 EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
2529 info.bw_estimations[0].actual_enc_bitrate);
2530 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
2531 << "Bandwidth stats should take all streams into account.";
2532 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
2533 << "Bandwidth stats should take all streams into account.";
2534}
2535
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002536TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
2537 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2538
2539 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
2540 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
2541
2542 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
2543 const size_t kDataLength = 12;
2544 uint8_t data[kDataLength];
2545 memset(data, 0, sizeof(data));
2546 rtc::SetBE32(&data[8], ssrcs[0]);
2547 rtc::Buffer packet(data, kDataLength);
2548 rtc::PacketTime packet_time;
2549 channel_->OnPacketReceived(&packet, packet_time);
2550
2551 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
2552 << "No default receive stream created.";
2553 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2554 EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size())
2555 << "Default receive stream should not have configured RTX";
2556
2557 EXPECT_TRUE(channel_->AddRecvStream(
2558 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
2559 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
2560 << "AddRecvStream should've reconfigured, not added a new receiver.";
2561 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
2562 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
2563 EXPECT_EQ(rtx_ssrcs[0],
2564 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
2565}
2566
Peter Boströmd4362cd2015-03-25 14:17:23 +01002567TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
2568 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2569
2570 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
2571 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
2572
2573 StreamParams sp =
2574 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
2575 sp.ssrcs = ssrcs; // Without RTXs, this is the important part.
2576
2577 EXPECT_FALSE(channel_->AddSendStream(sp));
2578 EXPECT_FALSE(channel_->AddRecvStream(sp));
2579}
2580
Peter Boströmd6f4c252015-03-26 16:23:04 +01002581TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
2582 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2583
2584 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
2585 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
2586
2587 StreamParams sp =
2588 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
2589
2590 EXPECT_TRUE(channel_->AddSendStream(sp));
2591 EXPECT_TRUE(channel_->AddRecvStream(sp));
2592
2593 // The RTX SSRC is already used in previous streams, using it should fail.
2594 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
2595 EXPECT_FALSE(channel_->AddSendStream(sp));
2596 EXPECT_FALSE(channel_->AddRecvStream(sp));
2597
2598 // After removing the original stream this should be fine to add (makes sure
2599 // that RTX ssrcs are not forever taken).
2600 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
2601 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
2602 EXPECT_TRUE(channel_->AddSendStream(sp));
2603 EXPECT_TRUE(channel_->AddRecvStream(sp));
2604}
2605
2606TEST_F(WebRtcVideoChannel2Test,
2607 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
2608 static const uint32 kFirstStreamSsrcs[] = {1, 2, 3};
2609 static const uint32 kOverlappingStreamSsrcs[] = {4, 3, 5};
2610 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
2611
2612 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
2613
2614 StreamParams sp =
2615 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
2616
2617 EXPECT_TRUE(channel_->AddSendStream(sp));
2618 EXPECT_TRUE(channel_->AddRecvStream(sp));
2619
2620 // One of the SSRCs is already used in previous streams, using it should fail.
2621 sp = cricket::CreateSimStreamParams("cname",
2622 MAKE_VECTOR(kOverlappingStreamSsrcs));
2623 EXPECT_FALSE(channel_->AddSendStream(sp));
2624 EXPECT_FALSE(channel_->AddRecvStream(sp));
2625
2626 // After removing the original stream this should be fine to add (makes sure
2627 // that RTX ssrcs are not forever taken).
2628 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
2629 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
2630 EXPECT_TRUE(channel_->AddSendStream(sp));
2631 EXPECT_TRUE(channel_->AddRecvStream(sp));
2632}
2633
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002634class WebRtcVideoEngine2SimulcastTest : public testing::Test {
2635 public:
Peter Boströmd4362cd2015-03-25 14:17:23 +01002636 WebRtcVideoEngine2SimulcastTest() : engine_(nullptr) {}
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002637
2638 protected:
2639 WebRtcVideoEngine2 engine_;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002640};
2641
2642class WebRtcVideoChannel2SimulcastTest : public WebRtcVideoEngine2SimulcastTest,
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002643 public WebRtcCallFactory {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002644 public:
2645 WebRtcVideoChannel2SimulcastTest() : fake_call_(NULL) {}
2646
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00002647 void SetUp() override {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002648 engine_.SetCallFactory(this);
2649 engine_.Init(rtc::Thread::Current());
2650 channel_.reset(engine_.CreateChannel(VideoOptions(), NULL));
2651 ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory.";
2652 last_ssrc_ = 123;
2653 }
2654
2655 protected:
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +00002656 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002657 assert(fake_call_ == NULL);
2658 fake_call_ = new FakeCall(config);
2659 return fake_call_;
2660 }
2661
2662 void VerifySimulcastSettings(const VideoCodec& codec,
2663 VideoOptions::HighestBitrate bitrate_mode,
2664 size_t num_configured_streams,
2665 size_t expected_num_streams,
2666 SimulcastBitrateMode simulcast_bitrate_mode) {
2667 cricket::VideoOptions options;
2668 options.video_highest_bitrate.Set(bitrate_mode);
2669 EXPECT_TRUE(channel_->SetOptions(options));
2670
2671 std::vector<VideoCodec> codecs;
2672 codecs.push_back(codec);
2673 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
2674
2675 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
2676 assert(num_configured_streams <= ssrcs.size());
2677 ssrcs.resize(num_configured_streams);
2678
2679 FakeVideoSendStream* stream =
2680 AddSendStream(CreateSimStreamParams("cname", ssrcs));
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002681 // Send a full-size frame to trigger a stream reconfiguration to use all
2682 // expected simulcast layers.
2683 cricket::FakeVideoCapturer capturer;
2684 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer));
2685 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
2686 codec.width, codec.height,
2687 cricket::VideoFormat::FpsToInterval(30),
2688 cricket::FOURCC_I420)));
2689 channel_->SetSend(true);
2690 EXPECT_TRUE(capturer.CaptureFrame());
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002691
2692 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
2693 ASSERT_EQ(expected_num_streams, video_streams.size());
2694
2695 std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
2696 num_configured_streams,
2697 simulcast_bitrate_mode,
2698 codec.width,
2699 codec.height,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002700 0,
2701 kDefaultQpMax,
2702 codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
2703
2704 ASSERT_EQ(expected_streams.size(), video_streams.size());
2705
2706 size_t num_streams = video_streams.size();
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002707 int total_max_bitrate_bps = 0;
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002708 for (size_t i = 0; i < num_streams; ++i) {
2709 EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
2710 EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
2711
2712 EXPECT_GT(video_streams[i].max_framerate, 0);
2713 EXPECT_EQ(expected_streams[i].max_framerate,
2714 video_streams[i].max_framerate);
2715
2716 EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
2717 EXPECT_EQ(expected_streams[i].min_bitrate_bps,
2718 video_streams[i].min_bitrate_bps);
2719
2720 EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
2721 EXPECT_EQ(expected_streams[i].target_bitrate_bps,
2722 video_streams[i].target_bitrate_bps);
2723
2724 EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
2725 EXPECT_EQ(expected_streams[i].max_bitrate_bps,
2726 video_streams[i].max_bitrate_bps);
2727
2728 EXPECT_GT(video_streams[i].max_qp, 0);
2729 EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
2730
2731 EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty());
2732 EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps,
2733 video_streams[i].temporal_layer_thresholds_bps);
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002734
2735 if (i == num_streams - 1) {
2736 total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
2737 } else {
2738 total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
2739 }
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002740 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002741 cricket::VideoMediaInfo info;
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002742 ASSERT_TRUE(channel_->GetStats(&info));
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002743 ASSERT_EQ(1u, info.senders.size());
2744 EXPECT_EQ(total_max_bitrate_bps, info.senders[0].preferred_bitrate);
2745
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002746 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL));
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002747 }
2748
2749 FakeVideoSendStream* AddSendStream() {
2750 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
2751 }
2752
2753 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
2754 size_t num_streams =
2755 fake_call_->GetVideoSendStreams().size();
2756 EXPECT_TRUE(channel_->AddSendStream(sp));
2757 std::vector<FakeVideoSendStream*> streams =
2758 fake_call_->GetVideoSendStreams();
2759 EXPECT_EQ(num_streams + 1, streams.size());
2760 return streams[streams.size() - 1];
2761 }
2762
2763 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
2764 return fake_call_->GetVideoSendStreams();
2765 }
2766
2767 FakeVideoReceiveStream* AddRecvStream() {
2768 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
2769 }
2770
2771 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
2772 size_t num_streams =
2773 fake_call_->GetVideoReceiveStreams().size();
2774 EXPECT_TRUE(channel_->AddRecvStream(sp));
2775 std::vector<FakeVideoReceiveStream*> streams =
2776 fake_call_->GetVideoReceiveStreams();
2777 EXPECT_EQ(num_streams + 1, streams.size());
2778 return streams[streams.size() - 1];
2779 }
2780
2781 FakeCall* fake_call_;
2782 rtc::scoped_ptr<VideoMediaChannel> channel_;
2783 uint32 last_ssrc_;
2784};
2785
2786TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
2787 VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
2788}
2789
2790TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
2791 VerifySimulcastSettings(
2792 kVp8Codec720p, VideoOptions::NORMAL, 3, 3, SBM_NORMAL);
2793}
2794
2795TEST_F(WebRtcVideoChannel2SimulcastTest,
2796 SetSendCodecsWith2SimulcastStreamsHighBitrateMode) {
2797 VerifySimulcastSettings(kVp8Codec, VideoOptions::HIGH, 2, 2, SBM_HIGH);
2798}
2799
2800TEST_F(WebRtcVideoChannel2SimulcastTest,
2801 SetSendCodecsWith3SimulcastStreamsHighBitrateMode) {
2802 VerifySimulcastSettings(kVp8Codec720p, VideoOptions::HIGH, 3, 3, SBM_HIGH);
2803}
2804
2805TEST_F(WebRtcVideoChannel2SimulcastTest,
2806 SetSendCodecsWith2SimulcastStreamsVeryHighBitrateMode) {
2807 VerifySimulcastSettings(
2808 kVp8Codec, VideoOptions::VERY_HIGH, 2, 2, SBM_VERY_HIGH);
2809}
2810
2811TEST_F(WebRtcVideoChannel2SimulcastTest,
2812 SetSendCodecsWith3SimulcastStreamsVeryHighBitrateMode) {
2813 VerifySimulcastSettings(
2814 kVp8Codec720p, VideoOptions::VERY_HIGH, 3, 3, SBM_VERY_HIGH);
2815}
2816
2817// Test that we normalize send codec format size in simulcast.
2818TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
2819 cricket::VideoCodec codec(kVp8Codec270p);
2820 codec.width += 1;
2821 codec.height += 1;
2822 VerifySimulcastSettings(codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
2823}
2824
2825// Test that if we add a stream with RTX SSRC's, SSRC's get set correctly.
2826TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestStreamWithRtx) {
2827 // TODO(pbos): Implement.
2828 FAIL() << "Not implemented.";
2829}
2830
2831// Test that if we get too few ssrcs are given in AddSendStream(),
2832// only supported sub-streams will be added.
2833TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TooFewSimulcastSsrcs) {
2834 // TODO(pbos): Implement.
2835 FAIL() << "Not implemented.";
2836}
2837
2838// Test that even more than enough ssrcs are given in AddSendStream(),
2839// only supported sub-streams will be added.
2840TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_MoreThanEnoughSimulcastSscrs) {
2841 // TODO(pbos): Implement.
2842 FAIL() << "Not implemented.";
2843}
2844
2845// Test that SetSendStreamFormat works well with simulcast.
2846TEST_F(WebRtcVideoEngine2SimulcastTest,
2847 DISABLED_SetSendStreamFormatWithSimulcast) {
2848 // TODO(pbos): Implement.
2849 FAIL() << "Not implemented.";
2850}
2851
2852// Test that simulcast send codec is reset on new video frame size.
2853TEST_F(WebRtcVideoEngine2SimulcastTest,
2854 DISABLED_ResetSimulcastSendCodecOnNewFrameSize) {
2855 // TODO(pbos): Implement.
2856 FAIL() << "Not implemented.";
2857}
2858
2859// Test that simulcast send codec is reset on new portait mode video frame.
2860TEST_F(WebRtcVideoEngine2SimulcastTest,
2861 DISABLED_ResetSimulcastSendCodecOnNewPortaitFrame) {
2862 // TODO(pbos): Implement.
2863 FAIL() << "Not implemented.";
2864}
2865
2866TEST_F(WebRtcVideoEngine2SimulcastTest,
2867 DISABLED_SetBandwidthInConferenceWithSimulcast) {
2868 // TODO(pbos): Implement.
2869 FAIL() << "Not implemented.";
2870}
2871
2872// Test that sending screencast frames in conference mode changes
2873// bitrate.
2874TEST_F(WebRtcVideoEngine2SimulcastTest,
2875 DISABLED_SetBandwidthScreencastInConference) {
2876 // TODO(pbos): Implement.
2877 FAIL() << "Not implemented.";
2878}
2879
2880// Test AddSendStream with simulcast rejects bad StreamParams.
2881TEST_F(WebRtcVideoEngine2SimulcastTest,
2882 DISABLED_AddSendStreamWithBadStreamParams) {
2883 // TODO(pbos): Implement.
2884 FAIL() << "Not implemented.";
2885}
2886
2887// Test AddSendStream with simulcast sets ssrc and cname correctly.
2888TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_AddSendStreamWithSimulcast) {
2889 // TODO(pbos): Implement.
2890 FAIL() << "Not implemented.";
2891}
2892
2893// Test RemoveSendStream with simulcast.
2894TEST_F(WebRtcVideoEngine2SimulcastTest,
2895 DISABLED_RemoveSendStreamWithSimulcast) {
2896 // TODO(pbos): Implement.
2897 FAIL() << "Not implemented.";
2898}
2899
2900// Test AddSendStream after send codec has already been set will reset
2901// send codec with simulcast settings.
2902TEST_F(WebRtcVideoEngine2SimulcastTest,
2903 DISABLED_AddSimulcastStreamAfterSetSendCodec) {
2904 // TODO(pbos): Implement.
2905 FAIL() << "Not implemented.";
2906}
2907
2908TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_GetStatsWithMultipleSsrcs) {
2909 // TODO(pbos): Implement.
2910 FAIL() << "Not implemented.";
2911}
2912
2913// Test receiving channel(s) local ssrc is set to the same as the first
2914// simulcast sending ssrc.
2915TEST_F(WebRtcVideoEngine2SimulcastTest,
2916 DISABLED_AddSimulcastStreamAfterCreatingRecvChannels) {
2917 // TODO(pbos): Implement.
2918 FAIL() << "Not implemented.";
2919}
2920
2921// Test 1:1 call never turn on simulcast.
2922TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_NoSimulcastWith1on1) {
2923 // TODO(pbos): Implement.
2924 FAIL() << "Not implemented.";
2925}
2926
2927// Test SetOptions with OPT_CONFERENCE flag.
2928TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_SetOptionsWithConferenceMode) {
2929 // TODO(pbos): Implement.
2930 FAIL() << "Not implemented.";
2931}
2932
2933// Test that two different streams can have different formats.
2934TEST_F(WebRtcVideoEngine2SimulcastTest,
2935 DISABLED_MultipleSendStreamsDifferentFormats) {
2936 // TODO(pbos): Implement.
2937 FAIL() << "Not implemented.";
2938}
2939
2940TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToOutputFormat) {
2941 // TODO(pbos): Implement.
2942 FAIL() << "Not implemented.";
2943}
2944
2945TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToCpuLoad) {
2946 // TODO(pbos): Implement.
2947 FAIL() << "Not implemented.";
2948}
2949
2950TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestAdaptToCpuLoadDisabled) {
2951 // TODO(pbos): Implement.
2952 FAIL() << "Not implemented.";
2953}
2954
2955TEST_F(WebRtcVideoEngine2SimulcastTest,
2956 DISABLED_TestAdaptWithCpuOveruseObserver) {
2957 // TODO(pbos): Implement.
2958 FAIL() << "Not implemented.";
2959}
2960
2961// Test that codec is not reset for every frame sent in non-conference and
2962// non-screencast mode.
2963TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_DontResetCodecOnSendFrame) {
2964 // TODO(pbos): Implement.
2965 FAIL() << "Not implemented.";
2966}
2967
2968TEST_F(WebRtcVideoEngine2SimulcastTest,
2969 DISABLED_UseSimulcastAdapterOnVp8OnlyFactory) {
2970 // TODO(pbos): Implement.
2971 FAIL() << "Not implemented.";
2972}
2973
2974TEST_F(WebRtcVideoEngine2SimulcastTest,
2975 DISABLED_DontUseSimulcastAdapterOnNoneVp8Factory) {
2976 // TODO(pbos): Implement.
2977 FAIL() << "Not implemented.";
2978}
2979
buildbot@webrtc.orga8530772014-12-10 09:01:18 +00002980TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x800) {
2981 // TODO(pbos): Implement.
2982 FAIL() << "Not implemented.";
2983}
2984
2985TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x720) {
2986 // TODO(pbos): Implement.
2987 FAIL() << "Not implemented.";
2988}
2989
2990TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x540) {
2991 // TODO(pbos): Implement.
2992 FAIL() << "Not implemented.";
2993}
2994
2995TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_960x600) {
2996 // TODO(pbos): Implement.
2997 FAIL() << "Not implemented.";
2998}
2999
3000TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x400) {
3001 // TODO(pbos): Implement.
3002 FAIL() << "Not implemented.";
3003}
3004
3005TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_640x360) {
3006 // TODO(pbos): Implement.
3007 FAIL() << "Not implemented.";
3008}
3009
3010TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_480x300) {
3011 // TODO(pbos): Implement.
3012 FAIL() << "Not implemented.";
3013}
3014
3015TEST_F(WebRtcVideoChannel2SimulcastTest,
3016 DISABLED_DISABLED_SimulcastSend_480x270) {
3017 // TODO(pbos): Implement.
3018 FAIL() << "Not implemented.";
3019}
3020
3021TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x200) {
3022 // TODO(pbos): Implement.
3023 FAIL() << "Not implemented.";
3024}
3025
3026TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_320x180) {
3027 // TODO(pbos): Implement.
3028 FAIL() << "Not implemented.";
3029}
3030
3031// Test reset send codec with simulcast.
3032// Disabled per b/6773425
3033TEST_F(WebRtcVideoChannel2SimulcastTest,
3034 DISABLED_DISABLED_SimulcastResetSendCodec) {
3035 // TODO(pbos): Implement.
3036 FAIL() << "Not implemented.";
3037}
3038
3039// Test simulcast streams are decodeable with expected sizes.
3040TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastStreams) {
3041 // TODO(pbos): Implement.
3042 FAIL() << "Not implemented.";
3043}
3044
3045// Simulcast and resolution resizing should be turned off when screencasting
3046// but not otherwise.
3047TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_ScreencastRendering) {
3048 // TODO(pbos): Implement.
3049 FAIL() << "Not implemented.";
3050}
3051
3052// Ensures that the correct settings are applied to the codec when single
3053// temporal layer screencasting is enabled, and that the correct simulcast
3054// settings are reapplied when disabling screencasting.
3055TEST_F(WebRtcVideoChannel2SimulcastTest,
3056 DISABLED_OneTemporalLayerScreencastSettings) {
3057 // TODO(pbos): Implement.
3058 FAIL() << "Not implemented.";
3059}
3060
3061// Ensures that the correct settings are applied to the codec when two temporal
3062// layer screencasting is enabled, and that the correct simulcast settings are
3063// reapplied when disabling screencasting.
3064TEST_F(WebRtcVideoChannel2SimulcastTest,
3065 DISABLED_TwoTemporalLayerScreencastSettings) {
3066 // TODO(pbos): Implement.
3067 FAIL() << "Not implemented.";
3068}
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00003069
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003070} // namespace cricket