Wire up FlexFEC in VideoEngine2.

webrtc/media/engine/webrtcvideoengine2_unittest.cc

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 20 matching lines @@
 using webrtc::RtpExtension;
 
 namespace {
 static const int kDefaultQpMax = 56;
 
 static const uint8_t kRedRtxPayloadType = 125;
 
 static const uint32_t kSsrcs1[] = {1};
 static const uint32_t kSsrcs3[] = {1, 2, 3};
 static const uint32_t kRtxSsrcs1[] = {4};
+static const uint32_t kFlexfecSsrc = 5;
 static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
 static const char kUnsupportedExtensionName[] =
     "urn:ietf:params:rtp-hdrext:unsupported";
 
 cricket::VideoCodec RemoveFeedbackParams(cricket::VideoCodec&& codec) {
   codec.feedback_params = cricket::FeedbackParams();
   return codec;
 }
 
 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
@@ skipping 1880 matching lines @@
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn);
   EXPECT_FALSE(vp9_settings.frameDroppingOn);
 
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
 }
 
 class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest {
  public:
-  Vp9SettingsTestWithFieldTrial(const char* field_trials)
+  explicit Vp9SettingsTestWithFieldTrial(const char* field_trials)
       : Vp9SettingsTest(field_trials) {}
 
  protected:
   void VerifySettings(int num_spatial_layers, int num_temporal_layers) {
     cricket::VideoSendParameters parameters;
     parameters.codecs.push_back(GetEngineCodec("VP9"));
     ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
     FakeVideoSendStream* stream = SetUpSimulcast(false, false);
 
@@ skipping 327 matching lines @@
   EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
   EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
   EXPECT_EQ(GetEngineCodec("red").id, config.rtp.ulpfec.red_payload_type);
 
   EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
   EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
   VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
   // TODO(juberti): Check RTCP, PLI, TMMBR.
 }
 
+// TODO(brandtr): Remove when FlexFEC _is_ exposed by default.
+TEST_F(WebRtcVideoChannel2Test, FlexfecCodecWithoutSsrcNotExposedByDefault) {
+  FakeVideoSendStream* stream = AddSendStream();
+  webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
+
+  EXPECT_EQ(-1, config.rtp.flexfec.flexfec_payload_type);
+}
+
+// TODO(brandtr): Remove when FlexFEC _is_ exposed by default.
+TEST_F(WebRtcVideoChannel2Test, FlexfecCodecWithSsrcNotExposedByDefault) {
+  FakeVideoSendStream* stream = AddSendStream(
+      CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+  webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
+
+  EXPECT_EQ(-1, config.rtp.flexfec.flexfec_payload_type);
+}
+
+// TODO(brandtr): When FlexFEC is no longer behind a field trial, merge all
+// tests that use this test fixture into the corresponding "non-field trial"
+// tests.
+class WebRtcVideoChannel2FlexfecTest : public WebRtcVideoChannel2Test {
+ public:
+  WebRtcVideoChannel2FlexfecTest()
+      : WebRtcVideoChannel2Test("WebRTC-FlexFEC-03/Enabled/") {}
+};
+
+// TODO(brandtr): Merge into "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest, SetDefaultSendCodecsWithoutSsrc) {
+  FakeVideoSendStream* stream = AddSendStream();
+  webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
+
+  EXPECT_EQ(GetEngineCodec("flexfec-03").id,
+            config.rtp.flexfec.flexfec_payload_type);
+  EXPECT_FALSE(config.rtp.flexfec.IsCompleteAndEnabled());
+}
+
+// TODO(brandtr): Merge into "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest, SetDefaultSendCodecsWithSsrc) {
+  FakeVideoSendStream* stream = AddSendStream(
+      CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+  webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
+
+  EXPECT_EQ(GetEngineCodec("flexfec-03").id,
+            config.rtp.flexfec.flexfec_payload_type);
+  EXPECT_TRUE(config.rtp.flexfec.IsCompleteAndEnabled());
+}
+
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   FakeVideoSendStream* stream = AddSendStream();
   webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
 
   EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type);
   EXPECT_EQ(-1, config.rtp.ulpfec.red_payload_type);
 }
 
+// TODO(brandtr): Merge into "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest, SetSendCodecsWithoutFec) {
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(GetEngineCodec("VP8"));
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
+
+  FakeVideoSendStream* stream = AddSendStream();
+  webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
+
+  EXPECT_EQ(-1, config.rtp.flexfec.flexfec_payload_type);
+}
+
 TEST_F(WebRtcVideoChannel2Test,
        SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
   const int kUnusedPayloadType = 127;
   EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType));
 
   cricket::VideoSendParameters parameters;
   cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx");
   parameters.codecs.push_back(rtx_codec);
   EXPECT_FALSE(channel_->SetSendParameters(parameters))
       << "RTX codec without associated payload type should be rejected.";
