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

Avoid using legacy rtp parser in neteq test::Packet

Browse Source 
Bug: None
Change-Id: I9184954d9c99f0a34ae335d03843171864071e5d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/222648
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34316}
This commit is contained in:
Danil Chapovalov
2021-06-16 14:23:22 +02:00
committed by WebRTC LUCI CQ
parent 35b21ba8d4
commit b4100ad06a
7 changed files with 117 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
modules/audio_coding/neteq/tools/packet.cc
View File

@ -10,30 +10,22 @@
#include "modules/audio_coding/neteq/tools/packet.h"
#include <string.h>
#include <memory>
#include "modules/rtp_rtcp/source/rtp_utility.h"
#include "api/array_view.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/checks.h"
#include "rtc_base/copy_on_write_buffer.h"
namespace webrtc {
namespace test {
using webrtc::RtpUtility::RtpHeaderParser;
Packet::Packet(uint8_t* packet_memory,
size_t allocated_bytes,
Packet::Packet(rtc::CopyOnWriteBuffer packet,
size_t virtual_packet_length_bytes,
double time_ms,
const RtpUtility::RtpHeaderParser& parser,
const RtpHeaderExtensionMap* extension_map /*= nullptr*/)
: payload_memory_(packet_memory),
packet_length_bytes_(allocated_bytes),
const RtpHeaderExtensionMap* extension_map)
: packet_(std::move(packet)),
virtual_packet_length_bytes_(virtual_packet_length_bytes),
virtual_payload_length_bytes_(0),
time_ms_(time_ms),
valid_header_(ParseHeader(parser, extension_map)) {}
valid_header_(ParseHeader(extension_map)) {}
Packet::Packet(const RTPHeader& header,
size_t virtual_packet_length_bytes,
@ -45,23 +37,6 @@ Packet::Packet(const RTPHeader& header,
time_ms_(time_ms),
valid_header_(true) {}
Packet::Packet(uint8_t* packet_memory, size_t allocated_bytes, double time_ms)
: Packet(packet_memory,
allocated_bytes,
allocated_bytes,
time_ms,
RtpUtility::RtpHeaderParser(packet_memory, allocated_bytes)) {}
Packet::Packet(uint8_t* packet_memory,
size_t allocated_bytes,
size_t virtual_packet_length_bytes,
double time_ms)
: Packet(packet_memory,
allocated_bytes,
virtual_packet_length_bytes,
time_ms,
RtpUtility::RtpHeaderParser(packet_memory, allocated_bytes)) {}
Packet::~Packet() = default;
bool Packet::ExtractRedHeaders(std::list<RTPHeader*>* headers) const {
@ -77,9 +52,8 @@ bool Packet::ExtractRedHeaders(std::list<RTPHeader*>* headers) const {
// +-+-+-+-+-+-+-+-+
//
RTC_DCHECK(payload_);
const uint8_t* payload_ptr = payload_;
const uint8_t* payload_end_ptr = payload_ptr + payload_length_bytes_;
const uint8_t* payload_ptr = payload();
const uint8_t* payload_end_ptr = payload_ptr + payload_length_bytes();
// Find all RED headers with the extension bit set to 1. That is, all headers
// but the last one.
@ -111,27 +85,43 @@ void Packet::DeleteRedHeaders(std::list<RTPHeader*>* headers) {
}
}
bool Packet::ParseHeader(const RtpHeaderParser& parser,
const RtpHeaderExtensionMap* extension_map) {
bool valid_header = parser.Parse(&header_, extension_map);
bool Packet::ParseHeader(const RtpHeaderExtensionMap* extension_map) {
// Use RtpPacketReceived instead of RtpPacket because former already has a
// converter into legacy RTPHeader.
webrtc::RtpPacketReceived rtp_packet(extension_map);
// Special case for dummy packets that have padding marked in the RTP header.
// This causes the RTP header parser to report failure, but is fine in this
// context.
const bool header_only_with_padding =
(header_.headerLength == packet_length_bytes_ &&
header_.paddingLength > 0);
if (!valid_header && !header_only_with_padding) {
return false;
// Because of the special case of dummy packets that have padding marked in
// the RTP header, but do not have rtp payload with the padding size, handle
// padding manually. Regular RTP packet parser reports failure, but it is fine
// in this context.
bool padding = (packet_[0] & 0b0010'0000);
size_t padding_size = 0;
if (padding) {
// Clear the padding bit to prevent failure when rtp payload is omited.
rtc::CopyOnWriteBuffer packet(packet_);
packet.MutableData()[0] &= ~0b0010'0000;
if (!rtp_packet.Parse(std::move(packet))) {
return false;
}
if (rtp_packet.payload_size() > 0) {
padding_size = rtp_packet.data()[rtp_packet.size() - 1];
}
if (padding_size > rtp_packet.payload_size()) {
return false;
}
} else {
if (!rtp_packet.Parse(packet_)) {
return false;
}
}
RTC_DCHECK_LE(header_.headerLength, packet_length_bytes_);
payload_ = &payload_memory_[header_.headerLength];
RTC_DCHECK_GE(packet_length_bytes_, header_.headerLength);
payload_length_bytes_ = packet_length_bytes_ - header_.headerLength;
RTC_CHECK_GE(virtual_packet_length_bytes_, packet_length_bytes_);
RTC_DCHECK_GE(virtual_packet_length_bytes_, header_.headerLength);
rtp_payload_ = rtc::MakeArrayView(packet_.data() + rtp_packet.headers_size(),
rtp_packet.payload_size() - padding_size);
rtp_packet.GetHeader(&header_);
RTC_CHECK_GE(virtual_packet_length_bytes_, rtp_packet.size());
RTC_DCHECK_GE(virtual_packet_length_bytes_, rtp_packet.headers_size());
virtual_payload_length_bytes_ =
virtual_packet_length_bytes_ - header_.headerLength;
virtual_packet_length_bytes_ - rtp_packet.headers_size();
return true;
}