ulpfec_generator.cc | Explore in Territory

/*
 *  Copyright (c) 2012 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/rtp_rtcp/source/ulpfec_generator.h"

#include <string.h>

#include <cstdint>
#include <memory>
#include <utility>

#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/byte_io.h"
#include "modules/rtp_rtcp/source/forward_error_correction.h"
#include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
#include "rtc_base/checks.h"
#include "rtc_base/synchronization/mutex.h"

namespace webrtc {

namespace {

constexpr size_t kRedForFecHeaderLength = …;

// This controls the maximum amount of excess overhead (actual - target)
// allowed in order to trigger EncodeFec(), before `params_.max_fec_frames`
// is reached. Overhead here is defined as relative to number of media packets.
constexpr int kMaxExcessOverhead = …;  // Q8.

// This is the minimum number of media packets required (above some protection
// level) in order to trigger EncodeFec(), before `params_.max_fec_frames` is
// reached.
constexpr size_t kMinMediaPackets = …;

// Threshold on the received FEC protection level, above which we enforce at
// least `kMinMediaPackets` packets for the FEC code. Below this
// threshold `kMinMediaPackets` is set to default value of 1.
//
// The range is between 0 and 255, where 255 corresponds to 100% overhead
// (relative to the number of protected media packets).
constexpr uint8_t kHighProtectionThreshold = …;

// This threshold is used to adapt the `kMinMediaPackets` threshold, based
// on the average number of packets per frame seen so far. When there are few
// packets per frame (as given by this threshold), at least
// `kMinMediaPackets` + 1 packets are sent to the FEC code.
constexpr float kMinMediaPacketsAdaptationThreshold = …;

// At construction time, we don't know the SSRC that is used for the generated
// FEC packets, but we still need to give it to the ForwardErrorCorrection ctor
// to be used in the decoding.
// TODO(brandtr): Get rid of this awkwardness by splitting
// ForwardErrorCorrection in two objects -- one encoder and one decoder.
constexpr uint32_t kUnknownSsrc = …;

}  // namespace

UlpfecGenerator::Params::Params() = default;
UlpfecGenerator::Params::Params(FecProtectionParams delta_params,
                                FecProtectionParams keyframe_params)
    : … { … }

UlpfecGenerator::UlpfecGenerator(const Environment& env,
                                 int red_payload_type,
                                 int ulpfec_payload_type)
    : … { … }

// Used by FlexFecSender, payload types are unused.
UlpfecGenerator::UlpfecGenerator(const Environment& env,
                                 std::unique_ptr<ForwardErrorCorrection> fec)
    : … { … }

UlpfecGenerator::~UlpfecGenerator() = default;

void UlpfecGenerator::SetProtectionParameters(
    const FecProtectionParams& delta_params,
    const FecProtectionParams& key_params) { … }

void UlpfecGenerator::AddPacketAndGenerateFec(const RtpPacketToSend& packet) { … }

bool UlpfecGenerator::ExcessOverheadBelowMax() const { … }

bool UlpfecGenerator::MinimumMediaPacketsReached() const { … }

const FecProtectionParams& UlpfecGenerator::CurrentParams() const { … }

size_t UlpfecGenerator::MaxPacketOverhead() const { … }

std::vector<std::unique_ptr<RtpPacketToSend>> UlpfecGenerator::GetFecPackets() { … }

DataRate UlpfecGenerator::CurrentFecRate() const { … }

int UlpfecGenerator::Overhead() const { … }

void UlpfecGenerator::ResetState() { … }

}  // namespace webrtc
chromium/third_party/webrtc/modules/rtp_rtcp/source/ulpfec_generator.cc
