mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-13 05:40:42 +01:00
50e2054c5b
Before this change bitrate limits for VP9 single spatial layer case were set in VideoCodecInitializer. Move this logic to GetVp9SvcConfig. This simplifies replication of WebRTC behaviour in codec level tests. The similar AV1 logic sits in SetAv1SvcConfig, not VideoCodecInitializer. Bug: webrtc:14852 Change-Id: Ie7202ec880d0e4b903e7265721eeef9b3920f21a Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/324286 Commit-Queue: Sergey Silkin <ssilkin@webrtc.org> Reviewed-by: Philip Eliasson <philipel@webrtc.org> Cr-Commit-Position: refs/heads/main@{#40992}
363 lines
15 KiB
C++
363 lines
15 KiB
C++
/*
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "modules/video_coding/include/video_codec_initializer.h"
|
|
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
#include <algorithm>
|
|
|
|
#include "absl/types/optional.h"
|
|
#include "api/scoped_refptr.h"
|
|
#include "api/units/data_rate.h"
|
|
#include "api/video_codecs/video_encoder.h"
|
|
#include "modules/video_coding/codecs/av1/av1_svc_config.h"
|
|
#include "modules/video_coding/codecs/vp8/vp8_scalability.h"
|
|
#include "modules/video_coding/codecs/vp9/svc_config.h"
|
|
#include "modules/video_coding/include/video_coding_defines.h"
|
|
#include "modules/video_coding/svc/scalability_mode_util.h"
|
|
#include "rtc_base/checks.h"
|
|
#include "rtc_base/experiments/min_video_bitrate_experiment.h"
|
|
#include "rtc_base/logging.h"
|
|
#include "rtc_base/numerics/safe_conversions.h"
|
|
|
|
namespace webrtc {
|
|
|
|
bool VideoCodecInitializer::SetupCodec(const VideoEncoderConfig& config,
|
|
const std::vector<VideoStream>& streams,
|
|
VideoCodec* codec) {
|
|
if (config.codec_type == kVideoCodecMultiplex) {
|
|
VideoEncoderConfig associated_config = config.Copy();
|
|
associated_config.codec_type = kVideoCodecVP9;
|
|
if (!SetupCodec(associated_config, streams, codec)) {
|
|
RTC_LOG(LS_ERROR) << "Failed to create stereo encoder configuration.";
|
|
return false;
|
|
}
|
|
codec->codecType = kVideoCodecMultiplex;
|
|
return true;
|
|
}
|
|
|
|
*codec = VideoEncoderConfigToVideoCodec(config, streams);
|
|
return true;
|
|
}
|
|
|
|
// TODO(sprang): Split this up and separate the codec specific parts.
|
|
VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
|
|
const VideoEncoderConfig& config,
|
|
const std::vector<VideoStream>& streams) {
|
|
static const int kEncoderMinBitrateKbps = 30;
|
|
RTC_DCHECK(!streams.empty());
|
|
RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
|
|
|
|
VideoCodec video_codec;
|
|
video_codec.codecType = config.codec_type;
|
|
|
|
switch (config.content_type) {
|
|
case VideoEncoderConfig::ContentType::kRealtimeVideo:
|
|
video_codec.mode = VideoCodecMode::kRealtimeVideo;
|
|
break;
|
|
case VideoEncoderConfig::ContentType::kScreen:
|
|
video_codec.mode = VideoCodecMode::kScreensharing;
|
|
break;
|
|
}
|
|
|
|
video_codec.legacy_conference_mode =
|
|
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;
|
|
bool codec_active = false;
|
|
// Active configuration might not be fully copied to `streams` for SVC yet.
|
|
// Therefore the `config` is checked here.
|
|
for (const VideoStream& stream : config.simulcast_layers) {
|
|
if (stream.active) {
|
|
codec_active = true;
|
|
break;
|
|
}
|
|
}
|
|
// Set active for the entire video codec for the non simulcast case.
|
|
video_codec.active = codec_active;
|
|
if (video_codec.minBitrate < kEncoderMinBitrateKbps)
|
|
video_codec.minBitrate = kEncoderMinBitrateKbps;
|
|
video_codec.timing_frame_thresholds = {kDefaultTimingFramesDelayMs,
|
|
kDefaultOutlierFrameSizePercent};
|
|
RTC_DCHECK_LE(streams.size(), kMaxSimulcastStreams);
|
|
|
|
int max_framerate = 0;
|
|
|
|
absl::optional<ScalabilityMode> scalability_mode =
|
|
streams[0].scalability_mode;
|
|
for (size_t i = 0; i < streams.size(); ++i) {
|
|
SimulcastStream* sim_stream = &video_codec.simulcastStream[i];
|
|
RTC_DCHECK_GT(streams[i].width, 0);
|
|
RTC_DCHECK_GT(streams[i].height, 0);
|
|
RTC_DCHECK_GT(streams[i].max_framerate, 0);
|
|
RTC_DCHECK_GE(streams[i].min_bitrate_bps, 0);
|
|
RTC_DCHECK_GE(streams[i].target_bitrate_bps, streams[i].min_bitrate_bps);
|
|
RTC_DCHECK_GE(streams[i].max_bitrate_bps, streams[i].target_bitrate_bps);
|
|
RTC_DCHECK_GE(streams[i].max_qp, 0);
|
|
|
|
sim_stream->width = static_cast<uint16_t>(streams[i].width);
|
|
sim_stream->height = static_cast<uint16_t>(streams[i].height);
|
|
sim_stream->maxFramerate = streams[i].max_framerate;
|
|
sim_stream->minBitrate = streams[i].min_bitrate_bps / 1000;
|
|
sim_stream->targetBitrate = streams[i].target_bitrate_bps / 1000;
|
|
sim_stream->maxBitrate = streams[i].max_bitrate_bps / 1000;
|
|
sim_stream->qpMax = streams[i].max_qp;
|
|
|
|
int num_temporal_layers =
|
|
streams[i].scalability_mode.has_value()
|
|
? ScalabilityModeToNumTemporalLayers(*streams[i].scalability_mode)
|
|
: streams[i].num_temporal_layers.value_or(1);
|
|
|
|
sim_stream->numberOfTemporalLayers =
|
|
static_cast<unsigned char>(num_temporal_layers);
|
|
sim_stream->active = streams[i].active;
|
|
|
|
video_codec.width =
|
|
std::max(video_codec.width, static_cast<uint16_t>(streams[i].width));
|
|
video_codec.height =
|
|
std::max(video_codec.height, static_cast<uint16_t>(streams[i].height));
|
|
video_codec.minBitrate =
|
|
std::min(static_cast<uint16_t>(video_codec.minBitrate),
|
|
static_cast<uint16_t>(streams[i].min_bitrate_bps / 1000));
|
|
video_codec.maxBitrate += streams[i].max_bitrate_bps / 1000;
|
|
video_codec.qpMax = std::max(video_codec.qpMax,
|
|
static_cast<unsigned int>(streams[i].max_qp));
|
|
max_framerate = std::max(max_framerate, streams[i].max_framerate);
|
|
|
|
// TODO(bugs.webrtc.org/11607): Since scalability mode is a top-level
|
|
// setting on VideoCodec, setting it makes sense only if it is the same for
|
|
// all active simulcast streams.
|
|
if (streams[i].active &&
|
|
streams[0].scalability_mode != streams[i].scalability_mode) {
|
|
scalability_mode.reset();
|
|
// For VP8, top-level scalability mode doesn't matter, since configuration
|
|
// is based on the per-simulcast stream configuration of temporal layers.
|
|
if (video_codec.codecType != kVideoCodecVP8) {
|
|
RTC_LOG(LS_WARNING) << "Inconsistent scalability modes configured.";
|
|
}
|
|
}
|
|
}
|
|
|
|
if (scalability_mode.has_value()) {
|
|
video_codec.SetScalabilityMode(*scalability_mode);
|
|
}
|
|
|
|
if (video_codec.maxBitrate == 0) {
|
|
// Unset max bitrate -> cap to one bit per pixel.
|
|
video_codec.maxBitrate =
|
|
(video_codec.width * video_codec.height * video_codec.maxFramerate) /
|
|
1000;
|
|
}
|
|
if (video_codec.maxBitrate < kEncoderMinBitrateKbps)
|
|
video_codec.maxBitrate = kEncoderMinBitrateKbps;
|
|
|
|
video_codec.maxFramerate = max_framerate;
|
|
video_codec.spatialLayers[0] = {0};
|
|
video_codec.spatialLayers[0].width = video_codec.width;
|
|
video_codec.spatialLayers[0].height = video_codec.height;
|
|
video_codec.spatialLayers[0].maxFramerate = max_framerate;
|
|
video_codec.spatialLayers[0].numberOfTemporalLayers =
|
|
streams[0].scalability_mode.has_value()
|
|
? ScalabilityModeToNumTemporalLayers(*streams[0].scalability_mode)
|
|
: streams[0].num_temporal_layers.value_or(1);
|
|
|
|
// Set codec specific options
|
|
if (config.encoder_specific_settings)
|
|
config.encoder_specific_settings->FillEncoderSpecificSettings(&video_codec);
|
|
|
|
switch (video_codec.codecType) {
|
|
case kVideoCodecVP8: {
|
|
if (!config.encoder_specific_settings) {
|
|
*video_codec.VP8() = VideoEncoder::GetDefaultVp8Settings();
|
|
}
|
|
|
|
// Validate specified scalability modes. If some layer has an unsupported
|
|
// mode, store it as the top-level scalability mode, which will make
|
|
// InitEncode fail with an appropriate error.
|
|
for (const auto& stream : streams) {
|
|
if (stream.scalability_mode.has_value() &&
|
|
!VP8SupportsScalabilityMode(*stream.scalability_mode)) {
|
|
RTC_LOG(LS_WARNING)
|
|
<< "Invalid scalability mode for VP8: "
|
|
<< ScalabilityModeToString(*stream.scalability_mode);
|
|
video_codec.SetScalabilityMode(*stream.scalability_mode);
|
|
break;
|
|
}
|
|
}
|
|
video_codec.VP8()->numberOfTemporalLayers =
|
|
streams.back().scalability_mode.has_value()
|
|
? ScalabilityModeToNumTemporalLayers(
|
|
*streams.back().scalability_mode)
|
|
: streams.back().num_temporal_layers.value_or(
|
|
video_codec.VP8()->numberOfTemporalLayers);
|
|
|
|
RTC_DCHECK_GE(video_codec.VP8()->numberOfTemporalLayers, 1);
|
|
RTC_DCHECK_LE(video_codec.VP8()->numberOfTemporalLayers,
|
|
kMaxTemporalStreams);
|
|
|
|
break;
|
|
}
|
|
case kVideoCodecVP9: {
|
|
// When the SvcRateAllocator is used, "active" is controlled by
|
|
// `SpatialLayer::active` instead.
|
|
if (video_codec.numberOfSimulcastStreams <= 1) {
|
|
video_codec.simulcastStream[0].active = codec_active;
|
|
}
|
|
|
|
if (!config.encoder_specific_settings) {
|
|
*video_codec.VP9() = VideoEncoder::GetDefaultVp9Settings();
|
|
}
|
|
|
|
video_codec.VP9()->numberOfTemporalLayers = static_cast<unsigned char>(
|
|
streams.back().num_temporal_layers.value_or(
|
|
video_codec.VP9()->numberOfTemporalLayers));
|
|
RTC_DCHECK_GE(video_codec.VP9()->numberOfTemporalLayers, 1);
|
|
RTC_DCHECK_LE(video_codec.VP9()->numberOfTemporalLayers,
|
|
kMaxTemporalStreams);
|
|
|
|
RTC_DCHECK(config.spatial_layers.empty() ||
|
|
config.spatial_layers.size() ==
|
|
video_codec.VP9()->numberOfSpatialLayers);
|
|
|
|
std::vector<SpatialLayer> spatial_layers;
|
|
if (!config.spatial_layers.empty()) {
|
|
// Layering is set explicitly.
|
|
spatial_layers = config.spatial_layers;
|
|
} else if (video_codec.GetScalabilityMode().has_value()) {
|
|
// Layering is set via scalability mode.
|
|
spatial_layers = GetVp9SvcConfig(video_codec);
|
|
} else {
|
|
size_t first_active_layer = 0;
|
|
for (size_t spatial_idx = 0;
|
|
spatial_idx < config.simulcast_layers.size(); ++spatial_idx) {
|
|
if (config.simulcast_layers[spatial_idx].active) {
|
|
first_active_layer = spatial_idx;
|
|
break;
|
|
}
|
|
}
|
|
|
|
spatial_layers = GetSvcConfig(
|
|
video_codec.width, video_codec.height, video_codec.maxFramerate,
|
|
first_active_layer, video_codec.VP9()->numberOfSpatialLayers,
|
|
video_codec.VP9()->numberOfTemporalLayers,
|
|
video_codec.mode == VideoCodecMode::kScreensharing);
|
|
|
|
// If there was no request for spatial layering, don't limit bitrate
|
|
// of single spatial layer.
|
|
const bool no_spatial_layering =
|
|
video_codec.VP9()->numberOfSpatialLayers <= 1;
|
|
if (no_spatial_layering) {
|
|
// Use codec's bitrate limits.
|
|
spatial_layers.back().minBitrate = video_codec.minBitrate;
|
|
spatial_layers.back().targetBitrate = video_codec.maxBitrate;
|
|
spatial_layers.back().maxBitrate = video_codec.maxBitrate;
|
|
}
|
|
|
|
for (size_t spatial_idx = first_active_layer;
|
|
spatial_idx < config.simulcast_layers.size() &&
|
|
spatial_idx < spatial_layers.size() + first_active_layer;
|
|
++spatial_idx) {
|
|
spatial_layers[spatial_idx - first_active_layer].active =
|
|
config.simulcast_layers[spatial_idx].active;
|
|
}
|
|
}
|
|
|
|
RTC_DCHECK(!spatial_layers.empty());
|
|
for (size_t i = 0; i < spatial_layers.size(); ++i) {
|
|
video_codec.spatialLayers[i] = spatial_layers[i];
|
|
}
|
|
|
|
// The top spatial layer dimensions may not be equal to the input
|
|
// resolution because of the rounding or explicit configuration.
|
|
// This difference must be propagated to the stream configuration.
|
|
video_codec.width = spatial_layers.back().width;
|
|
video_codec.height = spatial_layers.back().height;
|
|
// Only propagate if we're not doing simulcast. Simulcast is assumed not
|
|
// to have multiple spatial layers, if we wanted to support simulcast+SVC
|
|
// combos we would need to calculate unique spatial layers per simulcast
|
|
// layer, but VideoCodec is not capable of expressing per-simulcastStream
|
|
// spatialLayers.
|
|
if (video_codec.numberOfSimulcastStreams == 1) {
|
|
video_codec.simulcastStream[0].width = spatial_layers.back().width;
|
|
video_codec.simulcastStream[0].height = spatial_layers.back().height;
|
|
}
|
|
|
|
// Update layering settings.
|
|
video_codec.VP9()->numberOfSpatialLayers =
|
|
static_cast<unsigned char>(spatial_layers.size());
|
|
RTC_DCHECK_GE(video_codec.VP9()->numberOfSpatialLayers, 1);
|
|
RTC_DCHECK_LE(video_codec.VP9()->numberOfSpatialLayers,
|
|
kMaxSpatialLayers);
|
|
|
|
video_codec.VP9()->numberOfTemporalLayers = static_cast<unsigned char>(
|
|
spatial_layers.back().numberOfTemporalLayers);
|
|
RTC_DCHECK_GE(video_codec.VP9()->numberOfTemporalLayers, 1);
|
|
RTC_DCHECK_LE(video_codec.VP9()->numberOfTemporalLayers,
|
|
kMaxTemporalStreams);
|
|
|
|
break;
|
|
}
|
|
case kVideoCodecAV1:
|
|
if (SetAv1SvcConfig(video_codec,
|
|
/*num_temporal_layers=*/
|
|
streams.back().num_temporal_layers.value_or(1),
|
|
/*num_spatial_layers=*/
|
|
std::max<int>(config.spatial_layers.size(), 1))) {
|
|
for (size_t i = 0; i < config.spatial_layers.size(); ++i) {
|
|
video_codec.spatialLayers[i].active = config.spatial_layers[i].active;
|
|
}
|
|
} else {
|
|
RTC_LOG(LS_WARNING) << "Failed to configure svc bitrates for av1.";
|
|
}
|
|
break;
|
|
case kVideoCodecH264: {
|
|
RTC_CHECK(!config.encoder_specific_settings);
|
|
|
|
*video_codec.H264() = VideoEncoder::GetDefaultH264Settings();
|
|
video_codec.H264()->numberOfTemporalLayers = static_cast<unsigned char>(
|
|
streams.back().num_temporal_layers.value_or(
|
|
video_codec.H264()->numberOfTemporalLayers));
|
|
RTC_DCHECK_GE(video_codec.H264()->numberOfTemporalLayers, 1);
|
|
RTC_DCHECK_LE(video_codec.H264()->numberOfTemporalLayers,
|
|
kMaxTemporalStreams);
|
|
break;
|
|
}
|
|
case kVideoCodecH265:
|
|
// TODO(bugs.webrtc.org/13485)
|
|
break;
|
|
default:
|
|
// TODO(pbos): Support encoder_settings codec-agnostically.
|
|
RTC_DCHECK(!config.encoder_specific_settings)
|
|
<< "Encoder-specific settings for codec type not wired up.";
|
|
break;
|
|
}
|
|
|
|
const absl::optional<DataRate> experimental_min_bitrate =
|
|
GetExperimentalMinVideoBitrate(video_codec.codecType);
|
|
if (experimental_min_bitrate) {
|
|
const int experimental_min_bitrate_kbps =
|
|
rtc::saturated_cast<int>(experimental_min_bitrate->kbps());
|
|
video_codec.minBitrate = experimental_min_bitrate_kbps;
|
|
video_codec.simulcastStream[0].minBitrate = experimental_min_bitrate_kbps;
|
|
if (video_codec.codecType == kVideoCodecVP9) {
|
|
video_codec.spatialLayers[0].minBitrate = experimental_min_bitrate_kbps;
|
|
}
|
|
}
|
|
|
|
return video_codec;
|
|
}
|
|
|
|
} // namespace webrtc
|