webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc - Issue 1739273002: [Draft] RtpPacket sketched.

Unified Diff: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

Issue 1739273002: [Draft] RtpPacket sketched. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: rebase to use landed version of rtp::Packet Created 4 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

index b7238d26a223f5f800737ed9e7f4ba0966e3d1fd..d043cdb0c068692f41228f8201854cf73d2d9ce5 100644

--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

@@ -25,6 +25,7 @@

#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"

#include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"

#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"

+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"

#include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"

#include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"

#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"

@@ -178,15 +179,24 @@ class RtpSenderTest : public ::testing::Test {

EXPECT_EQ(0U, rtp_header.paddingLength);

}

- void SendPacket(int64_t capture_time_ms, int payload_length) {

- uint32_t timestamp = capture_time_ms * 90;

- int32_t rtp_length = rtp_sender_->BuildRTPheader(

- packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);

- ASSERT_GE(rtp_length, 0);

+ std::unique_ptr<RtpPacketToSend> CreatePacket(uint32_t timestamp,

+ int64_t capture_time_ms) {

+ std::unique_ptr<RtpPacketToSend> packet = rtp_sender_->CreatePacket();

+ rtp_sender_->BuildRtpHeader(packet.get(), timestamp, true);

+ packet->SetPayloadType(kPayload);

+ packet->SetMarker(kMarkerBit);

+ packet->set_capture_time_ms(capture_time_ms);

+ return packet;

+ }

+ void SendPacket(int64_t capture_time_ms, size_t payload_size) {

+ std::unique_ptr<RtpPacketToSend> packet =

+ CreatePacket(kTimestamp, capture_time_ms);

+ packet->AllocatePayload(payload_size);

// Packet should be stored in a send bucket.

EXPECT_EQ(0, rtp_sender_->SendToNetwork(

- packet_, payload_length, rtp_length, capture_time_ms,

+ std::move(packet), payload_size, capture_time_ms,

kAllowRetransmission, RtpPacketSender::kNormalPriority));

}

};

@@ -211,30 +221,23 @@ class RtpSenderVideoTest : public RtpSenderTest {

void VerifyCVOPacket(uint8_t* data,

size_t len,

bool expect_cvo,

- RtpHeaderExtensionMap* map,

+ RtpHeaderExtensionsManager* map,

uint16_t seq_num,

VideoRotation rotation) {

- webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len);

- webrtc::RTPHeader rtp_header;

- size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(

- packet_, kPayload, expect_cvo /* marker_bit */, kTimestamp, 0));

+ RtpPacketToSend packet(map);

+ ASSERT_TRUE(packet.Parse(data, len));

+ EXPECT_EQ(payload_, packet.PayloadType());

+ EXPECT_EQ(seq_num, packet.SequenceNumber());

+ EXPECT_EQ(kTimestamp, packet.Timestamp());

+ EXPECT_EQ(rtp_sender_->SSRC(), packet.Ssrc());

+ EXPECT_EQ(0U, packet.Csrcs().size());

+ EXPECT_EQ(0U, packet.padding_size());

+ VideoRotation packet_rotation;

+ EXPECT_EQ(expect_cvo,

+ packet.GetExtension<VideoOrientation>(&packet_rotation));

if (expect_cvo) {

- ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),

- length);

- } else {

- ASSERT_EQ(kRtpHeaderSize, length);

+ EXPECT_EQ(rotation, packet_rotation);

}

- ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map));

- ASSERT_FALSE(rtp_parser.RTCP());

- EXPECT_EQ(payload_, rtp_header.payloadType);

- EXPECT_EQ(seq_num, rtp_header.sequenceNumber);

- EXPECT_EQ(kTimestamp, rtp_header.timestamp);

- EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);

- EXPECT_EQ(0, rtp_header.numCSRCs);

- EXPECT_EQ(0U, rtp_header.paddingLength);

- EXPECT_EQ(ConvertVideoRotationToCVOByte(rotation),

- rtp_header.extension.videoRotation);

}

};

@@ -344,12 +347,15 @@ TEST_F(RtpSenderTestWithoutPacer, RegisterRtpVideoRotationHeaderExtension) {

}

TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {

- size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(

- packet_, kPayload, kMarkerBit, kTimestamp, 0));

- ASSERT_EQ(kRtpHeaderSize, length);

+ RtpPacketToSend packet(nullptr);

+ rtp_sender_->BuildRtpHeader(&packet, kTimestamp, false);

+ packet.SetPayloadType(kPayload);

