Use different RTX payload types for different H264 profiles

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.
  */
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/stringutils.h"
+#include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/base/testutils.h"
 #include "webrtc/media/base/videoengine_unittest.h"
 #include "webrtc/media/engine/fakewebrtccall.h"
 #include "webrtc/media/engine/fakewebrtcvideoengine.h"
 #include "webrtc/media/engine/simulcast.h"
 #include "webrtc/media/engine/webrtcvideoengine2.h"
 #include "webrtc/media/engine/webrtcvoiceengine.h"
 #include "webrtc/test/field_trial.h"
 #include "webrtc/video_encoder.h"
@@ skipping 25 matching lines @@
   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
       cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
       cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
       cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty)));
   EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
       cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
 }
 
+// Return true if any codec in |codecs| is an RTX codec with associated payload
+// type |payload_type|.
+bool HasRtxCodec(const std::vector<cricket::VideoCodec>& codecs,
+                 int payload_type) {
+  for (const cricket::VideoCodec& codec : codecs) {
+    int associated_payload_type;
+    if (cricket::CodecNamesEq(codec.name.c_str(), "rtx") &&
+        codec.GetParam(cricket::kCodecParamAssociatedPayloadType,
+                       &associated_payload_type) &&
+        associated_payload_type == payload_type) {
+      return true;
+    }
+  }
+  return false;
+}
+
 static rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateBlackFrameBuffer(
     int width,
     int height) {
   rtc::scoped_refptr<webrtc::I420Buffer> buffer =
       webrtc::I420Buffer::Create(width, height);
   buffer->SetToBlack();
   return buffer;
 }
 
 void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
@@ skipping 294 matching lines @@
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
   EXPECT_EQ(0u, encoder_factory.encoders().size());
 }
 
 // Test that when an external encoder factory supports a codec we don't
 // internally support, we still add an RTX codec for it.
 // TODO(deadbeef): Currently this test is only effective if WebRTC is
 // built with no internal H264 support. This test should be updated
 // if/when we start adding RTX codecs for unrecognized codec names.
 TEST_F(WebRtcVideoEngine2Test, RtxCodecAddedForExternalCodec) {
+  using webrtc::H264::ProfileLevelIdToString;
+  using webrtc::H264::ProfileLevelId;
+  using webrtc::H264::kLevel1;
+  cricket::VideoCodec h264_constrained_baseline("H264");
+  h264_constrained_baseline.params[kH264FmtpProfileLevelId] =
+      *ProfileLevelIdToString(
+          ProfileLevelId(webrtc::H264::kProfileConstrainedBaseline, kLevel1));
+  cricket::VideoCodec h264_constrained_high("H264");
+  h264_constrained_high.params[kH264FmtpProfileLevelId] =
+      *ProfileLevelIdToString(
+          ProfileLevelId(webrtc::H264::kProfileConstrainedHigh, kLevel1));
+  cricket::VideoCodec h264_high("H264");
+  h264_high.params[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
+      ProfileLevelId(webrtc::H264::kProfileHigh, kLevel1));
+
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
-  encoder_factory.AddSupportedVideoCodecType("H264");
+  encoder_factory.AddSupportedVideoCodec(h264_constrained_baseline);
+  encoder_factory.AddSupportedVideoCodec(h264_constrained_high);
+  encoder_factory.AddSupportedVideoCodec(h264_high);
   engine_.SetExternalEncoderFactory(&encoder_factory);
   engine_.Init();
 
-  auto codecs = engine_.codecs();
-  // First figure out what payload type the test codec got assigned.
-  auto test_codec_it =
-      std::find_if(codecs.begin(), codecs.end(),
-                   [](const VideoCodec& c) { return c.name == "H264"; });
-  ASSERT_NE(codecs.end(), test_codec_it);
-  // Now search for an RTX codec for it.
-  EXPECT_TRUE(std::any_of(codecs.begin(), codecs.end(),
-                          [&test_codec_it](const VideoCodec& c) {
-                            int associated_payload_type;
-                            return c.name == "rtx" &&
-                                   c.GetParam(kCodecParamAssociatedPayloadType,
-                                              &associated_payload_type) &&
-                                   associated_payload_type == test_codec_it->id;
-                          }));
+  // First figure out what payload types the test codecs got assigned.
+  const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
+  // Now search for RTX codecs for them. Expect that Constrained Baseline and
+  // Constrained High got an associated RTX codec, but not High.
+  EXPECT_TRUE(HasRtxCodec(
+      codecs, FindMatchingCodec(codecs, h264_constrained_baseline)->id));
+  EXPECT_TRUE(HasRtxCodec(
+      codecs, FindMatchingCodec(codecs, h264_constrained_high)->id));
+  EXPECT_FALSE(HasRtxCodec(
+      codecs, FindMatchingCodec(codecs, h264_high)->id));
 }
 
 void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse(
     bool use_external_encoder) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType("VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp8Codec);
   std::unique_ptr<VideoMediaChannel> channel;
   FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
@@ skipping 3330 matching lines @@
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
   VerifySimulcastSettings(kVp8Codec, 1280, 720, 3, 3);
 }
 
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
   cricket::VideoCodec codec(kVp8Codec);
   VerifySimulcastSettings(codec, 541, 271, 2, 2);
 }
 }  // namespace cricket