From 92be1caf4f6ab78d9e6a6f7e226e2f5a79bec2f4 Mon Sep 17 00:00:00 2001 From: Niels Moller Date: Wed, 21 Mar 2018 13:53:41 +0000 Subject: [PATCH] Revert "Move rtp-specific config out of EncoderSettings." This reverts commit bc900cb1d1810fcf678fe41cf1e3966daa39c88c. Reason for revert: Broke downstream projects. Original change's description: > 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 > Reviewed-by: Magnus Jedvert > Reviewed-by: Stefan Holmer > Reviewed-by: Rasmus Brandt > Cr-Commit-Position: refs/heads/master@{#22532} TBR=brandtr@webrtc.org,magjed@webrtc.org,nisse@webrtc.org,stefan@webrtc.org Change-Id: I01f06c1fcf21eb2cd40dca7d4f268614200ee490 No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: webrtc:8830 Reviewed-on: https://webrtc-review.googlesource.com/63720 Reviewed-by: Niels Moller Commit-Queue: Niels Moller Cr-Commit-Position: refs/heads/master@{#22537} --- call/bitrate_estimator_tests.cc | 13 ++++++---- call/call.cc | 4 +-- call/rampup_tests.cc | 2 +- call/video_config.cc | 7 ++---- call/video_config.h | 1 - call/video_send_stream.cc | 6 ++--- call/video_send_stream.h | 20 +++++++-------- media/engine/fakewebrtccall.cc | 6 ++--- media/engine/webrtcvideoengine.cc | 6 ++--- media/engine/webrtcvideoengine_unittest.cc | 2 +- .../include/video_codec_initializer.h | 5 +++- .../video_coding/video_codec_initializer.cc | 24 ++++++++++-------- .../video_codec_initializer_unittest.cc | 11 +++++--- test/call_test.cc | 9 +++---- test/encoder_settings.cc | 25 ++++++------------- test/encoder_settings.h | 7 ++---- video/encoder_rtcp_feedback_unittest.cc | 14 +++++------ video/end_to_end_tests/codec_tests.cc | 10 ++++---- .../extended_reports_tests.cc | 6 ++--- video/end_to_end_tests/fec_tests.cc | 14 +++++------ video/end_to_end_tests/histogram_tests.cc | 2 +- video/end_to_end_tests/log_tests.cc | 6 ++--- video/end_to_end_tests/multi_stream_tester.cc | 8 +++--- .../end_to_end_tests/retransmission_tests.cc | 2 +- video/end_to_end_tests/rtp_rtcp_tests.cc | 4 +-- video/picture_id_tests.cc | 3 +-- video/replay.cc | 6 +++-- video/send_statistics_proxy.cc | 2 +- video/video_quality_test.cc | 23 ++++++++--------- video/video_send_stream.cc | 16 ++++++------ video/video_send_stream_tests.cc | 19 ++++++-------- video/video_stream_encoder.cc | 5 ++-- video/video_stream_encoder_unittest.cc | 15 ++++------- 33 files changed, 143 insertions(+), 160 deletions(-) diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc index b4f808f30a..b833034209 100644 --- a/call/bitrate_estimator_tests.cc +++ b/call/bitrate_estimator_tests.cc @@ -118,9 +118,10 @@ 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_.rtp.payload_name = "FAKE"; - video_send_config_.rtp.payload_type = kFakeVideoSendPayloadType; - test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config_); + video_send_config_.encoder_settings.payload_name = "FAKE"; + video_send_config_.encoder_settings.payload_type = + kFakeVideoSendPayloadType; + test::FillEncoderConfiguration(1, &video_encoder_config_); receive_config_ = VideoReceiveStream::Config(receive_transport_.get()); // receive_config_.decoders will be set by every stream separately. @@ -181,8 +182,10 @@ class BitrateEstimatorTest : public test::CallTest { VideoReceiveStream::Decoder decoder; decoder.decoder = &fake_decoder_; - decoder.payload_type = test_->video_send_config_.rtp.payload_type; - decoder.payload_name = test_->video_send_config_.rtp.payload_name; + decoder.payload_type = + test_->video_send_config_.encoder_settings.payload_type; + 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 = diff --git a/call/call.cc b/call/call.cc index de3213d7ab..b7f54e554f 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.rtp.payload_name, - config.rtp.payload_type, + rtclog_config->codecs.emplace_back(config.encoder_settings.payload_name, + config.encoder_settings.payload_type, config.rtp.rtx.payload_type); return rtclog_config; } diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc index 024124cd2c..a93dd7957c 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->rtp.payload_type; + send_config->encoder_settings.payload_type; } ++i; } diff --git a/call/video_config.cc b/call/video_config.cc index eb32ed583e..02cfa382fa 100644 --- a/call/video_config.cc +++ b/call/video_config.cc @@ -46,8 +46,7 @@ std::string VideoStream::ToString() const { } VideoEncoderConfig::VideoEncoderConfig() - : codec_type(kVideoCodecUnknown), - content_type(ContentType::kRealtimeVideo), + : content_type(ContentType::kRealtimeVideo), encoder_specific_settings(nullptr), min_transmit_bitrate_bps(0), max_bitrate_bps(0), @@ -60,9 +59,7 @@ VideoEncoderConfig::~VideoEncoderConfig() = default; std::string VideoEncoderConfig::ToString() const { std::stringstream ss; - ss << "{codec_type: "; - ss << CodecTypeToPayloadString(codec_type); - ss << ", content_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 162d833c82..e9d95146c1 100644 --- a/call/video_config.h +++ b/call/video_config.h @@ -126,7 +126,6 @@ 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 cb857b1371..bf840d3ce7 100644 --- a/call/video_send_stream.cc +++ b/call/video_send_stream.cc @@ -86,7 +86,9 @@ std::string VideoSendStream::Config::ToString() const { std::string VideoSendStream::Config::EncoderSettings::ToString() const { std::stringstream ss; - ss << "{encoder: " << (encoder ? "(VideoEncoder)" : "nullptr"); + ss << "{payload_name: " << payload_name; + ss << ", payload_type: " << payload_type; + ss << ", encoder: " << (encoder ? "(VideoEncoder)" : "nullptr"); ss << '}'; return ss.str(); } @@ -122,8 +124,6 @@ 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 b4fac51a04..440b62e4a8 100644 --- a/call/video_send_stream.h +++ b/call/video_send_stream.h @@ -112,9 +112,17 @@ class VideoSendStream { struct EncoderSettings { EncoderSettings() = default; - explicit EncoderSettings(VideoEncoder* encoder) : encoder(encoder) {} + EncoderSettings(std::string payload_name, + 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; @@ -151,16 +159,6 @@ 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 0aa9cb0967..4bc01f0dd6 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_.rtp.payload_name == "VP8") { + if (config_.encoder_settings.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_.rtp.payload_name == "VP9") { + } else if (config_.encoder_settings.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_.rtp.payload_name; + << config_.encoder_settings.payload_name; } } codec_settings_set_ = config.encoder_specific_settings != NULL; diff --git a/media/engine/webrtcvideoengine.cc b/media/engine/webrtcvideoengine.cc index 6442c44337..7174524dd7 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.rtp.payload_name = codec_settings.codec.name; - parameters_.config.rtp.payload_type = codec_settings.codec.id; + parameters_.config.encoder_settings.payload_name = codec_settings.codec.name; + parameters_.config.encoder_settings.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,8 +1887,6 @@ 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 57442f48c1..d0b570725a 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.rtp.payload_type); + it = rtx_types.find(config.encoder_settings.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 9c5365c7c0..aded1f0ff7 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_config.h" +#include "call/video_send_stream.h" namespace webrtc { @@ -33,6 +33,7 @@ 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, @@ -48,6 +49,8 @@ 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 892113b100..e473a16581 100644 --- a/modules/video_coding/video_codec_initializer.cc +++ b/modules/video_coding/video_codec_initializer.cc @@ -26,15 +26,18 @@ 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 (config.codec_type == kVideoCodecMultiplex) { - VideoEncoderConfig associated_config = config.Copy(); - associated_config.codec_type = kVideoCodecVP9; - if (!SetupCodec(associated_config, streams, nack_enabled, codec, - 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)) { RTC_LOG(LS_ERROR) << "Failed to create stereo encoder configuration."; return false; } @@ -43,7 +46,8 @@ bool VideoCodecInitializer::SetupCodec( } *codec = - VideoEncoderConfigToVideoCodec(config, streams, nack_enabled); + VideoEncoderConfigToVideoCodec(config, streams, settings.payload_name, + settings.payload_type, nack_enabled); *bitrate_allocator = CreateBitrateAllocator(*codec); return true; @@ -69,6 +73,8 @@ 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()); @@ -76,7 +82,7 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec( VideoCodec video_codec; memset(&video_codec, 0, sizeof(video_codec)); - video_codec.codecType = config.codec_type; + video_codec.codecType = PayloadStringToCodecType(payload_name); switch (config.content_type) { case VideoEncoderConfig::ContentType::kRealtimeVideo: @@ -149,9 +155,7 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec( break; } - // TODO(nisse): The plType field should be deleted. Luckily, our - // callers don't need it. - video_codec.plType = 0; + video_codec.plType = payload_type; 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 6dd82c1f05..4e99fbbded 100644 --- a/modules/video_coding/video_codec_initializer_unittest.cc +++ b/modules/video_coding/video_codec_initializer_unittest.cc @@ -19,6 +19,8 @@ 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; @@ -47,8 +49,6 @@ 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,6 +60,8 @@ 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; @@ -70,8 +72,8 @@ class VideoCodecInitializerTest : public ::testing::Test { codec_out_ = VideoCodec(); bitrate_allocator_out_.reset(); temporal_layers_.clear(); - if (!VideoCodecInitializer::SetupCodec(config_, streams_, nack_enabled_, - &codec_out_, + if (!VideoCodecInitializer::SetupCodec(config_, settings_, streams_, + nack_enabled_, &codec_out_, &bitrate_allocator_out_)) { return false; } @@ -115,6 +117,7 @@ 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 57605de7d2..566574772c 100644 --- a/test/call_test.cc +++ b/test/call_test.cc @@ -194,15 +194,14 @@ 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->rtp.payload_name = "FAKE"; - video_config->rtp.payload_type = kFakeVideoSendPayloadType; + video_config->encoder_settings.payload_name = "FAKE"; + video_config->encoder_settings.payload_type = kFakeVideoSendPayloadType; video_config->rtp.extensions.push_back( RtpExtension(RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberExtensionId)); video_config->rtp.extensions.push_back(RtpExtension( RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId)); - FillEncoderConfiguration(kVideoCodecVP8, num_video_streams, - &video_encoder_config_); + FillEncoderConfiguration(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]); @@ -258,7 +257,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); + test::CreateMatchingDecoder(video_send_config.encoder_settings); 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 665c82b3e7..83dea9cd77 100644 --- a/test/encoder_settings.cc +++ b/test/encoder_settings.cc @@ -78,12 +78,10 @@ std::vector DefaultVideoStreamFactory::CreateEncoderStreams( return CreateVideoStreams(width, height, encoder_config); } -void FillEncoderConfiguration(VideoCodecType codec_type, - size_t num_streams, +void FillEncoderConfiguration(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(); @@ -96,17 +94,17 @@ void FillEncoderConfiguration(VideoCodecType codec_type, } VideoReceiveStream::Decoder CreateMatchingDecoder( - int payload_type, const std::string& payload_name) { + const VideoSendStream::Config::EncoderSettings& encoder_settings) { VideoReceiveStream::Decoder decoder; - decoder.payload_type = payload_type; - decoder.payload_name = payload_name; - if (payload_name == "H264") { + decoder.payload_type = encoder_settings.payload_type; + decoder.payload_name = encoder_settings.payload_name; + if (encoder_settings.payload_name == "H264") { decoder.decoder = H264Decoder::Create().release(); - } else if (payload_name == "VP8") { + } else if (encoder_settings.payload_name == "VP8") { decoder.decoder = VP8Decoder::Create().release(); - } else if (payload_name == "VP9") { + } else if (encoder_settings.payload_name == "VP9") { decoder.decoder = VP9Decoder::Create().release(); - } else if (payload_name == "multiplex") { + } else if (encoder_settings.payload_name == "multiplex") { decoder.decoder = new MultiplexDecoderAdapter( new InternalDecoderFactory(), SdpVideoFormat(cricket::kVp9CodecName)); } else { @@ -114,12 +112,5 @@ 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 787387b777..25cfa29897 100644 --- a/test/encoder_settings.h +++ b/test/encoder_settings.h @@ -45,14 +45,11 @@ std::vector CreateVideoStreams( int height, const webrtc::VideoEncoderConfig& encoder_config); -void FillEncoderConfiguration(VideoCodecType codec_type, size_t num_streams, +void FillEncoderConfiguration(size_t num_streams, VideoEncoderConfig* configuration); VideoReceiveStream::Decoder CreateMatchingDecoder( - int payload_type, const std::string& payload_name); - -VideoReceiveStream::Decoder CreateMatchingDecoder( - const VideoSendStream::Config& config); + const VideoSendStream::Config::EncoderSettings& encoder_settings); } // namespace test } // namespace webrtc diff --git a/video/encoder_rtcp_feedback_unittest.cc b/video/encoder_rtcp_feedback_unittest.cc index 398e3fd648..07e89781da 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(nullptr), - nullptr, - rtc::MakeUnique(CpuOveruseOptions(), - nullptr)) {} + : VideoStreamEncoder(1, + send_stats_proxy, + VideoSendStream::Config::EncoderSettings("fake", 0, + 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 1607382799..01c238a22c 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->rtp.payload_name = payload_name_; - send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType; + send_config->encoder_settings.payload_name = payload_name_; + send_config->encoder_settings.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->rtp.payload_type; + send_config->encoder_settings.payload_type; (*receive_configs)[0].decoders[0].payload_name = - send_config->rtp.payload_name; + send_config->encoder_settings.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 e0909ac8b3..3ce47ad3c4 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->rtp.payload_name = "VP8"; + send_config->encoder_settings.payload_name = "VP8"; (*receive_configs)[0].decoders.resize(1); (*receive_configs)[0].decoders[0].payload_type = - send_config->rtp.payload_type; + send_config->encoder_settings.payload_type; (*receive_configs)[0].decoders[0].payload_name = - send_config->rtp.payload_name; + send_config->encoder_settings.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 3434f29d89..36171fff2f 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->rtp.payload_name = "VP8"; - send_config->rtp.payload_type = kVideoSendPayloadType; + send_config->encoder_settings.payload_name = "VP8"; + send_config->encoder_settings.payload_type = kVideoSendPayloadType; VideoReceiveStream::Decoder decoder = - test::CreateMatchingDecoder(*send_config); + test::CreateMatchingDecoder(send_config->encoder_settings); 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->rtp.payload_name = "VP8"; - send_config->rtp.payload_type = kFakeVideoSendPayloadType; + send_config->encoder_settings.payload_name = "VP8"; + send_config->encoder_settings.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->rtp.payload_type; + send_config->encoder_settings.payload_type; (*receive_configs)[0].decoders[0].payload_name = - send_config->rtp.payload_name; + send_config->encoder_settings.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 12675061bd..2204e5ed56 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->rtp.payload_name = "VP8"; + send_config->encoder_settings.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 dc55feb52c..c04a401983 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->rtp.payload_name = "VP8"; + send_config->encoder_settings.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->rtp.payload_type; + send_config->encoder_settings.payload_type; (*receive_configs)[0].decoders[0].payload_name = - send_config->rtp.payload_name; + send_config->encoder_settings.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 2d501c15d1..87f0ea27c4 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.rtp.payload_name = "VP8"; - send_config.rtp.payload_type = kVideoPayloadType; + send_config.encoder_settings.payload_name = "VP8"; + send_config.encoder_settings.payload_type = kVideoPayloadType; VideoEncoderConfig encoder_config; - test::FillEncoderConfiguration(kVideoCodecVP8, 1, &encoder_config); + test::FillEncoderConfiguration(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); + test::CreateMatchingDecoder(send_config.encoder_settings); 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 752ee3bd8d..0d42cdafcd 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->rtp.payload_name = "VP8"; + send_config->encoder_settings.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 5f72c94e08..8fd861efaf 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_.rtp.payload_name = "VP8"; - video_send_config_.rtp.payload_type = kVideoSendPayloadType; + video_send_config_.encoder_settings.payload_name = "VP8"; + video_send_config_.encoder_settings.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 ff62ddca2b..9a43efe923 100644 --- a/video/picture_id_tests.cc +++ b/video/picture_id_tests.cc @@ -308,8 +308,7 @@ void PictureIdTest::SetupEncoder(VideoEncoder* encoder, CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get()); video_send_config_.encoder_settings.encoder = encoder; - video_send_config_.rtp.payload_name = payload_name; - video_encoder_config_.codec_type = PayloadStringToCodecType(payload_name); + video_send_config_.encoder_settings.payload_name = 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 88a5c58448..a79c3f984f 100644 --- a/video/replay.cc +++ b/video/replay.cc @@ -247,6 +247,9 @@ 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()) { @@ -254,8 +257,7 @@ void RtpReplay() { flags::DecoderBitstreamFilename().c_str())); receive_config.pre_decode_callback = bitstream_writer.get(); } - decoder = test::CreateMatchingDecoder(flags::MediaPayloadType(), - flags::Codec()); + decoder = test::CreateMatchingDecoder(encoder_settings); 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 6edbe545f2..8f36f46ea7 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.rtp.payload_name), + payload_name_(config.encoder_settings.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 79f29a9f98..bc46f138f9 100644 --- a/video/video_quality_test.cc +++ b/video/video_quality_test.cc @@ -1264,8 +1264,6 @@ 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 @@ -1399,9 +1397,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].rtp.payload_name = + video_send_configs_[video_idx].encoder_settings.payload_name = params_.video[video_idx].codec; - video_send_configs_[video_idx].rtp.payload_type = payload_type; + video_send_configs_[video_idx].encoder_settings.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) { @@ -1423,9 +1421,6 @@ 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; @@ -1479,8 +1474,10 @@ 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].rtp.payload_type; - decoder.payload_name = video_send_configs_[video_idx].rtp.payload_name; + decoder.payload_type = + video_send_configs_[video_idx].encoder_settings.payload_type; + 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); @@ -1615,8 +1612,9 @@ 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.rtp.payload_name = params_.video[0].codec; - thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8; + thumbnail_send_config.encoder_settings.payload_name = + params_.video[0].codec; + 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); @@ -1631,7 +1629,6 @@ 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; @@ -1658,7 +1655,7 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport, thumbnail_receive_config.renderer = &fake_renderer_; VideoReceiveStream::Decoder decoder = - test::CreateMatchingDecoder(thumbnail_send_config); + test::CreateMatchingDecoder(thumbnail_send_config.encoder_settings); 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 7db4a9d7d6..f54a4ab1d6 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_->rtp.payload_type, + config_->encoder_settings.payload_type, suspended_payload_states), weak_ptr_factory_(this), overhead_bytes_per_packet_(0), @@ -823,8 +823,9 @@ VideoSendStreamImpl::VideoSendStreamImpl( rtp_rtcp->RegisterRtcpStatisticsCallback(stats_proxy_); rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(stats_proxy_); rtp_rtcp->SetMaxRtpPacketSize(config_->rtp.max_packet_size); - rtp_rtcp->RegisterVideoSendPayload(config_->rtp.payload_type, - config_->rtp.payload_name.c_str()); + rtp_rtcp->RegisterVideoSendPayload( + config_->encoder_settings.payload_type, + config_->encoder_settings.payload_name.c_str()); } fec_controller_->SetProtectionCallback(this); @@ -834,8 +835,8 @@ VideoSendStreamImpl::VideoSendStreamImpl( } RTC_DCHECK(config_->encoder_settings.encoder); - RTC_DCHECK_GE(config_->rtp.payload_type, 0); - RTC_DCHECK_LE(config_->rtp.payload_type, 127); + RTC_DCHECK_GE(config_->encoder_settings.payload_type, 0); + RTC_DCHECK_LE(config_->encoder_settings.payload_type, 127); video_stream_encoder_->SetStartBitrate( bitrate_allocator_->GetStartBitrate(this)); @@ -1128,7 +1129,8 @@ 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_->rtp.payload_name)) { + !PayloadTypeSupportsSkippingFecPackets( + 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 " @@ -1206,7 +1208,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_->rtp.payload_type); + config_->encoder_settings.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 54c5f44459..b038f9c3e9 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->rtp.payload_name = payload_name_; + send_config->encoder_settings.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->rtp.payload_name = payload_name_; + send_config->encoder_settings.payload_name = payload_name_; if (header_extensions_enabled_) { send_config->rtp.extensions.push_back(RtpExtension( RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId)); @@ -718,7 +718,6 @@ class FlexfecObserver : public test::EndToEndTest { } else { send_config->rtp.extensions.clear(); } - encoder_config->codec_type = PayloadStringToCodecType(payload_name_); } void PerformTest() override { @@ -1074,7 +1073,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, } if (!test_generic_packetization_) - send_config->rtp.payload_name = "VP8"; + send_config->encoder_settings.payload_name = "VP8"; send_config->encoder_settings.encoder = &encoder_; send_config->rtp.max_packet_size = kMaxPacketSize; @@ -2118,7 +2117,7 @@ TEST_F(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) { video_send_config_.encoder_settings.encoder = &encoder; video_send_config_.encoder_settings.internal_source = true; - video_send_config_.rtp.payload_name = "VP8"; + video_send_config_.encoder_settings.payload_name = "VP8"; CreateVideoStreams(); }); @@ -2492,9 +2491,8 @@ class VideoCodecConfigObserver : public test::SendTest, std::vector* receive_configs, VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; - send_config->rtp.payload_name = codec_name_; + send_config->encoder_settings.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(); @@ -3067,8 +3065,8 @@ class Vp9HeaderObserver : public test::SendTest { std::vector* receive_configs, VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = vp9_encoder_.get(); - send_config->rtp.payload_name = "VP9"; - send_config->rtp.payload_type = kVp9PayloadType; + send_config->encoder_settings.payload_name = "VP9"; + send_config->encoder_settings.payload_type = kVp9PayloadType; ModifyVideoConfigsHook(send_config, receive_configs, encoder_config); encoder_config->encoder_specific_settings = new rtc::RefCountedObject< VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings_); @@ -3391,7 +3389,6 @@ 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; @@ -3446,7 +3443,6 @@ 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; @@ -3484,7 +3480,6 @@ 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 b598713b03..f5f0ca5cf3 100644 --- a/video/video_stream_encoder.cc +++ b/video/video_stream_encoder.cc @@ -552,8 +552,9 @@ void VideoStreamEncoder::ReconfigureEncoder() { crop_height_ = last_frame_info_->height - highest_stream_height; VideoCodec codec; - if (!VideoCodecInitializer::SetupCodec( - encoder_config_, streams, nack_enabled_, &codec, &rate_allocator_)) { + if (!VideoCodecInitializer::SetupCodec(encoder_config_, settings_, 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 2d99350215..8c12d8de71 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_.rtp.payload_name = "FAKE"; - video_send_config_.rtp.payload_type = 125; + video_send_config_.encoder_settings.payload_name = "FAKE"; + video_send_config_.encoder_settings.payload_type = 125; VideoEncoderConfig video_encoder_config; - test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); + test::FillEncoderConfiguration(1, &video_encoder_config); video_encoder_config.video_stream_factory = new rtc::RefCountedObject(1, max_framerate_); video_encoder_config_ = video_encoder_config.Copy(); @@ -325,10 +325,9 @@ class VideoStreamEncoderTest : public ::testing::Test { unsigned char num_spatial_layers, bool nack_enabled, bool screenshare) { - video_send_config_.rtp.payload_name = payload_name; + video_send_config_.encoder_settings.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 = @@ -784,7 +783,7 @@ TEST_F(VideoStreamEncoderTest, EXPECT_EQ(1, sink_.number_of_reconfigurations()); VideoEncoderConfig video_encoder_config; - test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); + test::FillEncoderConfiguration(1, &video_encoder_config); video_encoder_config.min_transmit_bitrate_bps = 9999; video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config), kMaxPayloadLength, @@ -2280,7 +2279,6 @@ 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 = @@ -2332,7 +2330,6 @@ 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 = @@ -2395,7 +2392,6 @@ 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 = @@ -3189,7 +3185,6 @@ 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 =