+ packet.SetMarker(kMarkerBit);

+ ASSERT_EQ(kRtpHeaderSize, packet.headers_size());

+ ASSERT_EQ(kRtpHeaderSize, packet.size());

// Verify

- webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);

+ webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet.data(), packet.size());

webrtc::RTPHeader rtp_header;

const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr);

@@ -357,7 +363,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {

ASSERT_TRUE(valid_rtp_header);

ASSERT_FALSE(rtp_parser.RTCP());

VerifyRTPHeaderCommon(rtp_header);

- EXPECT_EQ(length, rtp_header.headerLength);

+ EXPECT_EQ(packet.headers_size(), rtp_header.headerLength);

EXPECT_FALSE(rtp_header.extension.hasTransmissionTimeOffset);

EXPECT_FALSE(rtp_header.extension.hasAbsoluteSendTime);

EXPECT_FALSE(rtp_header.extension.hasAudioLevel);

@@ -721,7 +727,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {

EXPECT_CALL(mock_rtc_event_log_,

LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));

- rtp_sender_->SetStorePacketsStatus(true, 10);

+ rtp_sender_->SetStorePacketsSize(10);

EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(

kRtpExtensionTransmissionTimeOffset,

kTransmissionTimeOffsetExtensionId));

@@ -730,14 +736,13 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {

kAbsoluteSendTimeExtensionId));

rtp_sender_->SetTargetBitrate(300000);

int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();

- int rtp_length_int = rtp_sender_->BuildRTPheader(

- packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);

- ASSERT_NE(-1, rtp_length_int);

- size_t rtp_length = static_cast<size_t>(rtp_length_int);

+ std::unique_ptr<RtpPacketToSend> packet =

+ CreatePacket(kTimestamp, capture_time_ms);

+ size_t rtp_length = packet->size();

// Packet should be stored in a send bucket.

- EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,

- capture_time_ms, kAllowRetransmission,

+ EXPECT_EQ(0, rtp_sender_->SendToNetwork(std::move(packet), 0, capture_time_ms,

+ kAllowRetransmission,

RtpPacketSender::kNormalPriority));

EXPECT_EQ(0, transport_.packets_sent_);

@@ -774,7 +779,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {

EXPECT_CALL(mock_rtc_event_log_,

LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));

- rtp_sender_->SetStorePacketsStatus(true, 10);

+ rtp_sender_->SetStorePacketsSize(10);

EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(

kRtpExtensionTransmissionTimeOffset,

kTransmissionTimeOffsetExtensionId));

@@ -783,14 +788,13 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {

kAbsoluteSendTimeExtensionId));

rtp_sender_->SetTargetBitrate(300000);

int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();

- int rtp_length_int = rtp_sender_->BuildRTPheader(

- packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);

- ASSERT_NE(-1, rtp_length_int);

- size_t rtp_length = static_cast<size_t>(rtp_length_int);

+ std::unique_ptr<RtpPacketToSend> packet =

+ CreatePacket(kTimestamp, capture_time_ms);

+ size_t rtp_length = packet->size();

// Packet should be stored in a send bucket.

- EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,

- capture_time_ms, kAllowRetransmission,

+ EXPECT_EQ(0, rtp_sender_->SendToNetwork(std::move(packet), 0, capture_time_ms,

+ kAllowRetransmission,

RtpPacketSender::kNormalPriority));

EXPECT_EQ(0, transport_.packets_sent_);

@@ -801,7 +805,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {

const int kStoredTimeInMs = 100;

fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);

- EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum));

+ EXPECT_EQ(static_cast<int>(rtp_length), rtp_sender_->ReSendPacket(kSeqNum));

EXPECT_EQ(0, transport_.packets_sent_);

rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);