@@ skipping 31 matching lines @@
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   FakeVideoSendStream* stream = AddSendStream();
   webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
 
   EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
 
   parameters.codecs.pop_back();
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
   stream = fake_call_->GetVideoSendStreams()[0];
-  ASSERT_TRUE(stream != NULL);
+  ASSERT_TRUE(stream != nullptr);
   config = stream->GetConfig().Copy();
   EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type)
-      << "SetSendCodec without FEC should disable current FEC.";
+      << "SetSendCodec without ULPFEC should disable current ULPFEC.";
+}
+
+// TODO(brandtr): Merge into "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest, SetSendCodecsWithoutFecDisablesFec) {
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(GetEngineCodec("VP8"));
+  parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
+
+  FakeVideoSendStream* stream = AddSendStream(
+      CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+  webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
+
+  EXPECT_EQ(GetEngineCodec("flexfec-03").id,
+            config.rtp.flexfec.flexfec_payload_type);
+  EXPECT_EQ(kFlexfecSsrc, config.rtp.flexfec.flexfec_ssrc);
+  ASSERT_EQ(1U, config.rtp.flexfec.protected_media_ssrcs.size());
+  EXPECT_EQ(kSsrcs1[0], config.rtp.flexfec.protected_media_ssrcs[0]);
+
+  parameters.codecs.pop_back();
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
+  stream = fake_call_->GetVideoSendStreams()[0];
+  ASSERT_TRUE(stream != nullptr);
+  config = stream->GetConfig().Copy();
+  EXPECT_EQ(-1, config.rtp.flexfec.flexfec_payload_type)
+      << "SetSendCodec without FlexFEC should disable current FlexFEC.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
   cricket::VideoSendParameters parameters;
   cricket::VideoCodec codec(100, "VP8");
   codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax);
   parameters.codecs.push_back(codec);
 
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
   channel_->SetSend(true);
@@ skipping 325 matching lines @@
 
   FakeVideoReceiveStream* stream = AddRecvStream();
 
   EXPECT_EQ(GetEngineCodec("ulpfec").id,
             stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
 
   cricket::VideoRecvParameters recv_parameters;
   recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
   ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
   stream = fake_call_->GetVideoReceiveStreams()[0];
-  ASSERT_TRUE(stream != NULL);
+  ASSERT_TRUE(stream != nullptr);
   EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
-      << "SetSendCodec without FEC should disable current FEC.";
+      << "SetSendCodec without ULPFEC should disable current ULPFEC.";
+}
+
+// TODO(brandtr): Merge into "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest, SetRecvParamsWithoutFecDisablesFec) {
+  cricket::VideoSendParameters send_parameters;
+  send_parameters.codecs.push_back(GetEngineCodec("VP8"));
+  send_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
+  ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
+
+  AddRecvStream(
+      CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+  const std::vector<FakeFlexfecReceiveStream*>& streams =
+      fake_call_->GetFlexfecReceiveStreams();
+
+  EXPECT_EQ(1U, streams.size());
+  EXPECT_EQ(GetEngineCodec("flexfec-03").id,
+            streams[0]->GetConfig().flexfec_payload_type);
+  EXPECT_EQ(kFlexfecSsrc, streams[0]->GetConfig().flexfec_ssrc);
+  ASSERT_EQ(1U, streams[0]->GetConfig().protected_media_ssrcs.size());
+  EXPECT_EQ(kSsrcs1[0], streams[0]->GetConfig().protected_media_ssrcs[0]);
+
+  cricket::VideoRecvParameters recv_parameters;
+  recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
+  ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
+  EXPECT_TRUE(streams.empty())
+      << "SetSendCodec without FlexFEC should disable current FlexFEC.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec) {
   FakeVideoReceiveStream* stream = AddRecvStream();
   EXPECT_EQ(GetEngineCodec("ulpfec").id,
             stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
 
   cricket::VideoRecvParameters recv_parameters;
   recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
   recv_parameters.codecs.push_back(GetEngineCodec("red"));
   recv_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
   ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
   stream = fake_call_->GetVideoReceiveStreams()[0];
-  ASSERT_TRUE(stream != NULL);
+  ASSERT_TRUE(stream != nullptr);
   EXPECT_EQ(GetEngineCodec("ulpfec").id,
             stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
-      << "FEC should be enabled on the receive stream.";
+      << "ULPFEC should be enabled on the receive stream.";
 
   cricket::VideoSendParameters send_parameters;
   send_parameters.codecs.push_back(GetEngineCodec("VP8"));
   send_parameters.codecs.push_back(GetEngineCodec("red"));
   send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
   ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
   stream = fake_call_->GetVideoReceiveStreams()[0];
   EXPECT_EQ(GetEngineCodec("ulpfec").id,
             stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
-      << "FEC should be enabled on the receive stream.";
+      << "ULPFEC should be enabled on the receive stream.";
+}
+
+// TODO(brandtr): Merge into "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest, SetSendParamsWithFecEnablesFec) {
+  AddRecvStream(
+      CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc));
+  const std::vector<FakeFlexfecReceiveStream*>& streams =
+      fake_call_->GetFlexfecReceiveStreams();
+
+  cricket::VideoRecvParameters recv_parameters;
+  recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
+  recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
+  ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
+  EXPECT_EQ(1U, streams.size());
+  EXPECT_EQ(GetEngineCodec("flexfec-03").id,
+            streams[0]->GetConfig().flexfec_payload_type);
+  EXPECT_EQ(kFlexfecSsrc, streams[0]->GetConfig().flexfec_ssrc);
+  EXPECT_EQ(1U, streams[0]->GetConfig().protected_media_ssrcs.size());
+  EXPECT_EQ(kSsrcs1[0], streams[0]->GetConfig().protected_media_ssrcs[0]);
+
+  cricket::VideoSendParameters send_parameters;
+  send_parameters.codecs.push_back(GetEngineCodec("VP8"));
+  send_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
+  EXPECT_EQ(1U, streams.size());
+  EXPECT_EQ(GetEngineCodec("flexfec-03").id,
+            streams[0]->GetConfig().flexfec_payload_type);
+  EXPECT_EQ(kFlexfecSsrc, streams[0]->GetConfig().flexfec_ssrc);
+  EXPECT_EQ(1U, streams[0]->GetConfig().protected_media_ssrcs.size());
+  EXPECT_EQ(kSsrcs1[0], streams[0]->GetConfig().protected_media_ssrcs[0]);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
   cricket::VideoRecvParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   parameters.codecs.push_back(GetEngineCodec("red"));
   parameters.codecs[1].id = parameters.codecs[0].id;
   EXPECT_FALSE(channel_->SetRecvParameters(parameters));
 }
 
+// TODO(brandtr): Merge into "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest,
+       SetSendCodecsRejectDuplicateFecPayloads) {
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(GetEngineCodec("VP8"));
+  parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
+  parameters.codecs[1].id = parameters.codecs[0].id;
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
+}
+
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
   cricket::VideoRecvParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   parameters.codecs.push_back(GetEngineCodec("VP9"));
   parameters.codecs[1].id = parameters.codecs[0].id;
   EXPECT_FALSE(channel_->SetRecvParameters(parameters));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
