Move rtp-specific config out of EncoderSettings.

In VideoSendStream::Config, move payload_name and payload_type from
EncoderSettings to Rtp.

EncoderSettings now contains configuration for VideoStreamEncoder only,
and should perhaps be renamed in a follow up cl. It's no longer
passed as an argument to VideoCodecInitializer::SetupCodec.

The latter then needs a different way to know the codec type,
which is provided by a new codec_type member in VideoEncoderConfig.

Bug: webrtc:8830
Change-Id: Ifcc691aef1ee6a95e43c0452c5e630d92a511cd6
Reviewed-on: https://webrtc-review.googlesource.com/62062
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22532}

call/bitrate_estimator_tests.cc

@@ -118,10 +118,9 @@ class BitrateEstimatorTest : public test::CallTest {
       video_send_config_.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
       // Encoders will be set separately per stream.
       video_send_config_.encoder_settings.encoder = nullptr;
-      video_send_config_.encoder_settings.payload_name = "FAKE";
+      video_send_config_.rtp.payload_name = "FAKE";
-      video_send_config_.encoder_settings.payload_type =
+      video_send_config_.rtp.payload_type = kFakeVideoSendPayloadType;
-          kFakeVideoSendPayloadType;
+      test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config_);
-      test::FillEncoderConfiguration(1, &video_encoder_config_);
 
       receive_config_ = VideoReceiveStream::Config(receive_transport_.get());
       // receive_config_.decoders will be set by every stream separately.
@@ -182,10 +181,8 @@ class BitrateEstimatorTest : public test::CallTest {
 
       VideoReceiveStream::Decoder decoder;
       decoder.decoder = &fake_decoder_;
-      decoder.payload_type =
+      decoder.payload_type = test_->video_send_config_.rtp.payload_type;
-          test_->video_send_config_.encoder_settings.payload_type;
+      decoder.payload_name = test_->video_send_config_.rtp.payload_name;
-      decoder.payload_name =
-          test_->video_send_config_.encoder_settings.payload_name;
       test_->receive_config_.decoders.clear();
       test_->receive_config_.decoders.push_back(decoder);
       test_->receive_config_.rtp.remote_ssrc =

call/call.cc

@@ -133,8 +133,8 @@ std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
   rtclog_config->rtcp_mode = config.rtp.rtcp_mode;
   rtclog_config->rtp_extensions = config.rtp.extensions;
 
-  rtclog_config->codecs.emplace_back(config.encoder_settings.payload_name,
+  rtclog_config->codecs.emplace_back(config.rtp.payload_name,
-                                     config.encoder_settings.payload_type,
+                                     config.rtp.payload_type,
                                      config.rtp.rtx.payload_type);
   return rtclog_config;
 }

call/rampup_tests.cc

@@ -219,7 +219,7 @@ void RampUpTester::ModifyVideoConfigs(
       recv_config.rtp.rtx_ssrc = video_rtx_ssrcs_[i];
       recv_config.rtp
           .rtx_associated_payload_types[send_config->rtp.rtx.payload_type] =
-          send_config->encoder_settings.payload_type;
+          send_config->rtp.payload_type;
     }
     ++i;
   }

call/video_config.cc

@@ -46,7 +46,8 @@ std::string VideoStream::ToString() const {
 }
 
 VideoEncoderConfig::VideoEncoderConfig()
-    : content_type(ContentType::kRealtimeVideo),
+    : codec_type(kVideoCodecUnknown),
+      content_type(ContentType::kRealtimeVideo),
       encoder_specific_settings(nullptr),
       min_transmit_bitrate_bps(0),
       max_bitrate_bps(0),
