44303ea0ff
Reason for revert:
Breaks chromium.
Original issue's description:
> Add experimental simulcast screen content mode
>
> BUG=webrtc:4172
>
> Review-Url: https://codereview.webrtc.org/2636443002
> Cr-Commit-Position: refs/heads/master@{#16135}
> Committed: a28e971e3b
TBR=perkj@webrtc.org,asapersson@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:4172
Review-Url: https://codereview.webrtc.org/2643763002
Cr-Commit-Position: refs/heads/master@{#16145}
226 lines
9.0 KiB
C++
226 lines
9.0 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 "webrtc/modules/video_coding/include/video_codec_initializer.h"
|
|
|
|
#include "webrtc/base/basictypes.h"
|
|
#include "webrtc/base/logging.h"
|
|
#include "webrtc/common_video/include/video_bitrate_allocator.h"
|
|
#include "webrtc/common_types.h"
|
|
#include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
|
|
#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
|
|
#include "webrtc/modules/video_coding/utility/simulcast_rate_allocator.h"
|
|
#include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
|
|
#include "webrtc/system_wrappers/include/clock.h"
|
|
|
|
namespace webrtc {
|
|
|
|
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) {
|
|
*codec =
|
|
VideoEncoderConfigToVideoCodec(config, streams, settings.payload_name,
|
|
settings.payload_type, nack_enabled);
|
|
|
|
std::unique_ptr<TemporalLayersFactory> tl_factory;
|
|
switch (codec->codecType) {
|
|
case kVideoCodecVP8: {
|
|
if (!codec->VP8()->tl_factory) {
|
|
if (codec->mode == kScreensharing &&
|
|
codec->numberOfSimulcastStreams == 1 &&
|
|
codec->VP8()->numberOfTemporalLayers == 2) {
|
|
// Conference mode temporal layering for screen content.
|
|
tl_factory.reset(new ScreenshareTemporalLayersFactory());
|
|
} else {
|
|
// Standard video temporal layers.
|
|
tl_factory.reset(new TemporalLayersFactory());
|
|
}
|
|
codec->VP8()->tl_factory = tl_factory.get();
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
// TODO(sprang): Warn, once we have specific allocators for all supported
|
|
// codec types.
|
|
break;
|
|
}
|
|
}
|
|
*bitrate_allocator = CreateBitrateAllocator(*codec, std::move(tl_factory));
|
|
|
|
return true;
|
|
}
|
|
|
|
std::unique_ptr<VideoBitrateAllocator>
|
|
VideoCodecInitializer::CreateBitrateAllocator(
|
|
const VideoCodec& codec,
|
|
std::unique_ptr<TemporalLayersFactory> tl_factory) {
|
|
std::unique_ptr<VideoBitrateAllocator> rate_allocator;
|
|
|
|
switch (codec.codecType) {
|
|
case kVideoCodecVP8: {
|
|
// Set up default VP8 temporal layer factory, if not provided.
|
|
rate_allocator.reset(
|
|
new SimulcastRateAllocator(codec, std::move(tl_factory)));
|
|
} break;
|
|
default:
|
|
rate_allocator.reset(new DefaultVideoBitrateAllocator(codec));
|
|
}
|
|
|
|
return rate_allocator;
|
|
}
|
|
|
|
// TODO(sprang): Split this up and separate the codec specific parts.
|
|
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());
|
|
RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
|
|
|
|
VideoCodec video_codec;
|
|
memset(&video_codec, 0, sizeof(video_codec));
|
|
video_codec.codecType = PayloadNameToCodecType(payload_name)
|
|
.value_or(VideoCodecType::kVideoCodecGeneric);
|
|
|
|
switch (config.content_type) {
|
|
case VideoEncoderConfig::ContentType::kRealtimeVideo:
|
|
video_codec.mode = kRealtimeVideo;
|
|
break;
|
|
case VideoEncoderConfig::ContentType::kScreen:
|
|
video_codec.mode = kScreensharing;
|
|
if (streams.size() == 1 &&
|
|
streams[0].temporal_layer_thresholds_bps.size() == 1) {
|
|
video_codec.targetBitrate =
|
|
streams[0].temporal_layer_thresholds_bps[0] / 1000;
|
|
}
|
|
break;
|
|
}
|
|
|
|
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();
|
|
video_codec.VP8()->numberOfTemporalLayers = static_cast<unsigned char>(
|
|
streams.back().temporal_layer_thresholds_bps.size() + 1);
|
|
bool temporal_layers_configured = false;
|
|
for (const VideoStream& stream : streams) {
|
|
if (stream.temporal_layer_thresholds_bps.size() > 0)
|
|
temporal_layers_configured = true;
|
|
}
|
|
if (nack_enabled && !temporal_layers_configured) {
|
|
LOG(LS_INFO) << "No temporal layers and nack enabled -> resilience off";
|
|
video_codec.VP8()->resilience = kResilienceOff;
|
|
}
|
|
break;
|
|
}
|
|
case kVideoCodecVP9: {
|
|
if (!config.encoder_specific_settings)
|
|
*video_codec.VP9() = VideoEncoder::GetDefaultVp9Settings();
|
|
if (video_codec.mode == kScreensharing &&
|
|
config.encoder_specific_settings) {
|
|
video_codec.VP9()->flexibleMode = true;
|
|
// For now VP9 screensharing use 1 temporal and 2 spatial layers.
|
|
RTC_DCHECK_EQ(1, video_codec.VP9()->numberOfTemporalLayers);
|
|
RTC_DCHECK_EQ(2, video_codec.VP9()->numberOfSpatialLayers);
|
|
}
|
|
video_codec.VP9()->numberOfTemporalLayers = static_cast<unsigned char>(
|
|
streams.back().temporal_layer_thresholds_bps.size() + 1);
|
|
break;
|
|
}
|
|
case kVideoCodecH264: {
|
|
if (!config.encoder_specific_settings)
|
|
*video_codec.H264() = VideoEncoder::GetDefaultH264Settings();
|
|
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;
|
|
}
|
|
|
|
strncpy(video_codec.plName, payload_name.c_str(), kPayloadNameSize - 1);
|
|
video_codec.plName[kPayloadNameSize - 1] = '\0';
|
|
video_codec.plType = payload_type;
|
|
video_codec.numberOfSimulcastStreams =
|
|
static_cast<unsigned char>(streams.size());
|
|
video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;
|
|
if (video_codec.minBitrate < kEncoderMinBitrateKbps)
|
|
video_codec.minBitrate = kEncoderMinBitrateKbps;
|
|
RTC_DCHECK_LE(streams.size(), kMaxSimulcastStreams);
|
|
if (video_codec.codecType == kVideoCodecVP9) {
|
|
// If the vector is empty, bitrates will be configured automatically.
|
|
RTC_DCHECK(config.spatial_layers.empty() ||
|
|
config.spatial_layers.size() ==
|
|
video_codec.VP9()->numberOfSpatialLayers);
|
|
RTC_DCHECK_LE(video_codec.VP9()->numberOfSpatialLayers,
|
|
kMaxSimulcastStreams);
|
|
for (size_t i = 0; i < config.spatial_layers.size(); ++i)
|
|
video_codec.spatialLayers[i] = config.spatial_layers[i];
|
|
}
|
|
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);
|
|
// Different framerates not supported per stream at the moment.
|
|
RTC_DCHECK_EQ(streams[i].max_framerate, streams[0].max_framerate);
|
|
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->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;
|
|
sim_stream->numberOfTemporalLayers = static_cast<unsigned char>(
|
|
streams[i].temporal_layer_thresholds_bps.size() + 1);
|
|
|
|
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));
|
|
}
|
|
|
|
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;
|
|
|
|
RTC_DCHECK_GT(streams[0].max_framerate, 0);
|
|
video_codec.maxFramerate = streams[0].max_framerate;
|
|
return video_codec;
|
|
}
|
|
|
|
} // namespace webrtc
|