@@ skipping 619 matching lines @@
   const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
   TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
                                   false /* expect_created_receive_stream */);
 }
 
 TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
   TestReceiveUnsignaledSsrcPacket(GetEngineCodec("ulpfec").id,
                                   false /* expect_created_receive_stream */);
 }
 
+// TODO(brandtr): Change to "non-field trial" test when FlexFEC is enabled
+// by default.
+TEST_F(WebRtcVideoChannel2FlexfecTest,
+       FlexfecPacketDoesntCreateUnsignalledStream) {
+  TestReceiveUnsignaledSsrcPacket(GetEngineCodec("flexfec-03").id,
+                                  false /* expect_created_receive_stream */);
+}
+
 TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
   TestReceiveUnsignaledSsrcPacket(kRedRtxPayloadType,
                                   false /* expect_created_receive_stream */);
 }
 
 TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) {
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
   cricket::VideoFormat capture_format_hd =
       capturer.GetSupportedFormats()->front();
   EXPECT_EQ(1280, capture_format_hd.width);
   EXPECT_EQ(720, capture_format_hd.height);
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
   EXPECT_TRUE(channel_->SetSend(true));
   capturer.CaptureFrame();
 
   int default_encoder_bitrate = GetMaxEncoderBitrate();
-  EXPECT_TRUE(default_encoder_bitrate > 1000);
+  EXPECT_GT(default_encoder_bitrate, 1000);
 
   // TODO(skvlad): Resolve the inconsistency between the interpretation
   // of the global bitrate limit for audio and video:
   // - Audio: max_bandwidth_bps = 0 - fail the operation,
   //          max_bandwidth_bps = -1 - remove the bandwidth limit
   // - Video: max_bandwidth_bps = 0 - remove the bandwidth limit,
   //          max_bandwidth_bps = -1 - do not change the previously set
   //                                   limit.
 
   SetAndExpectMaxBitrate(1000, 0, 1000);
@@ skipping 404 matching lines @@
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3);
 }
 
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2);
 }
 }  // namespace cricket