Parse FlexFEC RTP headers in Call and add integration with BWE.
BUG=webrtc:5654
Review-Url: https://codereview.webrtc.org/2553863003
Cr-Original-Commit-Position: refs/heads/master@{#15709}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: ab2ffa3b28b55ef359232723049fb88b2dcd807a
diff --git a/call/call.cc b/call/call.cc
index 1c4b7b2..c7998b2 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -24,6 +24,7 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/logging.h"
+#include "webrtc/base/optional.h"
#include "webrtc/base/task_queue.h"
#include "webrtc/base/thread_annotations.h"
#include "webrtc/base/thread_checker.h"
@@ -39,6 +40,8 @@
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
#include "webrtc/modules/utility/include/process_thread.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/system_wrappers/include/cpu_info.h"
@@ -107,6 +110,8 @@
// Implements RecoveredPacketReceiver.
bool OnRecoveredPacket(const uint8_t* packet, size_t length) override;
+ void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet);
+
void SetBitrateConfig(
const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
@@ -154,6 +159,11 @@
return nullptr;
}
+ rtc::Optional<RtpPacketReceived> ParseRtpPacket(const uint8_t* packet,
+ size_t length,
+ const PacketTime& packet_time)
+ SHARED_LOCKS_REQUIRED(receive_crit_);
+
void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
void UpdateReceiveHistograms();
void UpdateHistograms();
@@ -192,6 +202,14 @@
std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
GUARDED_BY(receive_crit_);
+ // Registered RTP header extensions for each stream.
+ // Note that RTP header extensions are negotiated per track ("m= line") in the
+ // SDP, but we have no notion of tracks at the Call level. We therefore store
+ // the RTP header extensions per SSRC instead, which leads to some storage
+ // overhead.
+ std::map<uint32_t, RtpHeaderExtensionMap> received_rtp_header_extensions_
+ GUARDED_BY(receive_crit_);
+
std::unique_ptr<RWLockWrapper> send_crit_;
// Audio and Video send streams are owned by the client that creates them.
std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
@@ -345,6 +363,29 @@
Trace::ReturnTrace();
}
+rtc::Optional<RtpPacketReceived> Call::ParseRtpPacket(
+ const uint8_t* packet,
+ size_t length,
+ const PacketTime& packet_time) {
+ RtpPacketReceived parsed_packet;
+ if (!parsed_packet.Parse(packet, length))
+ return rtc::Optional<RtpPacketReceived>();
+
+ auto it = received_rtp_header_extensions_.find(parsed_packet.Ssrc());
+ if (it != received_rtp_header_extensions_.end())
+ parsed_packet.IdentifyExtensions(it->second);
+
+ int64_t arrival_time_ms;
+ if (packet_time.timestamp != -1) {
+ arrival_time_ms = (packet_time.timestamp + 500) / 1000;
+ } else {
+ arrival_time_ms = clock_->TimeInMilliseconds();
+ }
+ parsed_packet.set_arrival_time_ms(arrival_time_ms);
+
+ return rtc::Optional<RtpPacketReceived>(std::move(parsed_packet));
+}
+
void Call::UpdateHistograms() {
RTC_HISTOGRAM_COUNTS_100000(
"WebRTC.Call.LifetimeInSeconds",
@@ -659,25 +700,40 @@
const FlexfecReceiveStream::Config& config) {
TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
+
+ RecoveredPacketReceiver* recovered_packet_receiver = this;
FlexfecReceiveStreamImpl* receive_stream =
- new FlexfecReceiveStreamImpl(config, this);
+ new FlexfecReceiveStreamImpl(config, recovered_packet_receiver);
{
WriteLockScoped write_lock(*receive_crit_);
+
+ RTC_DCHECK(flexfec_receive_streams_.find(receive_stream) ==
+ flexfec_receive_streams_.end());
+ flexfec_receive_streams_.insert(receive_stream);
+
for (auto ssrc : config.protected_media_ssrcs)
flexfec_receive_ssrcs_media_.insert(std::make_pair(ssrc, receive_stream));
+
RTC_DCHECK(flexfec_receive_ssrcs_protection_.find(config.remote_ssrc) ==
flexfec_receive_ssrcs_protection_.end());
flexfec_receive_ssrcs_protection_[config.remote_ssrc] = receive_stream;
- flexfec_receive_streams_.insert(receive_stream);
+
+ RTC_DCHECK(received_rtp_header_extensions_.find(config.remote_ssrc) ==
+ received_rtp_header_extensions_.end());
+ RtpHeaderExtensionMap rtp_header_extensions(config.rtp_header_extensions);
+ received_rtp_header_extensions_[config.remote_ssrc] = rtp_header_extensions;
}
+
// TODO(brandtr): Store config in RtcEventLog here.
+
return receive_stream;
}
void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) {
TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream");
RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
+
RTC_DCHECK(receive_stream != nullptr);
// There exist no other derived classes of FlexfecReceiveStream,
// so this downcast is safe.
@@ -685,15 +741,12 @@
static_cast<FlexfecReceiveStreamImpl*>(receive_stream);
{
WriteLockScoped write_lock(*receive_crit_);
+
+ uint32_t ssrc = receive_stream_impl->GetConfig().remote_ssrc;
+ received_rtp_header_extensions_.erase(ssrc);
+
// Remove all SSRCs pointing to the FlexfecReceiveStreamImpl to be
// destroyed.
- auto media_it = flexfec_receive_ssrcs_media_.begin();
- while (media_it != flexfec_receive_ssrcs_media_.end()) {
- if (media_it->second == receive_stream_impl)
- media_it = flexfec_receive_ssrcs_media_.erase(media_it);
- else
- ++media_it;
- }
auto prot_it = flexfec_receive_ssrcs_protection_.begin();
while (prot_it != flexfec_receive_ssrcs_protection_.end()) {
if (prot_it->second == receive_stream_impl)
@@ -701,8 +754,17 @@
else
++prot_it;
}
+ auto media_it = flexfec_receive_ssrcs_media_.begin();
+ while (media_it != flexfec_receive_ssrcs_media_.end()) {
+ if (media_it->second == receive_stream_impl)
+ media_it = flexfec_receive_ssrcs_media_.erase(media_it);
+ else
+ ++media_it;
+ }
+
flexfec_receive_streams_.erase(receive_stream_impl);
}
+
delete receive_stream_impl;
}
@@ -1076,13 +1138,21 @@
if (it != video_receive_ssrcs_.end()) {
received_bytes_per_second_counter_.Add(static_cast<int>(length));
received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
+ // TODO(brandtr): Notify the BWE of received media packets here.
auto status = it->second->DeliverRtp(packet, length, packet_time)
? DELIVERY_OK
: DELIVERY_PACKET_ERROR;
- // Deliver media packets to FlexFEC subsystem.
- auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
- for (auto it = it_bounds.first; it != it_bounds.second; ++it)
- it->second->AddAndProcessReceivedPacket(packet, length);
+ // Deliver media packets to FlexFEC subsystem. RTP header extensions need
+ // not be parsed, as FlexFEC is oblivious to the semantic meaning of the
+ // packet contents beyond the 12 byte RTP base header. The BWE is fed
+ // information about these media packets from the regular media pipeline.
+ rtc::Optional<RtpPacketReceived> parsed_packet =
+ ParseRtpPacket(packet, length, packet_time);
+ if (parsed_packet) {
+ auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
+ for (auto it = it_bounds.first; it != it_bounds.second; ++it)
+ it->second->AddAndProcessReceivedPacket(*parsed_packet);
+ }
if (status == DELIVERY_OK)
event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
return status;
@@ -1091,12 +1161,18 @@
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
auto it = flexfec_receive_ssrcs_protection_.find(ssrc);
if (it != flexfec_receive_ssrcs_protection_.end()) {
- auto status = it->second->AddAndProcessReceivedPacket(packet, length)
- ? DELIVERY_OK
- : DELIVERY_PACKET_ERROR;
- if (status == DELIVERY_OK)
- event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
- return status;
+ rtc::Optional<RtpPacketReceived> parsed_packet =
+ ParseRtpPacket(packet, length, packet_time);
+ if (parsed_packet) {
+ NotifyBweOfReceivedPacket(*parsed_packet);
+ auto status =
+ it->second->AddAndProcessReceivedPacket(std::move(*parsed_packet))
+ ? DELIVERY_OK
+ : DELIVERY_PACKET_ERROR;
+ if (status == DELIVERY_OK)
+ event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
+ return status;
+ }
}
}
return DELIVERY_UNKNOWN_SSRC;
@@ -1128,5 +1204,12 @@
return it->second->OnRecoveredPacket(packet, length);
}
+void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet) {
+ RTPHeader header;
+ packet.GetHeader(&header);
+ congestion_controller_->OnReceivedPacket(packet.arrival_time_ms(),
+ packet.payload_size(), header);
+}
+
} // namespace internal
} // namespace webrtc
diff --git a/call/flexfec_receive_stream.h b/call/flexfec_receive_stream.h
index 83b212b..20a57f2 100644
--- a/call/flexfec_receive_stream.h
+++ b/call/flexfec_receive_stream.h
@@ -59,7 +59,7 @@
bool transport_cc = false;
// RTP header extensions that have been negotiated for this track.
- std::vector<RtpExtension> extensions;
+ std::vector<RtpExtension> rtp_header_extensions;
};
// Starts stream activity.
diff --git a/call/flexfec_receive_stream_impl.cc b/call/flexfec_receive_stream_impl.cc
index e0e49c1..13390a1 100644
--- a/call/flexfec_receive_stream_impl.cc
+++ b/call/flexfec_receive_stream_impl.cc
@@ -10,6 +10,8 @@
#include "webrtc/call/flexfec_receive_stream_impl.h"
+#include <utility>
+
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
@@ -34,12 +36,12 @@
if (!protected_media_ssrcs.empty())
ss << protected_media_ssrcs[i];
ss << "], transport_cc: " << (transport_cc ? "on" : "off");
- ss << ", extensions: [";
+ ss << ", rtp_header_extensions: [";
i = 0;
- for (; i + 1 < extensions.size(); ++i)
- ss << extensions[i].ToString() << ", ";
- if (!extensions.empty())
- ss << extensions[i].ToString();
+ for (; i + 1 < rtp_header_extensions.size(); ++i)
+ ss << rtp_header_extensions[i].ToString() << ", ";
+ if (!rtp_header_extensions.empty())
+ ss << rtp_header_extensions[i].ToString();
ss << "]}";
return ss.str();
}
@@ -49,7 +51,7 @@
// TODO(brandtr): Update this function when we support multistream protection.
std::unique_ptr<FlexfecReceiver> MaybeCreateFlexfecReceiver(
const FlexfecReceiveStream::Config& config,
- RecoveredPacketReceiver* recovered_packet_callback) {
+ RecoveredPacketReceiver* recovered_packet_receiver) {
if (config.payload_type < 0) {
LOG(LS_WARNING) << "Invalid FlexFEC payload type given. "
<< "This FlexfecReceiveStream will therefore be useless.";
@@ -79,18 +81,18 @@
RTC_DCHECK_EQ(1U, config.protected_media_ssrcs.size());
return std::unique_ptr<FlexfecReceiver>(
new FlexfecReceiver(config.remote_ssrc, config.protected_media_ssrcs[0],
- recovered_packet_callback));
+ recovered_packet_receiver));
}
} // namespace
FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
const Config& config,
- RecoveredPacketReceiver* recovered_packet_callback)
+ RecoveredPacketReceiver* recovered_packet_receiver)
: started_(false),
config_(config),
receiver_(
- MaybeCreateFlexfecReceiver(config_, recovered_packet_callback)) {
+ MaybeCreateFlexfecReceiver(config_, recovered_packet_receiver)) {
LOG(LS_INFO) << "FlexfecReceiveStreamImpl: " << config_.ToString();
}
@@ -100,8 +102,7 @@
}
bool FlexfecReceiveStreamImpl::AddAndProcessReceivedPacket(
- const uint8_t* packet,
- size_t packet_length) {
+ RtpPacketReceived packet) {
{
rtc::CritScope cs(&crit_);
if (!started_)
@@ -109,7 +110,7 @@
}
if (!receiver_)
return false;
- return receiver_->AddAndProcessReceivedPacket(packet, packet_length);
+ return receiver_->AddAndProcessReceivedPacket(std::move(packet));
}
void FlexfecReceiveStreamImpl::Start() {
diff --git a/call/flexfec_receive_stream_impl.h b/call/flexfec_receive_stream_impl.h
index 79c6cc0..7267dc0 100644
--- a/call/flexfec_receive_stream_impl.h
+++ b/call/flexfec_receive_stream_impl.h
@@ -18,16 +18,19 @@
#include "webrtc/base/criticalsection.h"
#include "webrtc/call/flexfec_receive_stream.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
namespace webrtc {
class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
public:
FlexfecReceiveStreamImpl(const Config& config,
- RecoveredPacketReceiver* recovered_packet_callback);
+ RecoveredPacketReceiver* recovered_packet_receiver);
~FlexfecReceiveStreamImpl() override;
- bool AddAndProcessReceivedPacket(const uint8_t* packet, size_t length);
+ const Config& GetConfig() const { return config_; }
+
+ bool AddAndProcessReceivedPacket(RtpPacketReceived packet);
// Implements FlexfecReceiveStream.
void Start() override;
diff --git a/call/flexfec_receive_stream_unittest.cc b/call/flexfec_receive_stream_unittest.cc
index 314d9c0..07d3943 100644
--- a/call/flexfec_receive_stream_unittest.cc
+++ b/call/flexfec_receive_stream_unittest.cc
@@ -8,24 +8,36 @@
* be found in the AUTHORS file in the root of the source tree.
*/
+#include "webrtc/base/array_view.h"
#include "webrtc/base/basictypes.h"
#include "webrtc/call/flexfec_receive_stream_impl.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
#include "webrtc/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h"
#include "webrtc/test/gmock.h"
#include "webrtc/test/gtest.h"
namespace webrtc {
+namespace {
+
+RtpPacketReceived ParsePacket(rtc::ArrayView<const uint8_t> packet) {
+ RtpPacketReceived parsed_packet(nullptr);
+ EXPECT_TRUE(parsed_packet.Parse(packet));
+ return parsed_packet;
+}
+
+} // namespace
+
TEST(FlexfecReceiveStreamTest, ConstructDestruct) {
FlexfecReceiveStream::Config config;
config.payload_type = 118;
config.remote_ssrc = 424223;
config.protected_media_ssrcs = {912512};
- MockRecoveredPacketReceiver callback;
+ MockRecoveredPacketReceiver recovered_packet_receiver;
- FlexfecReceiveStreamImpl receive_stream(config, &callback);
+ FlexfecReceiveStreamImpl receive_stream(config, &recovered_packet_receiver);
}
TEST(FlexfecReceiveStreamTest, StartStop) {
@@ -33,27 +45,13 @@
config.payload_type = 118;
config.remote_ssrc = 1652392;
config.protected_media_ssrcs = {23300443};
- MockRecoveredPacketReceiver callback;
- FlexfecReceiveStreamImpl receive_stream(config, &callback);
+ MockRecoveredPacketReceiver recovered_packet_receiver;
+ FlexfecReceiveStreamImpl receive_stream(config, &recovered_packet_receiver);
receive_stream.Start();
receive_stream.Stop();
}
-TEST(FlexfecReceiveStreamTest, DoesNotProcessPacketWhenNoMediaSsrcGiven) {
- FlexfecReceiveStream::Config config;
- config.payload_type = 118;
- config.remote_ssrc = 424223;
- config.protected_media_ssrcs = {};
- MockRecoveredPacketReceiver callback;
- FlexfecReceiveStreamImpl receive_stream(config, &callback);
- const uint8_t packet[] = {0x00, 0x11, 0x22, 0x33};
- const size_t packet_length = sizeof(packet);
-
- EXPECT_FALSE(
- receive_stream.AddAndProcessReceivedPacket(packet, packet_length));
-}
-
// Create a FlexFEC packet that protects a single media packet and ensure
// that the callback is called. Correctness of recovery is checked in the
// FlexfecReceiver unit tests.
@@ -91,7 +89,6 @@
// FEC payload.
kPayloadBits, kPayloadBits, kPayloadBits, kPayloadBits};
// clang-format on
- constexpr size_t kFlexfecPacketLength = sizeof(kFlexfecPacket);
FlexfecReceiveStream::Config config;
config.payload_type = kFlexfecPlType;
@@ -102,16 +99,14 @@
FlexfecReceiveStreamImpl receive_stream(config, &recovered_packet_receiver);
// Do not call back before being started.
- receive_stream.AddAndProcessReceivedPacket(kFlexfecPacket,
- kFlexfecPacketLength);
+ receive_stream.AddAndProcessReceivedPacket(ParsePacket(kFlexfecPacket));
// Call back after being started.
receive_stream.Start();
EXPECT_CALL(
recovered_packet_receiver,
OnRecoveredPacket(::testing::_, kRtpHeaderSize + kPayloadLength[1]));
- receive_stream.AddAndProcessReceivedPacket(kFlexfecPacket,
- kFlexfecPacketLength);
+ receive_stream.AddAndProcessReceivedPacket(ParsePacket(kFlexfecPacket));
}
} // namespace webrtc
diff --git a/media/engine/webrtcvideoengine2.cc b/media/engine/webrtcvideoengine2.cc
index 9d9f141..129eb32 100644
--- a/media/engine/webrtcvideoengine2.cc
+++ b/media/engine/webrtcvideoengine2.cc
@@ -2349,7 +2349,7 @@
// RTCP messages and RTP header extensions apply to the entire track
// in the SDP.
config.transport_cc = config_.rtp.transport_cc;
- config.extensions = config_.rtp.extensions;
+ config.rtp_header_extensions = config_.rtp.extensions;
flexfec_stream_ = call_->CreateFlexfecReceiveStream(config);
flexfec_stream_->Start();
}
diff --git a/modules/congestion_controller/congestion_controller.cc b/modules/congestion_controller/congestion_controller.cc
index bbdd968..2fae264 100644
--- a/modules/congestion_controller/congestion_controller.cc
+++ b/modules/congestion_controller/congestion_controller.cc
@@ -197,6 +197,23 @@
CongestionController::~CongestionController() {}
+void CongestionController::OnReceivedPacket(int64_t arrival_time_ms,
+ size_t payload_size,
+ const RTPHeader& header) {
+ // Send-side BWE.
+ if (header.extension.hasTransportSequenceNumber) {
+ remote_estimator_proxy_.IncomingPacket(arrival_time_ms, payload_size,
+ header);
+ return;
+ }
+
+ // Receive-side BWE.
+ if (remote_bitrate_estimator_) {
+ remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
+ header);
+ }
+}
+
void CongestionController::SetBweBitrates(int min_bitrate_bps,
int start_bitrate_bps,
int max_bitrate_bps) {
diff --git a/modules/congestion_controller/congestion_controller_unittest.cc b/modules/congestion_controller/congestion_controller_unittest.cc
index bdbaaf1..3850797 100644
--- a/modules/congestion_controller/congestion_controller_unittest.cc
+++ b/modules/congestion_controller/congestion_controller_unittest.cc
@@ -26,6 +26,18 @@
using testing::SaveArg;
using testing::StrictMock;
+namespace {
+
+// Helper to convert some time format to resolution used in absolute send time
+// header extension, rounded upwards. |t| is the time to convert, in some
+// resolution. |denom| is the value to divide |t| by to get whole seconds,
+// e.g. |denom| = 1000 if |t| is in milliseconds.
+uint32_t AbsSendTime(int64_t t, int64_t denom) {
+ return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful;
+}
+
+} // namespace
+
namespace webrtc {
namespace test {
@@ -201,5 +213,33 @@
controller_->Process();
}
+TEST_F(CongestionControllerTest, OnReceivedPacketWithAbsSendTime) {
+ NiceMock<MockCongestionObserver> observer;
+ StrictMock<MockRemoteBitrateObserver> remote_bitrate_observer;
+ std::unique_ptr<PacedSender> pacer(new NiceMock<MockPacedSender>());
+ controller_.reset(
+ new CongestionController(&clock_, &observer, &remote_bitrate_observer,
+ &event_log_, &packet_router_, std::move(pacer)));
+
+ size_t payload_size = 1000;
+ RTPHeader header;
+ header.ssrc = 0x11eb21c;
+ header.extension.hasAbsoluteSendTime = true;
+
+ std::vector<unsigned int> ssrcs;
+ EXPECT_CALL(remote_bitrate_observer, OnReceiveBitrateChanged(_, _))
+ .WillRepeatedly(SaveArg<0>(&ssrcs));
+
+ for (int i = 0; i < 10; ++i) {
+ clock_.AdvanceTimeMilliseconds((1000 * payload_size) / kInitialBitrateBps);
+ int64_t now_ms = clock_.TimeInMilliseconds();
+ header.extension.absoluteSendTime = AbsSendTime(now_ms, 1000);
+ controller_->OnReceivedPacket(now_ms, payload_size, header);
+ }
+
+ ASSERT_EQ(1u, ssrcs.size());
+ EXPECT_EQ(header.ssrc, ssrcs[0]);
+}
+
} // namespace test
} // namespace webrtc
diff --git a/modules/congestion_controller/include/congestion_controller.h b/modules/congestion_controller/include/congestion_controller.h
index 004a847..48b9531 100644
--- a/modules/congestion_controller/include/congestion_controller.h
+++ b/modules/congestion_controller/include/congestion_controller.h
@@ -68,6 +68,10 @@
std::unique_ptr<PacedSender> pacer);
virtual ~CongestionController();
+ virtual void OnReceivedPacket(int64_t arrival_time_ms,
+ size_t payload_size,
+ const RTPHeader& header);
+
virtual void SetBweBitrates(int min_bitrate_bps,
int start_bitrate_bps,
int max_bitrate_bps);
diff --git a/modules/congestion_controller/include/mock/mock_congestion_controller.h b/modules/congestion_controller/include/mock/mock_congestion_controller.h
index 1b932dc..aefb2be 100644
--- a/modules/congestion_controller/include/mock/mock_congestion_controller.h
+++ b/modules/congestion_controller/include/mock/mock_congestion_controller.h
@@ -13,6 +13,7 @@
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/socket.h"
+#include "webrtc/common_types.h"
#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
#include "webrtc/test/gmock.h"
@@ -44,6 +45,10 @@
remote_bitrate_observer,
event_log,
packet_router) {}
+ MOCK_METHOD3(OnReceivedPacket,
+ void(int64_t arrival_time_ms,
+ size_t payload_size,
+ const RTPHeader& header));
MOCK_METHOD3(SetBweBitrates,
void(int min_bitrate_bps,
int start_bitrate_bps,
diff --git a/modules/rtp_rtcp/include/flexfec_receiver.h b/modules/rtp_rtcp/include/flexfec_receiver.h
index 721d6c5..9ad0931 100644
--- a/modules/rtp_rtcp/include/flexfec_receiver.h
+++ b/modules/rtp_rtcp/include/flexfec_receiver.h
@@ -16,9 +16,9 @@
#include "webrtc/base/basictypes.h"
#include "webrtc/base/sequenced_task_checker.h"
#include "webrtc/call/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/modules/rtp_rtcp/source/rtp_packet_received.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
@@ -37,19 +37,19 @@
public:
FlexfecReceiver(uint32_t ssrc,
uint32_t protected_media_ssrc,
- RecoveredPacketReceiver* callback);
+ RecoveredPacketReceiver* recovered_packet_receiver);
~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.
- bool AddAndProcessReceivedPacket(const uint8_t* packet, size_t packet_length);
+ bool AddAndProcessReceivedPacket(RtpPacketReceived packet);
// Returns a counter describing the added and recovered packets.
FecPacketCounter GetPacketCounter() const;
private:
- bool AddReceivedPacket(const uint8_t* packet, size_t packet_length);
+ bool AddReceivedPacket(RtpPacketReceived packet);
bool ProcessReceivedPackets();
// Config.
@@ -63,7 +63,7 @@
GUARDED_BY(sequence_checker_);
ForwardErrorCorrection::RecoveredPacketList recovered_packets_
GUARDED_BY(sequence_checker_);
- RecoveredPacketReceiver* const callback_ GUARDED_BY(sequence_checker_);
+ RecoveredPacketReceiver* const recovered_packet_receiver_;
// Logging and stats.
Clock* const clock_;
diff --git a/modules/rtp_rtcp/source/flexfec_receiver.cc b/modules/rtp_rtcp/source/flexfec_receiver.cc
index 369dd31..204ce84 100644
--- a/modules/rtp_rtcp/source/flexfec_receiver.cc
+++ b/modules/rtp_rtcp/source/flexfec_receiver.cc
@@ -10,11 +10,8 @@
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
-#include <utility>
-
#include "webrtc/base/logging.h"
#include "webrtc/base/scoped_ref_ptr.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
namespace webrtc {
@@ -31,13 +28,14 @@
} // namespace
-FlexfecReceiver::FlexfecReceiver(uint32_t ssrc,
- uint32_t protected_media_ssrc,
- RecoveredPacketReceiver* callback)
+FlexfecReceiver::FlexfecReceiver(
+ uint32_t ssrc,
+ uint32_t protected_media_ssrc,
+ RecoveredPacketReceiver* recovered_packet_receiver)
: ssrc_(ssrc),
protected_media_ssrc_(protected_media_ssrc),
erasure_code_(ForwardErrorCorrection::CreateFlexfec()),
- callback_(callback),
+ recovered_packet_receiver_(recovered_packet_receiver),
clock_(Clock::GetRealTimeClock()),
last_recovered_packet_ms_(-1) {
// It's OK to create this object on a different thread/task queue than
@@ -47,10 +45,9 @@
FlexfecReceiver::~FlexfecReceiver() = default;
-bool FlexfecReceiver::AddAndProcessReceivedPacket(const uint8_t* packet,
- size_t packet_length) {
+bool FlexfecReceiver::AddAndProcessReceivedPacket(RtpPacketReceived packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
- if (!AddReceivedPacket(packet, packet_length)) {
+ if (!AddReceivedPacket(std::move(packet))) {
return false;
}
return ProcessReceivedPackets();
@@ -61,42 +58,32 @@
return packet_counter_;
}
-bool FlexfecReceiver::AddReceivedPacket(const uint8_t* packet,
- size_t packet_length) {
+bool FlexfecReceiver::AddReceivedPacket(RtpPacketReceived packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
// RTP packets with a full base header (12 bytes), but without payload,
// could conceivably be useful in the decoding. Therefore we check
- // with a strict inequality here.
- if (packet_length < kRtpHeaderSize) {
- LOG(LS_WARNING) << "Truncated packet, discarding.";
- return false;
- }
-
- // TODO(brandtr): Consider how to handle received FlexFEC packets and
- // the bandwidth estimator.
- RtpPacketReceived parsed_packet;
- if (!parsed_packet.Parse(packet, packet_length)) {
- return false;
- }
+ // with a non-strict inequality here.
+ RTC_DCHECK_GE(packet.size(), kRtpHeaderSize);
// Demultiplex based on SSRC, and insert into erasure code decoder.
std::unique_ptr<ReceivedPacket> received_packet(new ReceivedPacket());
- received_packet->seq_num = parsed_packet.SequenceNumber();
- received_packet->ssrc = parsed_packet.Ssrc();
+ received_packet->seq_num = packet.SequenceNumber();
+ received_packet->ssrc = packet.Ssrc();
if (received_packet->ssrc == ssrc_) {
- // This is a FEC packet belonging to this FlexFEC stream.
- if (parsed_packet.payload_size() < kMinFlexfecHeaderSize) {
+ // This is a FlexFEC packet.
+ if (packet.payload_size() < kMinFlexfecHeaderSize) {
LOG(LS_WARNING) << "Truncated FlexFEC packet, discarding.";
return false;
}
received_packet->is_fec = true;
++packet_counter_.num_fec_packets;
+
// Insert packet payload into erasure code.
// TODO(brandtr): Remove this memcpy when the FEC packet classes
// are using COW buffers internally.
received_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
- auto payload = parsed_packet.payload();
+ auto payload = packet.payload();
memcpy(received_packet->pkt->data, payload.data(), payload.size());
received_packet->pkt->length = payload.size();
} else {
@@ -106,13 +93,14 @@
return false;
}
received_packet->is_fec = false;
+
// Insert entire packet into erasure code.
// TODO(brandtr): Remove this memcpy too.
received_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
- memcpy(received_packet->pkt->data, parsed_packet.data(),
- parsed_packet.size());
- received_packet->pkt->length = parsed_packet.size();
+ memcpy(received_packet->pkt->data, packet.data(), packet.size());
+ received_packet->pkt->length = packet.size();
}
+
received_packets_.push_back(std::move(received_packet));
++packet_counter_.num_packets;
@@ -144,8 +132,8 @@
continue;
}
++packet_counter_.num_recovered_packets;
- if (!callback_->OnRecoveredPacket(recovered_packet->pkt->data,
- recovered_packet->pkt->length)) {
+ if (!recovered_packet_receiver_->OnRecoveredPacket(
+ recovered_packet->pkt->data, recovered_packet->pkt->length)) {
return false;
}
recovered_packet->returned = true;
diff --git a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
index 8b46878..8bf0f37 100644
--- a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
@@ -16,6 +16,7 @@
#include "webrtc/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.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/rtp_packet_received.h"
#include "webrtc/test/gmock.h"
#include "webrtc/test/gtest.h"
@@ -36,6 +37,12 @@
constexpr uint32_t kFlexfecSsrc = 42984;
constexpr uint32_t kMediaSsrc = 8353;
+RtpPacketReceived ParsePacket(const Packet& packet) {
+ RtpPacketReceived parsed_packet;
+ EXPECT_TRUE(parsed_packet.Parse(packet.data, packet.length));
+ return parsed_packet;
+}
+
} // namespace
class FlexfecReceiverTest : public ::testing::Test {
@@ -93,21 +100,8 @@
std::unique_ptr<Packet> media_packet(
packet_generator_.NextPacket(0, kPayloadLength));
- EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
- media_packet->length));
-}
-
-TEST_F(FlexfecReceiverTest, FailsOnTruncatedMediaPacket) {
- const size_t kNoPayload = 0;
-
- packet_generator_.NewFrame(1);
- std::unique_ptr<Packet> media_packet(
- packet_generator_.NextPacket(0, kNoPayload));
- // Simulate truncated media packet.
- media_packet->length = kRtpHeaderSize - 1;
-
- EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
- media_packet->length));
+ EXPECT_TRUE(
+ receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
}
TEST_F(FlexfecReceiverTest, ReceivesMediaAndFecPackets) {
@@ -117,13 +111,12 @@
PacketList media_packets;
PacketizeFrame(kNumMediaPackets, 0, &media_packets);
std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
- auto media_packet = media_packets.front().get();
+ const auto& media_packet = media_packets.front();
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(ParsePacket(*media_packet)));
+ EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(*fec_packet)));
}
TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) {
@@ -133,15 +126,14 @@
PacketList media_packets;
PacketizeFrame(kNumMediaPackets, 0, &media_packets);
std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
- auto media_packet = media_packets.front().get();
+ const auto& media_packet = media_packets.front();
// Simulate truncated FlexFEC payload.
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(ParsePacket(*media_packet)));
+ EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(ParsePacket(*fec_packet)));
}
TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
@@ -149,15 +141,15 @@
PacketList media_packets;
PacketizeFrame(kNumMediaPackets, 0, &media_packets);
- auto media_packet = media_packets.front().get();
+ auto& media_packet = media_packets.front();
// Corrupt the SSRC.
media_packet->data[8] = 0;
media_packet->data[9] = 1;
media_packet->data[10] = 2;
media_packet->data[11] = 3;
- EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
- media_packet->length));
+ EXPECT_FALSE(
+ receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
}
TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
@@ -167,7 +159,7 @@
PacketList media_packets;
PacketizeFrame(kNumMediaPackets, 0, &media_packets);
std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
- auto media_packet = media_packets.front().get();
+ const auto& media_packet = media_packets.front();
auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
// Corrupt the SSRC.
fec_packet->data[8] = 4;
@@ -175,10 +167,9 @@
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(ParsePacket(*media_packet)));
+ EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(ParsePacket(*fec_packet)));
}
TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
@@ -191,8 +182,8 @@
// 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(ParsePacket(*media_packet)));
}
// Receive FEC packet.
@@ -200,7 +191,7 @@
std::unique_ptr<Packet> packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(*fec_packet);
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
}
TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) {
@@ -213,8 +204,7 @@
// 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(ParsePacket(**media_it)));
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
@@ -227,7 +217,7 @@
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
}
TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
@@ -251,7 +241,7 @@
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
// Receive second FEC packet and recover second lost media packet.
fec_it++;
@@ -263,7 +253,7 @@
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
}
TEST_F(FlexfecReceiverTest, DoesNotRecoverFromMediaAndFecLoss) {
@@ -276,8 +266,7 @@
// Receive first media packet.
auto media_it = media_packets.begin();
- EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
- (*media_it)->length));
+ EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
// Drop second media packet and FEC packet. Do not expect call back.
}
@@ -292,8 +281,7 @@
// 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(ParsePacket(**media_it)));
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
@@ -306,11 +294,11 @@
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
// Receive FEC packet again.
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
// Do not call back again.
}
@@ -332,8 +320,7 @@
// 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(ParsePacket(**media_it)));
++media_it;
if (media_it == media_packets.end()) {
break;
@@ -356,7 +343,7 @@
ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- fec_packet_with_rtp_header->data, fec_packet_with_rtp_header->length));
+ ParsePacket(*fec_packet_with_rtp_header)));
++media_it;
}
}
@@ -383,8 +370,7 @@
// 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(ParsePacket(**media_it)));
++media_it;
}
@@ -399,7 +385,7 @@
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
}
TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
@@ -424,8 +410,7 @@
// 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(ParsePacket(**media_it)));
++media_it;
}
@@ -434,7 +419,7 @@
std::unique_ptr<Packet> packet_with_rtp_header =
packet_generator_.BuildFlexfecPacket(**fec_it);
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
// Do not expect a call back.
}
@@ -455,14 +440,14 @@
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(ParsePacket(**media_packet5)));
+ EXPECT_TRUE(
+ receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_packet2)));
+ EXPECT_TRUE(
+ receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_packet3)));
+ EXPECT_TRUE(
+ receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_packet0)));
// Expect to recover lost media packets.
EXPECT_CALL(recovered_packet_receiver_,
@@ -482,7 +467,7 @@
while (fec_it != fec_packets.end()) {
packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(**fec_it);
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
++fec_it;
}
}
@@ -497,8 +482,7 @@
// 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(ParsePacket(**media_it)));
// Receive FEC packet and ensure recovery of lost media packet.
auto fec_it = fec_packets.begin();
@@ -511,7 +495,7 @@
Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
.WillOnce(Return(true));
EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
- packet_with_rtp_header->data, packet_with_rtp_header->length));
+ ParsePacket(*packet_with_rtp_header)));
// Check stats calculations.
FecPacketCounter packet_counter = receiver_.GetPacketCounter();
diff --git a/modules/rtp_rtcp/source/rtp_packet.cc b/modules/rtp_rtcp/source/rtp_packet.cc
index b7d71c2..e720eeb 100644
--- a/modules/rtp_rtcp/source/rtp_packet.cc
+++ b/modules/rtp_rtcp/source/rtp_packet.cc
@@ -86,6 +86,10 @@
return true;
}
+bool Packet::Parse(rtc::ArrayView<const uint8_t> packet) {
+ return Parse(packet.data(), packet.size());
+}
+
bool Packet::Parse(rtc::CopyOnWriteBuffer buffer) {
if (!ParseBuffer(buffer.cdata(), buffer.size())) {
Clear();
diff --git a/modules/rtp_rtcp/source/rtp_packet.h b/modules/rtp_rtcp/source/rtp_packet.h
index 2b3d38e..3c02125 100644
--- a/modules/rtp_rtcp/source/rtp_packet.h
+++ b/modules/rtp_rtcp/source/rtp_packet.h
@@ -31,6 +31,7 @@
// Parse and copy given buffer into Packet.
bool Parse(const uint8_t* buffer, size_t size);
+ bool Parse(rtc::ArrayView<const uint8_t> packet);
// Parse and move given buffer into Packet.
bool Parse(rtc::CopyOnWriteBuffer packet);
diff --git a/test/fuzzers/flexfec_receiver_fuzzer.cc b/test/fuzzers/flexfec_receiver_fuzzer.cc
index 89ad494..533d0d1 100644
--- a/test/fuzzers/flexfec_receiver_fuzzer.cc
+++ b/test/fuzzers/flexfec_receiver_fuzzer.cc
@@ -14,6 +14,7 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
namespace webrtc {
@@ -61,7 +62,10 @@
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);
+ RtpPacketReceived parsed_packet;
+ if (parsed_packet.Parse(packet.get(), packet_length)) {
+ receiver.AddAndProcessReceivedPacket(parsed_packet);
+ }
}
}
