04f4d126f8
Timing information is gathered in EncodedImage, starting at encoders. Then it's sent using RTP header extension. In the end, it's gathered at the GenericDecoder. Actual reporting and tests will be in the next CLs. BUG=webrtc:7594 Review-Url: https://codereview.webrtc.org/2911193002 Cr-Commit-Position: refs/heads/master@{#18659}
234 lines
9.5 KiB
C++
234 lines
9.5 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_types.h"
|
|
#include "webrtc/common_video/include/video_bitrate_allocator.h"
|
|
#include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
|
|
#include "webrtc/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h"
|
|
#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
|
|
#include "webrtc/modules/video_coding/include/video_coding_defines.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->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.empty() &&
|
|
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;
|
|
video_codec.timing_frame_thresholds = {kDefaultTimingFramesDelayMs,
|
|
kDefaultOutlierFrameSizePercent};
|
|
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, unless it's
|
|
// screenshare where there is an exception and a simulcast encoder adapter,
|
|
// which supports different framerates, is used instead.
|
|
if (config.content_type != VideoEncoderConfig::ContentType::kScreen) {
|
|
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
|