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/nack_rtx_unittest.cc",
"rtp_rtcp/source/packet_loss_stats_unittest.cc", "rtp_rtcp/source/packet_loss_stats_unittest.cc",
"rtp_rtcp/source/playout_delay_oracle_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/receive_statistics_unittest.cc",
"rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc", "rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc",
"rtp_rtcp/source/rtcp_packet/app_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_rtcp_impl_unittest.cc",
"rtp_rtcp/source/rtp_sender_unittest.cc", "rtp_rtcp/source/rtp_sender_unittest.cc",
"rtp_rtcp/source/time_util_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_header_reader_writer_unittest.cc",
"rtp_rtcp/source/ulpfec_receiver_unittest.cc", "rtp_rtcp/source/ulpfec_receiver_unittest.cc",
"rtp_rtcp/source/vp8_partition_aggregator_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/packet_loss_stats.h",
"source/playout_delay_oracle.cc", "source/playout_delay_oracle.cc",
"source/playout_delay_oracle.h", "source/playout_delay_oracle.h",
"source/producer_fec.cc",
"source/producer_fec.h",
"source/receive_statistics_impl.cc", "source/receive_statistics_impl.cc",
"source/receive_statistics_impl.h", "source/receive_statistics_impl.h",
"source/remote_ntp_time_estimator.cc", "source/remote_ntp_time_estimator.cc",
@ -150,6 +148,8 @@ rtc_static_library("rtp_rtcp") {
"source/time_util.h", "source/time_util.h",
"source/tmmbr_help.cc", "source/tmmbr_help.cc",
"source/tmmbr_help.h", "source/tmmbr_help.h",
"source/ulpfec_generator.cc",
"source/ulpfec_generator.h",
"source/ulpfec_header_reader_writer.cc", "source/ulpfec_header_reader_writer.cc",
"source/ulpfec_header_reader_writer.h", "source/ulpfec_header_reader_writer.h",
"source/ulpfec_receiver_impl.cc", "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.h',
'source/forward_error_correction_internal.cc', 'source/forward_error_correction_internal.cc',
'source/forward_error_correction_internal.h', 'source/forward_error_correction_internal.h',
'source/producer_fec.cc',
'source/producer_fec.h',
'source/rtp_packet_history.cc', 'source/rtp_packet_history.cc',
'source/rtp_packet_history.h', 'source/rtp_packet_history.h',
'source/rtp_payload_registry.cc', 'source/rtp_payload_registry.cc',
@ -159,6 +157,8 @@
'source/rtp_format_vp9.h', 'source/rtp_format_vp9.h',
'source/rtp_format_video_generic.cc', 'source/rtp_format_video_generic.cc',
'source/rtp_format_video_generic.h', '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.cc',
'source/ulpfec_header_reader_writer.h', 'source/ulpfec_header_reader_writer.h',
'source/ulpfec_receiver_impl.cc', '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/base/trace_event.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.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/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_video_generic.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h" #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h" #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
@ -123,15 +122,15 @@ void RTPSenderVideo::SendVideoPacketAsRed(
rtc::CritScope cs(&crit_); rtc::CritScope cs(&crit_);
red_packet->SetPayloadType(red_payload_type_); red_packet->SetPayloadType(red_payload_type_);
if (protect) { if (protect) {
producer_fec_.AddRtpPacketAndGenerateFec(media_packet->data(), ulpfec_generator_.AddRtpPacketAndGenerateFec(
media_packet->payload_size(), media_packet->data(), media_packet->payload_size(),
media_packet->headers_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) { if (num_fec_packets > 0) {
uint16_t first_fec_sequence_number = uint16_t first_fec_sequence_number =
rtp_sender_->AllocateSequenceNumber(num_fec_packets); 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, red_payload_type_, fec_payload_type_, first_fec_sequence_number,
media_packet->headers_size()); media_packet->headers_size());
RTC_DCHECK_EQ(num_fec_packets, fec_packets.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; LOG(LS_WARNING) << "Failed to send RED packet " << media_seq_num;
} }
for (const auto& fec_packet : fec_packets) { 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. // reparsing them.
std::unique_ptr<RtpPacketToSend> rtp_packet( std::unique_ptr<RtpPacketToSend> rtp_packet(
new RtpPacketToSend(*media_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 // 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. // from an FEC viewpoint, they are part of the payload to be protected.
// (The base RTP header is already protected by the FEC header.) // (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); (rtp_sender_->RtpHeaderLength() - kRtpHeaderSize);
} }
if (fec_enabled_) if (fec_enabled_)
overhead += producer_fec_.MaxPacketOverhead(); overhead += ulpfec_generator_.MaxPacketOverhead();
return overhead; return overhead;
} }
@ -277,7 +276,7 @@ bool RTPSenderVideo::SendVideo(RtpVideoCodecTypes video_type,
rtc::CritScope cs(&crit_); rtc::CritScope cs(&crit_);
FecProtectionParams* fec_params = FecProtectionParams* fec_params =
frame_type == kVideoFrameKey ? &key_fec_params_ : &delta_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_); storage = packetizer->GetStorageType(retransmission_settings_);
red_payload_type = red_payload_type_; 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/common_types.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.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/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_rtcp_config.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_sender.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/rtp_utility.h"
#include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h"
#include "webrtc/modules/rtp_rtcp/source/video_codec_information.h" #include "webrtc/modules/rtp_rtcp/source/video_codec_information.h"
#include "webrtc/typedefs.h" #include "webrtc/typedefs.h"
@ -104,7 +104,7 @@ class RTPSenderVideo {
0, 1, kFecMaskRandom}; 0, 1, kFecMaskRandom};
FecProtectionParams key_fec_params_ GUARDED_BY(crit_) = FecProtectionParams{ FecProtectionParams key_fec_params_ GUARDED_BY(crit_) = FecProtectionParams{
0, 1, kFecMaskRandom}; 0, 1, kFecMaskRandom};
ProducerFec producer_fec_ GUARDED_BY(crit_); UlpfecGenerator ulpfec_generator_ GUARDED_BY(crit_);
rtc::CriticalSection stats_crit_; rtc::CriticalSection stats_crit_;
// Bitrate used for FEC payload, RED headers, RTP headers for FEC packets // 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. * 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 <memory>
#include <utility> #include <utility>
@ -52,10 +52,7 @@ constexpr float kMinMediaPacketsAdaptationThreshold = 2.0f;
} // namespace } // namespace
RedPacket::RedPacket(size_t length) RedPacket::RedPacket(size_t length)
: data_(new uint8_t[length]), : data_(new uint8_t[length]), length_(length), header_length_(0) {}
length_(length),
header_length_(0) {
}
void RedPacket::CreateHeader(const uint8_t* rtp_header, void RedPacket::CreateHeader(const uint8_t* rtp_header,
size_t header_length, size_t header_length,
@ -96,7 +93,7 @@ size_t RedPacket::length() const {
return length_; return length_;
} }
ProducerFec::ProducerFec() UlpfecGenerator::UlpfecGenerator()
: fec_(ForwardErrorCorrection::CreateUlpfec()), : fec_(ForwardErrorCorrection::CreateUlpfec()),
num_protected_frames_(0), num_protected_frames_(0),
min_num_media_packets_(1) { min_num_media_packets_(1) {
@ -104,9 +101,9 @@ ProducerFec::ProducerFec()
memset(&new_params_, 0, sizeof(new_params_)); 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, const uint8_t* data_buffer,
size_t payload_length, size_t payload_length,
size_t rtp_header_length, size_t rtp_header_length,
@ -120,7 +117,7 @@ std::unique_ptr<RedPacket> ProducerFec::BuildRedPacket(
return red_packet; return red_packet;
} }
void ProducerFec::SetFecParameters(const FecProtectionParams* params) { void UlpfecGenerator::SetFecParameters(const FecProtectionParams* params) {
RTC_DCHECK_GE(params->fec_rate, 0); RTC_DCHECK_GE(params->fec_rate, 0);
RTC_DCHECK_LE(params->fec_rate, 255); RTC_DCHECK_LE(params->fec_rate, 255);
// Store the new params and apply them for the next set of FEC packets being // 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, int UlpfecGenerator::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
size_t payload_length, size_t payload_length,
size_t rtp_header_length) { size_t rtp_header_length) {
RTC_DCHECK(generated_fec_packets_.empty()); RTC_DCHECK(generated_fec_packets_.empty());
if (media_packets_.empty()) { if (media_packets_.empty()) {
params_ = new_params_; params_ = new_params_;
@ -175,11 +172,11 @@ int ProducerFec::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
return 0; return 0;
} }
bool ProducerFec::ExcessOverheadBelowMax() const { bool UlpfecGenerator::ExcessOverheadBelowMax() const {
return ((Overhead() - params_.fec_rate) < kMaxExcessOverhead); return ((Overhead() - params_.fec_rate) < kMaxExcessOverhead);
} }
bool ProducerFec::MinimumMediaPacketsReached() const { bool UlpfecGenerator::MinimumMediaPacketsReached() const {
float average_num_packets_per_frame = float average_num_packets_per_frame =
static_cast<float>(media_packets_.size()) / num_protected_frames_; static_cast<float>(media_packets_.size()) / num_protected_frames_;
int num_media_packets = static_cast<int>(media_packets_.size()); 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(); return !generated_fec_packets_.empty();
} }
size_t ProducerFec::NumAvailableFecPackets() const { size_t UlpfecGenerator::NumAvailableFecPackets() const {
return generated_fec_packets_.size(); return generated_fec_packets_.size();
} }
size_t ProducerFec::MaxPacketOverhead() const { size_t UlpfecGenerator::MaxPacketOverhead() const {
return fec_->MaxPacketOverhead(); return fec_->MaxPacketOverhead();
} }
std::vector<std::unique_ptr<RedPacket>> ProducerFec::GetUlpfecPacketsAsRed( std::vector<std::unique_ptr<RedPacket>> UlpfecGenerator::GetUlpfecPacketsAsRed(
int red_payload_type, int red_payload_type,
int ulpfec_payload_type, int ulpfec_payload_type,
uint16_t first_seq_num, uint16_t first_seq_num,
@ -234,7 +231,7 @@ std::vector<std::unique_ptr<RedPacket>> ProducerFec::GetUlpfecPacketsAsRed(
return red_packets; return red_packets;
} }
int ProducerFec::Overhead() const { int UlpfecGenerator::Overhead() const {
RTC_DCHECK(!media_packets_.empty()); RTC_DCHECK(!media_packets_.empty());
int num_fec_packets = int num_fec_packets =
fec_->NumFecPackets(media_packets_.size(), params_.fec_rate); fec_->NumFecPackets(media_packets_.size(), params_.fec_rate);
@ -242,7 +239,7 @@ int ProducerFec::Overhead() const {
return (num_fec_packets << 8) / media_packets_.size(); return (num_fec_packets << 8) / media_packets_.size();
} }
void ProducerFec::ResetState() { void UlpfecGenerator::ResetState() {
media_packets_.clear(); media_packets_.clear();
generated_fec_packets_.clear(); generated_fec_packets_.clear();
num_protected_frames_ = 0; 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. * be found in the AUTHORS file in the root of the source tree.
*/ */
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_ #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_ #define WEBRTC_MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_
#include <list> #include <list>
#include <memory> #include <memory>
@ -39,10 +39,10 @@ class RedPacket {
size_t header_length_; size_t header_length_;
}; };
class ProducerFec { class UlpfecGenerator {
public: public:
ProducerFec(); UlpfecGenerator();
~ProducerFec(); ~UlpfecGenerator();
static std::unique_ptr<RedPacket> BuildRedPacket(const uint8_t* data_buffer, static std::unique_ptr<RedPacket> BuildRedPacket(const uint8_t* data_buffer,
size_t payload_length, size_t payload_length,
@ -106,4 +106,4 @@ class ProducerFec {
} // namespace webrtc } // 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/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/fec_test_helper.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/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" #include "webrtc/test/gtest.h"
namespace webrtc { namespace webrtc {
@ -50,11 +50,11 @@ void VerifyHeader(uint16_t seq_num,
EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]); EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]);
} }
class ProducerFecTest : public ::testing::Test { class UlpfecGeneratorTest : public ::testing::Test {
protected: protected:
ProducerFecTest() : packet_generator_(kMediaSsrc) {} UlpfecGeneratorTest() : packet_generator_(kMediaSsrc) {}
ProducerFec producer_; UlpfecGenerator ulpfec_generator_;
AugmentedPacketGenerator packet_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 // 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, // 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. // and if that byte didn't protect packets we would generate empty FEC.
TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) { TEST_F(UlpfecGeneratorTest, NoEmptyFecWithSeqNumGaps) {
struct Packet { struct Packet {
size_t header_size; size_t header_size;
size_t payload_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({21, 0, 55, 0});
protected_packets.push_back({13, 3, 57, 1}); protected_packets.push_back({13, 3, 57, 1});
FecProtectionParams params = {117, 3, kFecMaskBursty}; FecProtectionParams params = {117, 3, kFecMaskBursty};
producer_.SetFecParameters(&params); ulpfec_generator_.SetFecParameters(&params);
uint8_t packet[28] = {0}; uint8_t packet[28] = {0};
for (Packet p : protected_packets) { for (Packet p : protected_packets) {
if (p.marker_bit) { if (p.marker_bit) {
@ -90,18 +90,19 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) {
packet[1] &= ~0x80; packet[1] &= ~0x80;
} }
ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num); ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num);
producer_.AddRtpPacketAndGenerateFec(packet, p.payload_size, p.header_size); ulpfec_generator_.AddRtpPacketAndGenerateFec(packet, p.payload_size,
size_t num_fec_packets = producer_.NumAvailableFecPackets(); p.header_size);
size_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets();
if (num_fec_packets > 0) { if (num_fec_packets > 0) {
std::vector<std::unique_ptr<RedPacket>> fec_packets = std::vector<std::unique_ptr<RedPacket>> fec_packets =
producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100, ulpfec_generator_.GetUlpfecPacketsAsRed(
p.header_size); kRedPayloadType, kFecPayloadType, 100, p.header_size);
EXPECT_EQ(num_fec_packets, fec_packets.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 // The number of media packets (|kNumPackets|), number of frames (one for
// this test), and the protection factor (|params->fec_rate|) are set to make // this test), and the protection factor (|params->fec_rate|) are set to make
// sure the conditions for generating FEC are satisfied. This means: // sure the conditions for generating FEC are satisfied. This means:
@ -111,27 +112,27 @@ TEST_F(ProducerFecTest, OneFrameFec) {
constexpr size_t kNumPackets = 4; constexpr size_t kNumPackets = 4;
FecProtectionParams params = {15, 3, kFecMaskRandom}; FecProtectionParams params = {15, 3, kFecMaskRandom};
packet_generator_.NewFrame(kNumPackets); packet_generator_.NewFrame(kNumPackets);
producer_.SetFecParameters(&params); // Expecting one FEC packet. ulpfec_generator_.SetFecParameters(&params); // Expecting one FEC packet.
uint32_t last_timestamp = 0; uint32_t last_timestamp = 0;
for (size_t i = 0; i < kNumPackets; ++i) { for (size_t i = 0; i < kNumPackets; ++i) {
std::unique_ptr<AugmentedPacket> packet = std::unique_ptr<AugmentedPacket> packet =
packet_generator_.NextPacket(i, 10); packet_generator_.NextPacket(i, 10);
EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec(
packet->data, packet->length, kRtpHeaderSize)); packet->data, packet->length, kRtpHeaderSize));
last_timestamp = packet->header.header.timestamp; last_timestamp = packet->header.header.timestamp;
} }
EXPECT_TRUE(producer_.FecAvailable()); EXPECT_TRUE(ulpfec_generator_.FecAvailable());
uint16_t seq_num = packet_generator_.NextPacketSeqNum(); uint16_t seq_num = packet_generator_.NextPacketSeqNum();
std::vector<std::unique_ptr<RedPacket>> red_packets = std::vector<std::unique_ptr<RedPacket>> red_packets =
producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType,
kRtpHeaderSize); seq_num, kRtpHeaderSize);
EXPECT_FALSE(producer_.FecAvailable()); EXPECT_FALSE(ulpfec_generator_.FecAvailable());
ASSERT_EQ(1u, red_packets.size()); ASSERT_EQ(1u, red_packets.size());
VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
red_packets.front().get(), false); red_packets.front().get(), false);
} }
TEST_F(ProducerFecTest, TwoFrameFec) { TEST_F(UlpfecGeneratorTest, TwoFrameFec) {
// The number of media packets/frame (|kNumPackets|), the number of frames // The number of media packets/frame (|kNumPackets|), the number of frames
// (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to // (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to
// make sure the conditions for generating FEC are satisfied. This means: // make sure the conditions for generating FEC are satisfied. This means:
@ -143,35 +144,35 @@ TEST_F(ProducerFecTest, TwoFrameFec) {
constexpr size_t kNumFrames = 2; constexpr size_t kNumFrames = 2;
FecProtectionParams params = {15, 3, kFecMaskRandom}; 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; uint32_t last_timestamp = 0;
for (size_t i = 0; i < kNumFrames; ++i) { for (size_t i = 0; i < kNumFrames; ++i) {
packet_generator_.NewFrame(kNumPackets); packet_generator_.NewFrame(kNumPackets);
for (size_t j = 0; j < kNumPackets; ++j) { for (size_t j = 0; j < kNumPackets; ++j) {
std::unique_ptr<AugmentedPacket> packet = std::unique_ptr<AugmentedPacket> packet =
packet_generator_.NextPacket(i * kNumPackets + j, 10); packet_generator_.NextPacket(i * kNumPackets + j, 10);
EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec(
packet->data, packet->length, kRtpHeaderSize)); packet->data, packet->length, kRtpHeaderSize));
last_timestamp = packet->header.header.timestamp; last_timestamp = packet->header.header.timestamp;
} }
} }
EXPECT_TRUE(producer_.FecAvailable()); EXPECT_TRUE(ulpfec_generator_.FecAvailable());
uint16_t seq_num = packet_generator_.NextPacketSeqNum(); uint16_t seq_num = packet_generator_.NextPacketSeqNum();
std::vector<std::unique_ptr<RedPacket>> red_packets = std::vector<std::unique_ptr<RedPacket>> red_packets =
producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType,
kRtpHeaderSize); seq_num, kRtpHeaderSize);
EXPECT_FALSE(producer_.FecAvailable()); EXPECT_FALSE(ulpfec_generator_.FecAvailable());
ASSERT_EQ(1u, red_packets.size()); ASSERT_EQ(1u, red_packets.size());
VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
red_packets.front().get(), false); red_packets.front().get(), false);
} }
TEST_F(ProducerFecTest, BuildRedPacket) { TEST_F(UlpfecGeneratorTest, BuildRedPacket) {
packet_generator_.NewFrame(1); packet_generator_.NewFrame(1);
std::unique_ptr<AugmentedPacket> packet = packet_generator_.NextPacket(0, 10); std::unique_ptr<AugmentedPacket> packet = packet_generator_.NextPacket(0, 10);
std::unique_ptr<RedPacket> red_packet = std::unique_ptr<RedPacket> red_packet = UlpfecGenerator::BuildRedPacket(
ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize,
kRtpHeaderSize, kRedPayloadType); kRedPayloadType);
EXPECT_EQ(packet->length + 1, red_packet->length()); EXPECT_EQ(packet->length + 1, red_packet->length());
VerifyHeader(packet->header.header.sequenceNumber, VerifyHeader(packet->header.header.sequenceNumber,
packet->header.header.timestamp, kRedPayloadType, 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 kNumFrames = 1;
constexpr size_t kPayloadLength = 0; constexpr size_t kPayloadLength = 0;
constexpr size_t kRedForFecHeaderLength = 1; constexpr size_t kRedForFecHeaderLength = 1;
@ -190,9 +191,9 @@ TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) {
packet_generator_.NewFrame(kNumFrames); packet_generator_.NewFrame(kNumFrames);
std::unique_ptr<AugmentedPacket> packet( std::unique_ptr<AugmentedPacket> packet(
packet_generator_.NextPacket(0, kPayloadLength)); packet_generator_.NextPacket(0, kPayloadLength));
std::unique_ptr<RedPacket> red_packet = std::unique_ptr<RedPacket> red_packet = UlpfecGenerator::BuildRedPacket(
ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize,
kRtpHeaderSize, kRedPayloadType); kRedPayloadType);
EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length()); EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length());
VerifyHeader(packet->header.header.sequenceNumber, VerifyHeader(packet->header.header.sequenceNumber,
packet->header.header.timestamp, kRedPayloadType, 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 = [ sources = [
"producer_fec_fuzzer.cc", "ulpfec_generator_fuzzer.cc",
] ]
deps = [ deps = [
"../../modules/rtp_rtcp/", "../../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/base/checks.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.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/fec_test_helper.h"
#include "webrtc/modules/rtp_rtcp/source/producer_fec.h" #include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h"
namespace webrtc { namespace webrtc {
@ -23,13 +23,13 @@ constexpr uint8_t kRedPayloadType = 97;
} // namespace } // namespace
void FuzzOneInput(const uint8_t* data, size_t size) { void FuzzOneInput(const uint8_t* data, size_t size) {
ProducerFec producer; UlpfecGenerator generator;
size_t i = 0; size_t i = 0;
if (size < 4) if (size < 4)
return; return;
FecProtectionParams params = { FecProtectionParams params = {
data[i++] % 128, static_cast<int>(data[i++] % 10), kFecMaskBursty}; data[i++] % 128, static_cast<int>(data[i++] % 10), kFecMaskBursty};
producer.SetFecParameters(&params); generator.SetFecParameters(&params);
uint16_t seq_num = data[i++]; uint16_t seq_num = data[i++];
while (i + 3 < size) { 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++); ByteWriter<uint16_t>::WriteBigEndian(&packet[2], seq_num++);
i += payload_size + rtp_header_length; i += payload_size + rtp_header_length;
// Make sure sequence numbers are increasing. // 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); packet.get(), payload_size, rtp_header_length, kRedPayloadType);
const bool protect = data[i++] % 2 == 1; const bool protect = data[i++] % 2 == 1;
if (protect) { if (protect) {
producer.AddRtpPacketAndGenerateFec(packet.get(), payload_size, generator.AddRtpPacketAndGenerateFec(packet.get(), payload_size,
rtp_header_length); rtp_header_length);
} }
const size_t num_fec_packets = producer.NumAvailableFecPackets(); const size_t num_fec_packets = generator.NumAvailableFecPackets();
if (num_fec_packets > 0) { if (num_fec_packets > 0) {
std::vector<std::unique_ptr<RedPacket>> fec_packets = std::vector<std::unique_ptr<RedPacket>> fec_packets =
producer.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100, generator.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100,
rtp_header_length); rtp_header_length);
RTC_CHECK_EQ(num_fec_packets, fec_packets.size()); RTC_CHECK_EQ(num_fec_packets, fec_packets.size());
} }
} }