211 lines
8.3 KiB
C++
211 lines
8.3 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/fec_controller_default.h" // NOLINT
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <algorithm>
|
|
#include <string>
|
|
|
|
#include "modules/include/module_fec_types.h"
|
|
#include "rtc_base/logging.h"
|
|
#include "system_wrappers/include/field_trial.h"
|
|
|
|
namespace webrtc {
|
|
|
|
const float kProtectionOverheadRateThreshold = 0.5;
|
|
|
|
FecControllerDefault::FecControllerDefault(
|
|
Clock* clock,
|
|
VCMProtectionCallback* protection_callback)
|
|
: clock_(clock),
|
|
protection_callback_(protection_callback),
|
|
loss_prot_logic_(new media_optimization::VCMLossProtectionLogic(
|
|
clock_->TimeInMilliseconds())),
|
|
max_payload_size_(1460),
|
|
overhead_threshold_(GetProtectionOverheadRateThreshold()) {}
|
|
|
|
FecControllerDefault::FecControllerDefault(Clock* clock)
|
|
: clock_(clock),
|
|
loss_prot_logic_(new media_optimization::VCMLossProtectionLogic(
|
|
clock_->TimeInMilliseconds())),
|
|
max_payload_size_(1460),
|
|
overhead_threshold_(GetProtectionOverheadRateThreshold()) {}
|
|
|
|
FecControllerDefault::~FecControllerDefault(void) {
|
|
loss_prot_logic_->Release();
|
|
}
|
|
|
|
void FecControllerDefault::SetProtectionCallback(
|
|
VCMProtectionCallback* protection_callback) {
|
|
protection_callback_ = protection_callback;
|
|
}
|
|
|
|
void FecControllerDefault::SetEncodingData(size_t width,
|
|
size_t height,
|
|
size_t num_temporal_layers,
|
|
size_t max_payload_size) {
|
|
MutexLock lock(&mutex_);
|
|
loss_prot_logic_->UpdateFrameSize(width, height);
|
|
loss_prot_logic_->UpdateNumLayers(num_temporal_layers);
|
|
max_payload_size_ = max_payload_size;
|
|
}
|
|
|
|
float FecControllerDefault::GetProtectionOverheadRateThreshold() {
|
|
float overhead_threshold =
|
|
strtof(webrtc::field_trial::FindFullName(
|
|
"WebRTC-ProtectionOverheadRateThreshold")
|
|
.c_str(),
|
|
nullptr);
|
|
if (overhead_threshold > 0 && overhead_threshold <= 1) {
|
|
RTC_LOG(LS_INFO) << "ProtectionOverheadRateThreshold is set to "
|
|
<< overhead_threshold;
|
|
return overhead_threshold;
|
|
} else if (overhead_threshold < 0 || overhead_threshold > 1) {
|
|
RTC_LOG(WARNING) << "ProtectionOverheadRateThreshold field trial is set to "
|
|
"an invalid value, expecting a value between (0, 1].";
|
|
}
|
|
// WebRTC-ProtectionOverheadRateThreshold field trial string is not found, use
|
|
// the default value.
|
|
return kProtectionOverheadRateThreshold;
|
|
}
|
|
|
|
uint32_t FecControllerDefault::UpdateFecRates(
|
|
uint32_t estimated_bitrate_bps,
|
|
int actual_framerate_fps,
|
|
uint8_t fraction_lost,
|
|
std::vector<bool> loss_mask_vector,
|
|
int64_t round_trip_time_ms) {
|
|
float target_bitrate_kbps =
|
|
static_cast<float>(estimated_bitrate_bps) / 1000.0f;
|
|
// Sanity check.
|
|
if (actual_framerate_fps < 1.0) {
|
|
actual_framerate_fps = 1.0;
|
|
}
|
|
FecProtectionParams delta_fec_params;
|
|
FecProtectionParams key_fec_params;
|
|
{
|
|
MutexLock lock(&mutex_);
|
|
loss_prot_logic_->UpdateBitRate(target_bitrate_kbps);
|
|
loss_prot_logic_->UpdateRtt(round_trip_time_ms);
|
|
// Update frame rate for the loss protection logic class: frame rate should
|
|
// be the actual/sent rate.
|
|
loss_prot_logic_->UpdateFrameRate(actual_framerate_fps);
|
|
// Returns the filtered packet loss, used for the protection setting.
|
|
// The filtered loss may be the received loss (no filter), or some
|
|
// filtered value (average or max window filter).
|
|
// Use max window filter for now.
|
|
media_optimization::FilterPacketLossMode filter_mode =
|
|
media_optimization::kMaxFilter;
|
|
uint8_t packet_loss_enc = loss_prot_logic_->FilteredLoss(
|
|
clock_->TimeInMilliseconds(), filter_mode, fraction_lost);
|
|
// For now use the filtered loss for computing the robustness settings.
|
|
loss_prot_logic_->UpdateFilteredLossPr(packet_loss_enc);
|
|
if (loss_prot_logic_->SelectedType() == media_optimization::kNone) {
|
|
return estimated_bitrate_bps;
|
|
}
|
|
// Update method will compute the robustness settings for the given
|
|
// protection method and the overhead cost
|
|
// the protection method is set by the user via SetVideoProtection.
|
|
loss_prot_logic_->UpdateMethod();
|
|
// Get the bit cost of protection method, based on the amount of
|
|
// overhead data actually transmitted (including headers) the last
|
|
// second.
|
|
// Get the FEC code rate for Key frames (set to 0 when NA).
|
|
key_fec_params.fec_rate =
|
|
loss_prot_logic_->SelectedMethod()->RequiredProtectionFactorK();
|
|
// Get the FEC code rate for Delta frames (set to 0 when NA).
|
|
delta_fec_params.fec_rate =
|
|
loss_prot_logic_->SelectedMethod()->RequiredProtectionFactorD();
|
|
// The RTP module currently requires the same |max_fec_frames| for both
|
|
// key and delta frames.
|
|
delta_fec_params.max_fec_frames =
|
|
loss_prot_logic_->SelectedMethod()->MaxFramesFec();
|
|
key_fec_params.max_fec_frames =
|
|
loss_prot_logic_->SelectedMethod()->MaxFramesFec();
|
|
}
|
|
// Set the FEC packet mask type. |kFecMaskBursty| is more effective for
|
|
// consecutive losses and little/no packet re-ordering. As we currently
|
|
// do not have feedback data on the degree of correlated losses and packet
|
|
// re-ordering, we keep default setting to |kFecMaskRandom| for now.
|
|
delta_fec_params.fec_mask_type = kFecMaskRandom;
|
|
key_fec_params.fec_mask_type = kFecMaskRandom;
|
|
// Update protection callback with protection settings.
|
|
uint32_t sent_video_rate_bps = 0;
|
|
uint32_t sent_nack_rate_bps = 0;
|
|
uint32_t sent_fec_rate_bps = 0;
|
|
// Rate cost of the protection methods.
|
|
float protection_overhead_rate = 0.0f;
|
|
// TODO(Marco): Pass FEC protection values per layer.
|
|
protection_callback_->ProtectionRequest(
|
|
&delta_fec_params, &key_fec_params, &sent_video_rate_bps,
|
|
&sent_nack_rate_bps, &sent_fec_rate_bps);
|
|
uint32_t sent_total_rate_bps =
|
|
sent_video_rate_bps + sent_nack_rate_bps + sent_fec_rate_bps;
|
|
// Estimate the overhead costs of the next second as staying the same
|
|
// wrt the source bitrate.
|
|
if (sent_total_rate_bps > 0) {
|
|
protection_overhead_rate =
|
|
static_cast<float>(sent_nack_rate_bps + sent_fec_rate_bps) /
|
|
sent_total_rate_bps;
|
|
}
|
|
// Cap the overhead estimate to a threshold, default is 50%.
|
|
protection_overhead_rate =
|
|
std::min(protection_overhead_rate, overhead_threshold_);
|
|
// Source coding rate: total rate - protection overhead.
|
|
return estimated_bitrate_bps * (1.0 - protection_overhead_rate);
|
|
}
|
|
|
|
void FecControllerDefault::SetProtectionMethod(bool enable_fec,
|
|
bool enable_nack) {
|
|
media_optimization::VCMProtectionMethodEnum method(media_optimization::kNone);
|
|
if (enable_fec && enable_nack) {
|
|
method = media_optimization::kNackFec;
|
|
} else if (enable_nack) {
|
|
method = media_optimization::kNack;
|
|
} else if (enable_fec) {
|
|
method = media_optimization::kFec;
|
|
}
|
|
MutexLock lock(&mutex_);
|
|
loss_prot_logic_->SetMethod(method);
|
|
}
|
|
|
|
void FecControllerDefault::UpdateWithEncodedData(
|
|
const size_t encoded_image_length,
|
|
const VideoFrameType encoded_image_frametype) {
|
|
const size_t encoded_length = encoded_image_length;
|
|
MutexLock lock(&mutex_);
|
|
if (encoded_length > 0) {
|
|
const bool delta_frame =
|
|
encoded_image_frametype != VideoFrameType::kVideoFrameKey;
|
|
if (max_payload_size_ > 0 && encoded_length > 0) {
|
|
const float min_packets_per_frame =
|
|
encoded_length / static_cast<float>(max_payload_size_);
|
|
if (delta_frame) {
|
|
loss_prot_logic_->UpdatePacketsPerFrame(min_packets_per_frame,
|
|
clock_->TimeInMilliseconds());
|
|
} else {
|
|
loss_prot_logic_->UpdatePacketsPerFrameKey(
|
|
min_packets_per_frame, clock_->TimeInMilliseconds());
|
|
}
|
|
}
|
|
if (!delta_frame && encoded_length > 0) {
|
|
loss_prot_logic_->UpdateKeyFrameSize(static_cast<float>(encoded_length));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FecControllerDefault::UseLossVectorMask() {
|
|
return false;
|
|
}
|
|
|
|
} // namespace webrtc
|