@@ -59,7 +60,9 @@ VideoEncoderConfig::~VideoEncoderConfig() = default;
 
 std::string VideoEncoderConfig::ToString() const {
   std::stringstream ss;
-  ss << "{content_type: ";
+  ss << "{codec_type: ";
+  ss << CodecTypeToPayloadString(codec_type);
+  ss << ", content_type: ";
   switch (content_type) {
     case ContentType::kRealtimeVideo:
       ss << "kRealtimeVideo";

call/video_config.h

@@ -126,6 +126,7 @@ class VideoEncoderConfig {
   ~VideoEncoderConfig();
   std::string ToString() const;
 
+  VideoCodecType codec_type;
   rtc::scoped_refptr<VideoStreamFactoryInterface> video_stream_factory;
   std::vector<SpatialLayer> spatial_layers;
   ContentType content_type;

call/video_send_stream.cc

@@ -86,9 +86,7 @@ std::string VideoSendStream::Config::ToString() const {
 
 std::string VideoSendStream::Config::EncoderSettings::ToString() const {
   std::stringstream ss;
-  ss << "{payload_name: " << payload_name;
+  ss << "{encoder: " << (encoder ? "(VideoEncoder)" : "nullptr");
-  ss << ", payload_type: " << payload_type;
-  ss << ", encoder: " << (encoder ? "(VideoEncoder)" : "nullptr");
   ss << '}';
   return ss.str();
 }
@@ -124,6 +122,8 @@ std::string VideoSendStream::Config::Rtp::ToString() const {
 
   ss << ", nack: {rtp_history_ms: " << nack.rtp_history_ms << '}';
   ss << ", ulpfec: " << ulpfec.ToString();
+  ss << ", payload_name: " << payload_name;
+  ss << ", payload_type: " << payload_type;
 
   ss << ", flexfec: {payload_type: " << flexfec.payload_type;
   ss << ", ssrc: " << flexfec.ssrc;

call/video_send_stream.h

@@ -112,17 +112,9 @@ class VideoSendStream {
 
     struct EncoderSettings {
       EncoderSettings() = default;
-      EncoderSettings(std::string payload_name,
+      explicit EncoderSettings(VideoEncoder* encoder) : encoder(encoder) {}
-                      int payload_type,
-                      VideoEncoder* encoder)
-          : payload_name(std::move(payload_name)),
-            payload_type(payload_type),
-            encoder(encoder) {}
       std::string ToString() const;
 
-      std::string payload_name;
-      int payload_type = -1;
-
       // TODO(sophiechang): Delete this field when no one is using internal
       // sources anymore.
       bool internal_source = false;
@@ -159,6 +151,16 @@ class VideoSendStream {
       // RTP header extensions to use for this send stream.
       std::vector<RtpExtension> extensions;
 
+      // TODO(nisse): For now, these are fixed, but we'd like to support
+      // changing codec without recreating the VideoSendStream. Then these
+      // fields must be removed, and association between payload type and codec
+      // must move above the per-stream level. Ownership could be with
+      // RtpTransportControllerSend, with a reference from PayloadRouter, where
+      // the latter would be responsible for mapping the codec type of encoded
+      // images to the right payload type.
+      std::string payload_name;
+      int payload_type = -1;
+
       // See NackConfig for description.
       NackConfig nack;
 

media/engine/fakewebrtccall.cc

@@ -229,19 +229,19 @@ void FakeVideoSendStream::ReconfigureVideoEncoder(
   if (config.encoder_specific_settings != NULL) {
     const unsigned char num_temporal_layers = static_cast<unsigned char>(
         video_streams_.back().num_temporal_layers.value_or(1));
-    if (config_.encoder_settings.payload_name == "VP8") {
+    if (config_.rtp.payload_name == "VP8") {
       config.encoder_specific_settings->FillVideoCodecVp8(&vpx_settings_.vp8);
       if (!video_streams_.empty()) {
         vpx_settings_.vp8.numberOfTemporalLayers = num_temporal_layers;
       }
-    } else if (config_.encoder_settings.payload_name == "VP9") {
+    } else if (config_.rtp.payload_name == "VP9") {
       config.encoder_specific_settings->FillVideoCodecVp9(&vpx_settings_.vp9);
       if (!video_streams_.empty()) {
         vpx_settings_.vp9.numberOfTemporalLayers = num_temporal_layers;
       }
     } else {
       ADD_FAILURE() << "Unsupported encoder payload: "
-                    << config_.encoder_settings.payload_name;
+                    << config_.rtp.payload_name;
     }
   }
   codec_settings_set_ = config.encoder_specific_settings != NULL;

media/engine/webrtcvideoengine.cc

@@ -1734,8 +1734,8 @@ void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
   parameters_.config.encoder_settings.internal_source =
       info.has_internal_source;
 
-  parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
+  parameters_.config.rtp.payload_name = codec_settings.codec.name;
-  parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
+  parameters_.config.rtp.payload_type = codec_settings.codec.id;
   parameters_.config.rtp.ulpfec = codec_settings.ulpfec;
   parameters_.config.rtp.flexfec.payload_type =
       codec_settings.flexfec_payload_type;
@@ -1887,6 +1887,8 @@ WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const VideoCodec& codec) const {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   webrtc::VideoEncoderConfig encoder_config;
+  encoder_config.codec_type = webrtc::PayloadStringToCodecType(codec.name);
+
   bool is_screencast = parameters_.options.is_screencast.value_or(false);
   if (is_screencast) {
     encoder_config.min_transmit_bitrate_bps =

media/engine/webrtcvideoengine_unittest.cc

@@ -133,7 +133,7 @@ rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateBlackFrameBuffer(
 void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
                                  const std::map<int, int>& rtx_types) {
   std::map<int, int>::const_iterator it;
-  it = rtx_types.find(config.encoder_settings.payload_type);
+  it = rtx_types.find(config.rtp.payload_type);
   EXPECT_TRUE(it != rtx_types.end() &&
               it->second == config.rtp.rtx.payload_type);
 

modules/video_coding/include/video_codec_initializer.h

@@ -15,7 +15,7 @@
 #include <string>
 #include <vector>
 
-#include "call/video_send_stream.h"
+#include "call/video_config.h"
 
 namespace webrtc {
 
@@ -33,7 +33,6 @@ class VideoCodecInitializer {
   // GetBitrateAllocator is called implicitly from here, no need to call again.
   static bool SetupCodec(
       const VideoEncoderConfig& config,
-      const VideoSendStream::Config::EncoderSettings settings,
       const std::vector<VideoStream>& streams,
       bool nack_enabled,
       VideoCodec* codec,
@@ -49,8 +48,6 @@ class VideoCodecInitializer {
   static VideoCodec VideoEncoderConfigToVideoCodec(
       const VideoEncoderConfig& config,
       const std::vector<VideoStream>& streams,
-      const std::string& payload_name,
-      int payload_type,
       bool nack_enabled);
 };
 

modules/video_coding/video_codec_initializer.cc

@@ -26,18 +26,15 @@ namespace webrtc {
 
 bool VideoCodecInitializer::SetupCodec(
     const VideoEncoderConfig& config,
-    const VideoSendStream::Config::EncoderSettings settings,
     const std::vector<VideoStream>& streams,
     bool nack_enabled,
     VideoCodec* codec,
     std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator) {
-  if (PayloadStringToCodecType(settings.payload_name) == kVideoCodecMultiplex) {
+  if (config.codec_type == kVideoCodecMultiplex) {
-    VideoSendStream::Config::EncoderSettings associated_codec_settings =
+    VideoEncoderConfig associated_config = config.Copy();
-        settings;
+    associated_config.codec_type = kVideoCodecVP9;
-    associated_codec_settings.payload_name =
+    if (!SetupCodec(associated_config, streams, nack_enabled, codec,
-        CodecTypeToPayloadString(kVideoCodecVP9);
+                    bitrate_allocator)) {
-    if (!SetupCodec(config, associated_codec_settings, streams, nack_enabled,
-                    codec, bitrate_allocator)) {
       RTC_LOG(LS_ERROR) << "Failed to create stereo encoder configuration.";
       return false;
     }
@@ -46,8 +43,7 @@ bool VideoCodecInitializer::SetupCodec(
   }
 
   *codec =
-      VideoEncoderConfigToVideoCodec(config, streams, settings.payload_name,
+      VideoEncoderConfigToVideoCodec(config, streams, nack_enabled);
-                                     settings.payload_type, nack_enabled);
   *bitrate_allocator = CreateBitrateAllocator(*codec);
 
   return true;
@@ -73,8 +69,6 @@ VideoCodecInitializer::CreateBitrateAllocator(const VideoCodec& codec) {
 VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
     const VideoEncoderConfig& config,
     const std::vector<VideoStream>& streams,
-    const std::string& payload_name,
-    int payload_type,
     bool nack_enabled) {
   static const int kEncoderMinBitrateKbps = 30;
   RTC_DCHECK(!streams.empty());
@@ -82,7 +76,7 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
-  video_codec.codecType = PayloadStringToCodecType(payload_name);
+  video_codec.codecType = config.codec_type;
 
   switch (config.content_type) {
     case VideoEncoderConfig::ContentType::kRealtimeVideo:
@@ -155,7 +149,9 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
       break;
   }
 
-  video_codec.plType = payload_type;
+  // TODO(nisse): The plType field should be deleted. Luckily, our
+  // callers don't need it.
+  video_codec.plType = 0;
   video_codec.numberOfSimulcastStreams =
       static_cast<unsigned char>(streams.size());
   video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;

modules/video_coding/video_codec_initializer_unittest.cc

@@ -19,8 +19,6 @@
 namespace webrtc {
 
 namespace {
-static const char* kVp8PayloadName = "VP8";
-static const int kVp8PayloadType = 100;
 static const int kDefaultWidth = 1280;
 static const int kDefaultHeight = 720;
 static const int kDefaultFrameRate = 30;
@@ -49,6 +47,8 @@ class VideoCodecInitializerTest : public ::testing::Test {
                 int num_temporal_streams,
                 bool screenshare) {
     config_ = VideoEncoderConfig();
+    config_.codec_type = type;
+
     if (screenshare) {
       config_.min_transmit_bitrate_bps = kDefaultMinTransmitBitrateBps;
       config_.content_type = VideoEncoderConfig::ContentType::kScreen;
@@ -60,8 +60,6 @@ class VideoCodecInitializerTest : public ::testing::Test {
       vp8_settings.numberOfTemporalLayers = num_temporal_streams;
       config_.encoder_specific_settings = new rtc::RefCountedObject<
           webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
-      settings_.payload_name = kVp8PayloadName;
-      settings_.payload_type = kVp8PayloadType;
     } else if (type == VideoCodecType::kVideoCodecMultiplex) {
     } else {
       ADD_FAILURE() << "Unexpected codec type: " << type;
@@ -72,8 +70,8 @@ class VideoCodecInitializerTest : public ::testing::Test {
     codec_out_ = VideoCodec();
     bitrate_allocator_out_.reset();
     temporal_layers_.clear();
-    if (!VideoCodecInitializer::SetupCodec(config_, settings_, streams_,
+    if (!VideoCodecInitializer::SetupCodec(config_, streams_, nack_enabled_,
-                                           nack_enabled_, &codec_out_,
+                                           &codec_out_,
                                            &bitrate_allocator_out_)) {
       return false;
     }
@@ -117,7 +115,6 @@ class VideoCodecInitializerTest : public ::testing::Test {
 
   // Input settings.
   VideoEncoderConfig config_;
-  VideoSendStream::Config::EncoderSettings settings_;
   std::vector<VideoStream> streams_;
   bool nack_enabled_;
 

test/call_test.cc

@@ -194,14 +194,15 @@ void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config,
   RTC_DCHECK_LE(num_video_streams + num_used_ssrcs, kNumSsrcs);
   *video_config = VideoSendStream::Config(send_transport);
   video_config->encoder_settings.encoder = &fake_encoder_;
-  video_config->encoder_settings.payload_name = "FAKE";
+  video_config->rtp.payload_name = "FAKE";
-  video_config->encoder_settings.payload_type = kFakeVideoSendPayloadType;
+  video_config->rtp.payload_type = kFakeVideoSendPayloadType;
   video_config->rtp.extensions.push_back(
       RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                    kTransportSequenceNumberExtensionId));
   video_config->rtp.extensions.push_back(RtpExtension(
       RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId));
-  FillEncoderConfiguration(num_video_streams, &video_encoder_config_);
+  FillEncoderConfiguration(kVideoCodecVP8, num_video_streams,
+                           &video_encoder_config_);
 
   for (size_t i = 0; i < num_video_streams; ++i)
     video_config->rtp.ssrcs.push_back(kVideoSendSsrcs[num_used_ssrcs + i]);
@@ -257,7 +258,7 @@ CallTest::CreateMatchingVideoReceiveConfigs(
   video_config.renderer = &fake_renderer_;
   for (size_t i = 0; i < video_send_config.rtp.ssrcs.size(); ++i) {
     VideoReceiveStream::Decoder decoder =
-        test::CreateMatchingDecoder(video_send_config.encoder_settings);
+        test::CreateMatchingDecoder(video_send_config);
     allocated_decoders_.push_back(
         std::unique_ptr<VideoDecoder>(decoder.decoder));
     video_config.decoders.clear();

test/encoder_settings.cc

@@ -78,10 +78,12 @@ std::vector<VideoStream> DefaultVideoStreamFactory::CreateEncoderStreams(
   return CreateVideoStreams(width, height, encoder_config);
 }
 
-void FillEncoderConfiguration(size_t num_streams,
+void FillEncoderConfiguration(VideoCodecType codec_type,
+                              size_t num_streams,
                               VideoEncoderConfig* configuration) {
   RTC_DCHECK_LE(num_streams, DefaultVideoStreamFactory::kMaxNumberOfStreams);
 
+  configuration->codec_type = codec_type;
   configuration->number_of_streams = num_streams;
   configuration->video_stream_factory =
       new rtc::RefCountedObject<DefaultVideoStreamFactory>();
@@ -94,17 +96,17 @@ void FillEncoderConfiguration(size_t num_streams,
 }
 
 VideoReceiveStream::Decoder CreateMatchingDecoder(
-    const VideoSendStream::Config::EncoderSettings& encoder_settings) {
+    int payload_type, const std::string& payload_name) {
   VideoReceiveStream::Decoder decoder;
-  decoder.payload_type = encoder_settings.payload_type;
+  decoder.payload_type = payload_type;
-  decoder.payload_name = encoder_settings.payload_name;
+  decoder.payload_name = payload_name;
-  if (encoder_settings.payload_name == "H264") {
+  if (payload_name == "H264") {
     decoder.decoder = H264Decoder::Create().release();
-  } else if (encoder_settings.payload_name == "VP8") {
+  } else if (payload_name == "VP8") {
     decoder.decoder = VP8Decoder::Create().release();
-  } else if (encoder_settings.payload_name == "VP9") {
+  } else if (payload_name == "VP9") {
     decoder.decoder = VP9Decoder::Create().release();
-  } else if (encoder_settings.payload_name == "multiplex") {
+  } else if (payload_name == "multiplex") {
     decoder.decoder = new MultiplexDecoderAdapter(
         new InternalDecoderFactory(), SdpVideoFormat(cricket::kVp9CodecName));
   } else {
@@ -112,5 +114,12 @@ VideoReceiveStream::Decoder CreateMatchingDecoder(
   }
   return decoder;
 }
+
+VideoReceiveStream::Decoder CreateMatchingDecoder(
+    const VideoSendStream::Config& config) {
+  return CreateMatchingDecoder(config.rtp.payload_type,
+                               config.rtp.payload_name);
+}
+
 }  // namespace test
 }  // namespace webrtc

test/encoder_settings.h

@@ -45,11 +45,14 @@ std::vector<VideoStream> CreateVideoStreams(
     int height,
     const webrtc::VideoEncoderConfig& encoder_config);
 
-void FillEncoderConfiguration(size_t num_streams,
+void FillEncoderConfiguration(VideoCodecType codec_type, size_t num_streams,
                               VideoEncoderConfig* configuration);
 
 VideoReceiveStream::Decoder CreateMatchingDecoder(
-    const VideoSendStream::Config::EncoderSettings& encoder_settings);
+    int payload_type, const std::string& payload_name);
+
+VideoReceiveStream::Decoder CreateMatchingDecoder(
+    const VideoSendStream::Config& config);
 }  // namespace test
 }  // namespace webrtc
 

video/encoder_rtcp_feedback_unittest.cc

@@ -24,13 +24,13 @@ namespace webrtc {
 class MockVideoStreamEncoder : public VideoStreamEncoder {
  public:
   explicit MockVideoStreamEncoder(SendStatisticsProxy* send_stats_proxy)
-      : VideoStreamEncoder(1,
+      : VideoStreamEncoder(
+            1,
             send_stats_proxy,
-                           VideoSendStream::Config::EncoderSettings("fake", 0,
+            VideoSendStream::Config::EncoderSettings(nullptr),
-                                                                    nullptr),
             nullptr,
-                           rtc::MakeUnique<OveruseFrameDetector>(
+            rtc::MakeUnique<OveruseFrameDetector>(CpuOveruseOptions(),
-                               CpuOveruseOptions(), nullptr)) {}
+                                                  nullptr)) {}
   ~MockVideoStreamEncoder() { Stop(); }
 
   MOCK_METHOD0(SendKeyFrame, void());

video/end_to_end_tests/codec_tests.cc

@@ -68,17 +68,17 @@ class CodecObserver : public test::EndToEndTest,
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
+    encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
     send_config->encoder_settings.encoder = encoder_.get();
-    send_config->encoder_settings.payload_name = payload_name_;
+    send_config->rtp.payload_name = payload_name_;
-    send_config->encoder_settings.payload_type =
+    send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
-        test::CallTest::kVideoSendPayloadType;
 
     (*receive_configs)[0].renderer = this;
     (*receive_configs)[0].decoders.resize(1);
     (*receive_configs)[0].decoders[0].payload_type =
-        send_config->encoder_settings.payload_type;
+        send_config->rtp.payload_type;
     (*receive_configs)[0].decoders[0].payload_name =
-        send_config->encoder_settings.payload_name;
+        send_config->rtp.payload_name;
     (*receive_configs)[0].decoders[0].decoder = decoder_.get();
   }
 

video/end_to_end_tests/extended_reports_tests.cc

@@ -132,12 +132,12 @@ class RtcpXrObserver : public test::EndToEndTest {
           new rtc::RefCountedObject<ZeroTargetVideoStreamFactory>();
 
       // Configure VP8 to be able to use simulcast.
-      send_config->encoder_settings.payload_name = "VP8";
+      send_config->rtp.payload_name = "VP8";
       (*receive_configs)[0].decoders.resize(1);
       (*receive_configs)[0].decoders[0].payload_type =
-          send_config->encoder_settings.payload_type;
+          send_config->rtp.payload_type;
       (*receive_configs)[0].decoders[0].payload_name =
-          send_config->encoder_settings.payload_name;
+          send_config->rtp.payload_name;
     }
     if (enable_target_bitrate_) {
       // TargetBitrate only signaled for screensharing.

video/end_to_end_tests/fec_tests.cc

@@ -103,10 +103,10 @@ TEST_P(FecEndToEndTest, ReceivesUlpfec) {
       // Use VP8 instead of FAKE, since the latter does not have PictureID
       // in the packetization headers.
       send_config->encoder_settings.encoder = encoder_.get();
-      send_config->encoder_settings.payload_name = "VP8";
+      send_config->rtp.payload_name = "VP8";
-      send_config->encoder_settings.payload_type = kVideoSendPayloadType;
+      send_config->rtp.payload_type = kVideoSendPayloadType;
       VideoReceiveStream::Decoder decoder =
-          test::CreateMatchingDecoder(send_config->encoder_settings);
+          test::CreateMatchingDecoder(*send_config);
       decoder_.reset(decoder.decoder);
       (*receive_configs)[0].decoders.clear();
       (*receive_configs)[0].decoders.push_back(decoder);
@@ -452,8 +452,8 @@ TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
       send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
       // Set codec to VP8, otherwise NACK/FEC hybrid will be disabled.
       send_config->encoder_settings.encoder = encoder_.get();
-      send_config->encoder_settings.payload_name = "VP8";
+      send_config->rtp.payload_name = "VP8";
-      send_config->encoder_settings.payload_type = kFakeVideoSendPayloadType;
+      send_config->rtp.payload_type = kFakeVideoSendPayloadType;
 
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
@@ -461,9 +461,9 @@ TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
 
       (*receive_configs)[0].decoders.resize(1);
       (*receive_configs)[0].decoders[0].payload_type =
-          send_config->encoder_settings.payload_type;
+          send_config->rtp.payload_type;
       (*receive_configs)[0].decoders[0].payload_name =
-          send_config->encoder_settings.payload_name;
+          send_config->rtp.payload_name;
       (*receive_configs)[0].decoders[0].decoder = decoder_.get();
     }
 

video/end_to_end_tests/histogram_tests.cc

@@ -89,7 +89,7 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
         send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
         send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
         send_config->encoder_settings.encoder = vp8_encoder_.get();
-        send_config->encoder_settings.payload_name = "VP8";
+        send_config->rtp.payload_name = "VP8";
         (*receive_configs)[0].decoders[0].payload_name = "VP8";
         (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
         (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;

video/end_to_end_tests/log_tests.cc

@@ -77,14 +77,14 @@ TEST_F(LogEndToEndTest, LogsEncodedFramesWhenRequested) {
       decoder_ = VP8Decoder::Create();
 
       send_config->post_encode_callback = this;
-      send_config->encoder_settings.payload_name = "VP8";
+      send_config->rtp.payload_name = "VP8";
       send_config->encoder_settings.encoder = encoder_.get();
 
       (*receive_configs)[0].decoders.resize(1);
       (*receive_configs)[0].decoders[0].payload_type =
-          send_config->encoder_settings.payload_type;
+          send_config->rtp.payload_type;
       (*receive_configs)[0].decoders[0].payload_name =
-          send_config->encoder_settings.payload_name;
+          send_config->rtp.payload_name;
       (*receive_configs)[0].decoders[0].decoder = decoder_.get();
     }
 

video/end_to_end_tests/multi_stream_tester.cc

@@ -72,10 +72,10 @@ void MultiStreamTester::RunTest() {
       VideoSendStream::Config send_config(sender_transport.get());
       send_config.rtp.ssrcs.push_back(ssrc);
       send_config.encoder_settings.encoder = encoders[i].get();
-      send_config.encoder_settings.payload_name = "VP8";
+      send_config.rtp.payload_name = "VP8";
-      send_config.encoder_settings.payload_type = kVideoPayloadType;
+      send_config.rtp.payload_type = kVideoPayloadType;
       VideoEncoderConfig encoder_config;
-      test::FillEncoderConfiguration(1, &encoder_config);
+      test::FillEncoderConfiguration(kVideoCodecVP8, 1, &encoder_config);
       encoder_config.max_bitrate_bps = 100000;
 
       UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]);
@@ -88,7 +88,7 @@ void MultiStreamTester::RunTest() {
       receive_config.rtp.remote_ssrc = ssrc;
       receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc;
       VideoReceiveStream::Decoder decoder =
-          test::CreateMatchingDecoder(send_config.encoder_settings);
+          test::CreateMatchingDecoder(send_config);
       allocated_decoders.push_back(
           std::unique_ptr<VideoDecoder>(decoder.decoder));
       receive_config.decoders.push_back(decoder);

video/end_to_end_tests/retransmission_tests.cc

@@ -438,7 +438,7 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
       // doesn't support FEC with NACK.
       RTC_DCHECK_EQ(1, (*receive_configs)[0].decoders.size());
       send_config->encoder_settings.encoder = encoder_.get();
-      send_config->encoder_settings.payload_name = "VP8";
+      send_config->rtp.payload_name = "VP8";
       (*receive_configs)[0].decoders[0].payload_name = "VP8";
     }
 

video/end_to_end_tests/rtp_rtcp_tests.cc

@@ -496,8 +496,8 @@ TEST_F(RtpRtcpEndToEndTest, TestFlexfecRtpStatePreservation) {
                      send_transport.get());
     encoder = VP8Encoder::Create();
     video_send_config_.encoder_settings.encoder = encoder.get();
-    video_send_config_.encoder_settings.payload_name = "VP8";
+    video_send_config_.rtp.payload_name = "VP8";
-    video_send_config_.encoder_settings.payload_type = kVideoSendPayloadType;
+    video_send_config_.rtp.payload_type = kVideoSendPayloadType;
     video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
     video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;

video/picture_id_tests.cc

@@ -308,7 +308,8 @@ void PictureIdTest::SetupEncoder(VideoEncoder* encoder,
 
     CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get());
     video_send_config_.encoder_settings.encoder = encoder;
-    video_send_config_.encoder_settings.payload_name = payload_name;
+    video_send_config_.rtp.payload_name = payload_name;
+    video_encoder_config_.codec_type = PayloadStringToCodecType(payload_name);
     video_encoder_config_.video_stream_factory =
         new rtc::RefCountedObject<VideoStreamFactory>(num_temporal_layers_);
     video_encoder_config_.number_of_streams = 1;

video/replay.cc

@@ -247,9 +247,6 @@ void RtpReplay() {
   }
   receive_config.renderer = &file_passthrough;
 
-  VideoSendStream::Config::EncoderSettings encoder_settings;
-  encoder_settings.payload_name = flags::Codec();
-  encoder_settings.payload_type = flags::MediaPayloadType();
   VideoReceiveStream::Decoder decoder;
   std::unique_ptr<DecoderBitstreamFileWriter> bitstream_writer;
   if (!flags::DecoderBitstreamFilename().empty()) {
@@ -257,7 +254,8 @@ void RtpReplay() {
         flags::DecoderBitstreamFilename().c_str()));
     receive_config.pre_decode_callback = bitstream_writer.get();
   }
-  decoder = test::CreateMatchingDecoder(encoder_settings);
+  decoder = test::CreateMatchingDecoder(flags::MediaPayloadType(),
+                                        flags::Codec());
   if (!flags::DecoderBitstreamFilename().empty()) {
     // Replace with a null decoder if we're writing the bitstream to a file
     // instead.

video/send_statistics_proxy.cc

@@ -126,7 +126,7 @@ SendStatisticsProxy::SendStatisticsProxy(
     const VideoSendStream::Config& config,
     VideoEncoderConfig::ContentType content_type)
     : clock_(clock),
-      payload_name_(config.encoder_settings.payload_name),
+      payload_name_(config.rtp.payload_name),
       rtp_config_(config.rtp),
       fallback_max_pixels_(GetFallbackMaxPixelsIfFieldTrialEnabled()),
       fallback_max_pixels_disabled_(GetFallbackMaxPixelsIfFieldTrialDisabled()),

video/video_quality_test.cc

@@ -1264,6 +1264,8 @@ void VideoQualityTest::FillScalabilitySettings(
   if (params->ss[video_idx].streams.empty() &&
       params->ss[video_idx].infer_streams) {
     webrtc::VideoEncoderConfig encoder_config;
+    encoder_config.codec_type =
+        PayloadStringToCodecType(params->video[video_idx].codec);
     encoder_config.content_type =
         params->screenshare[video_idx].enabled
             ? webrtc::VideoEncoderConfig::ContentType::kScreen
@@ -1397,9 +1399,9 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
     }
     video_send_configs_[video_idx].encoder_settings.encoder =
         video_encoders_[video_idx].get();
-    video_send_configs_[video_idx].encoder_settings.payload_name =
+    video_send_configs_[video_idx].rtp.payload_name =
         params_.video[video_idx].codec;
-    video_send_configs_[video_idx].encoder_settings.payload_type = payload_type;
+    video_send_configs_[video_idx].rtp.payload_type = payload_type;
     video_send_configs_[video_idx].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     video_send_configs_[video_idx].rtp.rtx.payload_type = kSendRtxPayloadType;
     for (size_t i = 0; i < num_video_substreams; ++i) {
@@ -1421,6 +1423,9 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
     video_send_configs_[video_idx].rtp.extensions.push_back(RtpExtension(
         RtpExtension::kVideoTimingUri, test::kVideoTimingExtensionId));
 
+    video_encoder_configs_[video_idx].codec_type =
+        PayloadStringToCodecType(params_.video[video_idx].codec);
+
     video_encoder_configs_[video_idx].min_transmit_bitrate_bps =
         params_.video[video_idx].min_transmit_bps;
 
@@ -1474,10 +1479,8 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
           i != params_.ss[video_idx].selected_stream) {
         VideoReceiveStream::Decoder decoder;
         decoder.decoder = new test::FakeDecoder();
-        decoder.payload_type =
+        decoder.payload_type = video_send_configs_[video_idx].rtp.payload_type;
-            video_send_configs_[video_idx].encoder_settings.payload_type;
+        decoder.payload_name = video_send_configs_[video_idx].rtp.payload_name;
-        decoder.payload_name =
-            video_send_configs_[video_idx].encoder_settings.payload_name;
         new_receive_configs[i].decoders.clear();
         allocated_decoders_.emplace_back(decoder.decoder);
         new_receive_configs[i].decoders.push_back(decoder);
@@ -1612,9 +1615,8 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
     thumbnail_send_config.rtp.ssrcs.push_back(kThumbnailSendSsrcStart + i);
     thumbnail_send_config.encoder_settings.encoder =
         thumbnail_encoders_.back().get();
-    thumbnail_send_config.encoder_settings.payload_name =
+    thumbnail_send_config.rtp.payload_name = params_.video[0].codec;
-        params_.video[0].codec;
+    thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8;
-    thumbnail_send_config.encoder_settings.payload_type = kPayloadTypeVP8;
     thumbnail_send_config.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     thumbnail_send_config.rtp.rtx.payload_type = kSendRtxPayloadType;
     thumbnail_send_config.rtp.rtx.ssrcs.push_back(kThumbnailRtxSsrcStart + i);
@@ -1629,6 +1631,7 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
     }
 
     VideoEncoderConfig thumbnail_encoder_config;
+    thumbnail_encoder_config.codec_type = kVideoCodecVP8;
     thumbnail_encoder_config.min_transmit_bitrate_bps = 7500;
     thumbnail_send_config.suspend_below_min_bitrate =
         params_.video[0].suspend_below_min_bitrate;
@@ -1655,7 +1658,7 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
     thumbnail_receive_config.renderer = &fake_renderer_;
 
     VideoReceiveStream::Decoder decoder =
-        test::CreateMatchingDecoder(thumbnail_send_config.encoder_settings);
+        test::CreateMatchingDecoder(thumbnail_send_config);
     allocated_decoders_.push_back(
         std::unique_ptr<VideoDecoder>(decoder.decoder));
     thumbnail_receive_config.decoders.clear();

video/video_send_stream.cc

@@ -729,7 +729,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
                                              transport->keepalive_config())),
       payload_router_(rtp_rtcp_modules_,
                       config_->rtp.ssrcs,
-                      config_->encoder_settings.payload_type,
+                      config_->rtp.payload_type,
                       suspended_payload_states),
       weak_ptr_factory_(this),
       overhead_bytes_per_packet_(0),
@@ -823,9 +823,8 @@ VideoSendStreamImpl::VideoSendStreamImpl(
     rtp_rtcp->RegisterRtcpStatisticsCallback(stats_proxy_);
     rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(stats_proxy_);
     rtp_rtcp->SetMaxRtpPacketSize(config_->rtp.max_packet_size);
-    rtp_rtcp->RegisterVideoSendPayload(
+    rtp_rtcp->RegisterVideoSendPayload(config_->rtp.payload_type,
-        config_->encoder_settings.payload_type,
+                                       config_->rtp.payload_name.c_str());
-        config_->encoder_settings.payload_name.c_str());
   }
 
   fec_controller_->SetProtectionCallback(this);
@@ -835,8 +834,8 @@ VideoSendStreamImpl::VideoSendStreamImpl(
   }
 
   RTC_DCHECK(config_->encoder_settings.encoder);
-  RTC_DCHECK_GE(config_->encoder_settings.payload_type, 0);
+  RTC_DCHECK_GE(config_->rtp.payload_type, 0);
-  RTC_DCHECK_LE(config_->encoder_settings.payload_type, 127);
+  RTC_DCHECK_LE(config_->rtp.payload_type, 127);
 
   video_stream_encoder_->SetStartBitrate(
       bitrate_allocator_->GetStartBitrate(this));
@@ -1129,8 +1128,7 @@ void VideoSendStreamImpl::ConfigureProtection() {
   // is a waste of bandwidth since FEC packets still have to be transmitted.
   // Note that this is not the case with FlexFEC.
   if (nack_enabled && IsUlpfecEnabled() &&
-      !PayloadTypeSupportsSkippingFecPackets(
+      !PayloadTypeSupportsSkippingFecPackets(config_->rtp.payload_name)) {
-          config_->encoder_settings.payload_name)) {
     RTC_LOG(LS_WARNING)
         << "Transmitting payload type without picture ID using "
            "NACK+ULPFEC is a waste of bandwidth since ULPFEC packets "
@@ -1208,7 +1206,7 @@ void VideoSendStreamImpl::ConfigureSsrcs() {
   RTC_DCHECK_GE(config_->rtp.rtx.payload_type, 0);
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetRtxSendPayloadType(config_->rtp.rtx.payload_type,
-                                    config_->encoder_settings.payload_type);
+                                    config_->rtp.payload_type);
     rtp_rtcp->SetRtxSendStatus(kRtxRetransmitted | kRtxRedundantPayloads);
   }
   if (config_->rtp.ulpfec.red_payload_type != -1 &&

video/video_send_stream_tests.cc

@@ -532,7 +532,7 @@ class UlpfecObserver : public test::EndToEndTest {
               VideoSendStreamTest::kNackRtpHistoryMs;
     }
     send_config->encoder_settings.encoder = encoder_;
-    send_config->encoder_settings.payload_name = payload_name_;
+    send_config->rtp.payload_name = payload_name_;
     send_config->rtp.ulpfec.red_payload_type =
         VideoSendStreamTest::kRedPayloadType;
     send_config->rtp.ulpfec.ulpfec_payload_type =
@@ -709,7 +709,7 @@ class FlexfecObserver : public test::EndToEndTest {
               VideoSendStreamTest::kNackRtpHistoryMs;
     }
     send_config->encoder_settings.encoder = encoder_;
-    send_config->encoder_settings.payload_name = payload_name_;
+    send_config->rtp.payload_name = payload_name_;
     if (header_extensions_enabled_) {
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
@@ -718,6 +718,7 @@ class FlexfecObserver : public test::EndToEndTest {
     } else {
       send_config->rtp.extensions.clear();
     }
+    encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
   }
 
   void PerformTest() override {
@@ -1073,7 +1074,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
       }
 
       if (!test_generic_packetization_)
-        send_config->encoder_settings.payload_name = "VP8";
+        send_config->rtp.payload_name = "VP8";
 
       send_config->encoder_settings.encoder = &encoder_;
       send_config->rtp.max_packet_size = kMaxPacketSize;
@@ -2117,7 +2118,7 @@ TEST_F(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) {
 
     video_send_config_.encoder_settings.encoder = &encoder;
     video_send_config_.encoder_settings.internal_source = true;
-    video_send_config_.encoder_settings.payload_name = "VP8";
+    video_send_config_.rtp.payload_name = "VP8";
 
     CreateVideoStreams();
   });
@@ -2491,8 +2492,9 @@ class VideoCodecConfigObserver : public test::SendTest,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder = this;
-    send_config->encoder_settings.payload_name = codec_name_;
+    send_config->rtp.payload_name = codec_name_;
 
+    encoder_config->codec_type = video_codec_type_;
     encoder_config->encoder_specific_settings = GetEncoderSpecificSettings();
     encoder_config->video_stream_factory =
         new rtc::RefCountedObject<VideoStreamFactory>();
@@ -3065,8 +3067,8 @@ class Vp9HeaderObserver : public test::SendTest {
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder = vp9_encoder_.get();
-    send_config->encoder_settings.payload_name = "VP9";
+    send_config->rtp.payload_name = "VP9";
-    send_config->encoder_settings.payload_type = kVp9PayloadType;
+    send_config->rtp.payload_type = kVp9PayloadType;
     ModifyVideoConfigsHook(send_config, receive_configs, encoder_config);
     encoder_config->encoder_specific_settings = new rtc::RefCountedObject<
       VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings_);
@@ -3389,6 +3391,7 @@ void VideoSendStreamTest::TestVp9NonFlexMode(uint8_t num_temporal_layers,
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
+      encoder_config->codec_type = kVideoCodecVP9;
       vp9_settings_.flexibleMode = false;
       vp9_settings_.frameDroppingOn = false;
       vp9_settings_.keyFrameInterval = kKeyFrameInterval;
@@ -3443,6 +3446,7 @@ TEST_F(VideoSendStreamTest, Vp9NonFlexModeSmallResolution) {
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
+      encoder_config->codec_type = kVideoCodecVP9;
       vp9_settings_.flexibleMode = false;
       vp9_settings_.numberOfTemporalLayers = 1;
       vp9_settings_.numberOfSpatialLayers = 1;
@@ -3480,6 +3484,7 @@ TEST_F(VideoSendStreamTest, MAYBE_Vp9FlexModeRefCount) {
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
+      encoder_config->codec_type = kVideoCodecVP9;
       encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
       vp9_settings_.flexibleMode = true;
       vp9_settings_.numberOfTemporalLayers = 1;

video/video_stream_encoder.cc

@@ -552,9 +552,8 @@ void VideoStreamEncoder::ReconfigureEncoder() {
   crop_height_ = last_frame_info_->height - highest_stream_height;
 
   VideoCodec codec;
-  if (!VideoCodecInitializer::SetupCodec(encoder_config_, settings_, streams,
+  if (!VideoCodecInitializer::SetupCodec(
-                                         nack_enabled_, &codec,
+          encoder_config_, streams, nack_enabled_, &codec, &rate_allocator_)) {
-                                         &rate_allocator_)) {
     RTC_LOG(LS_ERROR) << "Failed to create encoder configuration.";
   }
 

video/video_stream_encoder_unittest.cc

@@ -284,11 +284,11 @@ class VideoStreamEncoderTest : public ::testing::Test {
     metrics::Reset();
     video_send_config_ = VideoSendStream::Config(nullptr);
     video_send_config_.encoder_settings.encoder = &fake_encoder_;
-    video_send_config_.encoder_settings.payload_name = "FAKE";
+    video_send_config_.rtp.payload_name = "FAKE";
-    video_send_config_.encoder_settings.payload_type = 125;
+    video_send_config_.rtp.payload_type = 125;
 
     VideoEncoderConfig video_encoder_config;
-    test::FillEncoderConfiguration(1, &video_encoder_config);
+    test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
     video_encoder_config.video_stream_factory =
         new rtc::RefCountedObject<VideoStreamFactory>(1, max_framerate_);
     video_encoder_config_ = video_encoder_config.Copy();
@@ -325,9 +325,10 @@ class VideoStreamEncoderTest : public ::testing::Test {
                     unsigned char num_spatial_layers,
                     bool nack_enabled,
                     bool screenshare) {
-    video_send_config_.encoder_settings.payload_name = payload_name;
+    video_send_config_.rtp.payload_name = payload_name;
 
     VideoEncoderConfig video_encoder_config;
+    video_encoder_config.codec_type = PayloadStringToCodecType(payload_name);
     video_encoder_config.number_of_streams = num_streams;
     video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
     video_encoder_config.video_stream_factory =
@@ -783,7 +784,7 @@ TEST_F(VideoStreamEncoderTest,
   EXPECT_EQ(1, sink_.number_of_reconfigurations());
 
   VideoEncoderConfig video_encoder_config;
-  test::FillEncoderConfiguration(1, &video_encoder_config);
+  test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   video_encoder_config.min_transmit_bitrate_bps = 9999;
   video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
                                           kMaxPayloadLength,
@@ -2279,6 +2280,7 @@ TEST_F(VideoStreamEncoderTest, OveruseDetectorUpdatedOnReconfigureAndAdaption) {
 
   // Trigger reconfigure encoder (without resetting the entire instance).
   VideoEncoderConfig video_encoder_config;
+  video_encoder_config.codec_type = kVideoCodecVP8;
   video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
   video_encoder_config.number_of_streams = 1;
   video_encoder_config.video_stream_factory =
@@ -2330,6 +2332,7 @@ TEST_F(VideoStreamEncoderTest,
 
   // Trigger initial configuration.
   VideoEncoderConfig video_encoder_config;
+  video_encoder_config.codec_type = kVideoCodecVP8;
   video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
   video_encoder_config.number_of_streams = 1;
   video_encoder_config.video_stream_factory =
@@ -2392,6 +2395,7 @@ TEST_F(VideoStreamEncoderTest,
 
   // Trigger initial configuration.
   VideoEncoderConfig video_encoder_config;
+  video_encoder_config.codec_type = kVideoCodecVP8;
   video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
   video_encoder_config.number_of_streams = 1;
   video_encoder_config.video_stream_factory =
@@ -3185,6 +3189,7 @@ TEST_F(VideoStreamEncoderTest, AcceptsFullHdAdaptedDownSimulcastFrames) {
   video_stream_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   // Trigger reconfigure encoder (without resetting the entire instance).
   VideoEncoderConfig video_encoder_config;
+  video_encoder_config.codec_type = kVideoCodecVP8;
   video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
   video_encoder_config.number_of_streams = 1;
   video_encoder_config.video_stream_factory =