src/third_party/libjingle/source/talk/media/webrtc/webrtcvideoengine2_unittest.cc

   1 /*
   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>
  29 #include <vector>
  30
  31 #include "talk/media/base/testutils.h"
  32 #include "talk/media/base/videoengine_unittest.h"
  33 #include "talk/media/webrtc/fakewebrtcvideoengine.h"
  34 #include "talk/media/webrtc/webrtcvideochannelfactory.h"
  35 #include "talk/media/webrtc/webrtcvideoengine2.h"
  36 #include "talk/media/webrtc/webrtcvideoengine2_unittest.h"
  37 #include "talk/media/webrtc/webrtcvoiceengine.h"
  38 #include "webrtc/base/gunit.h"
  39 #include "webrtc/base/stringutils.h"
  40 #include "webrtc/video_encoder.h"
  41
  42 namespace {
  43 static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0);
  44 static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30, 0);
  45
  46 static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0);
  47 static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0);
  48 static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0);
  49
  50 static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0);
  51 static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0);
  52
  53 static const uint32 kSsrcs1[] = {1};
  54 static const uint32 kRtxSsrcs1[] = {4};
  55 static const char kUnsupportedExtensionName[] =
  56     "urn:ietf:params:rtp-hdrext:unsupported";
  57
  58 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
  59   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
  60       cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
  61   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
  62       cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
  63   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
  64       cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
  65   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
  66       cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
  67 }
  68
  69 }  // namespace
  70
  71 namespace cricket {
  72 FakeVideoSendStream::FakeVideoSendStream(
  73     const webrtc::VideoSendStream::Config& config,
  74     const webrtc::VideoEncoderConfig& encoder_config)
  75     : sending_(false),
  76       config_(config),
  77       codec_settings_set_(false),
  78       num_swapped_frames_(0) {
  79   assert(config.encoder_settings.encoder != NULL);
  80   ReconfigureVideoEncoder(encoder_config);
  81 }
  82
  83 webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() const {
  84   return config_;
  85 }
  86
  87 webrtc::VideoEncoderConfig FakeVideoSendStream::GetEncoderConfig() const {
  88   return encoder_config_;
  89 }
  90
  91 std::vector<webrtc::VideoStream> FakeVideoSendStream::GetVideoStreams() {
  92   return encoder_config_.streams;
  93 }
  94
  95 bool FakeVideoSendStream::IsSending() const {
  96   return sending_;
  97 }
  98
  99 bool FakeVideoSendStream::GetVp8Settings(
 100     webrtc::VideoCodecVP8* settings) const {
 101   if (!codec_settings_set_) {
 102     return false;
 103   }
 104
 105   *settings = vp8_settings_;
 106   return true;
 107 }
 108
 109 int FakeVideoSendStream::GetNumberOfSwappedFrames() const {
 110   return num_swapped_frames_;
 111 }
 112
 113 int FakeVideoSendStream::GetLastWidth() const {
 114   return last_frame_.width();
 115 }
 116
 117 int FakeVideoSendStream::GetLastHeight() const {
 118   return last_frame_.height();
 119 }
 120
 121 void FakeVideoSendStream::SwapFrame(webrtc::I420VideoFrame* frame) {
 122   ++num_swapped_frames_;
 123   last_frame_.SwapFrame(frame);
 124 }
 125 webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() const {
 126   return webrtc::VideoSendStream::Stats();
 127 }
 128
 129 bool FakeVideoSendStream::ReconfigureVideoEncoder(
 130     const webrtc::VideoEncoderConfig& config) {
 131   encoder_config_ = config;
 132   if (config.encoder_specific_settings != NULL) {
 133     assert(config_.encoder_settings.payload_name == "VP8");
 134     vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>(
 135                         config.encoder_specific_settings);
 136   }
 137   codec_settings_set_ = config.encoder_specific_settings != NULL;
 138   return true;
 139 }
 140
 141 webrtc::VideoSendStreamInput* FakeVideoSendStream::Input() {
 142   return this;
 143 }
 144
 145 void FakeVideoSendStream::Start() {
 146   sending_ = true;
 147 }
 148
 149 void FakeVideoSendStream::Stop() {
 150   sending_ = false;
 151 }
 152
 153 FakeVideoReceiveStream::FakeVideoReceiveStream(
 154     const webrtc::VideoReceiveStream::Config& config)
 155     : config_(config), receiving_(false) {
 156 }
 157
 158 webrtc::VideoReceiveStream::Config FakeVideoReceiveStream::GetConfig() {
 159   return config_;
 160 }
 161
 162 bool FakeVideoReceiveStream::IsReceiving() const {
 163   return receiving_;
 164 }
 165
 166 webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const {
 167   return webrtc::VideoReceiveStream::Stats();
 168 }
 169
 170 void FakeVideoReceiveStream::Start() {
 171   receiving_ = true;
 172 }
 173
 174 void FakeVideoReceiveStream::Stop() {
 175   receiving_ = false;
 176 }
 177
 178 FakeCall::FakeCall(const webrtc::Call::Config& config)
 179     : config_(config), network_state_(kNetworkUp) {
 180   SetVideoCodecs(GetDefaultVideoCodecs());
 181 }
 182
 183 FakeCall::~FakeCall() {
 184   EXPECT_EQ(0u, video_send_streams_.size());
 185   EXPECT_EQ(0u, video_receive_streams_.size());
 186 }
 187
 188 void FakeCall::SetVideoCodecs(const std::vector<webrtc::VideoCodec> codecs) {
 189   codecs_ = codecs;
 190 }
 191
 192 webrtc::Call::Config FakeCall::GetConfig() const {
 193   return config_;
 194 }
 195
 196 std::vector<FakeVideoSendStream*> FakeCall::GetVideoSendStreams() {
 197   return video_send_streams_;
 198 }
 199
 200 std::vector<FakeVideoReceiveStream*> FakeCall::GetVideoReceiveStreams() {
 201   return video_receive_streams_;
 202 }
 203
 204 webrtc::VideoCodec FakeCall::GetEmptyVideoCodec() {
 205   webrtc::VideoCodec codec;
 206   codec.minBitrate = 300;
 207   codec.startBitrate = 800;
 208   codec.maxBitrate = 1500;
 209   codec.maxFramerate = 10;
 210   codec.width = 640;
 211   codec.height = 480;
 212   codec.qpMax = 56;
 213
 214   return codec;
 215 }
 216
 217 webrtc::VideoCodec FakeCall::GetVideoCodecVp8() {
 218   webrtc::VideoCodec vp8_codec = GetEmptyVideoCodec();
 219   vp8_codec.codecType = webrtc::kVideoCodecVP8;
 220   rtc::strcpyn(
 221       vp8_codec.plName, ARRAY_SIZE(vp8_codec.plName), kVp8Codec.name.c_str());
 222   vp8_codec.plType = kVp8Codec.id;
 223
 224   return vp8_codec;
 225 }
 226
 227 webrtc::VideoCodec FakeCall::GetVideoCodecVp9() {
 228   webrtc::VideoCodec vp9_codec = GetEmptyVideoCodec();
 229   // TODO(pbos): Add a correct codecType when webrtc has one.
 230   vp9_codec.codecType = webrtc::kVideoCodecVP8;
 231   rtc::strcpyn(
 232       vp9_codec.plName, ARRAY_SIZE(vp9_codec.plName), kVp9Codec.name.c_str());
 233   vp9_codec.plType = kVp9Codec.id;
 234
 235   return vp9_codec;
 236 }
 237
 238 std::vector<webrtc::VideoCodec> FakeCall::GetDefaultVideoCodecs() {
 239   std::vector<webrtc::VideoCodec> codecs;
 240   codecs.push_back(GetVideoCodecVp8());
 241   //    codecs.push_back(GetVideoCodecVp9());
 242
 243   return codecs;
 244 }
 245
 246 webrtc::Call::NetworkState FakeCall::GetNetworkState() const {
 247   return network_state_;
 248 }
 249
 250 webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
 251     const webrtc::VideoSendStream::Config& config,
 252     const webrtc::VideoEncoderConfig& encoder_config) {
 253   FakeVideoSendStream* fake_stream =
 254       new FakeVideoSendStream(config, encoder_config);
 255   video_send_streams_.push_back(fake_stream);
 256   return fake_stream;
 257 }
 258
 259 void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
 260   FakeVideoSendStream* fake_stream =
 261       static_cast<FakeVideoSendStream*>(send_stream);
 262   for (size_t i = 0; i < video_send_streams_.size(); ++i) {
 263     if (video_send_streams_[i] == fake_stream) {
 264       delete video_send_streams_[i];
 265       video_send_streams_.erase(video_send_streams_.begin() + i);
 266       return;
 267     }
 268   }
 269   ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter.";
 270 }
 271
 272 webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
 273     const webrtc::VideoReceiveStream::Config& config) {
 274   video_receive_streams_.push_back(new FakeVideoReceiveStream(config));
 275   return video_receive_streams_[video_receive_streams_.size() - 1];
 276 }
 277
 278 void FakeCall::DestroyVideoReceiveStream(
 279     webrtc::VideoReceiveStream* receive_stream) {
 280   FakeVideoReceiveStream* fake_stream =
 281       static_cast<FakeVideoReceiveStream*>(receive_stream);
 282   for (size_t i = 0; i < video_receive_streams_.size(); ++i) {
 283     if (video_receive_streams_[i] == fake_stream) {
 284       delete video_receive_streams_[i];
 285       video_receive_streams_.erase(video_receive_streams_.begin() + i);
 286       return;
 287     }
 288   }
 289   ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter.";
 290 }
 291
 292 webrtc::PacketReceiver* FakeCall::Receiver() {
 293   // TODO(pbos): Fix this.
 294   return NULL;
 295 }
 296
 297 webrtc::Call::Stats FakeCall::GetStats() const {
 298   webrtc::Call::Stats stats;
 299   return stats;
 300 }
 301
 302 void FakeCall::SignalNetworkState(webrtc::Call::NetworkState state) {
 303   network_state_ = state;
 304 }
 305
 306 class WebRtcVideoEngine2Test : public ::testing::Test {
 307  public:
 308   WebRtcVideoEngine2Test() {
 309     std::vector<VideoCodec> engine_codecs = engine_.codecs();
 310     assert(!engine_codecs.empty());
 311     bool codec_set = false;
 312     for (size_t i = 0; i < engine_codecs.size(); ++i) {
 313       if (engine_codecs[i].name == "red") {
 314         default_red_codec_ = engine_codecs[i];
 315       } else if (engine_codecs[i].name == "ulpfec") {
 316         default_ulpfec_codec_ = engine_codecs[i];
 317       } else if (engine_codecs[i].name == "rtx") {
 318         default_rtx_codec_ = engine_codecs[i];
 319       } else if (!codec_set) {
 320         default_codec_ = engine_codecs[i];
 321         codec_set = true;
 322       }
 323     }
 324
 325     assert(codec_set);
 326   }
 327
 328  protected:
 329   class FakeCallFactory : public WebRtcCallFactory {
 330    public:
 331     FakeCallFactory() : fake_call_(NULL) {}
 332     FakeCall* GetCall() { return fake_call_; }
 333
 334    private:
 335     virtual webrtc::Call* CreateCall(
 336         const webrtc::Call::Config& config) OVERRIDE {
 337       assert(fake_call_ == NULL);
 338       fake_call_ = new FakeCall(config);
 339       return fake_call_;
 340     }
 341
 342     FakeCall* fake_call_;
 343   };
 344
 345   VideoMediaChannel* SetUpForExternalEncoderFactory(
 346       cricket::WebRtcVideoEncoderFactory* encoder_factory,
 347       const std::vector<VideoCodec>& codecs);
 348
 349   VideoMediaChannel* SetUpForExternalDecoderFactory(
 350       cricket::WebRtcVideoDecoderFactory* decoder_factory,
 351       const std::vector<VideoCodec>& codecs);
 352
 353   void TestStartBitrate(bool override_start_bitrate, int start_bitrate_bps);
 354
 355   WebRtcVideoEngine2 engine_;
 356   VideoCodec default_codec_;
 357   VideoCodec default_red_codec_;
 358   VideoCodec default_ulpfec_codec_;
 359   VideoCodec default_rtx_codec_;
 360 };
 361
 362 TEST_F(WebRtcVideoEngine2Test, ConfiguresAvSyncForFirstReceiveChannel) {
 363   FakeCallFactory call_factory;
 364   engine_.SetCallFactory(&call_factory);
 365
 366   WebRtcVoiceEngine voice_engine;
 367   engine_.SetVoiceEngine(&voice_engine);
 368   voice_engine.Init(rtc::Thread::Current());
 369   engine_.Init(rtc::Thread::Current());
 370
 371   rtc::scoped_ptr<VoiceMediaChannel> voice_channel(
 372       voice_engine.CreateChannel());
 373   ASSERT_TRUE(voice_channel.get() != NULL);
 374   WebRtcVoiceMediaChannel* webrtc_voice_channel =
 375       static_cast<WebRtcVoiceMediaChannel*>(voice_channel.get());
 376   ASSERT_NE(webrtc_voice_channel->voe_channel(), -1);
 377   rtc::scoped_ptr<VideoMediaChannel> channel(
 378       engine_.CreateChannel(cricket::VideoOptions(), voice_channel.get()));
 379
 380   FakeCall* fake_call = call_factory.GetCall();
 381   ASSERT_TRUE(fake_call != NULL);
 382
 383   webrtc::Call::Config call_config = fake_call->GetConfig();
 384
 385   ASSERT_TRUE(voice_engine.voe()->engine() != NULL);
 386   ASSERT_EQ(voice_engine.voe()->engine(), call_config.voice_engine);
 387
 388   EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc)));
 389   EXPECT_TRUE(channel->AddRecvStream(StreamParams::CreateLegacy(kSsrc + 1)));
 390   std::vector<FakeVideoReceiveStream*> receive_streams =
 391       fake_call->GetVideoReceiveStreams();
 392
 393   ASSERT_EQ(2u, receive_streams.size());
 394   EXPECT_EQ(webrtc_voice_channel->voe_channel(),
 395             receive_streams[0]->GetConfig().audio_channel_id);
 396   EXPECT_EQ(-1, receive_streams[1]->GetConfig().audio_channel_id)
 397       << "AV sync should only be set up for the first receive channel.";
 398 }
 399
 400 TEST_F(WebRtcVideoEngine2Test, FindCodec) {
 401   const std::vector<cricket::VideoCodec>& c = engine_.codecs();
 402   EXPECT_EQ(4U, c.size());
 403
 404   cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0);
 405   EXPECT_TRUE(engine_.FindCodec(vp8));
 406
 407   cricket::VideoCodec vp8_ci(104, "vp8", 320, 200, 30, 0);
 408   EXPECT_TRUE(engine_.FindCodec(vp8));
 409
 410   cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50);
 411   EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref));
 412
 413   cricket::VideoCodec vp8_diff_id(95, "VP8", 320, 200, 30, 0);
 414   EXPECT_FALSE(engine_.FindCodec(vp8_diff_id));
 415   vp8_diff_id.id = 97;
 416   EXPECT_TRUE(engine_.FindCodec(vp8_diff_id));
 417
 418   // FindCodec ignores the codec size.
 419   // Test that FindCodec can accept uncommon codec size.
 420   cricket::VideoCodec vp8_diff_res(104, "VP8", 320, 111, 30, 0);
 421   EXPECT_TRUE(engine_.FindCodec(vp8_diff_res));
 422
 423   // PeerConnection doesn't negotiate the resolution at this point.
 424   // Test that FindCodec can handle the case when width/height is 0.
 425   cricket::VideoCodec vp8_zero_res(104, "VP8", 0, 0, 30, 0);
 426   EXPECT_TRUE(engine_.FindCodec(vp8_zero_res));
 427
 428   cricket::VideoCodec red(101, "RED", 0, 0, 30, 0);
 429   EXPECT_TRUE(engine_.FindCodec(red));
 430
 431   cricket::VideoCodec red_ci(101, "red", 0, 0, 30, 0);
 432   EXPECT_TRUE(engine_.FindCodec(red));
 433
 434   cricket::VideoCodec fec(102, "ULPFEC", 0, 0, 30, 0);
 435   EXPECT_TRUE(engine_.FindCodec(fec));
 436
 437   cricket::VideoCodec fec_ci(102, "ulpfec", 0, 0, 30, 0);
 438   EXPECT_TRUE(engine_.FindCodec(fec));
 439
 440   cricket::VideoCodec rtx(96, "rtx", 0, 0, 30, 0);
 441   EXPECT_TRUE(engine_.FindCodec(rtx));
 442 }
 443
 444 TEST_F(WebRtcVideoEngine2Test, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
 445   std::vector<VideoCodec> engine_codecs = engine_.codecs();
 446   for (size_t i = 0; i < engine_codecs.size(); ++i) {
 447     if (engine_codecs[i].name != kRtxCodecName)
 448       continue;
 449     int associated_payload_type;
 450     EXPECT_TRUE(engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
 451                                           &associated_payload_type));
 452     EXPECT_EQ(default_codec_.id, associated_payload_type);
 453     return;
 454   }
 455   FAIL() << "No RTX codec found among default codecs.";
 456 }
 457
 458 TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
 459   std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
 460   ASSERT_FALSE(extensions.empty());
 461   for (size_t i = 0; i < extensions.size(); ++i) {
 462     if (extensions[i].uri == kRtpTimestampOffsetHeaderExtension) {
 463       EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extensions[i].id);
 464       return;
 465     }
 466   }
 467   FAIL() << "Timestamp offset extension not in header-extension list.";
 468 }
 469
 470 TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
 471   std::vector<RtpHeaderExtension> extensions = engine_.rtp_header_extensions();
 472   ASSERT_FALSE(extensions.empty());
 473   for (size_t i = 0; i < extensions.size(); ++i) {
 474     if (extensions[i].uri == kRtpAbsoluteSenderTimeHeaderExtension) {
 475       EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId,
 476                 extensions[i].id);
 477       return;
 478     }
 479   }
 480   FAIL() << "Absolute Sender Time extension not in header-extension list.";
 481 }
 482
 483 void WebRtcVideoEngine2Test::TestStartBitrate(bool override_start_bitrate,
 484                                               int start_bitrate_bps) {
 485   FakeCallFactory call_factory;
 486   engine_.SetCallFactory(&call_factory);
 487
 488   engine_.Init(rtc::Thread::Current());
 489
 490   cricket::VideoOptions options;
 491   if (override_start_bitrate) {
 492     options.video_start_bitrate.Set(start_bitrate_bps / 1000);
 493   }
 494
 495   rtc::scoped_ptr<VideoMediaChannel> channel(
 496       engine_.CreateChannel(options, NULL));
 497
 498   EXPECT_EQ(override_start_bitrate
 499                 ? start_bitrate_bps
 500                 : webrtc::Call::Config::kDefaultStartBitrateBps,
 501             call_factory.GetCall()->GetConfig().stream_start_bitrate_bps);
 502 }
 503
 504 TEST_F(WebRtcVideoEngine2Test, UsesCorrectDefaultStartBitrate) {
 505   TestStartBitrate(false, -1);
 506 }
 507
 508 TEST_F(WebRtcVideoEngine2Test, CreateChannelCanUseIncreasedStartBitrate) {
 509   TestStartBitrate(true, 2 * webrtc::Call::Config::kDefaultStartBitrateBps);
 510 }
 511
 512 TEST_F(WebRtcVideoEngine2Test, CreateChannelCanUseDecreasedStartBitrate) {
 513   TestStartBitrate(true, webrtc::Call::Config::kDefaultStartBitrateBps / 2);
 514 }
 515
 516 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
 517   engine_.Init(rtc::Thread::Current());
 518   rtc::scoped_ptr<VideoMediaChannel> channel(
 519       engine_.CreateChannel(cricket::VideoOptions(), NULL));
 520
 521   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 522
 523   EXPECT_FALSE(channel->SetSend(true))
 524       << "Channel should not start without codecs.";
 525   EXPECT_TRUE(channel->SetSend(false))
 526       << "Channel should be stoppable even without set codecs.";
 527 }
 528
 529 TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
 530   engine_.Init(rtc::Thread::Current());
 531   rtc::scoped_ptr<VideoMediaChannel> channel(
 532       engine_.CreateChannel(cricket::VideoOptions(), NULL));
 533   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 534   VideoMediaInfo info;
 535   channel->GetStats(&info);
 536 }
 537
 538 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
 539   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
 540   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
 541   std::vector<cricket::VideoCodec> codecs;
 542   codecs.push_back(kVp8Codec);
 543
 544   rtc::scoped_ptr<VideoMediaChannel> channel(
 545       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 546
 547   EXPECT_TRUE(
 548       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
 549   ASSERT_EQ(1u, encoder_factory.encoders().size());
 550   EXPECT_TRUE(channel->SetSend(true));
 551
 552   cricket::FakeVideoCapturer capturer;
 553   EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
 554   EXPECT_EQ(cricket::CS_RUNNING,
 555             capturer.Start(capturer.GetSupportedFormats()->front()));
 556   EXPECT_TRUE(capturer.CaptureFrame());
 557
 558   EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
 559                    kTimeout);
 560
 561   // Setting codecs of the same type should not reallocate the encoder.
 562   EXPECT_TRUE(channel->SetSendCodecs(codecs));
 563   EXPECT_EQ(1, encoder_factory.GetNumCreatedEncoders());
 564
 565   // Remove stream previously added to free the external encoder instance.
 566   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
 567   EXPECT_EQ(0u, encoder_factory.encoders().size());
 568 }
 569
 570 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
 571     cricket::WebRtcVideoEncoderFactory* encoder_factory,
 572     const std::vector<VideoCodec>& codecs) {
 573   engine_.SetExternalEncoderFactory(encoder_factory);
 574   engine_.Init(rtc::Thread::Current());
 575
 576   VideoMediaChannel* channel =
 577       engine_.CreateChannel(cricket::VideoOptions(), NULL);
 578   EXPECT_TRUE(channel->SetSendCodecs(codecs));
 579
 580   return channel;
 581 }
 582
 583 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
 584     cricket::WebRtcVideoDecoderFactory* decoder_factory,
 585     const std::vector<VideoCodec>& codecs) {
 586   engine_.SetExternalDecoderFactory(decoder_factory);
 587   engine_.Init(rtc::Thread::Current());
 588
 589   VideoMediaChannel* channel =
 590       engine_.CreateChannel(cricket::VideoOptions(), NULL);
 591   EXPECT_TRUE(channel->SetRecvCodecs(codecs));
 592
 593   return channel;
 594 }
 595
 596 TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
 597   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
 598   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
 599   std::vector<cricket::VideoCodec> codecs;
 600   codecs.push_back(kH264Codec);
 601
 602   rtc::scoped_ptr<VideoMediaChannel> channel(
 603       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 604
 605   EXPECT_TRUE(
 606       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
 607   ASSERT_EQ(1u, encoder_factory.encoders().size());
 608
 609   codecs.clear();
 610   codecs.push_back(kVp8Codec);
 611   EXPECT_TRUE(channel->SetSendCodecs(codecs));
 612
 613   ASSERT_EQ(0u, encoder_factory.encoders().size());
 614 }
 615
 616 TEST_F(WebRtcVideoEngine2Test,
 617        DontUseExternalEncoderFactoryForUnsupportedCodecs) {
 618   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
 619   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
 620   std::vector<cricket::VideoCodec> codecs;
 621   codecs.push_back(kVp8Codec);
 622
 623   rtc::scoped_ptr<VideoMediaChannel> channel(
 624       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 625
 626   EXPECT_TRUE(
 627       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
 628   ASSERT_EQ(0u, encoder_factory.encoders().size());
 629 }
 630
 631 // Test external codec with be added to the end of the supported codec list.
 632 TEST_F(WebRtcVideoEngine2Test, ReportSupportedExternalCodecs) {
 633   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
 634   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
 635   engine_.SetExternalEncoderFactory(&encoder_factory);
 636
 637   engine_.Init(rtc::Thread::Current());
 638
 639   std::vector<cricket::VideoCodec> codecs(engine_.codecs());
 640   ASSERT_GE(codecs.size(), 2u);
 641   cricket::VideoCodec internal_codec = codecs.front();
 642   cricket::VideoCodec external_codec = codecs.back();
 643
 644   // The external codec will appear at last.
 645   EXPECT_EQ("VP8", internal_codec.name);
 646   EXPECT_EQ("H264", external_codec.name);
 647 }
 648
 649 TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
 650   cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
 651   decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
 652   std::vector<cricket::VideoCodec> codecs;
 653   codecs.push_back(kVp8Codec);
 654
 655   rtc::scoped_ptr<VideoMediaChannel> channel(
 656       SetUpForExternalDecoderFactory(&decoder_factory, codecs));
 657
 658   EXPECT_TRUE(
 659       channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
 660   ASSERT_EQ(1u, decoder_factory.decoders().size());
 661
 662   // Setting codecs of the same type should not reallocate the decoder.
 663   EXPECT_TRUE(channel->SetRecvCodecs(codecs));
 664   EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
 665
 666   // Remove stream previously added to free the external decoder instance.
 667   EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
 668   EXPECT_EQ(0u, decoder_factory.decoders().size());
 669 }
 670
 671 // Verifies that we can set up decoders that are not internally supported.
 672 TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
 673   // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
 674   // can't even query the WebRtcVideoDecoderFactory for supported codecs.
 675   // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
 676   // codecs.
 677   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
 678   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
 679   engine_.SetExternalEncoderFactory(&encoder_factory);
 680   cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
 681   decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
 682   std::vector<cricket::VideoCodec> codecs;
 683   codecs.push_back(kH264Codec);
 684
 685   rtc::scoped_ptr<VideoMediaChannel> channel(
 686       SetUpForExternalDecoderFactory(&decoder_factory, codecs));
 687
 688   EXPECT_TRUE(
 689       channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
 690   ASSERT_EQ(1u, decoder_factory.decoders().size());
 691 }
 692
 693 class WebRtcVideoEngine2BaseTest
 694     : public VideoEngineTest<cricket::WebRtcVideoEngine2> {
 695  protected:
 696   typedef VideoEngineTest<cricket::WebRtcVideoEngine2> Base;
 697 };
 698
 699 #define WEBRTC_ENGINE_BASE_TEST(test) \
 700   TEST_F(WebRtcVideoEngine2BaseTest, test) { Base::test##Body(); }
 701
 702 WEBRTC_ENGINE_BASE_TEST(ConstrainNewCodec2);
 703
 704 class WebRtcVideoChannel2BaseTest
 705     : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
 706  protected:
 707   typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
 708
 709   virtual cricket::VideoCodec DefaultCodec() OVERRIDE { return kVp8Codec; }
 710 };
 711
 712 #define WEBRTC_BASE_TEST(test) \
 713   TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); }
 714
 715 #define WEBRTC_DISABLED_BASE_TEST(test) \
 716   TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_##test) { Base::test(); }
 717
 718 // TODO(pbos): Fix WebRtcVideoEngine2BaseTest, where we want CheckCoInitialize.
 719 #if 0
 720 // TODO(juberti): Figure out why ViE is munging the COM refcount.
 721 #ifdef WIN32
 722 WEBRTC_DISABLED_BASE_TEST(CheckCoInitialize) {
 723   Base::CheckCoInitialize();
 724 }
 725 #endif
 726 #endif
 727
 728 WEBRTC_BASE_TEST(SetSend);
 729 WEBRTC_BASE_TEST(SetSendWithoutCodecs);
 730 WEBRTC_BASE_TEST(SetSendSetsTransportBufferSizes);
 731
 732 WEBRTC_BASE_TEST(GetStats);
 733 WEBRTC_BASE_TEST(GetStatsMultipleRecvStreams);
 734 WEBRTC_BASE_TEST(GetStatsMultipleSendStreams);
 735
 736 WEBRTC_BASE_TEST(SetSendBandwidth);
 737
 738 WEBRTC_BASE_TEST(SetSendSsrc);
 739 WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
 740
 741 WEBRTC_BASE_TEST(SetRenderer);
 742 WEBRTC_BASE_TEST(AddRemoveRecvStreams);
 743
 744 WEBRTC_DISABLED_BASE_TEST(AddRemoveRecvStreamAndRender);
 745
 746 WEBRTC_BASE_TEST(AddRemoveRecvStreamsNoConference);
 747
 748 WEBRTC_BASE_TEST(AddRemoveSendStreams);
 749
 750 WEBRTC_BASE_TEST(SimulateConference);
 751
 752 WEBRTC_BASE_TEST(AddRemoveCapturer);
 753
 754 WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
 755
 756 WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
 757
 758 // TODO(pbos): Figure out why this fails so often.
 759 WEBRTC_DISABLED_BASE_TEST(HighAspectHighHeightCapturer);
 760
 761 WEBRTC_BASE_TEST(RejectEmptyStreamParams);
 762
 763 WEBRTC_BASE_TEST(AdaptResolution16x10);
 764
 765 WEBRTC_BASE_TEST(AdaptResolution4x3);
 766
 767 // TODO(juberti): Restore this test once we support sending 0 fps.
 768 WEBRTC_DISABLED_BASE_TEST(AdaptDropAllFrames);
 769 // TODO(juberti): Understand why we get decode errors on this test.
 770 WEBRTC_DISABLED_BASE_TEST(AdaptFramerate);
 771
 772 WEBRTC_BASE_TEST(SendsLowerResolutionOnSmallerFrames);
 773
 774 WEBRTC_BASE_TEST(MuteStream);
 775
 776 WEBRTC_BASE_TEST(MultipleSendStreams);
 777
 778 WEBRTC_BASE_TEST(SetSendStreamFormat0x0);
 779
 780 // TODO(zhurunz): Fix the flakey test.
 781 WEBRTC_DISABLED_BASE_TEST(SetSendStreamFormat);
 782
 783 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
 784   SendAndReceive(cricket::VideoCodec(100, "VP8", 640, 400, 30, 0));
 785 }
 786
 787 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
 788   SendAndReceive(cricket::VideoCodec(100, "VP8", 320, 200, 30, 0));
 789 }
 790
 791 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
 792   SendAndReceive(cricket::VideoCodec(100, "VP8", 160, 100, 30, 0));
 793 }
 794
 795 TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
 796   Base::TwoStreamsSendAndReceive(kVp8Codec);
 797 }
 798
 799 TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsReUseFirstStream) {
 800   Base::TwoStreamsReUseFirstStream(kVp8Codec);
 801 }
 802
 803 WEBRTC_BASE_TEST(SendManyResizeOnce);
 804
 805 // TODO(pbos): Enable and figure out why this fails (or should work).
 806 TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_SendVp8HdAndReceiveAdaptedVp8Vga) {
 807   EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
 808   EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
 809   channel_->UpdateAspectRatio(1280, 720);
 810   video_capturer_.reset(new cricket::FakeVideoCapturer);
 811   const std::vector<cricket::VideoFormat>* formats =
 812       video_capturer_->GetSupportedFormats();
 813   cricket::VideoFormat capture_format_hd = (*formats)[0];
 814   EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format_hd));
 815   EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
 816
 817   // Capture format HD -> adapt (OnOutputFormatRequest VGA) -> VGA.
 818   cricket::VideoCodec codec = kVp8Codec720p;
 819   EXPECT_TRUE(SetOneCodec(codec));
 820   codec.width /= 2;
 821   codec.height /= 2;
 822   EXPECT_TRUE(SetSend(true));
 823   EXPECT_TRUE(channel_->SetRender(true));
 824   EXPECT_EQ(0, renderer_.num_rendered_frames());
 825   EXPECT_TRUE(SendFrame());
 826   EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
 827 }
 828
 829 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test,
 830                                 public WebRtcCallFactory {
 831  public:
 832   WebRtcVideoChannel2Test() : fake_call_(NULL) {}
 833   virtual void SetUp() OVERRIDE {
 834     engine_.SetCallFactory(this);
 835     engine_.Init(rtc::Thread::Current());
 836     channel_.reset(engine_.CreateChannel(cricket::VideoOptions(), NULL));
 837     ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory.";
 838     last_ssrc_ = 123;
 839     ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
 840   }
 841
 842  protected:
 843   virtual webrtc::Call* CreateCall(
 844       const webrtc::Call::Config& config) OVERRIDE {
 845     assert(fake_call_ == NULL);
 846     fake_call_ = new FakeCall(config);
 847     return fake_call_;
 848   }
 849
 850   FakeVideoSendStream* AddSendStream() {
 851     return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
 852   }
 853
 854   FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
 855     size_t num_streams = fake_call_->GetVideoSendStreams().size();
 856     EXPECT_TRUE(channel_->AddSendStream(sp));
 857     std::vector<FakeVideoSendStream*> streams =
 858         fake_call_->GetVideoSendStreams();
 859     EXPECT_EQ(num_streams + 1, streams.size());
 860     return streams[streams.size() - 1];
 861   }
 862
 863   std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
 864     return fake_call_->GetVideoSendStreams();
 865   }
 866
 867   FakeVideoReceiveStream* AddRecvStream() {
 868     return AddRecvStream(StreamParams::CreateLegacy(++last_ssrc_));
 869   }
 870
 871   FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
 872     size_t num_streams = fake_call_->GetVideoReceiveStreams().size();
 873     EXPECT_TRUE(channel_->AddRecvStream(sp));
 874     std::vector<FakeVideoReceiveStream*> streams =
 875         fake_call_->GetVideoReceiveStreams();
 876     EXPECT_EQ(num_streams + 1, streams.size());
 877     return streams[streams.size() - 1];
 878   }
 879
 880   void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate,
 881                                           const char* max_bitrate) {
 882     std::vector<VideoCodec> codecs;
 883     codecs.push_back(kVp8Codec);
 884     codecs[0].params[kCodecParamMinBitrate] = min_bitrate;
 885     codecs[0].params[kCodecParamMaxBitrate] = max_bitrate;
 886     EXPECT_TRUE(channel_->SetSendCodecs(codecs));
 887
 888     FakeVideoSendStream* stream = AddSendStream();
 889
 890     std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
 891     ASSERT_EQ(1u, video_streams.size());
 892     EXPECT_EQ(atoi(min_bitrate), video_streams.back().min_bitrate_bps / 1000);
 893     EXPECT_EQ(atoi(max_bitrate), video_streams.back().max_bitrate_bps / 1000);
 894
 895     VideoCodec codec;
 896     EXPECT_TRUE(channel_->GetSendCodec(&codec));
 897     EXPECT_EQ(min_bitrate, codec.params[kCodecParamMinBitrate]);
 898     EXPECT_EQ(max_bitrate, codec.params[kCodecParamMaxBitrate]);
 899   }
 900
 901   void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
 902                                       const std::string& webrtc_ext) {
 903     FakeCall* call = fake_call_;
 904     // Enable extension.
 905     const int id = 1;
 906     std::vector<cricket::RtpHeaderExtension> extensions;
 907     extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
 908     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
 909
 910     FakeVideoSendStream* send_stream =
 911         AddSendStream(cricket::StreamParams::CreateLegacy(123));
 912
 913     // Verify the send extension id.
 914     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
 915     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
 916     EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
 917     // Verify call with same set of extensions returns true.
 918     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
 919     // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
 920     // receivers.
 921     EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
 922                     ->GetConfig()
 923                     .rtp.extensions.empty());
 924
 925     // Verify that existing RTP header extensions can be removed.
 926     std::vector<cricket::RtpHeaderExtension> empty_extensions;
 927     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions));
 928     ASSERT_EQ(1u, call->GetVideoSendStreams().size());
 929     send_stream = call->GetVideoSendStreams()[0];
 930     EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
 931
 932     // Verify that adding receive RTP header extensions adds them for existing
 933     // streams.
 934     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
 935     send_stream = call->GetVideoSendStreams()[0];
 936     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
 937     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
 938     EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
 939   }
 940
 941   void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
 942                                       const std::string& webrtc_ext) {
 943     FakeCall* call = fake_call_;
 944     // Enable extension.
 945     const int id = 1;
 946     std::vector<cricket::RtpHeaderExtension> extensions;
 947     extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
 948     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
 949
 950     FakeVideoReceiveStream* recv_stream =
 951         AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 952
 953     // Verify the recv extension id.
 954     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
 955     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
 956     EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
 957     // Verify call with same set of extensions returns true.
 958     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
 959
 960     // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
 961     // senders.
 962     EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
 963                     ->GetConfig()
 964                     .rtp.extensions.empty());
 965
 966     // Verify that existing RTP header extensions can be removed.
 967     std::vector<cricket::RtpHeaderExtension> empty_extensions;
 968     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions));
 969     ASSERT_EQ(1u, call->GetVideoReceiveStreams().size());
 970     recv_stream = call->GetVideoReceiveStreams()[0];
 971     EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
 972
 973     // Verify that adding receive RTP header extensions adds them for existing
 974     // streams.
 975     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
 976     recv_stream = call->GetVideoReceiveStreams()[0];
 977     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
 978     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
 979     EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
 980   }
 981
 982   void TestCpuAdaptation(bool enable_overuse);
 983
 984   FakeCall* fake_call_;
 985   rtc::scoped_ptr<VideoMediaChannel> channel_;
 986   uint32 last_ssrc_;
 987 };
 988
 989 TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
 990   EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
 991   EXPECT_TRUE(channel_->SetSend(true));
 992   cricket::VideoOptions options;
 993   options.conference_mode.Set(true);
 994   EXPECT_TRUE(channel_->SetOptions(options));
 995
 996   // Send side.
 997   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
 998   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
 999   FakeVideoSendStream* send_stream = AddSendStream(
1000       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1001
1002   ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
1003   for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
1004     EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
1005
1006   // Receiver side.
1007   FakeVideoReceiveStream* recv_stream = AddRecvStream(
1008       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1009   ASSERT_GT(recv_stream->GetConfig().rtp.rtx.size(), 0u)
1010       << "No SSRCs for RTX configured by AddRecvStream.";
1011   ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size())
1012       << "This test only works with one receive codec. Please update the test.";
1013   EXPECT_EQ(rtx_ssrcs[0],
1014             recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
1015   // TODO(pbos): Make sure we set the RTX for correct payloads etc.
1016 }
1017
1018 TEST_F(WebRtcVideoChannel2Test, RecvStreamWithRtx) {
1019   // Setup one channel with an associated RTX stream.
1020   cricket::StreamParams params =
1021       cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1022   params.AddFidSsrc(kSsrcs1[0], kRtxSsrcs1[0]);
1023   FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1024   ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
1025   EXPECT_EQ(kRtxSsrcs1[0],
1026             recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
1027 }
1028
1029 TEST_F(WebRtcVideoChannel2Test, RecvStreamNoRtx) {
1030   // Setup one channel without an associated RTX stream.
1031   cricket::StreamParams params =
1032       cricket::StreamParams::CreateLegacy(kSsrcs1[0]);
1033   FakeVideoReceiveStream* recv_stream = AddRecvStream(params);
1034   ASSERT_TRUE(recv_stream->GetConfig().rtp.rtx.empty());
1035 }
1036
1037 TEST_F(WebRtcVideoChannel2Test, NoHeaderExtesionsByDefault) {
1038   FakeVideoSendStream* send_stream =
1039       AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1040   ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
1041
1042   FakeVideoReceiveStream* recv_stream =
1043       AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
1044   ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
1045 }
1046
1047 // Test support for RTP timestamp offset header extension.
1048 TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
1049   TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1050                                  webrtc::RtpExtension::kTOffset);
1051 }
1052 TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
1053   TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
1054                                  webrtc::RtpExtension::kTOffset);
1055 }
1056
1057 // Test support for absolute send time header extension.
1058 TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
1059   TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1060                                  webrtc::RtpExtension::kAbsSendTime);
1061 }
1062 TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
1063   TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
1064                                  webrtc::RtpExtension::kAbsSendTime);
1065 }
1066
1067 TEST_F(WebRtcVideoChannel2Test,
1068        SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
1069   const int kUnsupportedId = 1;
1070   const int kTOffsetId = 2;
1071
1072   std::vector<cricket::RtpHeaderExtension> extensions;
1073   extensions.push_back(
1074       cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
1075   extensions.push_back(
1076       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
1077   EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
1078   FakeVideoSendStream* send_stream =
1079       AddSendStream(cricket::StreamParams::CreateLegacy(123));
1080
1081   // Only timestamp offset extension is set to send stream,
1082   // unsupported rtp extension is ignored.
1083   ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1084   EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
1085                send_stream->GetConfig().rtp.extensions[0].name.c_str());
1086 }
1087
1088 TEST_F(WebRtcVideoChannel2Test,
1089        SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
1090   const int kUnsupportedId = 1;
1091   const int kTOffsetId = 2;
1092
1093   std::vector<cricket::RtpHeaderExtension> extensions;
1094   extensions.push_back(
1095       cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
1096   extensions.push_back(
1097       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
1098   EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
1099   FakeVideoReceiveStream* recv_stream =
1100       AddRecvStream(cricket::StreamParams::CreateLegacy(123));
1101
1102   // Only timestamp offset extension is set to receive stream,
1103   // unsupported rtp extension is ignored.
1104   ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
1105   EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
1106                recv_stream->GetConfig().rtp.extensions[0].name.c_str());
1107 }
1108
1109 TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
1110   const size_t kNumIncorrectIds = 4;
1111   const int kIncorrectIds[kNumIncorrectIds] = {-2, -1, 15, 16};
1112   for (size_t i = 0; i < kNumIncorrectIds; ++i) {
1113     std::vector<cricket::RtpHeaderExtension> extensions;
1114     extensions.push_back(cricket::RtpHeaderExtension(
1115         webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
1116     EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions))
1117         << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1118   }
1119 }
1120
1121 TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
1122   const size_t kNumIncorrectIds = 4;
1123   const int kIncorrectIds[kNumIncorrectIds] = {-2, -1, 15, 16};
1124   for (size_t i = 0; i < kNumIncorrectIds; ++i) {
1125     std::vector<cricket::RtpHeaderExtension> extensions;
1126     extensions.push_back(cricket::RtpHeaderExtension(
1127         webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
1128     EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions))
1129         << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
1130   }
1131 }
1132
1133 TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
1134   const int id = 1;
1135   std::vector<cricket::RtpHeaderExtension> extensions;
1136   extensions.push_back(
1137       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1138   extensions.push_back(
1139       cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
1140   EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
1141
1142   // Duplicate entries are also not supported.
1143   extensions.clear();
1144   extensions.push_back(
1145       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1146   extensions.push_back(extensions.back());
1147   EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
1148 }
1149
1150 TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
1151   const int id = 1;
1152   std::vector<cricket::RtpHeaderExtension> extensions;
1153   extensions.push_back(
1154       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1155   extensions.push_back(
1156       cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
1157   EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
1158
1159   // Duplicate entries are also not supported.
1160   extensions.clear();
1161   extensions.push_back(
1162       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
1163   extensions.push_back(extensions.back());
1164   EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
1165 }
1166
1167 TEST_F(WebRtcVideoChannel2Test, DISABLED_LeakyBucketTest) {
1168   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1169 }
1170
1171 TEST_F(WebRtcVideoChannel2Test, DISABLED_BufferedModeLatency) {
1172   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1173 }
1174
1175 TEST_F(WebRtcVideoChannel2Test, DISABLED_AdditiveVideoOptions) {
1176   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1177 }
1178
1179 TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
1180   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
1181   EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
1182 }
1183
1184 TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
1185   FakeVideoReceiveStream* stream = AddRecvStream();
1186   EXPECT_TRUE(stream->GetConfig().rtp.remb);
1187 }
1188
1189 TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1190   FakeVideoReceiveStream* stream = AddRecvStream();
1191   EXPECT_TRUE(stream->GetConfig().rtp.remb);
1192
1193   // Verify that REMB is turned off when codecs without REMB are set.
1194   std::vector<VideoCodec> codecs;
1195   codecs.push_back(kVp8Codec);
1196   EXPECT_TRUE(codecs[0].feedback_params.params().empty());
1197   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1198   stream = fake_call_->GetVideoReceiveStreams()[0];
1199   EXPECT_FALSE(stream->GetConfig().rtp.remb);
1200
1201   // Verify that REMB is turned on when setting default codecs since the
1202   // default codecs have REMB enabled.
1203   EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
1204   stream = fake_call_->GetVideoReceiveStreams()[0];
1205   EXPECT_TRUE(stream->GetConfig().rtp.remb);
1206 }
1207
1208 TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
1209   VerifyCodecHasDefaultFeedbackParams(default_codec_);
1210
1211   EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
1212   EXPECT_TRUE(channel_->SetSend(true));
1213
1214   // Send side.
1215   FakeVideoSendStream* send_stream =
1216       AddSendStream(cricket::StreamParams::CreateLegacy(1));
1217   EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1218
1219   // Receiver side.
1220   FakeVideoReceiveStream* recv_stream =
1221       AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1222   EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1223
1224   // Nack history size should match between sender and receiver.
1225   EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
1226             recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1227 }
1228
1229 TEST_F(WebRtcVideoChannel2Test, NackCanBeDisabled) {
1230   std::vector<VideoCodec> codecs;
1231   codecs.push_back(kVp8Codec);
1232
1233   // Send side.
1234   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1235   FakeVideoSendStream* send_stream =
1236       AddSendStream(cricket::StreamParams::CreateLegacy(1));
1237   EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1238
1239   // Receiver side.
1240   ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
1241   FakeVideoReceiveStream* recv_stream =
1242       AddRecvStream(cricket::StreamParams::CreateLegacy(1));
1243   EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1244 }
1245
1246 TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInterop) {
1247   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1248 }
1249
1250 TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInteropReversed) {
1251   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1252 }
1253
1254 TEST_F(WebRtcVideoChannel2Test, DISABLED_HybridNackFecConference) {
1255   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1256 }
1257
1258 TEST_F(WebRtcVideoChannel2Test, DISABLED_AddRemoveRecvStreamConference) {
1259   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1260 }
1261
1262 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetRender) {
1263   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1264 }
1265
1266 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAuto) {
1267   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1268 }
1269
1270 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthAutoCapped) {
1271   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1272 }
1273
1274 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthFixed) {
1275   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1276 }
1277
1278 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthInConference) {
1279   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1280 }
1281
1282 TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1283   static const int kScreenshareMinBitrateKbps = 800;
1284   cricket::VideoCodec codec = kVp8Codec360p;
1285   std::vector<cricket::VideoCodec> codecs;
1286   codecs.push_back(codec);
1287   EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1288   VideoOptions options;
1289   options.screencast_min_bitrate.Set(kScreenshareMinBitrateKbps);
1290   channel_->SetOptions(options);
1291
1292   AddSendStream();
1293
1294   cricket::FakeVideoCapturer capturer;
1295   capturer.SetScreencast(false);
1296   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1297   cricket::VideoFormat capture_format_hd =
1298       capturer.GetSupportedFormats()->front();
1299   EXPECT_EQ(1280, capture_format_hd.width);
1300   EXPECT_EQ(720, capture_format_hd.height);
1301   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1302
1303   EXPECT_TRUE(channel_->SetSend(true));
1304
1305   EXPECT_TRUE(capturer.CaptureFrame());
1306   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1307   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1308
1309   EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1310
1311   // Verify non-screencast settings.
1312   webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1313   EXPECT_EQ(webrtc::VideoEncoderConfig::kRealtimeVideo,
1314             encoder_config.content_type);
1315   EXPECT_EQ(codec.width, encoder_config.streams.front().width);
1316   EXPECT_EQ(codec.height, encoder_config.streams.front().height);
1317   EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
1318       << "Non-screenshare shouldn't use min-transmit bitrate.";
1319
1320   capturer.SetScreencast(true);
1321   EXPECT_TRUE(capturer.CaptureFrame());
1322
1323   EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1324
1325   // Verify screencast settings.
1326   encoder_config = send_stream->GetEncoderConfig();
1327   EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare,
1328             encoder_config.content_type);
1329   EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
1330             encoder_config.min_transmit_bitrate_bps);
1331
1332   EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width);
1333   EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
1334   EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
1335
1336   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1337 }
1338
1339 TEST_F(WebRtcVideoChannel2Test,
1340        ConferenceModeScreencastConfiguresTemporalLayer) {
1341   static const int kConferenceScreencastTemporalBitrateBps = 100000;
1342   VideoOptions options;
1343   options.conference_mode.Set(true);
1344   channel_->SetOptions(options);
1345
1346   AddSendStream();
1347
1348   cricket::FakeVideoCapturer capturer;
1349   capturer.SetScreencast(true);
1350   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1351   cricket::VideoFormat capture_format_hd =
1352       capturer.GetSupportedFormats()->front();
1353   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
1354
1355   EXPECT_TRUE(channel_->SetSend(true));
1356
1357   EXPECT_TRUE(capturer.CaptureFrame());
1358   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1359   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1360
1361   webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
1362
1363   // Verify screencast settings.
1364   encoder_config = send_stream->GetEncoderConfig();
1365   EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare,
1366             encoder_config.content_type);
1367   ASSERT_EQ(1u, encoder_config.streams.size());
1368   ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size());
1369   EXPECT_EQ(kConferenceScreencastTemporalBitrateBps,
1370             encoder_config.streams[0].temporal_layer_thresholds_bps[0]);
1371
1372   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1373 }
1374
1375 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetSendSsrcAndCname) {
1376   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1377 }
1378
1379 TEST_F(WebRtcVideoChannel2Test,
1380        DISABLED_SetSendSsrcAfterCreatingReceiveChannel) {
1381   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1382 }
1383
1384 TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
1385   FakeVideoSendStream* stream = AddSendStream();
1386   EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1387 }
1388
1389 TEST_F(WebRtcVideoChannel2Test, SetOptionsWithSuspendBelowMinBitrate) {
1390   VideoOptions options;
1391   options.suspend_below_min_bitrate.Set(true);
1392   channel_->SetOptions(options);
1393
1394   FakeVideoSendStream* stream = AddSendStream();
1395   EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
1396
1397   options.suspend_below_min_bitrate.Set(false);
1398   channel_->SetOptions(options);
1399
1400   stream = fake_call_->GetVideoSendStreams()[0];
1401   EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
1402 }
1403
1404 TEST_F(WebRtcVideoChannel2Test, RedundantPayloadsDisabledByDefault) {
1405   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1406   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1407   FakeVideoSendStream* stream = AddSendStream(
1408       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1409   EXPECT_FALSE(stream->GetConfig().rtp.rtx.pad_with_redundant_payloads);
1410 }
1411
1412 TEST_F(WebRtcVideoChannel2Test, SetOptionsWithPayloadPadding) {
1413   VideoOptions options;
1414   options.use_payload_padding.Set(true);
1415   channel_->SetOptions(options);
1416
1417   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1418   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1419   FakeVideoSendStream* stream = AddSendStream(
1420       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1421   EXPECT_TRUE(stream->GetConfig().rtp.rtx.pad_with_redundant_payloads);
1422
1423   options.use_payload_padding.Set(false);
1424   channel_->SetOptions(options);
1425
1426   stream = fake_call_->GetVideoSendStreams()[0];
1427   EXPECT_FALSE(stream->GetConfig().rtp.rtx.pad_with_redundant_payloads);
1428 }
1429
1430 TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1431   FakeVideoSendStream* stream = AddSendStream();
1432   webrtc::VideoCodecVP8 vp8_settings;
1433   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1434   EXPECT_TRUE(vp8_settings.denoisingOn);
1435 }
1436
1437 TEST_F(WebRtcVideoChannel2Test, SetOptionsWithDenoising) {
1438   VideoOptions options;
1439   options.video_noise_reduction.Set(false);
1440   channel_->SetOptions(options);
1441
1442   FakeVideoSendStream* stream = AddSendStream();
1443   webrtc::VideoCodecVP8 vp8_settings;
1444   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1445   EXPECT_FALSE(vp8_settings.denoisingOn);
1446
1447   options.video_noise_reduction.Set(true);
1448   channel_->SetOptions(options);
1449
1450   stream = fake_call_->GetVideoSendStreams()[0];
1451   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1452   EXPECT_TRUE(vp8_settings.denoisingOn);
1453 }
1454
1455 TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) {
1456   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1457 }
1458
1459 TEST_F(WebRtcVideoChannel2Test, DISABLED_SendReceiveBitratesStats) {
1460   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1461 }
1462
1463 TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruse) {
1464   TestCpuAdaptation(true);
1465 }
1466
1467 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
1468   TestCpuAdaptation(false);
1469 }
1470
1471 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse) {
1472   cricket::VideoCodec codec = kVp8Codec720p;
1473   std::vector<cricket::VideoCodec> codecs;
1474   codecs.push_back(codec);
1475   EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1476
1477   if (enable_overuse) {
1478     VideoOptions options;
1479     options.cpu_overuse_detection.Set(true);
1480     channel_->SetOptions(options);
1481   }
1482
1483   AddSendStream();
1484
1485   cricket::FakeVideoCapturer capturer;
1486   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
1487   EXPECT_EQ(cricket::CS_RUNNING,
1488             capturer.Start(capturer.GetSupportedFormats()->front()));
1489
1490   EXPECT_TRUE(channel_->SetSend(true));
1491
1492   // Trigger overuse.
1493   webrtc::LoadObserver* overuse_callback =
1494       fake_call_->GetConfig().overuse_callback;
1495   ASSERT_TRUE(overuse_callback != NULL);
1496   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
1497
1498   EXPECT_TRUE(capturer.CaptureFrame());
1499   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
1500   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1501
1502   EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
1503
1504   if (enable_overuse) {
1505     EXPECT_LT(send_stream->GetLastWidth(), codec.width);
1506     EXPECT_LT(send_stream->GetLastHeight(), codec.height);
1507   } else {
1508     EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1509     EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1510   }
1511
1512   // Trigger underuse which should go back to normal resolution.
1513   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
1514   EXPECT_TRUE(capturer.CaptureFrame());
1515
1516   EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
1517
1518   EXPECT_EQ(codec.width, send_stream->GetLastWidth());
1519   EXPECT_EQ(codec.height, send_stream->GetLastHeight());
1520
1521   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
1522 }
1523
1524 TEST_F(WebRtcVideoChannel2Test, DISABLED_WebRtcShouldLog) {
1525   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1526 }
1527
1528 TEST_F(WebRtcVideoChannel2Test, DISABLED_WebRtcShouldNotLog) {
1529   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1530 }
1531
1532 TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
1533   ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
1534
1535   VideoCodec codec;
1536   EXPECT_TRUE(channel_->GetSendCodec(&codec));
1537   EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
1538
1539   // Using a RTX setup to verify that the default RTX payload type is good.
1540   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
1541   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
1542   FakeVideoSendStream* stream = AddSendStream(
1543       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
1544   webrtc::VideoSendStream::Config config = stream->GetConfig();
1545
1546   // Make sure NACK and FEC are enabled on the correct payload types.
1547   EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
1548   EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
1549   EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
1550
1551   EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
1552   EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
1553   EXPECT_EQ(static_cast<int>(default_rtx_codec_.id),
1554             config.rtp.rtx.payload_type);
1555   // TODO(juberti): Check RTCP, PLI, TMMBR.
1556 }
1557
1558 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
1559   std::vector<VideoCodec> codecs;
1560   codecs.push_back(kVp8Codec);
1561   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1562
1563   FakeVideoSendStream* stream = AddSendStream();
1564   webrtc::VideoSendStream::Config config = stream->GetConfig();
1565
1566   EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
1567   EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
1568 }
1569
1570 TEST_F(WebRtcVideoChannel2Test,
1571        SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
1572   std::vector<VideoCodec> codecs;
1573   cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
1574   codecs.push_back(rtx_codec);
1575   EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1576       << "RTX codec without associated payload type should be rejected.";
1577 }
1578
1579 TEST_F(WebRtcVideoChannel2Test,
1580        SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
1581   std::vector<VideoCodec> codecs;
1582   cricket::VideoCodec rtx_codec =
1583       cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
1584   codecs.push_back(kVp8Codec);
1585   codecs.push_back(rtx_codec);
1586   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1587
1588   cricket::VideoCodec rtx_codec2 =
1589       cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
1590   codecs.pop_back();
1591   codecs.push_back(rtx_codec2);
1592   EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1593       << "RTX without matching video codec should be rejected.";
1594 }
1595
1596 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
1597   std::vector<VideoCodec> codecs;
1598   codecs.push_back(kVp8Codec);
1599   codecs.push_back(kUlpfecCodec);
1600   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1601
1602   FakeVideoSendStream* stream = AddSendStream();
1603   webrtc::VideoSendStream::Config config = stream->GetConfig();
1604
1605   EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
1606
1607   codecs.pop_back();
1608   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1609   stream = fake_call_->GetVideoSendStreams()[0];
1610   ASSERT_TRUE(stream != NULL);
1611   config = stream->GetConfig();
1612   EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
1613       << "SetSendCodec without FEC should disable current FEC.";
1614 }
1615
1616 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
1617   std::vector<VideoCodec> codecs;
1618   codecs.push_back(kVp8Codec720p);
1619   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1620
1621   std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
1622   EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
1623   EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
1624
1625   codecs.clear();
1626   codecs.push_back(kVp8Codec360p);
1627   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1628   streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
1629   EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
1630   EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
1631 }
1632
1633 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMinMaxBitrate) {
1634   SetSendCodecsShouldWorkForBitrates("100", "200");
1635 }
1636
1637 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
1638   std::vector<VideoCodec> video_codecs = engine_.codecs();
1639   video_codecs[0].params[kCodecParamMinBitrate] = "300";
1640   video_codecs[0].params[kCodecParamMaxBitrate] = "200";
1641   EXPECT_FALSE(channel_->SetSendCodecs(video_codecs));
1642 }
1643
1644 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptLargeMinMaxBitrate) {
1645   SetSendCodecsShouldWorkForBitrates("1000", "2000");
1646 }
1647
1648 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
1649   static const char* kMaxQuantization = "21";
1650   std::vector<VideoCodec> codecs;
1651   codecs.push_back(kVp8Codec);
1652   codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
1653   EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1654   EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
1655             AddSendStream()->GetVideoStreams().back().max_qp);
1656
1657   VideoCodec codec;
1658   EXPECT_TRUE(channel_->GetSendCodec(&codec));
1659   EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
1660 }
1661
1662 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
1663   std::vector<cricket::VideoCodec> codecs;
1664   codecs.push_back(kVp8Codec);
1665
1666   codecs[0].width = 0;
1667   EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1668       << "Codec set though codec width is zero.";
1669
1670   codecs[0].width = kVp8Codec.width;
1671   codecs[0].height = 0;
1672   EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1673       << "Codec set though codec height is zero.";
1674 }
1675
1676 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
1677   // TODO(pbos): Should we only allow the dynamic range?
1678   static const size_t kNumIncorrectPayloads = 4;
1679   static const int kIncorrectPayloads[kNumIncorrectPayloads] = {
1680       -2, -1, 128, 129};
1681   std::vector<cricket::VideoCodec> codecs;
1682   codecs.push_back(kVp8Codec);
1683   for (size_t i = 0; i < kNumIncorrectPayloads; ++i) {
1684     int payload_type = kIncorrectPayloads[i];
1685     codecs[0].id = payload_type;
1686     EXPECT_FALSE(channel_->SetSendCodecs(codecs))
1687         << "Bad payload type '" << payload_type << "' accepted.";
1688   }
1689 }
1690
1691 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
1692   std::vector<cricket::VideoCodec> codecs;
1693   codecs.push_back(kVp8Codec);
1694   for (int payload_type = 0; payload_type <= 127; ++payload_type) {
1695     codecs[0].id = payload_type;
1696     EXPECT_TRUE(channel_->SetSendCodecs(codecs))
1697         << "Payload type '" << payload_type << "' rejected.";
1698   }
1699 }
1700
1701 TEST_F(WebRtcVideoChannel2Test, DISABLED_ResetVieSendCodecOnNewFrameSize) {
1702   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1703 }
1704
1705 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
1706   std::vector<cricket::VideoCodec> codecs;
1707   codecs.push_back(kVp8Codec);
1708   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1709 }
1710
1711 // Test that we set our inbound RTX codecs properly.
1712 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
1713   std::vector<cricket::VideoCodec> codecs;
1714   codecs.push_back(kVp8Codec);
1715   cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
1716   codecs.push_back(rtx_codec);
1717   EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
1718       << "RTX codec without associated payload should be rejected.";
1719
1720   codecs[1].SetParam("apt", kVp8Codec.id + 1);
1721   EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
1722       << "RTX codec with invalid associated payload type should be rejected.";
1723
1724   codecs[1].SetParam("apt", kVp8Codec.id);
1725   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1726
1727   cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0);
1728   rtx_codec2.SetParam("apt", rtx_codec.id);
1729   codecs.push_back(rtx_codec2);
1730
1731   EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) << "RTX codec with another RTX "
1732                                                    "as associated payload type "
1733                                                    "should be rejected.";
1734 }
1735
1736 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
1737   std::vector<cricket::VideoCodec> codecs;
1738   codecs.push_back(kVp8Codec);
1739   codecs[0].id = 99;
1740   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1741 }
1742
1743 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
1744   EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
1745
1746   FakeVideoReceiveStream* stream = AddRecvStream();
1747   webrtc::VideoReceiveStream::Config config = stream->GetConfig();
1748   EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
1749   EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
1750 }
1751
1752 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
1753   std::vector<VideoCodec> codecs;
1754   codecs.push_back(kVp8Codec);
1755   codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
1756   EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
1757 }
1758
1759 // TODO(pbos): Enable VP9 through external codec support
1760 TEST_F(WebRtcVideoChannel2Test,
1761        DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
1762   std::vector<VideoCodec> codecs;
1763   codecs.push_back(kVp8Codec);
1764   codecs.push_back(kVp9Codec);
1765   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1766 }
1767
1768 TEST_F(WebRtcVideoChannel2Test,
1769        DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
1770   std::vector<VideoCodec> codecs;
1771   codecs.push_back(kVp8Codec);
1772   codecs.push_back(kVp9Codec);
1773   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1774   FAIL();  // TODO(pbos): Verify that the FEC parameters are set for all codecs.
1775 }
1776
1777 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
1778   std::vector<VideoCodec> codecs;
1779   codecs.push_back(kVp8Codec);
1780   codecs.push_back(kUlpfecCodec);
1781   ASSERT_TRUE(channel_->SetSendCodecs(codecs));
1782
1783   FakeVideoReceiveStream* stream = AddRecvStream();
1784   webrtc::VideoReceiveStream::Config config = stream->GetConfig();
1785
1786   EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
1787
1788   codecs.pop_back();
1789   ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
1790   stream = fake_call_->GetVideoReceiveStreams()[0];
1791   ASSERT_TRUE(stream != NULL);
1792   config = stream->GetConfig();
1793   EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
1794       << "SetSendCodec without FEC should disable current FEC.";
1795 }
1796
1797 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
1798   std::vector<VideoCodec> codecs;
1799   codecs.push_back(kVp8Codec);
1800   codecs.push_back(kRedCodec);
1801   codecs[1].id = codecs[0].id;
1802   EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
1803 }
1804
1805 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
1806   std::vector<VideoCodec> codecs;
1807   codecs.push_back(kVp8Codec);
1808   codecs.push_back(kVp9Codec);
1809   codecs[1].id = codecs[0].id;
1810   EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
1811 }
1812
1813 TEST_F(WebRtcVideoChannel2Test,
1814        SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
1815   std::vector<VideoCodec> codecs;
1816   codecs.push_back(kVp8Codec);
1817   codecs.push_back(kVp8Codec);
1818   codecs[1].id += 1;
1819   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
1820 }
1821
1822 TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
1823   EXPECT_FALSE(AddSendStream()->IsSending());
1824 }
1825
1826 TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
1827   EXPECT_TRUE(AddRecvStream()->IsReceiving());
1828 }
1829
1830 TEST_F(WebRtcVideoChannel2Test, SetSend) {
1831   FakeVideoSendStream* stream = AddSendStream();
1832   EXPECT_FALSE(stream->IsSending());
1833
1834   // false->true
1835   EXPECT_TRUE(channel_->SetSend(true));
1836   EXPECT_TRUE(stream->IsSending());
1837   // true->true
1838   EXPECT_TRUE(channel_->SetSend(true));
1839   EXPECT_TRUE(stream->IsSending());
1840   // true->false
1841   EXPECT_TRUE(channel_->SetSend(false));
1842   EXPECT_FALSE(stream->IsSending());
1843   // false->false
1844   EXPECT_TRUE(channel_->SetSend(false));
1845   EXPECT_FALSE(stream->IsSending());
1846
1847   EXPECT_TRUE(channel_->SetSend(true));
1848   FakeVideoSendStream* new_stream = AddSendStream();
1849   EXPECT_TRUE(new_stream->IsSending())
1850       << "Send stream created after SetSend(true) not sending initially.";
1851 }
1852
1853 TEST_F(WebRtcVideoChannel2Test, DISABLED_TestSetDscpOptions) {
1854   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1855 }
1856
1857 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetOptionsWithMaxBitrate) {
1858   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
1859 }
1860
1861 TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
1862   EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState());
1863
1864   channel_->OnReadyToSend(false);
1865   EXPECT_EQ(webrtc::Call::kNetworkDown, fake_call_->GetNetworkState());
1866
1867   channel_->OnReadyToSend(true);
1868   EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState());
1869 }
1870
1871 }  // namespace cricket