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

Migrate tests from RtpDepacketizer to VideoRtpDepacketizer interface

Browse Source 
Bug: webrtc:11152
Change-Id: I1b1c5183d35b791c09c14c9d1f0ca240c1749d9a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161455
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30055}
This commit is contained in:
Danil Chapovalov
2019-12-09 10:24:47 +01:00
committed by Commit Bot
parent 007915a37e
commit a3ecb7a656
3 changed files with 38 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
modules/rtp_rtcp/source/rtp_packet.h
View File

@ -67,6 +67,9 @@ class RtpPacket {
rtc::ArrayView<const uint8_t> payload() const {
return rtc::MakeArrayView(data() + payload_offset_, payload_size_);
}
rtc::CopyOnWriteBuffer PayloadBuffer() const {
return buffer_.Slice(payload_offset_, payload_size_);
}
// Buffer.
rtc::CopyOnWriteBuffer Buffer() const { return buffer_; }

78
test/layer_filtering_transport.cc
View File

@ -18,9 +18,9 @@
#include "api/rtp_headers.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtp_format.h"
#include "modules/rtp_rtcp/source/rtp_utility.h"
#include "modules/rtp_rtcp/source/create_video_rtp_depacketizer.h"
#include "modules/rtp_rtcp/source/rtp_video_header.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
#include "modules/video_coding/codecs/interface/common_constants.h"
#include "modules/video_coding/codecs/vp8/include/vp8_globals.h"
#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
@ -43,6 +43,8 @@ LayerFilteringTransport::LayerFilteringTransport(
: DirectTransport(task_queue, std::move(pipe), send_call, payload_type_map),
vp8_video_payload_type_(vp8_video_payload_type),
vp9_video_payload_type_(vp9_video_payload_type),
vp8_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP8)),
vp9_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP9)),
selected_tl_(selected_tl),
selected_sl_(selected_sl),
discarded_last_packet_(false),
@ -58,14 +60,16 @@ LayerFilteringTransport::LayerFilteringTransport(
int selected_tl,
int selected_sl,
const std::map<uint8_t, MediaType>& payload_type_map)
: DirectTransport(task_queue, std::move(pipe), send_call, payload_type_map),
vp8_video_payload_type_(vp8_video_payload_type),
vp9_video_payload_type_(vp9_video_payload_type),
selected_tl_(selected_tl),
selected_sl_(selected_sl),
discarded_last_packet_(false),
ssrc_to_filter_min_(0),
ssrc_to_filter_max_(0xFFFFFFFF) {}
: LayerFilteringTransport(task_queue,
std::move(pipe),
send_call,
vp8_video_payload_type,
vp9_video_payload_type,
selected_tl,
selected_sl,
payload_type_map,
/*ssrc_to_filter_min=*/0,
/*ssrc_to_filter_max=*/0xFFFFFFFF) {}
bool LayerFilteringTransport::DiscardedLastPacket() const {
return discarded_last_packet_;
@ -79,33 +83,21 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
return test::DirectTransport::SendRtp(packet, length, options);
}
bool set_marker_bit = false;
RtpUtility::RtpHeaderParser parser(packet, length);
RTPHeader header;
parser.Parse(&header);
RtpPacket rtp_packet;
rtp_packet.Parse(packet, length);
if (header.ssrc < ssrc_to_filter_min_ || header.ssrc > ssrc_to_filter_max_) {
if (rtp_packet.Ssrc() < ssrc_to_filter_min_ ||
rtp_packet.Ssrc() > ssrc_to_filter_max_) {
// Nothing to change, forward the packet immediately.
return test::DirectTransport::SendRtp(packet, length, options);
}
RTC_DCHECK_LE(length, IP_PACKET_SIZE);
uint8_t temp_buffer[IP_PACKET_SIZE];
memcpy(temp_buffer, packet, length);
if (header.payloadType == vp8_video_payload_type_ ||
header.payloadType == vp9_video_payload_type_) {
const uint8_t* payload = packet + header.headerLength;
RTC_DCHECK_GT(length, header.headerLength);
const size_t payload_length = length - header.headerLength;
RTC_DCHECK_GT(payload_length, header.paddingLength);
const size_t payload_data_length = payload_length - header.paddingLength;
const bool is_vp8 = header.payloadType == vp8_video_payload_type_;
std::unique_ptr<RtpDepacketizer> depacketizer(
RtpDepacketizer::Create(is_vp8 ? kVideoCodecVP8 : kVideoCodecVP9));
RtpDepacketizer::ParsedPayload parsed_payload;
if (depacketizer->Parse(&parsed_payload, payload, payload_data_length)) {
if (rtp_packet.PayloadType() == vp8_video_payload_type_ ||
rtp_packet.PayloadType() == vp9_video_payload_type_) {
const bool is_vp8 = rtp_packet.PayloadType() == vp8_video_payload_type_;
VideoRtpDepacketizer& depacketizer =
is_vp8 ? *vp8_depacketizer_ : *vp9_depacketizer_;
if (auto parsed_payload = depacketizer.Parse(rtp_packet.PayloadBuffer())) {
int temporal_idx;
int spatial_idx;
bool non_ref_for_inter_layer_pred;
@ -113,7 +105,7 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
if (is_vp8) {
temporal_idx = absl::get<RTPVideoHeaderVP8>(
parsed_payload.video_header().video_type_header)
parsed_payload->video_header.video_type_header)
.temporalIdx;
spatial_idx = kNoSpatialIdx;
num_active_spatial_layers_ = 1;
@ -121,7 +113,7 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
end_of_frame = true;
} else {
const auto& vp9_header = absl::get<RTPVideoHeaderVP9>(
parsed_payload.video_header().video_type_header);
parsed_payload->video_header.video_type_header);
temporal_idx = vp9_header.temporal_idx;
spatial_idx = vp9_header.spatial_idx;
non_ref_for_inter_layer_pred = vp9_header.non_ref_for_inter_layer_pred;
@ -145,7 +137,7 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
std::min(num_active_spatial_layers_ - 1, selected_sl_) &&
end_of_frame) {
// This layer is now the last in the superframe.
set_marker_bit = true;
rtp_packet.SetMarker(true);
} else {
const bool higher_temporal_layer =
(selected_tl_ >= 0 && temporal_idx != kNoTemporalIdx &&
@ -166,11 +158,10 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
if (higher_temporal_layer || higher_spatial_layer ||
lower_non_ref_spatial_layer) {
// Truncate packet to a padding packet.
length = header.headerLength + 1;
temp_buffer[0] |= (1 << 5); // P = 1.
temp_buffer[1] &= 0x7F; // M = 0.
rtp_packet.SetPayloadSize(0);
rtp_packet.SetPadding(1);
rtp_packet.SetMarker(false);
discarded_last_packet_ = true;
temp_buffer[header.headerLength] = 1; // One byte of padding.
}
}
} else {
@ -178,13 +169,8 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
}
}
// We are discarding some of the packets (specifically, whole layers), so
// make sure the marker bit is set properly, and that sequence numbers are
// continuous.
if (set_marker_bit)
temp_buffer[1] |= kRtpMarkerBitMask;
return test::DirectTransport::SendRtp(temp_buffer, length, options);
return test::DirectTransport::SendRtp(rtp_packet.data(), rtp_packet.size(),
options);
}
} // namespace test

3
test/layer_filtering_transport.h
View File

@ -20,6 +20,7 @@
#include "api/media_types.h"
#include "call/call.h"
#include "call/simulated_packet_receiver.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
#include "test/direct_transport.h"
namespace webrtc {
@ -57,6 +58,8 @@ class LayerFilteringTransport : public test::DirectTransport {
// Used to distinguish between VP8 and VP9.
const uint8_t vp8_video_payload_type_;
const uint8_t vp9_video_payload_type_;
const std::unique_ptr<VideoRtpDepacketizer> vp8_depacketizer_;
const std::unique_ptr<VideoRtpDepacketizer> vp9_depacketizer_;
// Discard or invalidate all temporal/spatial layers with id greater than the
// selected one. -1 to disable filtering.
const int selected_tl_;