@@ -840,7 +844,7 @@ TEST_F(RtpSenderTest, SendPadding) {

uint16_t seq_num = kSeqNum;

uint32_t timestamp = kTimestamp;

- rtp_sender_->SetStorePacketsStatus(true, 10);

+ rtp_sender_->SetStorePacketsSize(10);

size_t rtp_header_len = kRtpHeaderSize;

EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(

kRtpExtensionTransmissionTimeOffset,

@@ -863,16 +867,16 @@ TEST_F(RtpSenderTest, SendPadding) {

webrtc::RTPHeader rtp_header;

rtp_sender_->SetTargetBitrate(300000);

+ rtp_sender_->SetSendPayloadType(kPayload);

int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();

- int rtp_length_int = rtp_sender_->BuildRTPheader(

- packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);

+ std::unique_ptr<RtpPacketToSend> packet =

+ CreatePacket(timestamp, capture_time_ms);

const uint32_t media_packet_timestamp = timestamp;

- ASSERT_NE(-1, rtp_length_int);

- size_t rtp_length = static_cast<size_t>(rtp_length_int);

+ size_t rtp_length = packet->size();

// Packet should be stored in a send bucket.

- EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,

- capture_time_ms, kAllowRetransmission,

+ EXPECT_EQ(0, rtp_sender_->SendToNetwork(std::move(packet), 0, capture_time_ms,

+ kAllowRetransmission,

RtpPacketSender::kNormalPriority));

int total_packets_sent = 0;

@@ -920,17 +924,19 @@ TEST_F(RtpSenderTest, SendPadding) {

// Send a regular video packet again.

capture_time_ms = fake_clock_.TimeInMilliseconds();

- rtp_length_int = rtp_sender_->BuildRTPheader(packet_, kPayload, kMarkerBit,

- timestamp, capture_time_ms);

- ASSERT_NE(-1, rtp_length_int);

- rtp_length = static_cast<size_t>(rtp_length_int);

+ packet = rtp_sender_->CreatePacket();

+ rtp_sender_->BuildRtpHeader(packet.get(), timestamp, true);

+ packet->SetPayloadType(kPayload);

+ packet->SetMarker(kMarkerBit);

+ packet->set_capture_time_ms(capture_time_ms);

+ rtp_length = packet->size();

EXPECT_CALL(mock_paced_sender_,

InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _));

// Packet should be stored in a send bucket.

- EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,

- capture_time_ms, kAllowRetransmission,

+ EXPECT_EQ(0, rtp_sender_->SendToNetwork(std::move(packet), 0, capture_time_ms,

+ kAllowRetransmission,

RtpPacketSender::kNormalPriority));

rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false);

@@ -960,7 +966,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {

rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);

uint16_t seq_num = kSeqNum;

- rtp_sender_->SetStorePacketsStatus(true, 10);

+ rtp_sender_->SetStorePacketsSize(10);

int32_t rtp_header_len = kRtpHeaderSize;

EXPECT_EQ(

0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,

@@ -1105,7 +1111,7 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) {

ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,

0, 1500));

uint8_t payload[] = {47, 11, 32, 93, 89};

- rtp_sender_->SetStorePacketsStatus(true, 1);

+ rtp_sender_->SetStorePacketsSize(1);

uint32_t ssrc = rtp_sender_->SSRC();

EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))

@@ -1167,7 +1173,7 @@ TEST_F(RtpSenderTest, BitrateCallbacks) {

ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,

0, 1500));

uint8_t payload[] = {47, 11, 32, 93, 89};

- rtp_sender_->SetStorePacketsStatus(true, 1);

+ rtp_sender_->SetStorePacketsSize(1);

uint32_t ssrc = rtp_sender_->SSRC();

// Initial process call so we get a new time window.

@@ -1250,7 +1256,7 @@ TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {

ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,

0, 1500));

uint8_t payload[] = {47, 11, 32, 93, 89};

- rtp_sender_->SetStorePacketsStatus(true, 1);

+ rtp_sender_->SetStorePacketsSize(1);

uint32_t ssrc = rtp_sender_->SSRC();

rtp_sender_->RegisterRtpStatisticsCallback(&callback);

@@ -1476,7 +1482,7 @@ TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {

const int32_t kPacketSize = 1400;

const int32_t kNumPackets = 30;

- rtp_sender_->SetStorePacketsStatus(true, kNumPackets);

+ rtp_sender_->SetStorePacketsSize(kNumPackets);

// Set bitrate (in kbps) to fit kNumPackets á kPacketSize bytes in one second.

rtp_sender_->SetTargetBitrate(kNumPackets * kPacketSize * 8);

const uint16_t kStartSequenceNumber = rtp_sender_->SequenceNumber();

@@ -1518,8 +1524,8 @@ TEST_F(RtpSenderVideoTest, SendVideoWithCVO) {

kTimestamp, 0, packet_, sizeof(packet_), nullptr,

&hdr);

- RtpHeaderExtensionMap map;

- map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);

+ RtpHeaderExtensionsManager map;

+ map.Register<VideoOrientation>(kVideoRotationExtensionId);

// Verify that this packet does have CVO byte.

VerifyCVOPacket(

« no previous file with comments | « webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc ('k') | webrtc/modules/rtp_rtcp/source/rtp_sender_video.h » ('j') | no next file with comments »