admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move frame drop config to VideoCodec and VideoEncoderConfig.

Browse Source 
Intend to delete corresponding codec-specific settings in a followup.

Bug: webrtc:6883
Change-Id: I78ab07729a5aee1055f80d39d8f7289beb6721e1
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/262244
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36882}
This commit is contained in:
Niels Möller 2022-05-12 16:16:39 +02:00 committed by WebRTC LUCI CQ
parent 8f44ae4fa5
commit 807328fec7
23 changed files with 82 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
api/video_codecs/video_codec.cc
View File

@ -158,4 +158,24 @@ void VideoCodec::SetVideoEncoderComplexity(
complexity_ = complexity_setting;
}
bool VideoCodec::GetFrameDropEnabled() const {
if (frame_drop_enabled_.has_value()) {
return *frame_drop_enabled_;
}
switch (codecType) {
default:
return false;
case kVideoCodecVP8:
return VP8().frameDroppingOn;
case kVideoCodecVP9:
return VP9().frameDroppingOn;
case kVideoCodecH264:
return H264().frameDroppingOn;
}
}
void VideoCodec::SetFrameDropEnabled(bool enabled) {
frame_drop_enabled_ = enabled;
}
} // namespace webrtc

6
api/video_codecs/video_codec.h
View File

@ -116,6 +116,9 @@ class RTC_EXPORT VideoCodec {
VideoCodecComplexity GetVideoEncoderComplexity() const;
void SetVideoEncoderComplexity(VideoCodecComplexity complexity_setting);
bool GetFrameDropEnabled() const;
void SetFrameDropEnabled(bool enabled);
// Public variables. TODO(hta): Make them private with accessors.
VideoCodecType codecType;
@ -179,6 +182,9 @@ class RTC_EXPORT VideoCodec {
// 'complexity_' indicates the CPU capability of the client. It's used to
// determine encoder CPU complexity (e.g., cpu_used for VP8, VP9. and AV1).
absl::optional<VideoCodecComplexity> complexity_;
// TODO(bugs.webrtc.org/6883): When unset, GetEnableFrameDrop checks the
// codec-specific settings.
absl::optional<bool> frame_drop_enabled_;
};
} // namespace webrtc

2
api/video_codecs/video_encoder_config.cc
View File

@ -52,6 +52,7 @@ VideoEncoderConfig::VideoEncoderConfig()
: codec_type(kVideoCodecGeneric),
video_format("Unset"),
content_type(ContentType::kRealtimeVideo),
frame_drop_enabled(false),
encoder_specific_settings(nullptr),
min_transmit_bitrate_bps(0),
max_bitrate_bps(0),
@ -78,6 +79,7 @@ std::string VideoEncoderConfig::ToString() const {
ss << "kScreenshare";
break;
}
ss << ", frame_drop_enabled: " << frame_drop_enabled;
ss << ", encoder_specific_settings: ";
ss << (encoder_specific_settings != nullptr ? "(ptr)" : "NULL");

1
api/video_codecs/video_encoder_config.h
View File

@ -158,6 +158,7 @@ class VideoEncoderConfig {
rtc::scoped_refptr<VideoStreamFactoryInterface> video_stream_factory;
std::vector<SpatialLayer> spatial_layers;
ContentType content_type;
bool frame_drop_enabled;
rtc::scoped_refptr<const EncoderSpecificSettings> encoder_specific_settings;
// Padding will be used up to this bitrate regardless of the bitrate produced

2
media/engine/simulcast_encoder_adapter_unittest.cc
View File

@ -521,7 +521,7 @@ class TestSimulcastEncoderAdapterFake : public ::testing::Test,
target.VP8().numberOfTemporalLayers);
EXPECT_EQ(ref.VP8().denoisingOn, target.VP8().denoisingOn);
EXPECT_EQ(ref.VP8().automaticResizeOn, target.VP8().automaticResizeOn);
EXPECT_EQ(ref.VP8().frameDroppingOn, target.VP8().frameDroppingOn);
EXPECT_EQ(ref.GetFrameDropEnabled(), target.GetFrameDropEnabled());
EXPECT_EQ(ref.VP8().keyFrameInterval, target.VP8().keyFrameInterval);
EXPECT_EQ(ref.qpMax, target.qpMax);
EXPECT_EQ(0, target.numberOfSimulcastStreams);

