diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc index b833034209..b4f808f30a 100644 --- a/call/bitrate_estimator_tests.cc +++ b/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_.encoder_settings.payload_type = - kFakeVideoSendPayloadType; - test::FillEncoderConfiguration(1, &video_encoder_config_); + video_send_config_.rtp.payload_name = "FAKE"; + video_send_config_.rtp.payload_type = kFakeVideoSendPayloadType; + test::FillEncoderConfiguration(kVideoCodecVP8, 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 = - test_->video_send_config_.encoder_settings.payload_type; - decoder.payload_name = - test_->video_send_config_.encoder_settings.payload_name; + decoder.payload_type = test_->video_send_config_.rtp.payload_type; + decoder.payload_name = test_->video_send_config_.rtp.payload_name; test_->receive_config_.decoders.clear(); test_->receive_config_.decoders.push_back(decoder); test_->receive_config_.rtp.remote_ssrc = diff --git a/call/call.cc b/call/call.cc index b3f3978ae4..f9cb72b444 100644 --- a/call/call.cc +++ b/call/call.cc @@ -133,8 +133,8 @@ std::unique_ptr 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, - config.encoder_settings.payload_type, + rtclog_config->codecs.emplace_back(config.rtp.payload_name, + config.rtp.payload_type, config.rtp.rtx.payload_type); return rtclog_config; } diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc index a93dd7957c..024124cd2c 100644 --- a/call/rampup_tests.cc +++ b/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; } diff --git a/call/video_config.cc b/call/video_config.cc index 02cfa382fa..eb32ed583e 100644 --- a/call/video_config.cc +++ b/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"; diff --git a/call/video_config.h b/call/video_config.h index e9d95146c1..162d833c82 100644 --- a/call/video_config.h +++ b/call/video_config.h @@ -126,6 +126,7 @@ class VideoEncoderConfig { ~VideoEncoderConfig(); std::string ToString() const; + VideoCodecType codec_type; rtc::scoped_refptr video_stream_factory; std::vector spatial_layers; ContentType content_type; diff --git a/call/video_send_stream.cc b/call/video_send_stream.cc index bf840d3ce7..cb857b1371 100644 --- a/call/video_send_stream.cc +++ b/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 << ", payload_type: " << payload_type; - ss << ", encoder: " << (encoder ? "(VideoEncoder)" : "nullptr"); + 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; diff --git a/call/video_send_stream.h b/call/video_send_stream.h index 440b62e4a8..b4fac51a04 100644 --- a/call/video_send_stream.h +++ b/call/video_send_stream.h @@ -112,17 +112,9 @@ class VideoSendStream { struct EncoderSettings { EncoderSettings() = default; - EncoderSettings(std::string payload_name, - int payload_type, - VideoEncoder* encoder) - : payload_name(std::move(payload_name)), - payload_type(payload_type), - encoder(encoder) {} + explicit EncoderSettings(VideoEncoder* encoder) : 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 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; diff --git a/media/engine/fakewebrtccall.cc b/media/engine/fakewebrtccall.cc index 4bc01f0dd6..0aa9cb0967 100644 --- a/media/engine/fakewebrtccall.cc +++ b/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( 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; diff --git a/media/engine/webrtcvideoengine.cc b/media/engine/webrtcvideoengine.cc index 7174524dd7..6442c44337 100644 --- a/media/engine/webrtcvideoengine.cc +++ b/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.encoder_settings.payload_type = codec_settings.codec.id; + parameters_.config.rtp.payload_name = codec_settings.codec.name; + 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 = diff --git a/media/engine/webrtcvideoengine_unittest.cc b/media/engine/webrtcvideoengine_unittest.cc index d0b570725a..57442f48c1 100644 --- a/media/engine/webrtcvideoengine_unittest.cc +++ b/media/engine/webrtcvideoengine_unittest.cc @@ -133,7 +133,7 @@ rtc::scoped_refptr CreateBlackFrameBuffer( void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config, const std::map& rtx_types) { std::map::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); diff --git a/modules/video_coding/include/video_codec_initializer.h b/modules/video_coding/include/video_codec_initializer.h index aded1f0ff7..9c5365c7c0 100644 --- a/modules/video_coding/include/video_codec_initializer.h +++ b/modules/video_coding/include/video_codec_initializer.h @@ -15,7 +15,7 @@ #include #include -#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& streams, bool nack_enabled, VideoCodec* codec, @@ -49,8 +48,6 @@ class VideoCodecInitializer { static VideoCodec VideoEncoderConfigToVideoCodec( const VideoEncoderConfig& config, const std::vector& streams, - const std::string& payload_name, - int payload_type, bool nack_enabled); }; diff --git a/modules/video_coding/video_codec_initializer.cc b/modules/video_coding/video_codec_initializer.cc index e473a16581..892113b100 100644 --- a/modules/video_coding/video_codec_initializer.cc +++ b/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& streams, bool nack_enabled, VideoCodec* codec, std::unique_ptr* bitrate_allocator) { - if (PayloadStringToCodecType(settings.payload_name) == kVideoCodecMultiplex) { - VideoSendStream::Config::EncoderSettings associated_codec_settings = - settings; - associated_codec_settings.payload_name = - CodecTypeToPayloadString(kVideoCodecVP9); - if (!SetupCodec(config, associated_codec_settings, streams, nack_enabled, - codec, bitrate_allocator)) { + if (config.codec_type == kVideoCodecMultiplex) { + VideoEncoderConfig associated_config = config.Copy(); + associated_config.codec_type = kVideoCodecVP9; + if (!SetupCodec(associated_config, 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, - settings.payload_type, nack_enabled); + VideoEncoderConfigToVideoCodec(config, streams, 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& 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(streams.size()); video_codec.minBitrate = streams[0].min_bitrate_bps / 1000; diff --git a/modules/video_coding/video_codec_initializer_unittest.cc b/modules/video_coding/video_codec_initializer_unittest.cc index 4e99fbbded..6dd82c1f05 100644 --- a/modules/video_coding/video_codec_initializer_unittest.cc +++ b/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_, - nack_enabled_, &codec_out_, + if (!VideoCodecInitializer::SetupCodec(config_, streams_, nack_enabled_, + &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 streams_; bool nack_enabled_; diff --git a/test/call_test.cc b/test/call_test.cc index 566574772c..57605de7d2 100644 --- a/test/call_test.cc +++ b/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->encoder_settings.payload_type = kFakeVideoSendPayloadType; + video_config->rtp.payload_name = "FAKE"; + 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(decoder.decoder)); video_config.decoders.clear(); diff --git a/test/encoder_settings.cc b/test/encoder_settings.cc index 83dea9cd77..665c82b3e7 100644 --- a/test/encoder_settings.cc +++ b/test/encoder_settings.cc @@ -78,10 +78,12 @@ std::vector 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(); @@ -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_name = encoder_settings.payload_name; - if (encoder_settings.payload_name == "H264") { + decoder.payload_type = payload_type; + decoder.payload_name = payload_name; + 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 diff --git a/test/encoder_settings.h b/test/encoder_settings.h index 25cfa29897..787387b777 100644 --- a/test/encoder_settings.h +++ b/test/encoder_settings.h @@ -45,11 +45,14 @@ std::vector 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 diff --git a/video/encoder_rtcp_feedback_unittest.cc b/video/encoder_rtcp_feedback_unittest.cc index 07e89781da..398e3fd648 100644 --- a/video/encoder_rtcp_feedback_unittest.cc +++ b/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, - send_stats_proxy, - VideoSendStream::Config::EncoderSettings("fake", 0, - nullptr), - nullptr, - rtc::MakeUnique( - CpuOveruseOptions(), nullptr)) {} + : VideoStreamEncoder( + 1, + send_stats_proxy, + VideoSendStream::Config::EncoderSettings(nullptr), + nullptr, + rtc::MakeUnique(CpuOveruseOptions(), + nullptr)) {} ~MockVideoStreamEncoder() { Stop(); } MOCK_METHOD0(SendKeyFrame, void()); diff --git a/video/end_to_end_tests/codec_tests.cc b/video/end_to_end_tests/codec_tests.cc index 01c238a22c..1607382799 100644 --- a/video/end_to_end_tests/codec_tests.cc +++ b/video/end_to_end_tests/codec_tests.cc @@ -68,17 +68,17 @@ class CodecObserver : public test::EndToEndTest, VideoSendStream::Config* send_config, std::vector* 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->encoder_settings.payload_type = - test::CallTest::kVideoSendPayloadType; + send_config->rtp.payload_name = payload_name_; + send_config->rtp.payload_type = 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(); } diff --git a/video/end_to_end_tests/extended_reports_tests.cc b/video/end_to_end_tests/extended_reports_tests.cc index 3ce47ad3c4..e0909ac8b3 100644 --- a/video/end_to_end_tests/extended_reports_tests.cc +++ b/video/end_to_end_tests/extended_reports_tests.cc @@ -132,12 +132,12 @@ class RtcpXrObserver : public test::EndToEndTest { new rtc::RefCountedObject(); // 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. diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc index 36171fff2f..3434f29d89 100644 --- a/video/end_to_end_tests/fec_tests.cc +++ b/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->encoder_settings.payload_type = kVideoSendPayloadType; + send_config->rtp.payload_name = "VP8"; + 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->encoder_settings.payload_type = kFakeVideoSendPayloadType; + send_config->rtp.payload_name = "VP8"; + 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(); } diff --git a/video/end_to_end_tests/histogram_tests.cc b/video/end_to_end_tests/histogram_tests.cc index 2204e5ed56..12675061bd 100644 --- a/video/end_to_end_tests/histogram_tests.cc +++ b/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; diff --git a/video/end_to_end_tests/log_tests.cc b/video/end_to_end_tests/log_tests.cc index c04a401983..dc55feb52c 100644 --- a/video/end_to_end_tests/log_tests.cc +++ b/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(); } diff --git a/video/end_to_end_tests/multi_stream_tester.cc b/video/end_to_end_tests/multi_stream_tester.cc index 87f0ea27c4..2d501c15d1 100644 --- a/video/end_to_end_tests/multi_stream_tester.cc +++ b/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.encoder_settings.payload_type = kVideoPayloadType; + send_config.rtp.payload_name = "VP8"; + 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(decoder.decoder)); receive_config.decoders.push_back(decoder); diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc index 0d42cdafcd..752ee3bd8d 100644 --- a/video/end_to_end_tests/retransmission_tests.cc +++ b/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"; } diff --git a/video/end_to_end_tests/rtp_rtcp_tests.cc b/video/end_to_end_tests/rtp_rtcp_tests.cc index 8fd861efaf..5f72c94e08 100644 --- a/video/end_to_end_tests/rtp_rtcp_tests.cc +++ b/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_.encoder_settings.payload_type = kVideoSendPayloadType; + video_send_config_.rtp.payload_name = "VP8"; + 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; diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc index 9a43efe923..ff62ddca2b 100644 --- a/video/picture_id_tests.cc +++ b/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(num_temporal_layers_); video_encoder_config_.number_of_streams = 1; diff --git a/video/replay.cc b/video/replay.cc index a79c3f984f..88a5c58448 100644 --- a/video/replay.cc +++ b/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 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. diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc index 8f36f46ea7..6edbe545f2 100644 --- a/video/send_statistics_proxy.cc +++ b/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()), diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc index bc46f138f9..79f29a9f98 100644 --- a/video/video_quality_test.cc +++ b/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 = - video_send_configs_[video_idx].encoder_settings.payload_type; - decoder.payload_name = - video_send_configs_[video_idx].encoder_settings.payload_name; + decoder.payload_type = video_send_configs_[video_idx].rtp.payload_type; + decoder.payload_name = video_send_configs_[video_idx].rtp.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 = - params_.video[0].codec; - thumbnail_send_config.encoder_settings.payload_type = kPayloadTypeVP8; + thumbnail_send_config.rtp.payload_name = params_.video[0].codec; + thumbnail_send_config.rtp.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(decoder.decoder)); thumbnail_receive_config.decoders.clear(); diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc index f54a4ab1d6..7db4a9d7d6 100644 --- a/video/video_send_stream.cc +++ b/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( - config_->encoder_settings.payload_type, - config_->encoder_settings.payload_name.c_str()); + rtp_rtcp->RegisterVideoSendPayload(config_->rtp.payload_type, + config_->rtp.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_LE(config_->encoder_settings.payload_type, 127); + RTC_DCHECK_GE(config_->rtp.payload_type, 0); + 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( - config_->encoder_settings.payload_name)) { + !PayloadTypeSupportsSkippingFecPackets(config_->rtp.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 && diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc index b038f9c3e9..54c5f44459 100644 --- a/video/video_send_stream_tests.cc +++ b/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* 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(); @@ -3065,8 +3067,8 @@ class Vp9HeaderObserver : public test::SendTest { std::vector* receive_configs, VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = vp9_encoder_.get(); - send_config->encoder_settings.payload_name = "VP9"; - send_config->encoder_settings.payload_type = kVp9PayloadType; + send_config->rtp.payload_name = "VP9"; + 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* 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* 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* 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; diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc index f5f0ca5cf3..b598713b03 100644 --- a/video/video_stream_encoder.cc +++ b/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, - nack_enabled_, &codec, - &rate_allocator_)) { + if (!VideoCodecInitializer::SetupCodec( + encoder_config_, streams, nack_enabled_, &codec, &rate_allocator_)) { RTC_LOG(LS_ERROR) << "Failed to create encoder configuration."; } diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc index 8c12d8de71..2d99350215 100644 --- a/video/video_stream_encoder_unittest.cc +++ b/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_.encoder_settings.payload_type = 125; + video_send_config_.rtp.payload_name = "FAKE"; + 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(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 =