blob: d272929e42305cae90a74cc4599b5ba8e9c47b47 [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
28#include <map>
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000029#include <vector>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000030
31#include "talk/base/gunit.h"
pbos@webrtc.orgcb859ec2014-07-15 08:28:20 +000032#include "talk/base/stringutils.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000033#include "talk/media/base/testutils.h"
34#include "talk/media/base/videoengine_unittest.h"
35#include "talk/media/webrtc/webrtcvideoengine2.h"
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000036#include "talk/media/webrtc/webrtcvideoengine2_unittest.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000037#include "talk/media/webrtc/webrtcvideochannelfactory.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000038
39namespace {
40static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0);
41static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30, 0);
42static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30, 0);
43static const cricket::VideoCodec kVp8Codec180p(100, "VP8", 320, 180, 30, 0);
44
45static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0);
46static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0);
47static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0);
48static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0);
49
50static const uint32 kSsrcs1[] = {1};
51static const uint32 kRtxSsrcs1[] = {4};
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000052
53void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
54 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
55 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
56 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
57 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
58 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
59 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
60 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
61 cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
62}
63
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000064} // namespace
65
66namespace cricket {
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000067FakeVideoSendStream::FakeVideoSendStream(
68 const webrtc::VideoSendStream::Config& config,
69 const std::vector<webrtc::VideoStream>& video_streams)
70 : sending_(false), config_(config), video_streams_(video_streams) {
71}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000072
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000073webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() {
74 return config_;
75}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000076
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000077std::vector<webrtc::VideoStream> FakeVideoSendStream::GetVideoStreams() {
78 return video_streams_;
79}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000080
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000081bool FakeVideoSendStream::IsSending() {
82 return sending_;
83}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000084
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000085webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() const {
86 return webrtc::VideoSendStream::Stats();
87}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000088
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000089bool FakeVideoSendStream::ReconfigureVideoEncoder(
90 const std::vector<webrtc::VideoStream>& streams,
91 const void* encoder_specific) {
92 video_streams_ = streams;
93 return true;
94}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000095
pbos@webrtc.org86f613d2014-06-10 08:53:05 +000096webrtc::VideoSendStreamInput* FakeVideoSendStream::Input() {
97 // TODO(pbos): Fix.
98 return NULL;
99}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000100
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000101void FakeVideoSendStream::Start() {
102 sending_ = true;
103}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000104
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000105void FakeVideoSendStream::Stop() {
106 sending_ = false;
107}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000108
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000109FakeVideoReceiveStream::FakeVideoReceiveStream(
110 const webrtc::VideoReceiveStream::Config& config)
111 : config_(config), receiving_(false) {
112}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000113
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000114webrtc::VideoReceiveStream::Config FakeVideoReceiveStream::GetConfig() {
115 return config_;
116}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000117
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000118webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const {
119 return webrtc::VideoReceiveStream::Stats();
120}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000121
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000122void FakeVideoReceiveStream::Start() {
123 receiving_ = true;
124}
125void FakeVideoReceiveStream::Stop() {
126 receiving_ = false;
127}
128void FakeVideoReceiveStream::GetCurrentReceiveCodec(webrtc::VideoCodec* codec) {
129}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000130
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000131FakeCall::FakeCall() { SetVideoCodecs(GetDefaultVideoCodecs()); }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000132
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000133FakeCall::~FakeCall() {
134 EXPECT_EQ(0u, video_send_streams_.size());
135 EXPECT_EQ(0u, video_receive_streams_.size());
136}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000137
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000138void FakeCall::SetVideoCodecs(const std::vector<webrtc::VideoCodec> codecs) {
139 codecs_ = codecs;
140}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000141
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000142std::vector<FakeVideoSendStream*> FakeCall::GetVideoSendStreams() {
143 return video_send_streams_;
144}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000145
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000146std::vector<FakeVideoReceiveStream*> FakeCall::GetVideoReceiveStreams() {
147 return video_receive_streams_;
148}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000149
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000150webrtc::VideoCodec FakeCall::GetEmptyVideoCodec() {
151 webrtc::VideoCodec codec;
152 codec.minBitrate = 300;
153 codec.startBitrate = 800;
154 codec.maxBitrate = 1500;
155 codec.maxFramerate = 10;
156 codec.width = 640;
157 codec.height = 480;
158 codec.qpMax = 56;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000159
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000160 return codec;
161}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000162
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000163webrtc::VideoCodec FakeCall::GetVideoCodecVp8() {
164 webrtc::VideoCodec vp8_codec = GetEmptyVideoCodec();
165 vp8_codec.codecType = webrtc::kVideoCodecVP8;
pbos@webrtc.orgcb859ec2014-07-15 08:28:20 +0000166 talk_base::strcpyn(vp8_codec.plName, ARRAY_SIZE(vp8_codec.plName),
167 kVp8Codec.name.c_str());
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000168 vp8_codec.plType = kVp8Codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000169
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000170 return vp8_codec;
171}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000172
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000173webrtc::VideoCodec FakeCall::GetVideoCodecVp9() {
174 webrtc::VideoCodec vp9_codec = GetEmptyVideoCodec();
175 // TODO(pbos): Add a correct codecType when webrtc has one.
176 vp9_codec.codecType = webrtc::kVideoCodecVP8;
pbos@webrtc.orgcb859ec2014-07-15 08:28:20 +0000177 talk_base::strcpyn(vp9_codec.plName, ARRAY_SIZE(vp9_codec.plName),
178 kVp9Codec.name.c_str());
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000179 vp9_codec.plType = kVp9Codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000180
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000181 return vp9_codec;
182}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000183
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000184std::vector<webrtc::VideoCodec> FakeCall::GetDefaultVideoCodecs() {
185 std::vector<webrtc::VideoCodec> codecs;
186 codecs.push_back(GetVideoCodecVp8());
187 // codecs.push_back(GetVideoCodecVp9());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000188
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000189 return codecs;
190}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000191
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000192webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
193 const webrtc::VideoSendStream::Config& config,
194 const std::vector<webrtc::VideoStream>& video_streams,
195 const void* encoder_settings) {
196 FakeVideoSendStream* fake_stream =
197 new FakeVideoSendStream(config, video_streams);
198 video_send_streams_.push_back(fake_stream);
199 return fake_stream;
200}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000201
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000202void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
203 FakeVideoSendStream* fake_stream =
204 static_cast<FakeVideoSendStream*>(send_stream);
205 for (size_t i = 0; i < video_send_streams_.size(); ++i) {
206 if (video_send_streams_[i] == fake_stream) {
207 delete video_send_streams_[i];
208 video_send_streams_.erase(video_send_streams_.begin() + i);
209 return;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000210 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000211 }
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000212 ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter.";
213}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000214
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000215webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
216 const webrtc::VideoReceiveStream::Config& config) {
217 video_receive_streams_.push_back(new FakeVideoReceiveStream(config));
218 return video_receive_streams_[video_receive_streams_.size() - 1];
219}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000220
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000221void FakeCall::DestroyVideoReceiveStream(
222 webrtc::VideoReceiveStream* receive_stream) {
223 FakeVideoReceiveStream* fake_stream =
224 static_cast<FakeVideoReceiveStream*>(receive_stream);
225 for (size_t i = 0; i < video_receive_streams_.size(); ++i) {
226 if (video_receive_streams_[i] == fake_stream) {
227 delete video_receive_streams_[i];
228 video_receive_streams_.erase(video_receive_streams_.begin() + i);
229 return;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000230 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000231 }
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000232 ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter.";
233}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000234
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000235webrtc::PacketReceiver* FakeCall::Receiver() {
236 // TODO(pbos): Fix this.
237 return NULL;
238}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000239
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000240uint32_t FakeCall::SendBitrateEstimate() {
241 return 0;
242}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000243
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000244uint32_t FakeCall::ReceiveBitrateEstimate() {
245 return 0;
246}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000247
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000248FakeWebRtcVideoChannel2::FakeWebRtcVideoChannel2(
249 FakeCall* call,
250 WebRtcVideoEngine2* engine,
251 VoiceMediaChannel* voice_channel)
252 : WebRtcVideoChannel2(call, engine, engine->GetVideoEncoderFactory()),
253 fake_call_(call),
254 voice_channel_(voice_channel) {
255}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000256
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000257FakeWebRtcVideoChannel2::~FakeWebRtcVideoChannel2() {
258}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000259
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000260VoiceMediaChannel* FakeWebRtcVideoChannel2::GetVoiceChannel() {
261 return voice_channel_;
262}
263FakeCall* FakeWebRtcVideoChannel2::GetFakeCall() {
264 return fake_call_;
265}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000266
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000267FakeWebRtcVideoChannel2* FakeWebRtcVideoMediaChannelFactory::GetFakeChannel(
268 VideoMediaChannel* channel) {
269 return channel_map_[channel];
270}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000271
pbos@webrtc.org86f613d2014-06-10 08:53:05 +0000272WebRtcVideoChannel2* FakeWebRtcVideoMediaChannelFactory::Create(
273 WebRtcVideoEngine2* engine,
274 VoiceMediaChannel* voice_channel) {
275 FakeWebRtcVideoChannel2* channel =
276 new FakeWebRtcVideoChannel2(new FakeCall(), engine, voice_channel);
277 channel_map_[channel] = channel;
278 return channel;
279}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000280
281class WebRtcVideoEngine2Test : public testing::Test {
282 public:
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000283 WebRtcVideoEngine2Test() : engine_(&factory_) {
284 std::vector<VideoCodec> engine_codecs = engine_.codecs();
285 assert(!engine_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000286 bool codec_set = false;
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000287 for (size_t i = 0; i < engine_codecs.size(); ++i) {
288 if (engine_codecs[i].name == "red") {
289 default_red_codec_ = engine_codecs[i];
290 } else if (engine_codecs[i].name == "ulpfec") {
291 default_ulpfec_codec_ = engine_codecs[i];
292 } else if (engine_codecs[i].name == "rtx") {
293 default_rtx_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000294 } else if (!codec_set) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +0000295 default_codec_ = engine_codecs[i];
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000296 codec_set = true;
297 }
298 }
299
300 assert(codec_set);
301 }
302
303 protected:
304 FakeWebRtcVideoMediaChannelFactory factory_;
305 WebRtcVideoEngine2 engine_;
306 VideoCodec default_codec_;
307 VideoCodec default_red_codec_;
308 VideoCodec default_ulpfec_codec_;
309 VideoCodec default_rtx_codec_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000310};
311
312TEST_F(WebRtcVideoEngine2Test, CreateChannel) {
313 talk_base::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(NULL));
314 ASSERT_TRUE(channel.get() != NULL) << "Could not create channel.";
315 EXPECT_TRUE(factory_.GetFakeChannel(channel.get()) != NULL)
316 << "Channel not created through factory.";
317}
318
319TEST_F(WebRtcVideoEngine2Test, CreateChannelWithVoiceEngine) {
320 VoiceMediaChannel* voice_channel = reinterpret_cast<VoiceMediaChannel*>(0x42);
321 talk_base::scoped_ptr<VideoMediaChannel> channel(
322 engine_.CreateChannel(voice_channel));
323 ASSERT_TRUE(channel.get() != NULL) << "Could not create channel.";
324
325 FakeWebRtcVideoChannel2* fake_channel =
326 factory_.GetFakeChannel(channel.get());
327 ASSERT_TRUE(fake_channel != NULL) << "Channel not created through factory.";
328
329 EXPECT_TRUE(fake_channel->GetVoiceChannel() != NULL)
330 << "VoiceChannel not set.";
331 EXPECT_EQ(voice_channel, fake_channel->GetVoiceChannel())
332 << "Different VoiceChannel set than the provided one.";
333}
334
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000335TEST_F(WebRtcVideoEngine2Test, FindCodec) {
336 const std::vector<cricket::VideoCodec>& c = engine_.codecs();
337 EXPECT_EQ(4U, c.size());
338
339 cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0);
340 EXPECT_TRUE(engine_.FindCodec(vp8));
341
342 cricket::VideoCodec vp8_ci(104, "vp8", 320, 200, 30, 0);
343 EXPECT_TRUE(engine_.FindCodec(vp8));
344
345 cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50);
346 EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref));
347
348 cricket::VideoCodec vp8_diff_id(95, "VP8", 320, 200, 30, 0);
349 EXPECT_FALSE(engine_.FindCodec(vp8_diff_id));
350 vp8_diff_id.id = 97;
351 EXPECT_TRUE(engine_.FindCodec(vp8_diff_id));
352
353 cricket::VideoCodec vp8_diff_res(104, "VP8", 320, 111, 30, 0);
354 EXPECT_FALSE(engine_.FindCodec(vp8_diff_res));
355
356 // PeerConnection doesn't negotiate the resolution at this point.
357 // Test that FindCodec can handle the case when width/height is 0.
358 cricket::VideoCodec vp8_zero_res(104, "VP8", 0, 0, 30, 0);
359 EXPECT_TRUE(engine_.FindCodec(vp8_zero_res));
360
361 cricket::VideoCodec red(101, "RED", 0, 0, 30, 0);
362 EXPECT_TRUE(engine_.FindCodec(red));
363
364 cricket::VideoCodec red_ci(101, "red", 0, 0, 30, 0);
365 EXPECT_TRUE(engine_.FindCodec(red));
366
367 cricket::VideoCodec fec(102, "ULPFEC", 0, 0, 30, 0);
368 EXPECT_TRUE(engine_.FindCodec(fec));
369
370 cricket::VideoCodec fec_ci(102, "ulpfec", 0, 0, 30, 0);
371 EXPECT_TRUE(engine_.FindCodec(fec));
372
373 cricket::VideoCodec rtx(96, "rtx", 0, 0, 30, 0);
374 EXPECT_TRUE(engine_.FindCodec(rtx));
375}
376
377TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
378 std::vector<VideoCodec> engine_codecs = engine_.codecs();
379 for (size_t i = 0; i < engine_codecs.size(); ++i) {
380 if (engine_codecs[i].name != kRtxCodecName)
381 continue;
382 int associated_payload_type;
383 EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
384 &associated_payload_type));
385 EXPECT_EQ(default_codec_.id, associated_payload_type);
386 return;
387 }
388 FAIL() << "No RTX codec found among default codecs.";
389}
390
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000391TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
392 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
393 ASSERT_FALSE(extensions.empty());
394 for (size_t i = 0; i < extensions.size(); ++i) {
395 if (extensions[i].uri == kRtpTimestampOffsetHeaderExtension) {
396 EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extensions[i].id);
397 return;
398 }
399 }
400 FAIL() << "Timestamp offset extension not in header-extension list.";
401}
402
403TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
404 std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
405 ASSERT_FALSE(extensions.empty());
406 for (size_t i = 0; i < extensions.size(); ++i) {
407 if (extensions[i].uri == kRtpAbsoluteSenderTimeHeaderExtension) {
408 EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId,
409 extensions[i].id);
410 return;
411 }
412 }
413 FAIL() << "Absolute Sender Time extension not in header-extension list.";
414}
415
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000416TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
417 talk_base::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(NULL));
418
419 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
420
421 EXPECT_FALSE(channel->SetSend(true))
422 << "Channel should not start without codecs.";
423 EXPECT_TRUE(channel->SetSend(false))
424 << "Channel should be stoppable even without set codecs.";
425}
426
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000427class WebRtcVideoChannel2BaseTest
428 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
429 protected:
430 virtual cricket::VideoCodec DefaultCodec() OVERRIDE { return kVp8Codec; }
431 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
432};
433
434// TODO(pbos): Fix WebRtcVideoEngine2BaseTest, where we want CheckCoInitialize.
435#if 0
436// TODO(juberti): Figure out why ViE is munging the COM refcount.
437#ifdef WIN32
438TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_CheckCoInitialize) {
439 Base::CheckCoInitialize();
440}
441#endif
442#endif
443
444TEST_F(WebRtcVideoChannel2BaseTest, SetSend) { Base::SetSend(); }
445
446TEST_F(WebRtcVideoChannel2BaseTest, SetSendWithoutCodecs) {
447 Base::SetSendWithoutCodecs();
448}
449
450TEST_F(WebRtcVideoChannel2BaseTest, SetSendSetsTransportBufferSizes) {
451 Base::SetSendSetsTransportBufferSizes();
452}
453
454// TODO(juberti): Fix this test to tolerate missing stats.
455TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_GetStats) { Base::GetStats(); }
456
457// TODO(juberti): Fix this test to tolerate missing stats.
458TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_GetStatsMultipleRecvStreams) {
459 Base::GetStatsMultipleRecvStreams();
460}
461
462TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_GetStatsMultipleSendStreams) {
463 Base::GetStatsMultipleSendStreams();
464}
465
466TEST_F(WebRtcVideoChannel2BaseTest, SetSendBandwidth) {
467 Base::SetSendBandwidth();
468}
469TEST_F(WebRtcVideoChannel2BaseTest, SetSendSsrc) { Base::SetSendSsrc(); }
470TEST_F(WebRtcVideoChannel2BaseTest, SetSendSsrcAfterSetCodecs) {
471 Base::SetSendSsrcAfterSetCodecs();
472}
473
474TEST_F(WebRtcVideoChannel2BaseTest, SetRenderer) { Base::SetRenderer(); }
475
476TEST_F(WebRtcVideoChannel2BaseTest, AddRemoveRecvStreams) {
477 Base::AddRemoveRecvStreams();
478}
479
480TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_AddRemoveRecvStreamAndRender) {
481 Base::AddRemoveRecvStreamAndRender();
482}
483
484TEST_F(WebRtcVideoChannel2BaseTest, AddRemoveRecvStreamsNoConference) {
485 Base::AddRemoveRecvStreamsNoConference();
486}
487
488TEST_F(WebRtcVideoChannel2BaseTest, AddRemoveSendStreams) {
489 Base::AddRemoveSendStreams();
490}
491
492TEST_F(WebRtcVideoChannel2BaseTest, SimulateConference) {
493 Base::SimulateConference();
494}
495
496TEST_F(WebRtcVideoChannel2BaseTest, AddRemoveCapturer) {
497 Base::AddRemoveCapturer();
498}
499
500TEST_F(WebRtcVideoChannel2BaseTest, RemoveCapturerWithoutAdd) {
501 Base::RemoveCapturerWithoutAdd();
502}
503
504TEST_F(WebRtcVideoChannel2BaseTest, AddRemoveCapturerMultipleSources) {
505 Base::AddRemoveCapturerMultipleSources();
506}
507
508// TODO(pbos): Figure out why this fails so often.
509TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_HighAspectHighHeightCapturer) {
510 Base::HighAspectHighHeightCapturer();
511}
512
513TEST_F(WebRtcVideoChannel2BaseTest, RejectEmptyStreamParams) {
514 Base::RejectEmptyStreamParams();
515}
516
517TEST_F(WebRtcVideoChannel2BaseTest, AdaptResolution16x10) {
518 Base::AdaptResolution16x10();
519}
520
521TEST_F(WebRtcVideoChannel2BaseTest, AdaptResolution4x3) {
522 Base::AdaptResolution4x3();
523}
524
525TEST_F(WebRtcVideoChannel2BaseTest, MuteStream) { Base::MuteStream(); }
526
527TEST_F(WebRtcVideoChannel2BaseTest, MultipleSendStreams) {
528 Base::MultipleSendStreams();
529}
530
531// TODO(juberti): Restore this test once we support sending 0 fps.
532TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_AdaptDropAllFrames) {
533 Base::AdaptDropAllFrames();
534}
535// TODO(juberti): Understand why we get decode errors on this test.
536TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_AdaptFramerate) {
537 Base::AdaptFramerate();
538}
539
540TEST_F(WebRtcVideoChannel2BaseTest, SetSendStreamFormat0x0) {
541 Base::SetSendStreamFormat0x0();
542}
543
544// TODO(zhurunz): Fix the flakey test.
545TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_SetSendStreamFormat) {
546 Base::SetSendStreamFormat();
547}
548
549TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
550 Base::TwoStreamsSendAndReceive(kVp8Codec);
551}
552
553TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsReUseFirstStream) {
554 Base::TwoStreamsReUseFirstStream(kVp8Codec);
555}
556
557class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
558 public:
559 virtual void SetUp() OVERRIDE {
560 channel_.reset(engine_.CreateChannel(NULL));
561 fake_channel_ = factory_.GetFakeChannel(channel_.get());
562 last_ssrc_ = 123;
563 ASSERT_TRUE(fake_channel_ != NULL)
564 << "Channel not created through factory.";
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000565 EXPECT_TRUE(fake_channel_->SetSendCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000566 }
567
568 protected:
569 FakeVideoSendStream* AddSendStream() {
570 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
571 }
572
573 FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
574 size_t num_streams =
575 fake_channel_->GetFakeCall()->GetVideoSendStreams().size();
576 EXPECT_TRUE(channel_->AddSendStream(sp));
577 std::vector<FakeVideoSendStream*> streams =
578 fake_channel_->GetFakeCall()->GetVideoSendStreams();
579 EXPECT_EQ(num_streams + 1, streams.size());
580 return streams[streams.size() - 1];
581 }
582
583 std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
584 return fake_channel_->GetFakeCall()->GetVideoSendStreams();
585 }
586
587 FakeVideoReceiveStream* AddRecvStream() {
588 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
589 }
590
591 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
592 size_t num_streams =
593 fake_channel_->GetFakeCall()->GetVideoReceiveStreams().size();
594 EXPECT_TRUE(channel_->AddRecvStream(sp));
595 std::vector<FakeVideoReceiveStream*> streams =
596 fake_channel_->GetFakeCall()->GetVideoReceiveStreams();
597 EXPECT_EQ(num_streams + 1, streams.size());
598 return streams[streams.size() - 1];
599 }
600
601 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate,
602 const char* max_bitrate) {
603 std::vector<VideoCodec> codecs;
604 codecs.push_back(kVp8Codec);
605 codecs[0].params[kCodecParamMinBitrate] = min_bitrate;
606 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate;
607 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
608
609 FakeVideoSendStream* stream = AddSendStream();
610
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000611 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
612 ASSERT_EQ(1u, video_streams.size());
613 EXPECT_EQ(atoi(min_bitrate), video_streams.back().min_bitrate_bps / 1000);
614 EXPECT_EQ(atoi(max_bitrate), video_streams.back().max_bitrate_bps / 1000);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000615
616 VideoCodec codec;
617 EXPECT_TRUE(channel_->GetSendCodec(&codec));
618 EXPECT_EQ(min_bitrate, codec.params[kCodecParamMinBitrate]);
619 EXPECT_EQ(max_bitrate, codec.params[kCodecParamMaxBitrate]);
620 }
621
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000622 void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
623 const std::string& webrtc_ext) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000624 FakeCall* call = fake_channel_->GetFakeCall();
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000625 // Enable extension.
626 const int id = 1;
627 std::vector<cricket::RtpHeaderExtension> extensions;
628 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
629 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
630
631 FakeVideoSendStream* send_stream =
632 AddSendStream(cricket::StreamParams::CreateLegacy(123));
633
634 // Verify the send extension id.
635 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
636 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
637 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
638 // Verify call with same set of extensions returns true.
639 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
640 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
641 // receivers.
642 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
643 ->GetConfig()
644 .rtp.extensions.empty());
645
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000646 // Verify that existing RTP header extensions can be removed.
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000647 std::vector<cricket::RtpHeaderExtension> empty_extensions;
648 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000649 ASSERT_EQ(1u, call->GetVideoSendStreams().size());
650 send_stream = call->GetVideoSendStreams()[0];
651 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
652
653 // Verify that adding receive RTP header extensions adds them for existing
654 // streams.
655 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
656 send_stream = call->GetVideoSendStreams()[0];
657 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
658 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
659 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000660 }
661
662 void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
663 const std::string& webrtc_ext) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000664 FakeCall* call = fake_channel_->GetFakeCall();
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000665 // Enable extension.
666 const int id = 1;
667 std::vector<cricket::RtpHeaderExtension> extensions;
668 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
669 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
670
671 FakeVideoReceiveStream* recv_stream =
672 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
673
674 // Verify the recv extension id.
675 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
676 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
677 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
678 // Verify call with same set of extensions returns true.
679 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000680
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000681 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
682 // senders.
683 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
684 ->GetConfig()
685 .rtp.extensions.empty());
686
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000687 // Verify that existing RTP header extensions can be removed.
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000688 std::vector<cricket::RtpHeaderExtension> empty_extensions;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000689 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions));
690 ASSERT_EQ(1u, call->GetVideoReceiveStreams().size());
691 recv_stream = call->GetVideoReceiveStreams()[0];
692 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
693
694 // Verify that adding receive RTP header extensions adds them for existing
695 // streams.
696 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
697 recv_stream = call->GetVideoReceiveStreams()[0];
698 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
699 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
700 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000701 }
702
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000703 talk_base::scoped_ptr<VideoMediaChannel> channel_;
704 FakeWebRtcVideoChannel2* fake_channel_;
705 uint32 last_ssrc_;
706};
707
708TEST_F(WebRtcVideoChannel2Test, DISABLED_MaxBitrateResetsWithConferenceMode) {
709 FAIL() << "Not implemented."; // TODO(pbos): Implement.
710}
711
712TEST_F(WebRtcVideoChannel2Test, DISABLED_StartSendBitrate) {
713 // TODO(pbos): Is this test testing vie_ ? this is confusing. No API to set
714 // start send bitrate from outside? Add defaults here that should be kept?
715 std::vector<cricket::VideoCodec> codec_list;
716 codec_list.push_back(kVp8Codec);
717 EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
718 const unsigned int kVideoMinSendBitrateKbps = 50;
719 const unsigned int kVideoTargetSendBitrateKbps = 300;
720 const unsigned int kVideoMaxSendBitrateKbps = 2000;
721 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000722 std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
723 ASSERT_EQ(1u, video_streams.size());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000724 EXPECT_EQ(kVideoMinSendBitrateKbps,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000725 video_streams.back().min_bitrate_bps / 1000);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000726 EXPECT_EQ(kVideoTargetSendBitrateKbps,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000727 video_streams.back().target_bitrate_bps / 1000);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000728 EXPECT_EQ(kVideoMaxSendBitrateKbps,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000729 video_streams.back().max_bitrate_bps / 1000);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000730#if 0
731 // TODO(pbos): un-#if
732 VerifyVP8SendCodec(send_channel, kVP8Codec.width, kVP8Codec.height, 0,
733 kVideoMaxSendBitrateKbps, kVideoMinSendBitrateKbps,
734 kVideoDefaultStartSendBitrateKbps);
735 EXPECT_EQ(0, vie_.StartSend(send_channel));
736
737 // Increase the send bitrate and verify it is used as start bitrate.
738 const unsigned int kVideoSendBitrateBps = 768000;
739 vie_.SetSendBitrates(send_channel, kVideoSendBitrateBps, 0, 0);
740 EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
741 VerifyVP8SendCodec(send_channel, kVP8Codec.width, kVP8Codec.height, 0,
742 kVideoMaxSendBitrateKbps, kVideoMinSendBitrateKbps,
743 kVideoSendBitrateBps / 1000);
744
745 // Never set a start bitrate higher than the max bitrate.
746 vie_.SetSendBitrates(send_channel, kVideoMaxSendBitrateKbps + 500, 0, 0);
747 EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
748 VerifyVP8SendCodec(send_channel, kVP8Codec.width, kVP8Codec.height, 0,
749 kVideoMaxSendBitrateKbps, kVideoMinSendBitrateKbps,
750 kVideoDefaultStartSendBitrateKbps);
751
752 // Use the default start bitrate if the send bitrate is lower.
753 vie_.SetSendBitrates(send_channel, kVideoDefaultStartSendBitrateKbps - 50, 0,
754 0);
755 EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
756 VerifyVP8SendCodec(send_channel, kVP8Codec.width, kVP8Codec.height, 0,
757 kVideoMaxSendBitrateKbps, kVideoMinSendBitrateKbps,
758 kVideoDefaultStartSendBitrateKbps);
759#endif
760}
761
762TEST_F(WebRtcVideoChannel2Test, DISABLED_RtcpEnabled) {
763 // Note(pbos): This is a receiver-side setting, dumbo.
764 FAIL() << "Not implemented."; // TODO(pbos): Implement.
765}
766
767TEST_F(WebRtcVideoChannel2Test, DISABLED_KeyFrameRequestEnabled) {
768 FAIL() << "Not implemented."; // TODO(pbos): Implement.
769}
770
771TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
772 FakeVideoReceiveStream* stream = AddRecvStream();
773 EXPECT_TRUE(stream->GetConfig().rtp.remb);
774}
775
776TEST_F(WebRtcVideoChannel2Test, DISABLED_RembEnabledOnReceiveChannels) {
777 FAIL() << "Not implemented."; // TODO(pbos): Implement.
778}
779
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000780TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000781 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
782 EXPECT_TRUE(channel_->SetSend(true));
783 cricket::VideoOptions options;
784 options.conference_mode.Set(true);
785 EXPECT_TRUE(channel_->SetOptions(options));
786
787 // Send side.
788 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
789 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
790 FakeVideoSendStream* send_stream = AddSendStream(
791 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
792
793 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
794 for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
795 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
796
797 // Receiver side.
798 FakeVideoReceiveStream* recv_stream = AddRecvStream(
799 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
800 ASSERT_GT(recv_stream->GetConfig().rtp.rtx.size(), 0u)
801 << "No SSRCs for RTX configured by AddRecvStream.";
802 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size())
803 << "This test only works with one receive codec. Please update the test.";
804 EXPECT_EQ(rtx_ssrcs[0],
805 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
806 // TODO(pbos): Make sure we set the RTX for correct payloads etc.
807}
808
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000809TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
810 // Setup one channel with an associated RTX stream.
811 cricket::StreamParams params =
812 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
813 params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
814 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
815 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
816 EXPECT_EQ(kRtxSsrcs1[0],
817 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000818}
819
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000820TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
821 // Setup one channel without an associated RTX stream.
822 cricket::StreamParams params =
823 cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
824 FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
825 ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000826}
827
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000828TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
829 FakeVideoSendStream* send_stream =
830 AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
831 ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
832
833 FakeVideoReceiveStream* recv_stream =
834 AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
835 ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000836}
837
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000838// Test support for RTP timestamp offset header extension.
839TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
840 TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
841 webrtc::RtpExtension::kTOffset);
842}
843TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
844 TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
845 webrtc::RtpExtension::kTOffset);
846}
847
848// Test support for absolute send time header extension.
849TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
850 TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
851 webrtc::RtpExtension::kAbsSendTime);
852}
853TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
854 TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
855 webrtc::RtpExtension::kAbsSendTime);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000856}
857
858TEST_F(WebRtcVideoChannel2Test, DISABLED_LeakyBucketTest) {
859 FAIL() << "Not implemented."; // TODO(pbos): Implement.
860}
861
862TEST_F(WebRtcVideoChannel2Test, DISABLED_BufferedModeLatency) {
863 FAIL() << "Not implemented."; // TODO(pbos): Implement.
864}
865
866TEST_F(WebRtcVideoChannel2Test, DISABLED_AdditiveVideoOptions) {
867 FAIL() << "Not implemented."; // TODO(pbos): Implement.
868}
869
870TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
871 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
872 EXPECT_EQ(1u, fake_channel_->GetFakeCall()->GetVideoReceiveStreams().size());
873}
874
875TEST_F(WebRtcVideoChannel2Test, DISABLED_NoRembChangeAfterAddRecvStream) {
876 FAIL() << "Not implemented."; // TODO(pbos): Implement.
877}
878
879TEST_F(WebRtcVideoChannel2Test, DISABLED_RembOnOff) {
880 FAIL() << "Not implemented."; // TODO(pbos): Implement.
881}
882
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +0000883TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
884 VerifyCodecHasDefaultFeedbackParams(default_codec_);
885
pbos@webrtc.org19864742014-05-30 07:35:47 +0000886 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
887 EXPECT_TRUE(channel_->SetSend(true));
888
889 // Send side.
890 FakeVideoSendStream* send_stream =
891 AddSendStream(cricket::StreamParams::CreateLegacy(1));
892 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
893
894 // Receiver side.
895 FakeVideoReceiveStream* recv_stream =
896 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
897 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
898
899 // Nack history size should match between sender and receiver.
900 EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
901 recv_stream->GetConfig().rtp.nack.rtp_history_ms);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000902}
903
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +0000904TEST_F(WebRtcVideoChannel2Test, NackCanBeDisabled) {
905 std::vector<VideoCodec> codecs;
906 codecs.push_back(kVp8Codec);
907
908 // Send side.
909 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
910 FakeVideoSendStream* send_stream =
911 AddSendStream(cricket::StreamParams::CreateLegacy(1));
912 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
913
914 // Receiver side.
915 ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
916 FakeVideoReceiveStream* recv_stream =
917 AddRecvStream(cricket::StreamParams::CreateLegacy(1));
918 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
919}
920
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000921TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInterop) {
922 FAIL() << "Not implemented."; // TODO(pbos): Implement.
923}
924
925TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInteropReversed) {
926 FAIL() << "Not implemented."; // TODO(pbos): Implement.
927}
928
929TEST_F(WebRtcVideoChannel2Test, DISABLED_HybridNackFecConference) {
930 FAIL() << "Not implemented."; // TODO(pbos): Implement.
931}
932
933TEST_F(WebRtcVideoChannel2Test, DISABLED_AddRemoveRecvStreamConference) {
934 FAIL() << "Not implemented."; // TODO(pbos): Implement.
935}
936
937TEST_F(WebRtcVideoChannel2Test, DISABLED_SetRender) {
938 FAIL() << "Not implemented."; // TODO(pbos): Implement.
939}
940
941TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAuto) {
942 FAIL() << "Not implemented."; // TODO(pbos): Implement.
943}
944
945TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAutoCapped) {
946 FAIL() << "Not implemented."; // TODO(pbos): Implement.
947}
948
949TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthFixed) {
950 FAIL() << "Not implemented."; // TODO(pbos): Implement.
951}
952
953TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthInConference) {
954 FAIL() << "Not implemented."; // TODO(pbos): Implement.
955}
956
957TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthScreencast) {
958 FAIL() << "Not implemented."; // TODO(pbos): Implement.
959}
960
961TEST_F(WebRtcVideoChannel2Test, DISABLED_SetSendSsrcAndCname) {
962 FAIL() << "Not implemented."; // TODO(pbos): Implement.
963}
964
965TEST_F(WebRtcVideoChannel2Test,
966 DISABLED_SetSendSsrcAfterCreatingReceiveChannel) {
967 FAIL() << "Not implemented."; // TODO(pbos): Implement.
968}
969
970TEST_F(WebRtcVideoChannel2Test, DISABLED_SetOptionsWithDenoising) {
971 FAIL() << "Not implemented."; // TODO(pbos): Implement.
972}
973
974TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) {
975 FAIL() << "Not implemented."; // TODO(pbos): Implement.
976}
977
978TEST_F(WebRtcVideoChannel2Test, DISABLED_DISABLED_SendReceiveBitratesStats) {
979 FAIL() << "Not implemented."; // TODO(pbos): Implement.
980}
981
982TEST_F(WebRtcVideoChannel2Test, DISABLED_TestSetAdaptInputToCpuUsage) {
983 FAIL() << "Not implemented."; // TODO(pbos): Implement.
984}
985
986TEST_F(WebRtcVideoChannel2Test, DISABLED_TestSetCpuThreshold) {
987 FAIL() << "Not implemented."; // TODO(pbos): Implement.
988}
989
990TEST_F(WebRtcVideoChannel2Test, DISABLED_TestSetInvalidCpuThreshold) {
991 FAIL() << "Not implemented."; // TODO(pbos): Implement.
992}
993
994TEST_F(WebRtcVideoChannel2Test, DISABLED_WebRtcShouldLog) {
995 FAIL() << "Not implemented."; // TODO(pbos): Implement.
996}
997
998TEST_F(WebRtcVideoChannel2Test, DISABLED_WebRtcShouldNotLog) {
999 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1000}
1001
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001002TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001003 ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001004
1005 VideoCodec codec;
1006 EXPECT_TRUE(channel_->GetSendCodec(&codec));
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001007 EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001008
1009 // Using a RTX setup to verify that the default RTX payload type is good.
1010 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1011 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1012 FakeVideoSendStream* stream = AddSendStream(
1013 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1014 webrtc::VideoSendStream::Config config = stream->GetConfig();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001015
1016 // Make sure NACK and FEC are enabled on the correct payload types.
1017 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
1018 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
1019 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001020
1021 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
1022 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001023 EXPECT_EQ(static_cast<int>(default_rtx_codec_.id),
1024 config.rtp.rtx.payload_type);
1025 // TODO(juberti): Check RTCP, PLI, TMMBR.
1026}
1027
1028TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
1029 std::vector<VideoCodec> codecs;
1030 codecs.push_back(kVp8Codec);
1031 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1032
1033 FakeVideoSendStream* stream = AddSendStream();
1034 webrtc::VideoSendStream::Config config = stream->GetConfig();
1035
1036 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
1037 EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
1038}
1039
1040TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001041 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
1042 std::vector<VideoCodec> codecs;
1043 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
1044 codecs.push_back(rtx_codec);
1045 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1046 << "RTX codec without associated payload type should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001047}
1048
1049TEST_F(WebRtcVideoChannel2Test,
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001050 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
1051 std::vector<VideoCodec> codecs;
1052 cricket::VideoCodec rtx_codec =
1053 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
1054 codecs.push_back(kVp8Codec);
1055 codecs.push_back(rtx_codec);
1056 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1057
1058 cricket::VideoCodec rtx_codec2 =
1059 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
1060 codecs.pop_back();
1061 codecs.push_back(rtx_codec2);
1062 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1063 << "RTX without matching video codec should be rejected.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001064}
1065
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001066TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
1067 std::vector<VideoCodec> codecs;
1068 codecs.push_back(kVp8Codec);
1069 codecs.push_back(kUlpfecCodec);
1070 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1071
1072 FakeVideoSendStream* stream = AddSendStream();
1073 webrtc::VideoSendStream::Config config = stream->GetConfig();
1074
1075 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
1076
1077 codecs.pop_back();
1078 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1079 stream = fake_channel_->GetFakeCall()->GetVideoSendStreams()[0];
1080 ASSERT_TRUE(stream != NULL);
1081 config = stream->GetConfig();
1082 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
1083 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001084}
1085
pbos@webrtc.org38ce7d02014-07-16 08:01:38 +00001086TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
1087 std::vector<VideoCodec> codecs;
1088 codecs.push_back(kVp8Codec720p);
1089 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1090
1091 std::vector<webrtc::VideoStream> streams =
1092 AddSendStream()->GetVideoStreams();
1093 EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
1094 EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
1095
1096 codecs.clear();
1097 codecs.push_back(kVp8Codec360p);
1098 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1099 streams = fake_channel_->GetFakeCall()->GetVideoSendStreams()[0]
1100 ->GetVideoStreams();
1101 EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
1102 EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001103}
1104
1105TEST_F(WebRtcVideoChannel2Test,
1106 DISABLED_ConstrainsSetCodecsAccordingToEncoderConfig) {
1107 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1108}
1109
1110TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMinMaxBitrate) {
1111 SetSendCodecsShouldWorkForBitrates("10", "20");
1112}
1113
1114TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
pbos@webrtc.org9fbb7172014-06-13 09:34:13 +00001115 std::vector<VideoCodec> video_codecs = engine_.codecs();
1116 video_codecs[0].params[kCodecParamMinBitrate] = "30";
1117 video_codecs[0].params[kCodecParamMaxBitrate] = "20";
1118 EXPECT_FALSE(channel_->SetSendCodecs(video_codecs));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001119}
1120
1121TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptLargeMinMaxBitrate) {
1122 SetSendCodecsShouldWorkForBitrates("1000", "2000");
1123}
1124
1125TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
1126 static const char* kMaxQuantization = "21";
1127 std::vector<VideoCodec> codecs;
1128 codecs.push_back(kVp8Codec);
1129 codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
1130 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001131 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
1132 AddSendStream()->GetVideoStreams().back().max_qp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001133
1134 VideoCodec codec;
1135 EXPECT_TRUE(channel_->GetSendCodec(&codec));
1136 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
1137}
1138
1139TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
1140 std::vector<cricket::VideoCodec> codecs;
1141 codecs.push_back(kVp8Codec);
1142
1143 codecs[0].width = 0;
1144 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1145 << "Codec set though codec width is zero.";
1146
1147 codecs[0].width = kVp8Codec.width;
1148 codecs[0].height = 0;
1149 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1150 << "Codec set though codec height is zero.";
1151}
1152
1153TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
1154 // TODO(pbos): Should we only allow the dynamic range?
1155 static const size_t kNumIncorrectPayloads = 4;
1156 static const int kIncorrectPayloads[kNumIncorrectPayloads] = {-2, -1, 128,
1157 129};
1158 std::vector<cricket::VideoCodec> codecs;
1159 codecs.push_back(kVp8Codec);
1160 for (size_t i = 0; i < kNumIncorrectPayloads; ++i) {
1161 int payload_type = kIncorrectPayloads[i];
1162 codecs[0].id = payload_type;
1163 EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1164 << "Bad payload type '" << payload_type << "' accepted.";
1165 }
1166}
1167
1168TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
1169 std::vector<cricket::VideoCodec> codecs;
1170 codecs.push_back(kVp8Codec);
1171 for (int payload_type = 0; payload_type <= 127; ++payload_type) {
1172 codecs[0].id = payload_type;
1173 EXPECT_TRUE(channel_->SetSendCodecs(codecs))
1174 << "Payload type '" << payload_type << "' rejected.";
1175 }
1176}
1177
1178TEST_F(WebRtcVideoChannel2Test, DISABLED_ResetVieSendCodecOnNewFrameSize) {
1179 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1180}
1181
1182TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
1183 std::vector<cricket::VideoCodec> codecs;
1184 codecs.push_back(kVp8Codec);
1185 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1186}
1187
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001188// Test that we set our inbound RTX codecs properly.
1189TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
1190 std::vector<cricket::VideoCodec> codecs;
1191 codecs.push_back(kVp8Codec);
1192 cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
1193 codecs.push_back(rtx_codec);
1194 EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
1195 << "RTX codec without associated payload should be rejected.";
1196
1197 codecs[1].SetParam("apt", kVp8Codec.id + 1);
1198 EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
1199 << "RTX codec with invalid associated payload type should be rejected.";
1200
1201 codecs[1].SetParam("apt", kVp8Codec.id);
1202 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1203
1204 cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0);
1205 rtx_codec2.SetParam("apt", rtx_codec.id);
1206 codecs.push_back(rtx_codec2);
1207
1208 EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) << "RTX codec with another RTX "
1209 "as associated payload type "
1210 "should be rejected.";
1211}
1212
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001213TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
1214 std::vector<cricket::VideoCodec> codecs;
1215 codecs.push_back(kVp8Codec);
1216 codecs[0].id = 99;
1217 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1218}
1219
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00001220TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001221 EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
pbos@webrtc.orgccbed3b2014-07-11 13:02:54 +00001222
1223 FakeVideoReceiveStream* stream = AddRecvStream();
1224 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
1225 EXPECT_STREQ(engine_.codecs()[0].name.c_str(), config.codecs[0].plName);
1226 EXPECT_EQ(engine_.codecs()[0].id, config.codecs[0].plType);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001227}
1228
1229TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
1230 std::vector<VideoCodec> codecs;
1231 codecs.push_back(kVp8Codec);
1232 codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
1233 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
1234}
1235
1236// TODO(pbos): Enable VP9 through external codec support
1237TEST_F(WebRtcVideoChannel2Test,
1238 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
1239 std::vector<VideoCodec> codecs;
1240 codecs.push_back(kVp8Codec);
1241 codecs.push_back(kVp9Codec);
1242 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1243}
1244
1245TEST_F(WebRtcVideoChannel2Test,
1246 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
1247 std::vector<VideoCodec> codecs;
1248 codecs.push_back(kVp8Codec);
1249 codecs.push_back(kVp9Codec);
1250 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1251 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
1252}
1253
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001254TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
1255 std::vector<VideoCodec> codecs;
1256 codecs.push_back(kVp8Codec);
1257 codecs.push_back(kUlpfecCodec);
1258 ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1259
1260 FakeVideoReceiveStream* stream = AddRecvStream();
1261 webrtc::VideoReceiveStream::Config config = stream->GetConfig();
1262
1263 EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
1264
1265 codecs.pop_back();
1266 ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
1267 stream = fake_channel_->GetFakeCall()->GetVideoReceiveStreams()[0];
1268 ASSERT_TRUE(stream != NULL);
1269 config = stream->GetConfig();
1270 EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
1271 << "SetSendCodec without FEC should disable current FEC.";
pbos@webrtc.org269605c2014-06-26 08:49:03 +00001272}
1273
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001274TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
1275 std::vector<VideoCodec> codecs;
1276 codecs.push_back(kVp8Codec);
1277 codecs.push_back(kRedCodec);
1278 codecs[1].id = codecs[0].id;
1279 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
1280}
1281
1282TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
1283 std::vector<VideoCodec> codecs;
1284 codecs.push_back(kVp8Codec);
1285 codecs.push_back(kVp9Codec);
1286 codecs[1].id = codecs[0].id;
1287 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
1288}
1289
1290TEST_F(WebRtcVideoChannel2Test,
1291 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
1292 std::vector<VideoCodec> codecs;
1293 codecs.push_back(kVp8Codec);
1294 codecs.push_back(kVp8Codec);
1295 codecs[1].id += 1;
1296 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1297}
1298
1299TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
1300 EXPECT_FALSE(AddSendStream()->IsSending());
1301}
1302
1303TEST_F(WebRtcVideoChannel2Test, DISABLED_ReceiveStreamReceivingByDefault) {
1304 // Is this test correct though? Auto-receive? Enable receive on first packet?
1305 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1306}
1307
1308TEST_F(WebRtcVideoChannel2Test, SetSend) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001309 FakeVideoSendStream* stream = AddSendStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001310 EXPECT_FALSE(stream->IsSending());
1311
1312 // false->true
1313 EXPECT_TRUE(channel_->SetSend(true));
1314 EXPECT_TRUE(stream->IsSending());
1315 // true->true
1316 EXPECT_TRUE(channel_->SetSend(true));
1317 EXPECT_TRUE(stream->IsSending());
1318 // true->false
1319 EXPECT_TRUE(channel_->SetSend(false));
1320 EXPECT_FALSE(stream->IsSending());
1321 // false->false
1322 EXPECT_TRUE(channel_->SetSend(false));
1323 EXPECT_FALSE(stream->IsSending());
1324
1325 EXPECT_TRUE(channel_->SetSend(true));
1326 FakeVideoSendStream* new_stream = AddSendStream();
1327 EXPECT_TRUE(new_stream->IsSending())
1328 << "Send stream created after SetSend(true) not sending initially.";
1329}
1330
1331TEST_F(WebRtcVideoChannel2Test, DISABLED_SendAndReceiveVp8Vga) {
1332 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1333}
1334
1335TEST_F(WebRtcVideoChannel2Test, DISABLED_SendAndReceiveVp8Qvga) {
1336 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1337}
1338
1339TEST_F(WebRtcVideoChannel2Test, DISABLED_SendAndReceiveH264SvcQqvga) {
1340 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1341}
1342
1343TEST_F(WebRtcVideoChannel2Test, DISABLED_SendManyResizeOnce) {
1344 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1345}
1346
1347TEST_F(WebRtcVideoChannel2Test, DISABLED_SendVp8HdAndReceiveAdaptedVp8Vga) {
1348 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1349}
1350
1351TEST_F(WebRtcVideoChannel2Test, DISABLED_TestSetDscpOptions) {
1352 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1353}
1354
1355TEST_F(WebRtcVideoChannel2Test, DISABLED_SetOptionsWithMaxBitrate) {
1356 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1357}
1358
1359TEST_F(WebRtcVideoChannel2Test, DISABLED_SetOptionsWithLoweredBitrate) {
1360 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1361}
1362
1363TEST_F(WebRtcVideoChannel2Test, DISABLED_SetOptionsSucceedsWhenSending) {
1364 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1365}
1366
1367TEST_F(WebRtcVideoChannel2Test, DISABLED_ResetCodecOnScreencast) {
1368 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1369}
1370
1371TEST_F(WebRtcVideoChannel2Test, DISABLED_DontResetCodecOnSendFrame) {
1372 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1373}
1374
1375TEST_F(WebRtcVideoChannel2Test,
1376 DISABLED_DontRegisterDecoderIfFactoryIsNotGiven) {
1377 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1378}
1379
1380TEST_F(WebRtcVideoChannel2Test, DISABLED_RegisterDecoderIfFactoryIsGiven) {
1381 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1382}
1383
1384TEST_F(WebRtcVideoChannel2Test, DISABLED_DontRegisterDecoderMultipleTimes) {
1385 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1386}
1387
1388TEST_F(WebRtcVideoChannel2Test, DISABLED_DontRegisterDecoderForNonVP8) {
1389 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1390}
1391
1392TEST_F(WebRtcVideoChannel2Test,
1393 DISABLED_DontRegisterEncoderIfFactoryIsNotGiven) {
1394 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1395}
1396
1397TEST_F(WebRtcVideoChannel2Test, DISABLED_RegisterEncoderIfFactoryIsGiven) {
1398 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1399}
1400
1401TEST_F(WebRtcVideoChannel2Test, DISABLED_DontRegisterEncoderMultipleTimes) {
1402 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1403}
1404
1405TEST_F(WebRtcVideoChannel2Test,
1406 DISABLED_RegisterEncoderWithMultipleSendStreams) {
1407 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1408}
1409
1410TEST_F(WebRtcVideoChannel2Test, DISABLED_DontRegisterEncoderForNonVP8) {
1411 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1412}
1413
1414TEST_F(WebRtcVideoChannel2Test, DISABLED_FeedbackParamsForNonVP8) {
1415 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1416}
1417
1418TEST_F(WebRtcVideoChannel2Test, DISABLED_ExternalCodecAddedToTheEnd) {
1419 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1420}
1421
1422TEST_F(WebRtcVideoChannel2Test, DISABLED_ExternalCodecIgnored) {
1423 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1424}
1425
1426TEST_F(WebRtcVideoChannel2Test, DISABLED_UpdateEncoderCodecsAfterSetFactory) {
1427 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1428}
1429
1430TEST_F(WebRtcVideoChannel2Test, DISABLED_OnReadyToSend) {
1431 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1432}
1433
1434TEST_F(WebRtcVideoChannel2Test, DISABLED_CaptureFrameTimestampToNtpTimestamp) {
1435 FAIL() << "Not implemented."; // TODO(pbos): Implement.
1436}
1437} // namespace cricket