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 <nisse@webrtc.org>
> Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
> Reviewed-by: Stefan Holmer <stefan@webrtc.org>
> Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#22532}
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 <nisse@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22537}diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index b4f808f..b833034 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -118,9 +118,10 @@
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 @@
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 de3213d..b7f54e5 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -133,8 +133,8 @@
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 024124c..a93dd79 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -219,7 +219,7 @@
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 eb32ed5..02cfa38 100644
--- a/call/video_config.cc
+++ b/call/video_config.cc
@@ -46,8 +46,7 @@
}
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 @@
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 162d833..e9d9514 100644
--- a/call/video_config.h
+++ b/call/video_config.h
@@ -126,7 +126,6 @@
~VideoEncoderConfig();
std::string ToString() const;
- VideoCodecType codec_type;
rtc::scoped_refptr<VideoStreamFactoryInterface> video_stream_factory;
std::vector<SpatialLayer> spatial_layers;
ContentType content_type;
diff --git a/call/video_send_stream.cc b/call/video_send_stream.cc
index cb857b1..bf840d3 100644
--- a/call/video_send_stream.cc
+++ b/call/video_send_stream.cc
@@ -86,7 +86,9 @@
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 @@
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 b4fac51..440b62e 100644
--- a/call/video_send_stream.h
+++ b/call/video_send_stream.h
@@ -112,9 +112,17 @@
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 @@
// RTP header extensions to use for this send stream.
std::vector<RtpExtension> extensions;
- // TODO(nisse): For now, these are fixed, but we'd like to support
- // changing codec without recreating the VideoSendStream. Then these
- // fields must be removed, and association between payload type and codec
- // must move above the per-stream level. Ownership could be with
- // RtpTransportControllerSend, with a reference from PayloadRouter, where
- // the latter would be responsible for mapping the codec type of encoded
- // images to the right payload type.
- std::string payload_name;
- int payload_type = -1;
-
// See NackConfig for description.
NackConfig nack;
diff --git a/media/engine/fakewebrtccall.cc b/media/engine/fakewebrtccall.cc
index 0aa9cb0..4bc01f0 100644
--- a/media/engine/fakewebrtccall.cc
+++ b/media/engine/fakewebrtccall.cc
@@ -229,19 +229,19 @@
if (config.encoder_specific_settings != NULL) {
const unsigned char num_temporal_layers = static_cast<unsigned char>(
video_streams_.back().num_temporal_layers.value_or(1));
- if (config_.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 6442c44..7174524 100644
--- a/media/engine/webrtcvideoengine.cc
+++ b/media/engine/webrtcvideoengine.cc
@@ -1734,8 +1734,8 @@
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 @@
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 57442f4..d0b5707 100644
--- a/media/engine/webrtcvideoengine_unittest.cc
+++ b/media/engine/webrtcvideoengine_unittest.cc
@@ -133,7 +133,7 @@
void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
const std::map<int, int>& rtx_types) {
std::map<int, int>::const_iterator it;
- it = rtx_types.find(config.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 9c5365c..aded1f0 100644
--- a/modules/video_coding/include/video_codec_initializer.h
+++ b/modules/video_coding/include/video_codec_initializer.h
@@ -15,7 +15,7 @@
#include <string>
#include <vector>
-#include "call/video_config.h"
+#include "call/video_send_stream.h"
namespace webrtc {
@@ -33,6 +33,7 @@
// GetBitrateAllocator is called implicitly from here, no need to call again.
static bool SetupCodec(
const VideoEncoderConfig& config,
+ const VideoSendStream::Config::EncoderSettings settings,
const std::vector<VideoStream>& streams,
bool nack_enabled,
VideoCodec* codec,
@@ -48,6 +49,8 @@
static VideoCodec VideoEncoderConfigToVideoCodec(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& 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 892113b..e473a16 100644
--- a/modules/video_coding/video_codec_initializer.cc
+++ b/modules/video_coding/video_codec_initializer.cc
@@ -26,15 +26,18 @@
bool VideoCodecInitializer::SetupCodec(
const VideoEncoderConfig& config,
+ const VideoSendStream::Config::EncoderSettings settings,
const std::vector<VideoStream>& streams,
bool nack_enabled,
VideoCodec* codec,
std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator) {
- if (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 @@
}
*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 @@
VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
+ const std::string& payload_name,
+ int payload_type,
bool nack_enabled) {
static const int kEncoderMinBitrateKbps = 30;
RTC_DCHECK(!streams.empty());
@@ -76,7 +82,7 @@
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 @@
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<unsigned char>(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 6dd82c1..4e99fbb 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 @@
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 @@
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 @@
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 @@
// Input settings.
VideoEncoderConfig config_;
+ VideoSendStream::Config::EncoderSettings settings_;
std::vector<VideoStream> streams_;
bool nack_enabled_;
diff --git a/test/call_test.cc b/test/call_test.cc
index 57605de..5665747 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -194,15 +194,14 @@
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 @@
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<VideoDecoder>(decoder.decoder));
video_config.decoders.clear();
diff --git a/test/encoder_settings.cc b/test/encoder_settings.cc
index 665c82b..83dea9c 100644
--- a/test/encoder_settings.cc
+++ b/test/encoder_settings.cc
@@ -78,12 +78,10 @@
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<DefaultVideoStreamFactory>();
@@ -96,17 +94,17 @@
}
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 @@
}
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 787387b..25cfa29 100644
--- a/test/encoder_settings.h
+++ b/test/encoder_settings.h
@@ -45,14 +45,11 @@
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 398e3fd..07e8978 100644
--- a/video/encoder_rtcp_feedback_unittest.cc
+++ b/video/encoder_rtcp_feedback_unittest.cc
@@ -24,13 +24,13 @@
class MockVideoStreamEncoder : public VideoStreamEncoder {
public:
explicit MockVideoStreamEncoder(SendStatisticsProxy* send_stats_proxy)
- : VideoStreamEncoder(
- 1,
- send_stats_proxy,
- VideoSendStream::Config::EncoderSettings(nullptr),
- nullptr,
- rtc::MakeUnique<OveruseFrameDetector>(CpuOveruseOptions(),
- nullptr)) {}
+ : VideoStreamEncoder(1,
+ send_stats_proxy,
+ VideoSendStream::Config::EncoderSettings("fake", 0,
+ nullptr),
+ nullptr,
+ rtc::MakeUnique<OveruseFrameDetector>(
+ 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 1607382..01c238a 100644
--- a/video/end_to_end_tests/codec_tests.cc
+++ b/video/end_to_end_tests/codec_tests.cc
@@ -68,17 +68,17 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
send_config->encoder_settings.encoder = encoder_.get();
- send_config->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 e0909ac..3ce47ad 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 @@
new rtc::RefCountedObject<ZeroTargetVideoStreamFactory>();
// 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 3434f29..36171ff 100644
--- a/video/end_to_end_tests/fec_tests.cc
+++ b/video/end_to_end_tests/fec_tests.cc
@@ -103,10 +103,10 @@
// 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 @@
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 @@
(*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 1267506..2204e5e 100644
--- a/video/end_to_end_tests/histogram_tests.cc
+++ b/video/end_to_end_tests/histogram_tests.cc
@@ -89,7 +89,7 @@
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 dc55feb..c04a401 100644
--- a/video/end_to_end_tests/log_tests.cc
+++ b/video/end_to_end_tests/log_tests.cc
@@ -77,14 +77,14 @@
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 2d501c1..87f0ea2 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 @@
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 @@
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<VideoDecoder>(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 752ee3b..0d42cda 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/video/end_to_end_tests/retransmission_tests.cc
@@ -438,7 +438,7 @@
// 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 5f72c94..8fd861e 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 @@
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 ff62ddc..9a43efe 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -308,8 +308,7 @@
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<VideoStreamFactory>(num_temporal_layers_);
video_encoder_config_.number_of_streams = 1;
diff --git a/video/replay.cc b/video/replay.cc
index 88a5c58..a79c3f9 100644
--- a/video/replay.cc
+++ b/video/replay.cc
@@ -247,6 +247,9 @@
}
receive_config.renderer = &file_passthrough;
+ VideoSendStream::Config::EncoderSettings encoder_settings;
+ encoder_settings.payload_name = flags::Codec();
+ encoder_settings.payload_type = flags::MediaPayloadType();
VideoReceiveStream::Decoder decoder;
std::unique_ptr<DecoderBitstreamFileWriter> bitstream_writer;
if (!flags::DecoderBitstreamFilename().empty()) {
@@ -254,8 +257,7 @@
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 6edbe54..8f36f46 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -126,7 +126,7 @@
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 79f29a9..bc46f13 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -1264,8 +1264,6 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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<VideoDecoder>(decoder.decoder));
thumbnail_receive_config.decoders.clear();
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index 7db4a9d..f54a4ab 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -729,7 +729,7 @@
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 @@
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 @@
}
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 @@
// 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 @@
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 54c5f44..b038f9c 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -532,7 +532,7 @@
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 @@
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 @@
} else {
send_config->rtp.extensions.clear();
}
- encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
}
void PerformTest() override {
@@ -1074,7 +1073,7 @@
}
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 @@
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 @@
std::vector<VideoReceiveStream::Config>* 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<VideoStreamFactory>();
@@ -3067,8 +3065,8 @@
std::vector<VideoReceiveStream::Config>* 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 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- encoder_config->codec_type = kVideoCodecVP9;
vp9_settings_.flexibleMode = false;
vp9_settings_.frameDroppingOn = false;
vp9_settings_.keyFrameInterval = kKeyFrameInterval;
@@ -3446,7 +3443,6 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- encoder_config->codec_type = kVideoCodecVP9;
vp9_settings_.flexibleMode = false;
vp9_settings_.numberOfTemporalLayers = 1;
vp9_settings_.numberOfSpatialLayers = 1;
@@ -3484,7 +3480,6 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- encoder_config->codec_type = kVideoCodecVP9;
encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
vp9_settings_.flexibleMode = true;
vp9_settings_.numberOfTemporalLayers = 1;
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index b598713b..f5f0ca5 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -552,8 +552,9 @@
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 2d99350..8c12d8d 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -284,11 +284,11 @@
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<VideoStreamFactory>(1, max_framerate_);
video_encoder_config_ = video_encoder_config.Copy();
@@ -325,10 +325,9 @@
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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
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 =