5
media/engine/webrtc_video_engine.cc
View File

@ -526,8 +526,6 @@ WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
// VP9 denoising is disabled by default.
vp9_settings.denoisingOn = codec_default_denoising ? true : denoising;
vp9_settings.automaticResizeOn = automatic_resize;
// Ensure frame dropping is always enabled.
RTC_DCHECK(vp9_settings.frameDroppingOn);
if (!is_screencast) {
webrtc::FieldTrialFlag interlayer_pred_experiment_enabled("Enabled");
webrtc::FieldTrialEnum<webrtc::InterLayerPredMode> inter_layer_pred_mode(
@ -2512,6 +2510,9 @@ WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
(parameters_.config.rtp.ssrcs.size() == 1 ||
NumActiveStreams(rtp_parameters_) == 1);
// Ensure frame dropping is always enabled.
encoder_config.frame_drop_enabled = true;
int max_qp = kDefaultQpMax;
codec.GetParam(kCodecParamMaxQuantization, &max_qp);
encoder_config.video_stream_factory =

18
media/engine/webrtc_video_engine_unittest.cc
View File

@ -3427,14 +3427,14 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) {
ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
EXPECT_FALSE(vp8_settings.denoisingOn);
EXPECT_TRUE(vp8_settings.automaticResizeOn);
EXPECT_TRUE(vp8_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, true);
ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
EXPECT_TRUE(vp8_settings.denoisingOn);
EXPECT_TRUE(vp8_settings.automaticResizeOn);
EXPECT_TRUE(vp8_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
stream = SetUpSimulcast(true, false);
@ -3446,7 +3446,7 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) {
ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
// Autmatic resize off when using simulcast.
EXPECT_FALSE(vp8_settings.automaticResizeOn);
EXPECT_TRUE(vp8_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
// In screen-share mode, denoising is forced off.
VideoOptions options;
@ -3460,14 +3460,14 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) {
EXPECT_FALSE(vp8_settings.denoisingOn);
// Resizing always off for screen sharing.
EXPECT_FALSE(vp8_settings.automaticResizeOn);
EXPECT_TRUE(vp8_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, true);
ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
EXPECT_FALSE(vp8_settings.denoisingOn);
EXPECT_FALSE(vp8_settings.automaticResizeOn);
EXPECT_TRUE(vp8_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
}
@ -3542,13 +3542,13 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
EXPECT_FALSE(vp9_settings.denoisingOn);
// Frame dropping always on for real time video.
EXPECT_TRUE(vp9_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, true);
ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
EXPECT_TRUE(vp9_settings.denoisingOn);
EXPECT_TRUE(vp9_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
// In screen-share mode, denoising is forced off.
VideoOptions options;
@ -3560,13 +3560,13 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
EXPECT_FALSE(vp9_settings.denoisingOn);
// Frame dropping always on for screen sharing.
EXPECT_TRUE(vp9_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false);
ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
EXPECT_FALSE(vp9_settings.denoisingOn);
EXPECT_TRUE(vp9_settings.frameDroppingOn);
EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled);
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
}

2
modules/video_coding/codecs/h264/h264_encoder_impl.cc
View File

@ -239,7 +239,7 @@ int32_t H264EncoderImpl::InitEncode(const VideoCodec* inst,
configurations_[i].width = codec_.simulcastStream[idx].width;
configurations_[i].height = codec_.simulcastStream[idx].height;
configurations_[i].max_frame_rate = static_cast<float>(codec_.maxFramerate);
configurations_[i].frame_dropping_on = codec_.H264()->frameDroppingOn;
configurations_[i].frame_dropping_on = codec_.GetFrameDropEnabled();
configurations_[i].key_frame_interval = codec_.H264()->keyFrameInterval;
configurations_[i].num_temporal_layers =
std::max(codec_.H264()->numberOfTemporalLayers,

2
modules/video_coding/codecs/h264/h264_encoder_impl_unittest.cc
View File

@ -33,7 +33,7 @@ void SetDefaultSettings(VideoCodec* codec_settings) {
codec_settings->height = 480;
// If frame dropping is false, we get a warning that bitrate can't
// be controlled for RC_QUALITY_MODE; RC_BITRATE_MODE and RC_TIMESTAMP_MODE
codec_settings->H264()->frameDroppingOn = true;
codec_settings->SetFrameDropEnabled(true);
codec_settings->startBitrate = 2000;
codec_settings->maxBitrate = 4000;
}

8
modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
View File

@ -108,7 +108,6 @@ std::string CodecSpecificToString(const VideoCodec& codec) {
<< static_cast<int>(codec.VP8().numberOfTemporalLayers);
ss << "\ndenoising: " << codec.VP8().denoisingOn;
ss << "\nautomatic_resize: " << codec.VP8().automaticResizeOn;
ss << "\nframe_dropping: " << codec.VP8().frameDroppingOn;
ss << "\nkey_frame_interval: " << codec.VP8().keyFrameInterval;
break;
case kVideoCodecVP9:
@ -117,14 +116,12 @@ std::string CodecSpecificToString(const VideoCodec& codec) {
ss << "\nnum_spatial_layers: "
<< static_cast<int>(codec.VP9().numberOfSpatialLayers);
ss << "\ndenoising: " << codec.VP9().denoisingOn;
ss << "\nframe_dropping: " << codec.VP9().frameDroppingOn;
ss << "\nkey_frame_interval: " << codec.VP9().keyFrameInterval;
ss << "\nadaptive_qp_mode: " << codec.VP9().adaptiveQpMode;
ss << "\nautomatic_resize: " << codec.VP9().automaticResizeOn;
ss << "\nflexible_mode: " << codec.VP9().flexibleMode;
break;
case kVideoCodecH264:
ss << "frame_dropping: " << codec.H264().frameDroppingOn;
ss << "\nkey_frame_interval: " << codec.H264().keyFrameInterval;
ss << "\nnum_temporal_layers: "
<< static_cast<int>(codec.H264().numberOfTemporalLayers);
@ -209,20 +206,19 @@ void VideoCodecTestFixtureImpl::Config::SetCodecSettings(
num_simulcast_streams <= 1 ? 0
: static_cast<uint8_t>(num_simulcast_streams);
codec_settings.SetFrameDropEnabled(frame_dropper_on);
switch (codec_settings.codecType) {
case kVideoCodecVP8:
codec_settings.VP8()->numberOfTemporalLayers =
static_cast<uint8_t>(num_temporal_layers);
codec_settings.VP8()->denoisingOn = denoising_on;
codec_settings.VP8()->automaticResizeOn = spatial_resize_on;
codec_settings.VP8()->frameDroppingOn = frame_dropper_on;
codec_settings.VP8()->keyFrameInterval = kBaseKeyFrameInterval;
break;
case kVideoCodecVP9:
codec_settings.VP9()->numberOfTemporalLayers =
static_cast<uint8_t>(num_temporal_layers);
codec_settings.VP9()->denoisingOn = denoising_on;
codec_settings.VP9()->frameDroppingOn = frame_dropper_on;
codec_settings.VP9()->keyFrameInterval = kBaseKeyFrameInterval;
codec_settings.VP9()->automaticResizeOn = spatial_resize_on;
codec_settings.VP9()->numberOfSpatialLayers =
@ -232,7 +228,6 @@ void VideoCodecTestFixtureImpl::Config::SetCodecSettings(
codec_settings.qpMax = 63;
break;
case kVideoCodecH264:
codec_settings.H264()->frameDroppingOn = frame_dropper_on;
codec_settings.H264()->keyFrameInterval = kBaseKeyFrameInterval;
codec_settings.H264()->numberOfTemporalLayers =
static_cast<uint8_t>(num_temporal_layers);
@ -302,6 +297,7 @@ std::string VideoCodecTestFixtureImpl::Config::ToString() const {
ss << "\n\n--> codec_settings." << codec_type;
ss << "complexity: "
<< static_cast<int>(codec_settings.GetVideoEncoderComplexity());
ss << "\nframe_dropping: " << codec_settings.GetFrameDropEnabled();
ss << "\n" << CodecSpecificToString(codec_settings);
if (codec_settings.numberOfSimulcastStreams > 1) {
for (int i = 0; i < codec_settings.numberOfSimulcastStreams; ++i) {

2
modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
View File

@ -845,7 +845,7 @@ uint32_t LibvpxVp8Encoder::MaxIntraTarget(uint32_t optimalBuffersize) {
}
uint32_t LibvpxVp8Encoder::FrameDropThreshold(size_t spatial_idx) const {
if (!codec_.VP8().frameDroppingOn) {
if (!codec_.GetFrameDropEnabled()) {
return 0;
}

2
modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -436,7 +436,7 @@ TEST_F(TestVp8Impl, DontDropKeyframes) {
// Screensharing has the internal frame dropper off, and instead per frame
// asks ScreenshareLayers to decide if it should be dropped or not.
codec_settings_.VP8()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.mode = VideoCodecMode::kScreensharing;
// ScreenshareLayers triggers on 2 temporal layers and 1000kbps max bitrate.
codec_settings_.VP8()->numberOfTemporalLayers = 2;

2
modules/video_coding/codecs/vp9/libvpx_vp9_encoder.cc
View File

@ -629,7 +629,7 @@ int LibvpxVp9Encoder::InitEncode(const VideoCodec* inst,
config_->g_lag_in_frames = 0; // 0- no frame lagging
config_->g_threads = 1;
// Rate control settings.
config_->rc_dropframe_thresh = inst->VP9().frameDroppingOn ? 30 : 0;
config_->rc_dropframe_thresh = inst->GetFrameDropEnabled() ? 30 : 0;
config_->rc_end_usage = VPX_CBR;
config_->g_pass = VPX_RC_ONE_PASS;
config_->rc_min_quantizer =

40
modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
View File

@ -85,7 +85,7 @@ void ConfigureSvc(VideoCodec& codec_settings,
int num_temporal_layers = 1) {
codec_settings.VP9()->numberOfSpatialLayers = num_spatial_layers;
codec_settings.VP9()->numberOfTemporalLayers = num_temporal_layers;
codec_settings.VP9()->frameDroppingOn = false;
codec_settings.SetFrameDropEnabled(false);
std::vector<SpatialLayer> layers = GetSvcConfig(
codec_settings.width, codec_settings.height, codec_settings.maxFramerate,
@ -435,7 +435,7 @@ TEST_F(TestVp9Impl, EnableDisableSpatialLayers) {
const size_t num_frames_to_encode = 5;
ConfigureSvc(codec_settings_, num_spatial_layers);
codec_settings_.VP9()->frameDroppingOn = true;
codec_settings_.SetFrameDropEnabled(true);
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
encoder_->InitEncode(&codec_settings_, kSettings));
@ -491,7 +491,7 @@ TEST(Vp9ImplTest, EnableDisableSpatialLayersWithSvcController) {
std::unique_ptr<VideoEncoder> encoder = VP9Encoder::Create();
VideoCodec codec_settings = DefaultCodecSettings();
ConfigureSvc(codec_settings, num_spatial_layers);
codec_settings.VP9()->frameDroppingOn = true;
codec_settings.SetFrameDropEnabled(true);
EXPECT_EQ(encoder->InitEncode(&codec_settings, kSettings),
WEBRTC_VIDEO_CODEC_OK);
@ -559,7 +559,7 @@ TEST(Vp9ImplTest, SpatialUpswitchNotAtGOFBoundary) {
VideoCodec codec_settings = DefaultCodecSettings();
ConfigureSvc(codec_settings, /*num_spatial_layers=*/3,
/*num_temporal_layers=*/3);
codec_settings.VP9()->frameDroppingOn = true;
codec_settings.SetFrameDropEnabled(true);
EXPECT_EQ(encoder->InitEncode(&codec_settings, kSettings),
WEBRTC_VIDEO_CODEC_OK);
@ -605,7 +605,7 @@ TEST_F(TestVp9Impl, DISABLED_DisableEnableBaseLayerTriggersKeyFrame) {
const size_t num_frames_to_encode = 5;
ConfigureSvc(codec_settings_, num_spatial_layers, num_temporal_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.VP9()->flexibleMode = false;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOnKeyPic;
codec_settings_.mode = VideoCodecMode::kRealtimeVideo;
@ -762,7 +762,7 @@ TEST(Vp9ImplTest,
std::unique_ptr<VideoEncoder> encoder = VP9Encoder::Create();
VideoCodec codec_settings = DefaultCodecSettings();
ConfigureSvc(codec_settings, num_spatial_layers, num_temporal_layers);
codec_settings.VP9()->frameDroppingOn = false;
codec_settings.SetFrameDropEnabled(false);
codec_settings.VP9()->flexibleMode = false;
codec_settings.VP9()->interLayerPred = InterLayerPredMode::kOnKeyPic;
codec_settings.mode = VideoCodecMode::kRealtimeVideo;
@ -877,7 +877,7 @@ TEST_F(TestVp9Impl, DisableEnableBaseLayerTriggersKeyFrameForScreenshare) {
const size_t num_frames_to_encode = 5;
ConfigureSvc(codec_settings_, num_spatial_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.mode = VideoCodecMode::kScreensharing;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;
codec_settings_.VP9()->flexibleMode = true;
@ -1036,7 +1036,7 @@ TEST_F(TestVp9Impl, EndOfPicture) {
TEST_F(TestVp9Impl, InterLayerPred) {
const size_t num_spatial_layers = 2;
ConfigureSvc(codec_settings_, num_spatial_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
VideoBitrateAllocation bitrate_allocation;
for (size_t i = 0; i < num_spatial_layers; ++i) {
@ -1111,7 +1111,7 @@ TEST_F(TestVp9Impl,
const size_t num_frames_to_encode = 2;
ConfigureSvc(codec_settings_, num_spatial_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
const std::vector<InterLayerPredMode> inter_layer_pred_modes = {
InterLayerPredMode::kOff, InterLayerPredMode::kOn,
@ -1168,7 +1168,7 @@ TEST_F(TestVp9Impl,
const size_t num_frames_to_encode = 2;
ConfigureSvc(codec_settings_, num_spatial_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.VP9()->flexibleMode = false;
const std::vector<InterLayerPredMode> inter_layer_pred_modes = {
@ -1223,7 +1223,7 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerInTheSameGof) {
const size_t num_temporal_layers = 2;
ConfigureSvc(codec_settings_, num_spatial_layers, num_temporal_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.VP9()->flexibleMode = false;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;
@ -1295,7 +1295,7 @@ TEST_F(TestVp9Impl, EnablingDisablingUpperLayerAccrossGof) {
const size_t num_temporal_layers = 2;
ConfigureSvc(codec_settings_, num_spatial_layers, num_temporal_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.VP9()->flexibleMode = false;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;
@ -1381,7 +1381,7 @@ TEST_F(TestVp9Impl, EnablingNewLayerInScreenshareForcesAllLayersWithSS) {
// simplifies the test.
codec_settings_.spatialLayers[1].maxFramerate = 30.0;
codec_settings_.spatialLayers[2].maxFramerate = 30.0;
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.mode = VideoCodecMode::kScreensharing;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;
codec_settings_.VP9()->flexibleMode = true;
@ -1438,7 +1438,7 @@ TEST_F(TestVp9Impl, ScreenshareFrameDropping) {
codec_settings_.spatialLayers[0].maxFramerate = 30.0;
codec_settings_.spatialLayers[1].maxFramerate = 30.0;
codec_settings_.spatialLayers[2].maxFramerate = 30.0;
codec_settings_.VP9()->frameDroppingOn = true;
codec_settings_.SetFrameDropEnabled(true);
codec_settings_.mode = VideoCodecMode::kScreensharing;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;
codec_settings_.VP9()->flexibleMode = true;
@ -1530,7 +1530,7 @@ TEST_F(TestVp9Impl, RemovingLayerIsNotDelayedInScreenshareAndAddsSsInfo) {
// simplifies the test.
codec_settings_.spatialLayers[1].maxFramerate = 30.0;
codec_settings_.spatialLayers[2].maxFramerate = 30.0;
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.mode = VideoCodecMode::kScreensharing;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;
codec_settings_.VP9()->flexibleMode = true;
@ -1611,7 +1611,7 @@ TEST_F(TestVp9Impl, DisableNewLayerInVideoDelaysSsInfoTillTL0) {
// Chosen by hand, the 2nd frame is dropped with configured per-layer max
// framerate.
ConfigureSvc(codec_settings_, num_spatial_layers, num_temporal_layers);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.mode = VideoCodecMode::kRealtimeVideo;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOnKeyPic;
codec_settings_.VP9()->flexibleMode = false;
@ -1670,7 +1670,7 @@ TEST_F(TestVp9Impl, DisableNewLayerInVideoDelaysSsInfoTillTL0) {
TEST_F(TestVp9Impl,
LowLayerMarkedAsRefIfHighLayerNotEncodedAndInterLayerPredIsEnabled) {
ConfigureSvc(codec_settings_, 3);
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
@ -1839,7 +1839,7 @@ TEST_P(Vp9ImplWithLayeringTest, FlexibleMode) {
std::unique_ptr<VideoEncoder> encoder = VP9Encoder::Create();
VideoCodec codec_settings = DefaultCodecSettings();
codec_settings.VP9()->flexibleMode = true;
codec_settings.VP9()->frameDroppingOn = false;
codec_settings.SetFrameDropEnabled(false);
codec_settings.VP9()->numberOfSpatialLayers = num_spatial_layers_;
codec_settings.VP9()->numberOfTemporalLayers = num_temporal_layers_;
EXPECT_EQ(encoder->InitEncode(&codec_settings, kSettings),
@ -1945,7 +1945,7 @@ TEST_F(TestVp9ImplFrameDropping, DifferentFrameratePerSpatialLayer) {
const size_t num_input_frames = video_duration_secs * input_framerate_fps;
codec_settings_.VP9()->numberOfSpatialLayers = num_spatial_layers;
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.VP9()->flexibleMode = true;
VideoBitrateAllocation bitrate_allocation;
@ -2088,7 +2088,7 @@ TEST_F(TestVp9Impl, ReenablingUpperLayerAfterKFWithInterlayerPredIsEnabled) {
const size_t num_spatial_layers = 2;
const int num_frames_to_encode = 10;
codec_settings_.VP9()->flexibleMode = true;
codec_settings_.VP9()->frameDroppingOn = false;
codec_settings_.SetFrameDropEnabled(false);
codec_settings_.VP9()->numberOfSpatialLayers = num_spatial_layers;
codec_settings_.VP9()->numberOfTemporalLayers = 1;
codec_settings_.VP9()->interLayerPred = InterLayerPredMode::kOn;

3
modules/video_coding/utility/simulcast_test_fixture_impl.cc
View File

@ -242,13 +242,12 @@ void SimulcastTestFixtureImpl::DefaultSettings(
kMinBitrates[2], kTargetBitrates[2], kMaxFramerates[2],
&settings->simulcastStream[layer_order[2]],
temporal_layer_profile[2]);
settings->SetFrameDropEnabled(true);
if (codec_type == kVideoCodecVP8) {
settings->VP8()->denoisingOn = true;
settings->VP8()->automaticResizeOn = false;
settings->VP8()->frameDroppingOn = true;
settings->VP8()->keyFrameInterval = 3000;
} else {
settings->H264()->frameDroppingOn = true;
settings->H264()->keyFrameInterval = 3000;
}
}

1
modules/video_coding/video_codec_initializer.cc
View File

@ -72,6 +72,7 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
config.content_type == VideoEncoderConfig::ContentType::kScreen &&
config.legacy_conference_mode;
video_codec.SetFrameDropEnabled(config.frame_drop_enabled);
video_codec.numberOfSimulcastStreams =
static_cast<unsigned char>(streams.size());
video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;

4
rtc_tools/converter/yuv_to_ivf_converter.cc
View File

@ -127,23 +127,21 @@ class Encoder {
codec_settings.startBitrate = kBitrateBps;
codec_settings.minBitrate = kBitrateBps;
codec_settings.maxBitrate = kBitrateBps;
codec_settings.SetFrameDropEnabled(false);
switch (video_codec_type) {
case VideoCodecType::kVideoCodecVP8: {
VideoCodecVP8* vp8_settings = codec_settings.VP8();
vp8_settings->frameDroppingOn = false;
vp8_settings->keyFrameInterval = kKeyFrameIntervalMs;
vp8_settings->denoisingOn = false;
} break;
case VideoCodecType::kVideoCodecVP9: {
VideoCodecVP9* vp9_settings = codec_settings.VP9();
vp9_settings->denoisingOn = false;
vp9_settings->frameDroppingOn = false;
vp9_settings->keyFrameInterval = kKeyFrameIntervalMs;
vp9_settings->automaticResizeOn = false;
} break;
case VideoCodecType::kVideoCodecH264: {
VideoCodecH264* h264_settings = codec_settings.H264();
h264_settings->frameDroppingOn = false;
h264_settings->keyFrameInterval = kKeyFrameIntervalMs;
} break;
default:

2
test/fuzzers/vp9_encoder_references_fuzzer.cc
View File

@ -235,7 +235,7 @@ VideoCodec CodecSettings(FuzzDataHelper& rng) {
codec_settings.VP9()->interLayerPred = static_cast<InterLayerPredMode>(
inter_layer_pred < 3 ? inter_layer_pred : 0);
codec_settings.VP9()->flexibleMode = (config & (1u << 6)) != 0;
codec_settings.VP9()->frameDroppingOn = (config & (1u << 7)) != 0;
codec_settings.SetFrameDropEnabled((config & (1u << 7)) != 0);
codec_settings.mode = VideoCodecMode::kRealtimeVideo;
return codec_settings;
}

4
test/scenario/video_stream.cc
View File

@ -155,7 +155,6 @@ CreateVp9SpecificSettings(VideoStreamConfig video_config) {
constexpr auto kScreen = VideoStreamConfig::Encoder::ContentType::kScreen;
VideoStreamConfig::Encoder conf = video_config.encoder;
VideoCodecVP9 vp9 = VideoEncoder::GetDefaultVp9Settings();
vp9.frameDroppingOn = conf.frame_dropping;
vp9.keyFrameInterval = conf.key_frame_interval.value_or(0);
vp9.numberOfTemporalLayers = static_cast<uint8_t>(conf.layers.temporal);
vp9.numberOfSpatialLayers = static_cast<uint8_t>(conf.layers.spatial);
@ -181,7 +180,6 @@ CreateVp9SpecificSettings(VideoStreamConfig video_config) {
rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings>
CreateVp8SpecificSettings(VideoStreamConfig config) {
VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
vp8_settings.frameDroppingOn = config.encoder.frame_dropping;
vp8_settings.keyFrameInterval = config.encoder.key_frame_interval.value_or(0);
vp8_settings.numberOfTemporalLayers = config.encoder.layers.temporal;
if (config.encoder.layers.spatial * config.encoder.layers.temporal > 1) {
@ -201,7 +199,6 @@ CreateH264SpecificSettings(VideoStreamConfig config) {
RTC_DCHECK_EQ(config.encoder.layers.spatial, 1);
VideoCodecH264 h264_settings = VideoEncoder::GetDefaultH264Settings();
h264_settings.frameDroppingOn = config.encoder.frame_dropping;
h264_settings.keyFrameInterval =
config.encoder.key_frame_interval.value_or(0);
return rtc::make_ref_counted<VideoEncoderConfig::H264EncoderSpecificSettings>(
@ -259,6 +256,7 @@ VideoEncoderConfig CreateVideoEncoderConfig(VideoStreamConfig config) {
config.encoder.max_data_rate.value_or(DataRate::KilobitsPerSec(10000))
.bps();
encoder_config.frame_drop_enabled = config.encoder.frame_dropping;
encoder_config.encoder_specific_settings =
CreateEncoderSpecificSettings(config);
if (config.encoder.max_framerate) {

1
video/quality_scaling_tests.cc
View File

@ -133,6 +133,7 @@ class ScalingObserver : public test::SendTest {
stream.scale_resolution_down_by = scale_factor;
scale_factor *= (payload_name_ == "VP9") ? 1.0 : 2.0;
}
encoder_config->frame_drop_enabled = true;
SetEncoderSpecific(encoder_config, codec_type, automatic_resize_,
streams_active_.size());
}

5
video/video_send_stream_tests.cc
View File

@ -2404,7 +2404,7 @@ class VideoCodecConfigObserver : public test::SendTest,
<< "VideoEncoder not initialized.";
// Change encoder settings to actually trigger reconfiguration.
encoder_settings_.frameDroppingOn = !encoder_settings_.frameDroppingOn;
encoder_config_.frame_drop_enabled = !encoder_config_.frame_drop_enabled;
encoder_config_.encoder_specific_settings = GetEncoderSpecificSettings();
SendTask(RTC_FROM_HERE, task_queue_, [&]() {
stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
@ -3374,8 +3374,9 @@ void VideoSendStreamTest::TestVp9NonFlexMode(
EXPECT_EQ(1u, encoder_config->number_of_streams);
EXPECT_EQ(1u, encoder_config->simulcast_layers.size());
encoder_config->frame_drop_enabled = false;
vp9_settings_.flexibleMode = false;
vp9_settings_.frameDroppingOn = false;
vp9_settings_.automaticResizeOn = false;
vp9_settings_.keyFrameInterval = kKeyFrameInterval;
if (!use_scalability_mode_identifier_) {

4
video/video_stream_encoder.cc
View File

@ -90,7 +90,9 @@ bool RequiresEncoderReset(const VideoCodec& prev_send_codec,
new_send_codec.qpMax != prev_send_codec.qpMax ||
new_send_codec.numberOfSimulcastStreams !=
prev_send_codec.numberOfSimulcastStreams ||
new_send_codec.mode != prev_send_codec.mode) {
new_send_codec.mode != prev_send_codec.mode ||
new_send_codec.GetFrameDropEnabled() !=
prev_send_codec.GetFrameDropEnabled()) {
return true;
}

5
video/video_stream_encoder_unittest.cc
View File

@ -8772,10 +8772,7 @@ TEST_P(VideoStreamEncoderWithRealEncoderTest, HandlesLayerToggling) {
}
if (codec_type_ == VideoCodecType::kVideoCodecH264) {
// Turn off frame dropping to prevent flakiness.
VideoCodecH264 h264_settings = VideoEncoder::GetDefaultH264Settings();
h264_settings.frameDroppingOn = false;
config.encoder_specific_settings = rtc::make_ref_counted<
VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
config.frame_drop_enabled = false;
}
}