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

Delete legacy RtpHeaderParser wrapper

Browse Source 
Bug: None
Change-Id: I4deec4fab631488ef2d0706848cbbe4e085825bc
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/221617
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34341}
This commit is contained in:
Danil Chapovalov
2021-06-08 12:30:46 +02:00
committed by WebRTC LUCI CQ
parent 257f81b98e
commit 76a35d9ce2
8 changed files with 36 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
rtc_tools/BUILD.gn
View File

@ -243,6 +243,7 @@ if (!is_component_build) {
"../call:call_interfaces",
"../common_video",
"../media:rtc_internal_video_codecs",
"../modules/rtp_rtcp:rtp_rtcp_format",
"../modules/video_coding:video_coding_utility",
"../rtc_base:checks",
"../rtc_base:rtc_json",

31
rtc_tools/video_replay.cc
View File

@ -25,6 +25,7 @@
#include "call/call.h"
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "media/engine/internal_decoder_factory.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
#include "modules/video_coding/utility/ivf_file_writer.h"
#include "rtc_base/checks.h"
#include "rtc_base/string_to_number.h"
@ -39,7 +40,6 @@
#include "test/gtest.h"
#include "test/null_transport.h"
#include "test/rtp_file_reader.h"
#include "test/rtp_header_parser.h"
#include "test/run_loop.h"
#include "test/run_test.h"
#include "test/test_video_capturer.h"
@ -544,11 +544,11 @@ class RtpReplayer final {
if (!rtp_reader->NextPacket(&packet)) {
break;
}
RTPHeader header;
std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::CreateForTest());
parser->Parse(packet.data, packet.length, &header);
if (header.timestamp < start_timestamp ||
header.timestamp > stop_timestamp) {
rtc::CopyOnWriteBuffer packet_buffer(packet.data, packet.length);
RtpPacket header;
header.Parse(packet_buffer);
if (header.Timestamp() < start_timestamp ||
header.Timestamp() > stop_timestamp) {
continue;
}
@ -560,9 +560,8 @@ class RtpReplayer final {
++num_packets;
PacketReceiver::DeliveryStatus result = PacketReceiver::DELIVERY_OK;
worker_thread->PostTask(ToQueuedTask([&]() {
result = call->Receiver()->DeliverPacket(
webrtc::MediaType::VIDEO,
rtc::CopyOnWriteBuffer(packet.data, packet.length),
result = call->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
std::move(packet_buffer),
/* packet_time_us */ -1);
event.Set();
}));
@ -571,21 +570,17 @@ class RtpReplayer final {
case PacketReceiver::DELIVERY_OK:
break;
case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {
if (unknown_packets[header.ssrc] == 0)
fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc);
++unknown_packets[header.ssrc];
if (unknown_packets[header.Ssrc()] == 0)
fprintf(stderr, "Unknown SSRC: %u!\n", header.Ssrc());
++unknown_packets[header.Ssrc()];
break;
}
case PacketReceiver::DELIVERY_PACKET_ERROR: {
fprintf(stderr,
"Packet error, corrupt packets or incorrect setup?\n");
RTPHeader header;
std::unique_ptr<RtpHeaderParser> parser(
RtpHeaderParser::CreateForTest());
parser->Parse(packet.data, packet.length, &header);
fprintf(stderr, "Packet len=%zu pt=%u seq=%u ts=%u ssrc=0x%8x\n",
packet.length, header.payloadType, header.sequenceNumber,
header.timestamp, header.ssrc);
packet.length, header.PayloadType(), header.SequenceNumber(),
header.Timestamp(), header.Ssrc());
break;
}
}

1
test/BUILD.gn
View File

@ -212,6 +212,7 @@ rtc_library("rtp_test_utils") {
"../rtc_base/synchronization:mutex",
"../rtc_base/system:arch",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
}
rtc_library("field_trial") {

21
test/fuzzers/rtp_header_parser_fuzzer.cc
View File

@ -22,27 +22,6 @@ namespace webrtc {
void FuzzOneInput(const uint8_t* data, size_t size) {
RtpHeaderParser::IsRtcp(data, size);
RtpHeaderParser::GetSsrc(data, size);
RTPHeader rtp_header;
std::unique_ptr<RtpHeaderParser> rtp_header_parser(
RtpHeaderParser::CreateForTest());
rtp_header_parser->Parse(data, size, &rtp_header);
for (int i = 1; i < kRtpExtensionNumberOfExtensions; ++i) {
if (size > 0 && i >= data[size - 1]) {
RTPExtensionType add_extension = static_cast<RTPExtensionType>(i);
rtp_header_parser->RegisterRtpHeaderExtension(add_extension, i);
}
}
rtp_header_parser->Parse(data, size, &rtp_header);
for (int i = 1; i < kRtpExtensionNumberOfExtensions; ++i) {
if (size > 1 && i >= data[size - 2]) {
RTPExtensionType remove_extension = static_cast<RTPExtensionType>(i);
rtp_header_parser->DeregisterRtpHeaderExtension(remove_extension);
}
}
rtp_header_parser->Parse(data, size, &rtp_header);
}
} // namespace webrtc

1
test/fuzzers/utils/BUILD.gn
View File

@ -24,6 +24,7 @@ rtc_library("rtp_replayer") {
"../../../call:call_interfaces",
"../../../common_video",
"../../../media:rtc_internal_video_codecs",
"../../../modules/rtp_rtcp:rtp_rtcp_format",
"../../../rtc_base:checks",
"../../../rtc_base:rtc_base_approved",
"../../../rtc_base:rtc_base_tests_utils",

35
test/fuzzers/utils/rtp_replayer.cc
View File

@ -17,13 +17,13 @@
#include "api/task_queue/default_task_queue_factory.h"
#include "api/transport/field_trial_based_config.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
#include "rtc_base/strings/json.h"
#include "system_wrappers/include/clock.h"
#include "test/call_config_utils.h"
#include "test/encoder_settings.h"
#include "test/fake_decoder.h"
#include "test/rtp_file_reader.h"
#include "test/rtp_header_parser.h"
#include "test/run_loop.h"
namespace webrtc {
@ -164,37 +164,32 @@ void RtpReplayer::ReplayPackets(rtc::FakeClock* clock,
std::min(deliver_in_ms, static_cast<int64_t>(100))));
}
rtc::CopyOnWriteBuffer packet_buffer(packet.data, packet.length);
++num_packets;
switch (call->Receiver()->DeliverPacket(
webrtc::MediaType::VIDEO,
rtc::CopyOnWriteBuffer(packet.data, packet.length),
switch (call->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
packet_buffer,
/* packet_time_us */ -1)) {
case PacketReceiver::DELIVERY_OK:
break;
case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {
RTPHeader header;
std::unique_ptr<RtpHeaderParser> parser(
RtpHeaderParser::CreateForTest());
parser->Parse(packet.data, packet.length, &header);
if (unknown_packets[header.ssrc] == 0) {
RTC_LOG(LS_ERROR) << "Unknown SSRC: " << header.ssrc;
webrtc::RtpPacket header;
header.Parse(packet_buffer);
if (unknown_packets[header.Ssrc()] == 0) {
RTC_LOG(LS_ERROR) << "Unknown SSRC: " << header.Ssrc();
}
++unknown_packets[header.ssrc];
++unknown_packets[header.Ssrc()];
break;
}
case PacketReceiver::DELIVERY_PACKET_ERROR: {
RTC_LOG(LS_ERROR)
<< "Packet error, corrupt packets or incorrect setup?";
RTPHeader header;
std::unique_ptr<RtpHeaderParser> parser(
RtpHeaderParser::CreateForTest());
parser->Parse(packet.data, packet.length, &header);
webrtc::RtpPacket header;
header.Parse(packet_buffer);
RTC_LOG(LS_ERROR) << "Packet packet_length=" << packet.length
<< " payload_type=" << header.payloadType
<< " sequence_number=" << header.sequenceNumber
<< " time_stamp=" << header.timestamp
<< " ssrc=" << header.ssrc;
<< " payload_type=" << header.PayloadType()
<< " sequence_number=" << header.SequenceNumber()
<< " time_stamp=" << header.Timestamp()
<< " ssrc=" << header.Ssrc();
break;
}
}

70
test/rtp_header_parser.cc
View File

@ -9,41 +9,10 @@
*/
#include "test/rtp_header_parser.h"
#include <memory>
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
#include "modules/rtp_rtcp/source/rtp_utility.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
class RtpHeaderParserImpl : public RtpHeaderParser {
public:
RtpHeaderParserImpl();
~RtpHeaderParserImpl() override = default;
bool Parse(const uint8_t* packet,
size_t length,
RTPHeader* header) const override;
bool RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id) override;
bool RegisterRtpHeaderExtension(RtpExtension extension) override;
bool DeregisterRtpHeaderExtension(RTPExtensionType type) override;
bool DeregisterRtpHeaderExtension(RtpExtension extension) override;
private:
mutable Mutex mutex_;
RtpHeaderExtensionMap rtp_header_extension_map_ RTC_GUARDED_BY(mutex_);
};
std::unique_ptr<RtpHeaderParser> RtpHeaderParser::CreateForTest() {
return std::make_unique<RtpHeaderParserImpl>();
}
RtpHeaderParserImpl::RtpHeaderParserImpl() {}
bool RtpHeaderParser::IsRtcp(const uint8_t* packet, size_t length) {
RtpUtility::RtpHeaderParser rtp_parser(packet, length);
return rtp_parser.RTCP();
@ -59,43 +28,4 @@ absl::optional<uint32_t> RtpHeaderParser::GetSsrc(const uint8_t* packet,
return absl::nullopt;
}
bool RtpHeaderParserImpl::Parse(const uint8_t* packet,
size_t length,
RTPHeader* header) const {
RtpUtility::RtpHeaderParser rtp_parser(packet, length);
*header = RTPHeader();
RtpHeaderExtensionMap map;
{
MutexLock lock(&mutex_);
map = rtp_header_extension_map_;
}
const bool valid_rtpheader = rtp_parser.Parse(header, &map);
if (!valid_rtpheader) {
return false;
}
return true;
}
bool RtpHeaderParserImpl::RegisterRtpHeaderExtension(RtpExtension extension) {
MutexLock lock(&mutex_);
return rtp_header_extension_map_.RegisterByUri(extension.id, extension.uri);
}
bool RtpHeaderParserImpl::RegisterRtpHeaderExtension(RTPExtensionType type,
uint8_t id) {
MutexLock lock(&mutex_);
return rtp_header_extension_map_.RegisterByType(id, type);
}
bool RtpHeaderParserImpl::DeregisterRtpHeaderExtension(RtpExtension extension) {
MutexLock lock(&mutex_);
return rtp_header_extension_map_.Deregister(
rtp_header_extension_map_.GetType(extension.id));
}
bool RtpHeaderParserImpl::DeregisterRtpHeaderExtension(RTPExtensionType type) {
MutexLock lock(&mutex_);
return rtp_header_extension_map_.Deregister(type) == 0;
}
} // namespace webrtc

32
test/rtp_header_parser.h
View File

@ -10,44 +10,18 @@
#ifndef TEST_RTP_HEADER_PARSER_H_
#define TEST_RTP_HEADER_PARSER_H_
#include <memory>
#include <stddef.h>
#include <stdint.h>
#include "api/rtp_parameters.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "absl/types/optional.h"
namespace webrtc {
struct RTPHeader;
class RtpHeaderParser {
public:
static std::unique_ptr<RtpHeaderParser> CreateForTest();
virtual ~RtpHeaderParser() {}
// Returns true if the packet is an RTCP packet, false otherwise.
static bool IsRtcp(const uint8_t* packet, size_t length);
static absl::optional<uint32_t> GetSsrc(const uint8_t* packet, size_t length);
// Parses the packet and stores the parsed packet in |header|. Returns true on
// success, false otherwise.
// This method is thread-safe in the sense that it can parse multiple packets
// at once.
virtual bool Parse(const uint8_t* packet,
size_t length,
RTPHeader* header) const = 0;
// Registers an RTP header extension and binds it to |id|.
virtual bool RegisterRtpHeaderExtension(RTPExtensionType type,
uint8_t id) = 0;
// Registers an RTP header extension.
virtual bool RegisterRtpHeaderExtension(RtpExtension extension) = 0;
// De-registers an RTP header extension.
virtual bool DeregisterRtpHeaderExtension(RTPExtensionType type) = 0;
// De-registers an RTP header extension.
virtual bool DeregisterRtpHeaderExtension(RtpExtension extension) = 0;
};
} // namespace webrtc
#endif // TEST_RTP_HEADER_PARSER_H_