mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-14 14:20:45 +01:00
1dccfeb395
Bug: webrtc:15673 Change-Id: I7d3cdcda537c85f3be578cb00452e0611759704f Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/336280 Commit-Queue: Åsa Persson <asapersson@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/main@{#41621}
249 lines
10 KiB
C++
249 lines
10 KiB
C++
/*
|
|
* Copyright (c) 2018 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/codecs/vp9/svc_config.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "media/base/video_common.h"
|
|
#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
|
|
#include "modules/video_coding/svc/create_scalability_structure.h"
|
|
#include "modules/video_coding/svc/scalability_mode_util.h"
|
|
#include "rtc_base/checks.h"
|
|
#include "rtc_base/logging.h"
|
|
|
|
namespace webrtc {
|
|
|
|
namespace {
|
|
const size_t kMinVp9SvcBitrateKbps = 30;
|
|
|
|
const size_t kMaxNumLayersForScreenSharing = 3;
|
|
const float kMaxScreenSharingLayerFramerateFps[] = {5.0, 10.0, 30.0};
|
|
const size_t kMinScreenSharingLayerBitrateKbps[] = {30, 200, 500};
|
|
const size_t kTargetScreenSharingLayerBitrateKbps[] = {150, 350, 950};
|
|
const size_t kMaxScreenSharingLayerBitrateKbps[] = {250, 500, 950};
|
|
|
|
// Gets limited number of layers for given resolution.
|
|
size_t GetLimitedNumSpatialLayers(size_t width, size_t height) {
|
|
const bool is_landscape = width >= height;
|
|
const size_t min_width = is_landscape ? kMinVp9SpatialLayerLongSideLength
|
|
: kMinVp9SpatialLayerShortSideLength;
|
|
const size_t min_height = is_landscape ? kMinVp9SpatialLayerShortSideLength
|
|
: kMinVp9SpatialLayerLongSideLength;
|
|
const size_t num_layers_fit_horz = static_cast<size_t>(
|
|
std::floor(1 + std::max(0.0f, std::log2(1.0f * width / min_width))));
|
|
const size_t num_layers_fit_vert = static_cast<size_t>(
|
|
std::floor(1 + std::max(0.0f, std::log2(1.0f * height / min_height))));
|
|
return std::min(num_layers_fit_horz, num_layers_fit_vert);
|
|
}
|
|
} // namespace
|
|
|
|
std::vector<SpatialLayer> ConfigureSvcScreenSharing(size_t input_width,
|
|
size_t input_height,
|
|
float max_framerate_fps,
|
|
size_t num_spatial_layers) {
|
|
num_spatial_layers =
|
|
std::min(num_spatial_layers, kMaxNumLayersForScreenSharing);
|
|
std::vector<SpatialLayer> spatial_layers;
|
|
|
|
for (size_t sl_idx = 0; sl_idx < num_spatial_layers; ++sl_idx) {
|
|
SpatialLayer spatial_layer = {0};
|
|
spatial_layer.width = input_width;
|
|
spatial_layer.height = input_height;
|
|
spatial_layer.maxFramerate =
|
|
std::min(kMaxScreenSharingLayerFramerateFps[sl_idx], max_framerate_fps);
|
|
spatial_layer.numberOfTemporalLayers = 1;
|
|
spatial_layer.minBitrate =
|
|
static_cast<int>(kMinScreenSharingLayerBitrateKbps[sl_idx]);
|
|
spatial_layer.maxBitrate =
|
|
static_cast<int>(kMaxScreenSharingLayerBitrateKbps[sl_idx]);
|
|
spatial_layer.targetBitrate =
|
|
static_cast<int>(kTargetScreenSharingLayerBitrateKbps[sl_idx]);
|
|
spatial_layer.active = true;
|
|
spatial_layers.push_back(spatial_layer);
|
|
}
|
|
|
|
return spatial_layers;
|
|
}
|
|
|
|
std::vector<SpatialLayer> ConfigureSvcNormalVideo(
|
|
size_t input_width,
|
|
size_t input_height,
|
|
float max_framerate_fps,
|
|
size_t first_active_layer,
|
|
size_t num_spatial_layers,
|
|
size_t num_temporal_layers,
|
|
absl::optional<ScalableVideoController::StreamLayersConfig> config) {
|
|
RTC_DCHECK_LT(first_active_layer, num_spatial_layers);
|
|
|
|
// Limit number of layers for given resolution.
|
|
size_t limited_num_spatial_layers =
|
|
GetLimitedNumSpatialLayers(input_width, input_height);
|
|
if (limited_num_spatial_layers < num_spatial_layers) {
|
|
RTC_LOG(LS_WARNING) << "Reducing number of spatial layers from "
|
|
<< num_spatial_layers << " to "
|
|
<< limited_num_spatial_layers
|
|
<< " due to low input resolution.";
|
|
num_spatial_layers = limited_num_spatial_layers;
|
|
}
|
|
|
|
// First active layer must be configured.
|
|
num_spatial_layers = std::max(num_spatial_layers, first_active_layer + 1);
|
|
|
|
// Ensure top layer is even enough.
|
|
int required_divisiblity = 1 << (num_spatial_layers - first_active_layer - 1);
|
|
if (config) {
|
|
required_divisiblity = 1;
|
|
for (size_t sl_idx = 0; sl_idx < num_spatial_layers; ++sl_idx) {
|
|
required_divisiblity = cricket::LeastCommonMultiple(
|
|
required_divisiblity, config->scaling_factor_den[sl_idx]);
|
|
}
|
|
}
|
|
input_width = input_width - input_width % required_divisiblity;
|
|
input_height = input_height - input_height % required_divisiblity;
|
|
|
|
std::vector<SpatialLayer> spatial_layers;
|
|
for (size_t sl_idx = first_active_layer; sl_idx < num_spatial_layers;
|
|
++sl_idx) {
|
|
SpatialLayer spatial_layer = {0};
|
|
spatial_layer.width = input_width >> (num_spatial_layers - sl_idx - 1);
|
|
spatial_layer.height = input_height >> (num_spatial_layers - sl_idx - 1);
|
|
spatial_layer.maxFramerate = max_framerate_fps;
|
|
spatial_layer.numberOfTemporalLayers = num_temporal_layers;
|
|
spatial_layer.active = true;
|
|
|
|
if (config) {
|
|
spatial_layer.width = input_width * config->scaling_factor_num[sl_idx] /
|
|
config->scaling_factor_den[sl_idx];
|
|
spatial_layer.height = input_height * config->scaling_factor_num[sl_idx] /
|
|
config->scaling_factor_den[sl_idx];
|
|
}
|
|
|
|
// minBitrate and maxBitrate formulas were derived from
|
|
// subjective-quality data to determing bit rates below which video
|
|
// quality is unacceptable and above which additional bits do not provide
|
|
// benefit. The formulas express rate in units of kbps.
|
|
|
|
// TODO(ssilkin): Add to the comment PSNR/SSIM we get at encoding certain
|
|
// video to min/max bitrate specified by those formulas.
|
|
const size_t num_pixels = spatial_layer.width * spatial_layer.height;
|
|
int min_bitrate =
|
|
static_cast<int>((600. * std::sqrt(num_pixels) - 95000.) / 1000.);
|
|
min_bitrate = std::max(min_bitrate, 0);
|
|
spatial_layer.minBitrate =
|
|
std::max(static_cast<size_t>(min_bitrate), kMinVp9SvcBitrateKbps);
|
|
spatial_layer.maxBitrate =
|
|
static_cast<int>((1.6 * num_pixels + 50 * 1000) / 1000);
|
|
spatial_layer.targetBitrate =
|
|
(spatial_layer.minBitrate + spatial_layer.maxBitrate) / 2;
|
|
spatial_layers.push_back(spatial_layer);
|
|
}
|
|
|
|
// A workaround for situation when single HD layer is left with minBitrate
|
|
// about 500kbps. This would mean that there will always be at least 500kbps
|
|
// allocated to video regardless of how low is the actual BWE.
|
|
// Also, boost maxBitrate for the first layer to account for lost ability to
|
|
// predict from previous layers.
|
|
if (first_active_layer > 0) {
|
|
spatial_layers[0].minBitrate = kMinVp9SvcBitrateKbps;
|
|
// TODO(ilnik): tune this value or come up with a different formula to
|
|
// ensure that all singlecast configurations look good and not too much
|
|
// bitrate is added.
|
|
spatial_layers[0].maxBitrate *= 1.1;
|
|
}
|
|
|
|
return spatial_layers;
|
|
}
|
|
|
|
// Uses scalability mode to configure spatial layers.
|
|
std::vector<SpatialLayer> GetVp9SvcConfig(VideoCodec& codec) {
|
|
RTC_DCHECK_EQ(codec.codecType, kVideoCodecVP9);
|
|
|
|
absl::optional<ScalabilityMode> scalability_mode = codec.GetScalabilityMode();
|
|
RTC_DCHECK(scalability_mode.has_value());
|
|
|
|
bool requested_single_spatial_layer =
|
|
ScalabilityModeToNumSpatialLayers(*scalability_mode) == 1;
|
|
|
|
// Limit number of spatial layers for given resolution.
|
|
int limited_num_spatial_layers =
|
|
GetLimitedNumSpatialLayers(codec.width, codec.height);
|
|
if (limited_num_spatial_layers <
|
|
ScalabilityModeToNumSpatialLayers(*scalability_mode)) {
|
|
ScalabilityMode limited_scalability_mode =
|
|
LimitNumSpatialLayers(*scalability_mode, limited_num_spatial_layers);
|
|
RTC_LOG(LS_WARNING)
|
|
<< "Reducing number of spatial layers due to low input resolution: "
|
|
<< ScalabilityModeToString(*scalability_mode) << " to "
|
|
<< ScalabilityModeToString(limited_scalability_mode);
|
|
scalability_mode = limited_scalability_mode;
|
|
codec.SetScalabilityMode(limited_scalability_mode);
|
|
}
|
|
|
|
codec.VP9()->interLayerPred =
|
|
ScalabilityModeToInterLayerPredMode(*scalability_mode);
|
|
|
|
absl::optional<ScalableVideoController::StreamLayersConfig> info =
|
|
ScalabilityStructureConfig(*scalability_mode);
|
|
if (!info.has_value()) {
|
|
RTC_LOG(LS_WARNING) << "Failed to create structure "
|
|
<< ScalabilityModeToString(*scalability_mode);
|
|
return {};
|
|
}
|
|
|
|
// TODO(bugs.webrtc.org/11607): Add support for screensharing.
|
|
std::vector<SpatialLayer> spatial_layers =
|
|
GetSvcConfig(codec.width, codec.height, codec.maxFramerate,
|
|
/*first_active_layer=*/0, info->num_spatial_layers,
|
|
info->num_temporal_layers, /*is_screen_sharing=*/false,
|
|
codec.GetScalabilityMode() ? info : absl::nullopt);
|
|
RTC_DCHECK(!spatial_layers.empty());
|
|
|
|
spatial_layers[0].minBitrate = kMinVp9SvcBitrateKbps;
|
|
|
|
// Use codec bitrate limits if spatial layering is not requested.
|
|
if (requested_single_spatial_layer) {
|
|
SpatialLayer& spatial_layer = spatial_layers[0];
|
|
spatial_layer.minBitrate = codec.minBitrate;
|
|
spatial_layer.maxBitrate = codec.maxBitrate;
|
|
spatial_layer.targetBitrate = codec.maxBitrate;
|
|
}
|
|
|
|
return spatial_layers;
|
|
}
|
|
|
|
std::vector<SpatialLayer> GetSvcConfig(
|
|
size_t input_width,
|
|
size_t input_height,
|
|
float max_framerate_fps,
|
|
size_t first_active_layer,
|
|
size_t num_spatial_layers,
|
|
size_t num_temporal_layers,
|
|
bool is_screen_sharing,
|
|
absl::optional<ScalableVideoController::StreamLayersConfig> config) {
|
|
RTC_DCHECK_GT(input_width, 0);
|
|
RTC_DCHECK_GT(input_height, 0);
|
|
RTC_DCHECK_GT(num_spatial_layers, 0);
|
|
RTC_DCHECK_GT(num_temporal_layers, 0);
|
|
|
|
if (is_screen_sharing) {
|
|
return ConfigureSvcScreenSharing(input_width, input_height,
|
|
max_framerate_fps, num_spatial_layers);
|
|
} else {
|
|
return ConfigureSvcNormalVideo(input_width, input_height, max_framerate_fps,
|
|
first_active_layer, num_spatial_layers,
|
|
num_temporal_layers, config);
|
|
}
|
|
}
|
|
|
|
} // namespace webrtc
|