zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename ProducerFec to UlpfecGenerator.

Browse Source 
BUG=webrtc:5654

Review-Url: https://codereview.webrtc.org/2449783002
Cr-Commit-Position: refs/heads/master@{#14847}
This commit is contained in:
brandtr
2016-10-31 05:27:07 -07:00
committed by Commit bot
parent d55c3f68c8
commit 869e7cd8e7
10 changed files with 83 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/modules/BUILD.gn
View File

@ -421,7 +421,6 @@ if (rtc_include_tests) {
"rtp_rtcp/source/nack_rtx_unittest.cc",
"rtp_rtcp/source/packet_loss_stats_unittest.cc",
"rtp_rtcp/source/playout_delay_oracle_unittest.cc",
"rtp_rtcp/source/producer_fec_unittest.cc",
"rtp_rtcp/source/receive_statistics_unittest.cc",
"rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc",
"rtp_rtcp/source/rtcp_packet/app_unittest.cc",
@ -464,6 +463,7 @@ if (rtc_include_tests) {
"rtp_rtcp/source/rtp_rtcp_impl_unittest.cc",
"rtp_rtcp/source/rtp_sender_unittest.cc",
"rtp_rtcp/source/time_util_unittest.cc",
"rtp_rtcp/source/ulpfec_generator_unittest.cc",
"rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc",
"rtp_rtcp/source/ulpfec_receiver_unittest.cc",
"rtp_rtcp/source/vp8_partition_aggregator_unittest.cc",

4
webrtc/modules/rtp_rtcp/BUILD.gn
View File

@ -38,8 +38,6 @@ rtc_static_library("rtp_rtcp") {
"source/packet_loss_stats.h",
"source/playout_delay_oracle.cc",
"source/playout_delay_oracle.h",
"source/producer_fec.cc",
"source/producer_fec.h",
"source/receive_statistics_impl.cc",
"source/receive_statistics_impl.h",
"source/remote_ntp_time_estimator.cc",
@ -150,6 +148,8 @@ rtc_static_library("rtp_rtcp") {
"source/time_util.h",
"source/tmmbr_help.cc",
"source/tmmbr_help.h",
"source/ulpfec_generator.cc",
"source/ulpfec_generator.h",
"source/ulpfec_header_reader_writer.cc",
"source/ulpfec_header_reader_writer.h",
"source/ulpfec_receiver_impl.cc",

4
webrtc/modules/rtp_rtcp/rtp_rtcp.gypi
View File

@ -137,8 +137,6 @@
'source/forward_error_correction.h',
'source/forward_error_correction_internal.cc',
'source/forward_error_correction_internal.h',
'source/producer_fec.cc',
'source/producer_fec.h',
'source/rtp_packet_history.cc',
'source/rtp_packet_history.h',
'source/rtp_payload_registry.cc',
@ -159,6 +157,8 @@
'source/rtp_format_vp9.h',
'source/rtp_format_video_generic.cc',
'source/rtp_format_video_generic.h',
'source/ulpfec_generator.cc',
'source/ulpfec_generator.h',
'source/ulpfec_header_reader_writer.cc',
'source/ulpfec_header_reader_writer.h',
'source/ulpfec_receiver_impl.cc',

19
webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -22,7 +22,6 @@
#include "webrtc/base/trace_event.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/producer_fec.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
@ -123,15 +122,15 @@ void RTPSenderVideo::SendVideoPacketAsRed(
rtc::CritScope cs(&crit_);
red_packet->SetPayloadType(red_payload_type_);
if (protect) {
producer_fec_.AddRtpPacketAndGenerateFec(media_packet->data(),
media_packet->payload_size(),
media_packet->headers_size());
ulpfec_generator_.AddRtpPacketAndGenerateFec(
media_packet->data(), media_packet->payload_size(),
media_packet->headers_size());
}
uint16_t num_fec_packets = producer_fec_.NumAvailableFecPackets();
uint16_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets();
if (num_fec_packets > 0) {
uint16_t first_fec_sequence_number =
rtp_sender_->AllocateSequenceNumber(num_fec_packets);
fec_packets = producer_fec_.GetUlpfecPacketsAsRed(
fec_packets = ulpfec_generator_.GetUlpfecPacketsAsRed(
red_payload_type_, fec_payload_type_, first_fec_sequence_number,
media_packet->headers_size());
RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
@ -152,7 +151,7 @@ void RTPSenderVideo::SendVideoPacketAsRed(
LOG(LS_WARNING) << "Failed to send RED packet " << media_seq_num;
}
for (const auto& fec_packet : fec_packets) {
// TODO(danilchap): Make producer_fec_ generate RtpPacketToSend to avoid
// TODO(danilchap): Make ulpfec_generator_ generate RtpPacketToSend to avoid
// reparsing them.
std::unique_ptr<RtpPacketToSend> rtp_packet(
new RtpPacketToSend(*media_packet));
@ -202,11 +201,11 @@ size_t RTPSenderVideo::FecPacketOverhead() const {
// This reason for the header extensions to be included here is that
// from an FEC viewpoint, they are part of the payload to be protected.
// (The base RTP header is already protected by the FEC header.)
return producer_fec_.MaxPacketOverhead() + kRedForFecHeaderLength +
return ulpfec_generator_.MaxPacketOverhead() + kRedForFecHeaderLength +
(rtp_sender_->RtpHeaderLength() - kRtpHeaderSize);
}
if (fec_enabled_)
overhead += producer_fec_.MaxPacketOverhead();
overhead += ulpfec_generator_.MaxPacketOverhead();
return overhead;
}
@ -277,7 +276,7 @@ bool RTPSenderVideo::SendVideo(RtpVideoCodecTypes video_type,
rtc::CritScope cs(&crit_);
FecProtectionParams* fec_params =
frame_type == kVideoFrameKey ? &key_fec_params_ : &delta_fec_params_;
producer_fec_.SetFecParameters(fec_params);
ulpfec_generator_.SetFecParameters(fec_params);
storage = packetizer->GetStorageType(retransmission_settings_);
red_payload_type = red_payload_type_;
}

4
webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -22,10 +22,10 @@
#include "webrtc/common_types.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
#include "webrtc/modules/rtp_rtcp/source/producer_fec.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h"
#include "webrtc/modules/rtp_rtcp/source/video_codec_information.h"
#include "webrtc/typedefs.h"
@ -104,7 +104,7 @@ class RTPSenderVideo {
0, 1, kFecMaskRandom};
FecProtectionParams key_fec_params_ GUARDED_BY(crit_) = FecProtectionParams{
0, 1, kFecMaskRandom};
ProducerFec producer_fec_ GUARDED_BY(crit_);
UlpfecGenerator ulpfec_generator_ GUARDED_BY(crit_);
rtc::CriticalSection stats_crit_;
// Bitrate used for FEC payload, RED headers, RTP headers for FEC packets

37
webrtc/modules/rtp_rtcp/source/producer_fec.cc → webrtc/modules/rtp_rtcp/source/ulpfec_generator.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/modules/rtp_rtcp/source/producer_fec.h"
#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h"
#include <memory>
#include <utility>
@ -52,10 +52,7 @@ constexpr float kMinMediaPacketsAdaptationThreshold = 2.0f;
} // namespace
RedPacket::RedPacket(size_t length)
: data_(new uint8_t[length]),
length_(length),
header_length_(0) {
}
: data_(new uint8_t[length]), length_(length), header_length_(0) {}
void RedPacket::CreateHeader(const uint8_t* rtp_header,
size_t header_length,
@ -96,7 +93,7 @@ size_t RedPacket::length() const {
return length_;
}
ProducerFec::ProducerFec()
UlpfecGenerator::UlpfecGenerator()
: fec_(ForwardErrorCorrection::CreateUlpfec()),
num_protected_frames_(0),
min_num_media_packets_(1) {
@ -104,9 +101,9 @@ ProducerFec::ProducerFec()
memset(&new_params_, 0, sizeof(new_params_));
}
ProducerFec::~ProducerFec() = default;
UlpfecGenerator::~UlpfecGenerator() = default;
std::unique_ptr<RedPacket> ProducerFec::BuildRedPacket(
std::unique_ptr<RedPacket> UlpfecGenerator::BuildRedPacket(
const uint8_t* data_buffer,
size_t payload_length,
size_t rtp_header_length,
@ -120,7 +117,7 @@ std::unique_ptr<RedPacket> ProducerFec::BuildRedPacket(
return red_packet;
}
void ProducerFec::SetFecParameters(const FecProtectionParams* params) {
void UlpfecGenerator::SetFecParameters(const FecProtectionParams* params) {
RTC_DCHECK_GE(params->fec_rate, 0);
RTC_DCHECK_LE(params->fec_rate, 255);
// Store the new params and apply them for the next set of FEC packets being
@ -133,9 +130,9 @@ void ProducerFec::SetFecParameters(const FecProtectionParams* params) {
}
}
int ProducerFec::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
size_t payload_length,
size_t rtp_header_length) {
int UlpfecGenerator::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
size_t payload_length,
size_t rtp_header_length) {
RTC_DCHECK(generated_fec_packets_.empty());
if (media_packets_.empty()) {
params_ = new_params_;
@ -175,11 +172,11 @@ int ProducerFec::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
return 0;
}
bool ProducerFec::ExcessOverheadBelowMax() const {
bool UlpfecGenerator::ExcessOverheadBelowMax() const {
return ((Overhead() - params_.fec_rate) < kMaxExcessOverhead);
}
bool ProducerFec::MinimumMediaPacketsReached() const {
bool UlpfecGenerator::MinimumMediaPacketsReached() const {
float average_num_packets_per_frame =
static_cast<float>(media_packets_.size()) / num_protected_frames_;
int num_media_packets = static_cast<int>(media_packets_.size());
@ -192,19 +189,19 @@ bool ProducerFec::MinimumMediaPacketsReached() const {
}
}
bool ProducerFec::FecAvailable() const {
bool UlpfecGenerator::FecAvailable() const {
return !generated_fec_packets_.empty();
}
size_t ProducerFec::NumAvailableFecPackets() const {
size_t UlpfecGenerator::NumAvailableFecPackets() const {
return generated_fec_packets_.size();
}
size_t ProducerFec::MaxPacketOverhead() const {
size_t UlpfecGenerator::MaxPacketOverhead() const {
return fec_->MaxPacketOverhead();
}
std::vector<std::unique_ptr<RedPacket>> ProducerFec::GetUlpfecPacketsAsRed(
std::vector<std::unique_ptr<RedPacket>> UlpfecGenerator::GetUlpfecPacketsAsRed(
int red_payload_type,
int ulpfec_payload_type,
uint16_t first_seq_num,
@ -234,7 +231,7 @@ std::vector<std::unique_ptr<RedPacket>> ProducerFec::GetUlpfecPacketsAsRed(
return red_packets;
}
int ProducerFec::Overhead() const {
int UlpfecGenerator::Overhead() const {
RTC_DCHECK(!media_packets_.empty());
int num_fec_packets =
fec_->NumFecPackets(media_packets_.size(), params_.fec_rate);
@ -242,7 +239,7 @@ int ProducerFec::Overhead() const {
return (num_fec_packets << 8) / media_packets_.size();
}
void ProducerFec::ResetState() {
void UlpfecGenerator::ResetState() {
media_packets_.clear();
generated_fec_packets_.clear();
num_protected_frames_ = 0;

12
webrtc/modules/rtp_rtcp/source/producer_fec.h → webrtc/modules/rtp_rtcp/source/ulpfec_generator.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_
#include <list>
#include <memory>
@ -39,10 +39,10 @@ class RedPacket {
size_t header_length_;
};
class ProducerFec {
class UlpfecGenerator {
public:
ProducerFec();
~ProducerFec();
UlpfecGenerator();
~UlpfecGenerator();
static std::unique_ptr<RedPacket> BuildRedPacket(const uint8_t* data_buffer,
size_t payload_length,
@ -106,4 +106,4 @@ class ProducerFec {
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_

65
webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc → webrtc/modules/rtp_rtcp/source/ulpfec_generator_unittest.cc
View File

@ -17,7 +17,7 @@
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
#include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
#include "webrtc/modules/rtp_rtcp/source/producer_fec.h"
#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h"
#include "webrtc/test/gtest.h"
namespace webrtc {
@ -50,11 +50,11 @@ void VerifyHeader(uint16_t seq_num,
EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]);
}
class ProducerFecTest : public ::testing::Test {
class UlpfecGeneratorTest : public ::testing::Test {
protected:
ProducerFecTest() : packet_generator_(kMediaSsrc) {}
UlpfecGeneratorTest() : packet_generator_(kMediaSsrc) {}
ProducerFec producer_;
UlpfecGenerator ulpfec_generator_;
AugmentedPacketGenerator packet_generator_;
};
@ -62,7 +62,7 @@ class ProducerFecTest : public ::testing::Test {
// to move past the end of the current FEC packet mask byte without moving to
// the next byte. That likely caused us to repeatedly read from the same byte,
// and if that byte didn't protect packets we would generate empty FEC.
TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) {
TEST_F(UlpfecGeneratorTest, NoEmptyFecWithSeqNumGaps) {
struct Packet {
size_t header_size;
size_t payload_size;
@ -81,7 +81,7 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) {
protected_packets.push_back({21, 0, 55, 0});
protected_packets.push_back({13, 3, 57, 1});
FecProtectionParams params = {117, 3, kFecMaskBursty};
producer_.SetFecParameters(&params);
ulpfec_generator_.SetFecParameters(&params);
uint8_t packet[28] = {0};
for (Packet p : protected_packets) {
if (p.marker_bit) {
@ -90,18 +90,19 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) {
packet[1] &= ~0x80;
}
ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num);
producer_.AddRtpPacketAndGenerateFec(packet, p.payload_size, p.header_size);
size_t num_fec_packets = producer_.NumAvailableFecPackets();
ulpfec_generator_.AddRtpPacketAndGenerateFec(packet, p.payload_size,
p.header_size);
size_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets();
if (num_fec_packets > 0) {
std::vector<std::unique_ptr<RedPacket>> fec_packets =
producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100,
p.header_size);
ulpfec_generator_.GetUlpfecPacketsAsRed(
kRedPayloadType, kFecPayloadType, 100, p.header_size);
EXPECT_EQ(num_fec_packets, fec_packets.size());
}
}
}
TEST_F(ProducerFecTest, OneFrameFec) {
TEST_F(UlpfecGeneratorTest, OneFrameFec) {
// The number of media packets (|kNumPackets|), number of frames (one for
// this test), and the protection factor (|params->fec_rate|) are set to make
// sure the conditions for generating FEC are satisfied. This means:
@ -111,27 +112,27 @@ TEST_F(ProducerFecTest, OneFrameFec) {
constexpr size_t kNumPackets = 4;
FecProtectionParams params = {15, 3, kFecMaskRandom};
packet_generator_.NewFrame(kNumPackets);
producer_.SetFecParameters(&params); // Expecting one FEC packet.
ulpfec_generator_.SetFecParameters(&params); // Expecting one FEC packet.
uint32_t last_timestamp = 0;
for (size_t i = 0; i < kNumPackets; ++i) {
std::unique_ptr<AugmentedPacket> packet =
packet_generator_.NextPacket(i, 10);
EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec(
packet->data, packet->length, kRtpHeaderSize));
last_timestamp = packet->header.header.timestamp;
}
EXPECT_TRUE(producer_.FecAvailable());
EXPECT_TRUE(ulpfec_generator_.FecAvailable());
uint16_t seq_num = packet_generator_.NextPacketSeqNum();
std::vector<std::unique_ptr<RedPacket>> red_packets =
producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num,
kRtpHeaderSize);
EXPECT_FALSE(producer_.FecAvailable());
ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType,
seq_num, kRtpHeaderSize);
EXPECT_FALSE(ulpfec_generator_.FecAvailable());
ASSERT_EQ(1u, red_packets.size());
VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
red_packets.front().get(), false);
}
TEST_F(ProducerFecTest, TwoFrameFec) {
TEST_F(UlpfecGeneratorTest, TwoFrameFec) {
// The number of media packets/frame (|kNumPackets|), the number of frames
// (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to
// make sure the conditions for generating FEC are satisfied. This means:
@ -143,35 +144,35 @@ TEST_F(ProducerFecTest, TwoFrameFec) {
constexpr size_t kNumFrames = 2;
FecProtectionParams params = {15, 3, kFecMaskRandom};
producer_.SetFecParameters(&params); // Expecting one FEC packet.
ulpfec_generator_.SetFecParameters(&params); // Expecting one FEC packet.
uint32_t last_timestamp = 0;
for (size_t i = 0; i < kNumFrames; ++i) {
packet_generator_.NewFrame(kNumPackets);
for (size_t j = 0; j < kNumPackets; ++j) {
std::unique_ptr<AugmentedPacket> packet =
packet_generator_.NextPacket(i * kNumPackets + j, 10);
EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec(
packet->data, packet->length, kRtpHeaderSize));
last_timestamp = packet->header.header.timestamp;
}
}
EXPECT_TRUE(producer_.FecAvailable());
EXPECT_TRUE(ulpfec_generator_.FecAvailable());
uint16_t seq_num = packet_generator_.NextPacketSeqNum();
std::vector<std::unique_ptr<RedPacket>> red_packets =
producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num,
kRtpHeaderSize);
EXPECT_FALSE(producer_.FecAvailable());
ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType,
seq_num, kRtpHeaderSize);
EXPECT_FALSE(ulpfec_generator_.FecAvailable());
ASSERT_EQ(1u, red_packets.size());
VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
red_packets.front().get(), false);
}
TEST_F(ProducerFecTest, BuildRedPacket) {
TEST_F(UlpfecGeneratorTest, BuildRedPacket) {
packet_generator_.NewFrame(1);
std::unique_ptr<AugmentedPacket> packet = packet_generator_.NextPacket(0, 10);
std::unique_ptr<RedPacket> red_packet =
ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize,
kRtpHeaderSize, kRedPayloadType);
std::unique_ptr<RedPacket> red_packet = UlpfecGenerator::BuildRedPacket(
packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize,
kRedPayloadType);
EXPECT_EQ(packet->length + 1, red_packet->length());
VerifyHeader(packet->header.header.sequenceNumber,
packet->header.header.timestamp, kRedPayloadType,
@ -182,7 +183,7 @@ TEST_F(ProducerFecTest, BuildRedPacket) {
}
}
TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) {
TEST_F(UlpfecGeneratorTest, BuildRedPacketWithEmptyPayload) {
constexpr size_t kNumFrames = 1;
constexpr size_t kPayloadLength = 0;
constexpr size_t kRedForFecHeaderLength = 1;
@ -190,9 +191,9 @@ TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) {
packet_generator_.NewFrame(kNumFrames);
std::unique_ptr<AugmentedPacket> packet(
packet_generator_.NextPacket(0, kPayloadLength));
std::unique_ptr<RedPacket> red_packet =
ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize,
kRtpHeaderSize, kRedPayloadType);
std::unique_ptr<RedPacket> red_packet = UlpfecGenerator::BuildRedPacket(
packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize,
kRedPayloadType);
EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length());
VerifyHeader(packet->header.header.sequenceNumber,
packet->header.header.timestamp, kRedPayloadType,

4
webrtc/test/fuzzers/BUILD.gn
View File

@ -86,9 +86,9 @@ webrtc_fuzzer_test("ulpfec_header_reader_fuzzer") {
]
}
webrtc_fuzzer_test("producer_fec_fuzzer") {
webrtc_fuzzer_test("ulpfec_generator_fuzzer") {
sources = [
"producer_fec_fuzzer.cc",
"ulpfec_generator_fuzzer.cc",
]
deps = [
"../../modules/rtp_rtcp/",

18
webrtc/test/fuzzers/producer_fec_fuzzer.cc → webrtc/test/fuzzers/ulpfec_generator_fuzzer.cc
View File

@ -13,7 +13,7 @@
#include "webrtc/base/checks.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
#include "webrtc/modules/rtp_rtcp/source/producer_fec.h"
#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h"
namespace webrtc {
@ -23,13 +23,13 @@ constexpr uint8_t kRedPayloadType = 97;
} // namespace
void FuzzOneInput(const uint8_t* data, size_t size) {
ProducerFec producer;
UlpfecGenerator generator;
size_t i = 0;
if (size < 4)
return;
FecProtectionParams params = {
data[i++] % 128, static_cast<int>(data[i++] % 10), kFecMaskBursty};
producer.SetFecParameters(&params);
generator.SetFecParameters(&params);
uint16_t seq_num = data[i++];
while (i + 3 < size) {
@ -43,18 +43,18 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
ByteWriter<uint16_t>::WriteBigEndian(&packet[2], seq_num++);
i += payload_size + rtp_header_length;
// Make sure sequence numbers are increasing.
std::unique_ptr<RedPacket> red_packet = ProducerFec::BuildRedPacket(
std::unique_ptr<RedPacket> red_packet = UlpfecGenerator::BuildRedPacket(
packet.get(), payload_size, rtp_header_length, kRedPayloadType);
const bool protect = data[i++] % 2 == 1;
if (protect) {
producer.AddRtpPacketAndGenerateFec(packet.get(), payload_size,
rtp_header_length);
generator.AddRtpPacketAndGenerateFec(packet.get(), payload_size,
rtp_header_length);
}
const size_t num_fec_packets = producer.NumAvailableFecPackets();
const size_t num_fec_packets = generator.NumAvailableFecPackets();
if (num_fec_packets > 0) {
std::vector<std::unique_ptr<RedPacket>> fec_packets =
producer.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100,
rtp_header_length);
generator.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100,
rtp_header_length);
RTC_CHECK_EQ(num_fec_packets, fec_packets.size());
}
}