admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make FlexfecReceiver a concrete class.

Browse Source 
There is no need for it to be an interface.

In this CL, I also took the opportunity to make two small fixes:
- remove the 'flexfec_' prefix from some member variables
- remove unnecessary use of a stringstream object

BUG=webrtc:5654

Review-Url: https://codereview.webrtc.org/2471073003
Cr-Commit-Position: refs/heads/master@{#14919}
This commit is contained in:
brandtr 2016-11-03 08:18:27 -07:00 committed by Commit bot
parent 9531092e72
commit 0a4c1616bf
8 changed files with 110 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
webrtc/call/flexfec_receive_stream.cc
View File

@ -42,9 +42,9 @@ std::unique_ptr<FlexfecReceiver> MaybeUpdateConfigAndCreateFlexfecReceiver(
<< config->protected_media_ssrcs[0] << ".";
config->protected_media_ssrcs.resize(1);
}
return FlexfecReceiver::Create(config->flexfec_ssrc,
config->protected_media_ssrcs[0],
recovered_packet_callback);
return std::unique_ptr<FlexfecReceiver>(new FlexfecReceiver(
config->flexfec_ssrc, config->protected_media_ssrcs[0],
recovered_packet_callback));
}
} // namespace

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

@ -27,8 +27,7 @@ rtc_static_library("rtp_rtcp") {
"source/fec_private_tables_random.h",
"source/flexfec_header_reader_writer.cc",
"source/flexfec_header_reader_writer.h",
"source/flexfec_receiver_impl.cc",
"source/flexfec_receiver_impl.h",
"source/flexfec_receiver.cc",
"source/forward_error_correction.cc",
"source/forward_error_correction.h",
"source/forward_error_correction_internal.cc",

40
webrtc/modules/rtp_rtcp/include/flexfec_receiver.h
View File

@ -14,7 +14,12 @@
#include <memory>
#include "webrtc/base/basictypes.h"
#include "webrtc/base/sequenced_task_checker.h"
#include "webrtc/call.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
#include "webrtc/modules/rtp_rtcp/include/ulpfec_receiver.h"
#include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
@ -30,20 +35,39 @@ class RecoveredPacketReceiver {
class FlexfecReceiver {
public:
static std::unique_ptr<FlexfecReceiver> Create(
uint32_t flexfec_ssrc,
uint32_t protected_media_ssrc,
RecoveredPacketReceiver* callback);
virtual ~FlexfecReceiver();
FlexfecReceiver(uint32_t ssrc,
uint32_t protected_media_ssrc,
RecoveredPacketReceiver* callback);
~FlexfecReceiver();
// Inserts a received packet (can be either media or FlexFEC) into the
// internal buffer, and sends the received packets to the erasure code.
// All newly recovered packets are sent back through the callback.
virtual bool AddAndProcessReceivedPacket(const uint8_t* packet,
size_t packet_length) = 0;
bool AddAndProcessReceivedPacket(const uint8_t* packet, size_t packet_length);
// Returns a counter describing the added and recovered packets.
virtual FecPacketCounter GetPacketCounter() const = 0;
FecPacketCounter GetPacketCounter() const;
private:
bool AddReceivedPacket(const uint8_t* packet, size_t packet_length);
bool ProcessReceivedPackets();
// Config.
const uint32_t ssrc_;
const uint32_t protected_media_ssrc_;
// Erasure code interfacing and callback.
std::unique_ptr<ForwardErrorCorrection> erasure_code_;
ForwardErrorCorrection::ReceivedPacketList received_packets_;
ForwardErrorCorrection::RecoveredPacketList recovered_packets_;
RecoveredPacketReceiver* const callback_;
// Logging and stats.
Clock* const clock_;
int64_t last_recovered_packet_ms_;
FecPacketCounter packet_counter_;
rtc::SequencedTaskChecker sequence_checker_;
};
} // namespace webrtc

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

@ -28,8 +28,7 @@
'include/rtp_rtcp_defines.h',
'include/ulpfec_receiver.h',
'source/byte_io.h',
'source/flexfec_receiver_impl.cc',
'source/flexfec_receiver_impl.h',
'source/flexfec_receiver.cc',
'source/packet_loss_stats.cc',
'source/packet_loss_stats.h',
'source/playout_delay_oracle.cc',

42
webrtc/modules/rtp_rtcp/source/flexfec_receiver_impl.cc → webrtc/modules/rtp_rtcp/source/flexfec_receiver.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/flexfec_receiver_impl.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
#include <utility>
@ -31,20 +31,10 @@ constexpr int kPacketLogIntervalMs = 10000;
} // namespace
std::unique_ptr<FlexfecReceiver> FlexfecReceiver::Create(
uint32_t flexfec_ssrc,
uint32_t protected_media_ssrc,
RecoveredPacketReceiver* callback) {
return std::unique_ptr<FlexfecReceiver>(
new FlexfecReceiverImpl(flexfec_ssrc, protected_media_ssrc, callback));
}
FlexfecReceiver::~FlexfecReceiver() = default;
FlexfecReceiverImpl::FlexfecReceiverImpl(uint32_t flexfec_ssrc,
uint32_t protected_media_ssrc,
RecoveredPacketReceiver* callback)
: flexfec_ssrc_(flexfec_ssrc),
FlexfecReceiver::FlexfecReceiver(uint32_t ssrc,
uint32_t protected_media_ssrc,
RecoveredPacketReceiver* callback)
: ssrc_(ssrc),
protected_media_ssrc_(protected_media_ssrc),
erasure_code_(ForwardErrorCorrection::CreateFlexfec()),
callback_(callback),
@ -55,10 +45,10 @@ FlexfecReceiverImpl::FlexfecReceiverImpl(uint32_t flexfec_ssrc,
sequence_checker_.Detach();
}
FlexfecReceiverImpl::~FlexfecReceiverImpl() = default;
FlexfecReceiver::~FlexfecReceiver() = default;
bool FlexfecReceiverImpl::AddAndProcessReceivedPacket(const uint8_t* packet,
size_t packet_length) {
bool FlexfecReceiver::AddAndProcessReceivedPacket(const uint8_t* packet,
size_t packet_length) {
RTC_DCHECK(sequence_checker_.CalledSequentially());
if (!AddReceivedPacket(packet, packet_length)) {
@ -67,13 +57,13 @@ bool FlexfecReceiverImpl::AddAndProcessReceivedPacket(const uint8_t* packet,
return ProcessReceivedPackets();
}
FecPacketCounter FlexfecReceiverImpl::GetPacketCounter() const {
FecPacketCounter FlexfecReceiver::GetPacketCounter() const {
RTC_DCHECK(sequence_checker_.CalledSequentially());
return packet_counter_;
}
bool FlexfecReceiverImpl::AddReceivedPacket(const uint8_t* packet,
size_t packet_length) {
bool FlexfecReceiver::AddReceivedPacket(const uint8_t* packet,
size_t packet_length) {
RTC_DCHECK(sequence_checker_.CalledSequentially());
// RTP packets with a full base header (12 bytes), but without payload,
@ -95,7 +85,7 @@ bool FlexfecReceiverImpl::AddReceivedPacket(const uint8_t* packet,
std::unique_ptr<ReceivedPacket> received_packet(new ReceivedPacket());
received_packet->seq_num = parsed_packet.SequenceNumber();
received_packet->ssrc = parsed_packet.Ssrc();
if (received_packet->ssrc == flexfec_ssrc_) {
if (received_packet->ssrc == ssrc_) {
// This is a FEC packet belonging to this FlexFEC stream.
if (parsed_packet.payload_size() < kMinFlexfecHeaderSize) {
LOG(LS_WARNING) << "Truncated FlexFEC packet, discarding.";
@ -139,7 +129,7 @@ bool FlexfecReceiverImpl::AddReceivedPacket(const uint8_t* packet,
// Here, however, the received media pipeline is more decoupled from the
// FlexFEC decoder, and we therefore do not interfere with the reception
// of non-recovered media packets.
bool FlexfecReceiverImpl::ProcessReceivedPackets() {
bool FlexfecReceiver::ProcessReceivedPackets() {
RTC_DCHECK(sequence_checker_.CalledSequentially());
// Decode.
@ -165,10 +155,8 @@ bool FlexfecReceiverImpl::ProcessReceivedPackets() {
if (now_ms - last_recovered_packet_ms_ > kPacketLogIntervalMs) {
uint32_t media_ssrc =
ForwardErrorCorrection::ParseSsrc(recovered_packet->pkt->data);
std::stringstream ss;
ss << "Recovered media packet with SSRC: " << media_ssrc
<< " from FlexFEC stream with SSRC: " << flexfec_ssrc_ << ".";
LOG(LS_INFO) << ss.str();
LOG(LS_INFO) << "Recovered media packet with SSRC: " << media_ssrc
<< " from FlexFEC stream with SSRC: " << ssrc_ << ".";
last_recovered_packet_ms_ = now_ms;
}
}

60
webrtc/modules/rtp_rtcp/source/flexfec_receiver_impl.h
View File

@ -1,60 +0,0 @@
/*
* 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.
*/
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_FLEXFEC_RECEIVER_IMPL_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_FLEXFEC_RECEIVER_IMPL_H_
#include <memory>
#include "webrtc/base/basictypes.h"
#include "webrtc/base/sequenced_task_checker.h"
#include "webrtc/call.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
#include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
class FlexfecReceiverImpl : public FlexfecReceiver {
public:
FlexfecReceiverImpl(uint32_t flexfec_ssrc,
uint32_t protected_media_ssrc,
RecoveredPacketReceiver* callback);
~FlexfecReceiverImpl();
// Implements FlexfecReceiver.
bool AddAndProcessReceivedPacket(const uint8_t* packet, size_t packet_length);
FecPacketCounter GetPacketCounter() const;
private:
bool AddReceivedPacket(const uint8_t* packet, size_t packet_length);
bool ProcessReceivedPackets();
// Config.
const uint32_t flexfec_ssrc_;
const uint32_t protected_media_ssrc_;
// Erasure code interfacing and callback.
std::unique_ptr<ForwardErrorCorrection> erasure_code_;
ForwardErrorCorrection::ReceivedPacketList received_packets_;
ForwardErrorCorrection::RecoveredPacketList recovered_packets_;
RecoveredPacketReceiver* const callback_;
// Logging and stats.
Clock* const clock_;
int64_t last_recovered_packet_ms_;
FecPacketCounter packet_counter_;
rtc::SequencedTaskChecker sequence_checker_;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_FLEXFEC_RECEIVER_IMPL_H_

114
webrtc/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
View File

@ -41,9 +41,7 @@ constexpr uint32_t kMediaSsrc = 8353;
class FlexfecReceiverTest : public ::testing::Test {
protected:
FlexfecReceiverTest()
: receiver_(FlexfecReceiver::Create(kFlexfecSsrc,
kMediaSsrc,
&recovered_packet_receiver_)),
: receiver_(kFlexfecSsrc, kMediaSsrc, &recovered_packet_receiver_),
erasure_code_(ForwardErrorCorrection::CreateFlexfec()),
packet_generator_(kMediaSsrc, kFlexfecSsrc) {}
@ -56,7 +54,7 @@ class FlexfecReceiverTest : public ::testing::Test {
std::list<Packet*> EncodeFec(const PacketList& media_packets,
size_t num_fec_packets);
std::unique_ptr<FlexfecReceiver> receiver_;
FlexfecReceiver receiver_;
std::unique_ptr<ForwardErrorCorrection> erasure_code_;
FlexfecPacketGenerator packet_generator_;
@ -95,8 +93,8 @@ TEST_F(FlexfecReceiverTest, ReceivesMediaPacket) {
std::unique_ptr<Packet> media_packet(
packet_generator_.NextPacket(0, kPayloadLength));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
}
TEST_F(FlexfecReceiverTest, FailsOnTruncatedMediaPacket) {
@ -108,8 +106,8 @@ TEST_F(FlexfecReceiverTest, FailsOnTruncatedMediaPacket) {
// Simulate truncated media packet.
media_packet->length = kRtpHeaderSize - 1;
EXPECT_FALSE(receiver_->AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
}
TEST_F(FlexfecReceiverTest, ReceivesMediaAndFecPackets) {
@ -122,10 +120,10 @@ TEST_F(FlexfecReceiverTest, ReceivesMediaAndFecPackets) {
auto media_packet = media_packets.front().get();
auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(fec_packet->data,
fec_packet->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
fec_packet->length));
}
TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) {
@ -140,10 +138,10 @@ TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) {
fec_packets.front()->length = 1;
auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_FALSE(receiver_->AddAndProcessReceivedPacket(fec_packet->data,
fec_packet->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
fec_packet->length));
}
TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
@ -158,8 +156,8 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
media_packet->data[10] = 2;
media_packet->data[11] = 3;
EXPECT_FALSE(receiver_->AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
}
TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
@ -177,10 +175,10 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
fec_packet->data[10] = 6;
fec_packet->data[11] = 7;
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_FALSE(receiver_->AddAndProcessReceivedPacket(fec_packet->data,
fec_packet->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
fec_packet->length));
}
TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
@ -193,15 +191,15 @@ TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
// Receive all media packets.
for (const auto& media_packet : media_packets) {
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
media_packet->length));
}
// Receive FEC packet.
auto fec_packet = fec_packets.front();
std::unique_ptr<Packet> packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(*fec_packet);
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
}
@ -215,8 +213,8 @@ TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) {
// Receive first media packet but drop second.
auto media_it = media_packets.begin();
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
@ -228,7 +226,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) {
.With(
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
}
@ -252,7 +250,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
.With(
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
// Receive second FEC packet and recover second lost media packet.
@ -264,7 +262,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
.With(
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
}
@ -278,8 +276,8 @@ TEST_F(FlexfecReceiverTest, DoesNotRecoverFromMediaAndFecLoss) {
// Receive first media packet.
auto media_it = media_packets.begin();
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
// Drop second media packet and FEC packet. Do not expect call back.
}
@ -294,8 +292,8 @@ TEST_F(FlexfecReceiverTest, DoesNotCallbackTwice) {
// Receive first media packet but drop second.
auto media_it = media_packets.begin();
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
@ -307,11 +305,11 @@ TEST_F(FlexfecReceiverTest, DoesNotCallbackTwice) {
.With(
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
// Receive FEC packet again.
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
// Do not call back again.
@ -334,8 +332,8 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) {
// Drop every second media packet.
auto media_it = media_packets.begin();
while (media_it != media_packets.end()) {
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
++media_it;
if (media_it == media_packets.end()) {
break;
@ -357,7 +355,7 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) {
.With(Args<0, 1>(
ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
fec_packet_with_rtp_header->data, fec_packet_with_rtp_header->length));
++media_it;
}
@ -385,8 +383,8 @@ TEST_F(FlexfecReceiverTest, DelayedFecPacketDoesHelp) {
// Receive all other media packets.
while (media_it != media_packets.end()) {
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
++media_it;
}
@ -400,7 +398,7 @@ TEST_F(FlexfecReceiverTest, DelayedFecPacketDoesHelp) {
.With(
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
}
@ -426,8 +424,8 @@ TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
// Receive all other media packets.
while (media_it != media_packets.end()) {
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
++media_it;
}
@ -435,7 +433,7 @@ TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
auto fec_it = fec_packets.begin();
std::unique_ptr<Packet> packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
// Do not expect a call back.
@ -457,14 +455,14 @@ TEST_F(FlexfecReceiverTest, RecoversWithMediaPacketsOutOfOrder) {
auto media_packet3 = media_it++;
auto media_packet4 = media_it++;
auto media_packet5 = media_it++;
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_packet5)->data,
(*media_packet5)->length));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_packet2)->data,
(*media_packet2)->length));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_packet3)->data,
(*media_packet3)->length));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_packet0)->data,
(*media_packet0)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet5)->data,
(*media_packet5)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet2)->data,
(*media_packet2)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet3)->data,
(*media_packet3)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet0)->data,
(*media_packet0)->length));
// Expect to recover lost media packets.
EXPECT_CALL(recovered_packet_receiver_,
@ -483,7 +481,7 @@ TEST_F(FlexfecReceiverTest, RecoversWithMediaPacketsOutOfOrder) {
std::unique_ptr<Packet> packet_with_rtp_header;
while (fec_it != fec_packets.end()) {
packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(**fec_it);
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
++fec_it;
}
@ -499,8 +497,8 @@ TEST_F(FlexfecReceiverTest, CalculatesNumberOfPackets) {
// Receive first media packet but drop second.
auto media_it = media_packets.begin();
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
(*media_it)->length));
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
@ -512,11 +510,11 @@ TEST_F(FlexfecReceiverTest, CalculatesNumberOfPackets) {
.With(
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
packet_with_rtp_header->data, packet_with_rtp_header->length));
// Check stats calculations.
FecPacketCounter packet_counter = receiver_->GetPacketCounter();
FecPacketCounter packet_counter = receiver_.GetPacketCounter();
EXPECT_EQ(2U, packet_counter.num_packets);
EXPECT_EQ(1U, packet_counter.num_fec_packets);
EXPECT_EQ(1U, packet_counter.num_recovered_packets);

5
webrtc/test/fuzzers/flexfec_receiver_fuzzer.cc
View File

@ -39,8 +39,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
memcpy(&media_seq_num, data + 10, 2);
DummyCallback callback;
std::unique_ptr<FlexfecReceiver> receiver =
FlexfecReceiver::Create(flexfec_ssrc, media_ssrc, &callback);
FlexfecReceiver receiver(flexfec_ssrc, media_ssrc, &callback);
std::unique_ptr<uint8_t[]> packet;
size_t packet_length;
@ -62,7 +61,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
ByteWriter<uint16_t>::WriteBigEndian(packet.get() + 2, media_seq_num++);
ByteWriter<uint32_t>::WriteBigEndian(packet.get() + 8, media_ssrc);
}
receiver->AddAndProcessReceivedPacket(packet.get(), packet_length);
receiver.AddAndProcessReceivedPacket(packet.get(), packet_length);
}
}