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

[rtp_rtcp] Lint errors cleaned from rtp_utility

Browse Source 
R=åsapersson
BUG=webrtc:5277

Review URL: https://codereview.webrtc.org/1539423003

Cr-Commit-Position: refs/heads/master@{#11131}
This commit is contained in:
danilchap
2015-12-28 10:18:46 -08:00
committed by Commit bot
parent e0d56a7225
commit f6975f4613
12 changed files with 106 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/modules/rtp_rtcp/source/CPPLINT.cfg
View File

@ -1,7 +1,5 @@
#tmmbr_help is refactored in CL#1474693002 #tmmbr_help is refactored in CL#1474693002
exclude_files=tmmbr_help.* exclude_files=tmmbr_help.*
#rtp_utility is refactored in CL#1481773004
exclude_files=rtp_utility.*
#rtcp_utility planned to be removed when webrtc:5260 will be finished. #rtcp_utility planned to be removed when webrtc:5260 will be finished.
exclude_files=rtcp_utility.* exclude_files=rtcp_utility.*
#rtcp_receiver/rtcp_receiver_help will be refactored more deeply as part of webrtc:5260 #rtcp_receiver/rtcp_receiver_help will be refactored more deeply as part of webrtc:5260

2
webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc
View File

@ -58,7 +58,7 @@ bool RtpHeaderParserImpl::Parse(const uint8_t* packet,
rtp_header_extension_map_.GetCopy(&map); rtp_header_extension_map_.GetCopy(&map);
} }
const bool valid_rtpheader = rtp_parser.Parse(*header, &map); const bool valid_rtpheader = rtp_parser.Parse(header, &map);
if (!valid_rtpheader) { if (!valid_rtpheader) {
return false; return false;
} }

21
webrtc/modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -579,7 +579,7 @@ size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) {
break; break;
RtpUtility::RtpHeaderParser rtp_parser(buffer, length); RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
RTPHeader rtp_header; RTPHeader rtp_header;
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
bytes_left -= static_cast<int>(length - rtp_header.headerLength); bytes_left -= static_cast<int>(length - rtp_header.headerLength);
} }
return bytes_to_send - bytes_left; return bytes_to_send - bytes_left;
@ -589,8 +589,7 @@ void RTPSender::BuildPaddingPacket(uint8_t* packet,
size_t header_length, size_t header_length,
size_t padding_length) { size_t padding_length) {
packet[0] |= 0x20; // Set padding bit. packet[0] |= 0x20; // Set padding bit.
int32_t *data = int32_t* data = reinterpret_cast<int32_t*>(&(packet[header_length]));
reinterpret_cast<int32_t *>(&(packet[header_length]));
// Fill data buffer with random data. // Fill data buffer with random data.
for (size_t j = 0; j < (padding_length >> 2); ++j) { for (size_t j = 0; j < (padding_length >> 2); ++j) {
@ -671,7 +670,7 @@ size_t RTPSender::SendPadData(size_t bytes,
RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length); RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length);
RTPHeader rtp_header; RTPHeader rtp_header;
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
if (capture_time_ms > 0) { if (capture_time_ms > 0) {
UpdateTransmissionTimeOffset( UpdateTransmissionTimeOffset(
@ -723,7 +722,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) {
if (paced_sender_) { if (paced_sender_) {
RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length); RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length);
RTPHeader header; RTPHeader header;
if (!rtp_parser.Parse(header)) { if (!rtp_parser.Parse(&header)) {
assert(false); assert(false);
return -1; return -1;
} }
@ -909,11 +908,11 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
int64_t capture_time_ms, int64_t capture_time_ms,
bool send_over_rtx, bool send_over_rtx,
bool is_retransmit) { bool is_retransmit) {
uint8_t *buffer_to_send_ptr = buffer; uint8_t* buffer_to_send_ptr = buffer;
RtpUtility::RtpHeaderParser rtp_parser(buffer, length); RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
RTPHeader rtp_header; RTPHeader rtp_header;
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
if (!is_retransmit && rtp_header.markerBit) { if (!is_retransmit && rtp_header.markerBit) {
TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend", TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
capture_time_ms); capture_time_ms);
@ -1032,7 +1031,7 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer,
RtpUtility::RtpHeaderParser rtp_parser(buffer, RtpUtility::RtpHeaderParser rtp_parser(buffer,
payload_length + rtp_header_length); payload_length + rtp_header_length);
RTPHeader rtp_header; RTPHeader rtp_header;
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
int64_t now_ms = clock_->TimeInMilliseconds(); int64_t now_ms = clock_->TimeInMilliseconds();
@ -1175,7 +1174,7 @@ size_t RTPSender::CreateRtpHeader(uint8_t* header,
int32_t rtp_header_length = kRtpHeaderLength; int32_t rtp_header_length = kRtpHeaderLength;
if (csrcs.size() > 0) { if (csrcs.size() > 0) {
uint8_t *ptr = &header[rtp_header_length]; uint8_t* ptr = &header[rtp_header_length];
for (size_t i = 0; i < csrcs.size(); ++i) { for (size_t i = 0; i < csrcs.size(); ++i) {
ByteWriter<uint32_t>::WriteBigEndian(ptr, csrcs[i]); ByteWriter<uint32_t>::WriteBigEndian(ptr, csrcs[i]);
ptr += 4; ptr += 4;
@ -1827,7 +1826,7 @@ void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length,
reinterpret_cast<const uint8_t*>(buffer), *length); reinterpret_cast<const uint8_t*>(buffer), *length);
RTPHeader rtp_header; RTPHeader rtp_header;
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
// Add original RTP header. // Add original RTP header.
memcpy(data_buffer_rtx, buffer, rtp_header.headerLength); memcpy(data_buffer_rtx, buffer, rtp_header.headerLength);
@ -1840,7 +1839,7 @@ void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length,
} }
// Replace sequence number. // Replace sequence number.
uint8_t *ptr = data_buffer_rtx + 2; uint8_t* ptr = data_buffer_rtx + 2;
ByteWriter<uint16_t>::WriteBigEndian(ptr, sequence_number_rtx_++); ByteWriter<uint16_t>::WriteBigEndian(ptr, sequence_number_rtx_++);
// Replace SSRC. // Replace SSRC.

2
webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
View File

@ -350,7 +350,7 @@ int32_t RTPSenderAudio::SendAudio(FrameType frameType,
size_t packetSize = payloadSize + rtpHeaderLength; size_t packetSize = payloadSize + rtpHeaderLength;
RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize); RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize);
RTPHeader rtp_header; RTPHeader rtp_header;
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
_rtpSender->UpdateAudioLevel(dataBuffer, packetSize, rtp_header, _rtpSender->UpdateAudioLevel(dataBuffer, packetSize, rtp_header,
(frameType == kAudioFrameSpeech), (frameType == kAudioFrameSpeech),
audio_level_dbov); audio_level_dbov);

42
webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -208,7 +208,7 @@ class RtpSenderVideoTest : public RtpSenderTest {
} else { } else {
ASSERT_EQ(kRtpHeaderSize, length); ASSERT_EQ(kRtpHeaderSize, length);
} }
ASSERT_TRUE(rtp_parser.Parse(rtp_header, map)); ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map));
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
EXPECT_EQ(payload_, rtp_header.payloadType); EXPECT_EQ(payload_, rtp_header.payloadType);
EXPECT_EQ(seq_num, rtp_header.sequenceNumber); EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
@ -335,7 +335,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, nullptr); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
@ -370,7 +370,7 @@ TEST_F(RtpSenderTestWithoutPacer,
RtpHeaderExtensionMap map; RtpHeaderExtensionMap map;
map.Register(kRtpExtensionTransmissionTimeOffset, map.Register(kRtpExtensionTransmissionTimeOffset,
kTransmissionTimeOffsetExtensionId); kTransmissionTimeOffsetExtensionId);
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
@ -381,7 +381,7 @@ TEST_F(RtpSenderTestWithoutPacer,
// Parse without map extension // Parse without map extension
webrtc::RTPHeader rtp_header2; webrtc::RTPHeader rtp_header2;
const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
ASSERT_TRUE(valid_rtp_header2); ASSERT_TRUE(valid_rtp_header2);
VerifyRTPHeaderCommon(rtp_header2); VerifyRTPHeaderCommon(rtp_header2);
@ -410,7 +410,7 @@ TEST_F(RtpSenderTestWithoutPacer,
RtpHeaderExtensionMap map; RtpHeaderExtensionMap map;
map.Register(kRtpExtensionTransmissionTimeOffset, map.Register(kRtpExtensionTransmissionTimeOffset,
kTransmissionTimeOffsetExtensionId); kTransmissionTimeOffsetExtensionId);
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
@ -437,7 +437,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {
RtpHeaderExtensionMap map; RtpHeaderExtensionMap map;
map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId); map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
@ -448,7 +448,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {
// Parse without map extension // Parse without map extension
webrtc::RTPHeader rtp_header2; webrtc::RTPHeader rtp_header2;
const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
ASSERT_TRUE(valid_rtp_header2); ASSERT_TRUE(valid_rtp_header2);
VerifyRTPHeaderCommon(rtp_header2); VerifyRTPHeaderCommon(rtp_header2);
@ -476,7 +476,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) {
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header, &map)); ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
VerifyRTPHeaderCommon(rtp_header); VerifyRTPHeaderCommon(rtp_header);
EXPECT_EQ(length, rtp_header.headerLength); EXPECT_EQ(length, rtp_header.headerLength);
@ -504,7 +504,7 @@ TEST_F(RtpSenderTestWithoutPacer,
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header, &map)); ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
VerifyRTPHeaderCommon(rtp_header, false); VerifyRTPHeaderCommon(rtp_header, false);
EXPECT_EQ(length, rtp_header.headerLength); EXPECT_EQ(length, rtp_header.headerLength);
@ -525,12 +525,12 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
// Updating audio level is done in RTPSenderAudio, so simulate it here. // Updating audio level is done in RTPSenderAudio, so simulate it here.
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
RtpHeaderExtensionMap map; RtpHeaderExtensionMap map;
map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId); map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
@ -542,7 +542,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {
// Parse without map extension // Parse without map extension
webrtc::RTPHeader rtp_header2; webrtc::RTPHeader rtp_header2;
const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
ASSERT_TRUE(valid_rtp_header2); ASSERT_TRUE(valid_rtp_header2);
VerifyRTPHeaderCommon(rtp_header2); VerifyRTPHeaderCommon(rtp_header2);
@ -579,7 +579,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
// Updating audio level is done in RTPSenderAudio, so simulate it here. // Updating audio level is done in RTPSenderAudio, so simulate it here.
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
RtpHeaderExtensionMap map; RtpHeaderExtensionMap map;
@ -589,7 +589,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {
map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId); map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
map.Register(kRtpExtensionTransportSequenceNumber, map.Register(kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId); kTransportSequenceNumberExtensionId);
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
ASSERT_FALSE(rtp_parser.RTCP()); ASSERT_FALSE(rtp_parser.RTCP());
@ -608,7 +608,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {
// Parse without map extension // Parse without map extension
webrtc::RTPHeader rtp_header2; webrtc::RTPHeader rtp_header2;
const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
ASSERT_TRUE(valid_rtp_header2); ASSERT_TRUE(valid_rtp_header2);
VerifyRTPHeaderCommon(rtp_header2); VerifyRTPHeaderCommon(rtp_header2);
@ -667,7 +667,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
map.Register(kRtpExtensionTransmissionTimeOffset, map.Register(kRtpExtensionTransmissionTimeOffset,
kTransmissionTimeOffsetExtensionId); kTransmissionTimeOffsetExtensionId);
map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId); map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
// Verify transmission time offset. // Verify transmission time offset.
@ -727,7 +727,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
map.Register(kRtpExtensionTransmissionTimeOffset, map.Register(kRtpExtensionTransmissionTimeOffset,
kTransmissionTimeOffsetExtensionId); kTransmissionTimeOffsetExtensionId);
map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId); map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
ASSERT_TRUE(valid_rtp_header); ASSERT_TRUE(valid_rtp_header);
// Verify transmission time offset. // Verify transmission time offset.
@ -934,7 +934,7 @@ TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_); transport_.last_sent_packet_len_);
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header)); ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
const uint8_t* payload_data = const uint8_t* payload_data =
GetPayloadData(rtp_header, transport_.last_sent_packet_); GetPayloadData(rtp_header, transport_.last_sent_packet_);
@ -959,7 +959,7 @@ TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_, RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_,
transport_.last_sent_packet_len_); transport_.last_sent_packet_len_);
ASSERT_TRUE(rtp_parser.Parse(rtp_header)); ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_); payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
generic_header = *payload_data++; generic_header = *payload_data++;
@ -1217,7 +1217,7 @@ TEST_F(RtpSenderAudioTest, SendAudio) {
RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_); transport_.last_sent_packet_len_);
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header)); ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
const uint8_t* payload_data = const uint8_t* payload_data =
GetPayloadData(rtp_header, transport_.last_sent_packet_); GetPayloadData(rtp_header, transport_.last_sent_packet_);
@ -1246,7 +1246,7 @@ TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_); transport_.last_sent_packet_len_);
webrtc::RTPHeader rtp_header; webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header)); ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
const uint8_t* payload_data = const uint8_t* payload_data =
GetPayloadData(rtp_header, transport_.last_sent_packet_); GetPayloadData(rtp_header, transport_.last_sent_packet_);

2
webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -304,7 +304,7 @@ int32_t RTPSenderVideo::SendVideo(const RtpVideoCodecTypes videoType,
size_t packetSize = payloadSize + rtp_header_length; size_t packetSize = payloadSize + rtp_header_length;
RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize); RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize);
RTPHeader rtp_header; RTPHeader rtp_header;
rtp_parser.Parse(rtp_header); rtp_parser.Parse(&rtp_header);
_rtpSender.UpdateVideoRotation(dataBuffer, packetSize, rtp_header, _rtpSender.UpdateVideoRotation(dataBuffer, packetSize, rtp_header,
rtpHdr->rotation); rtpHdr->rotation);
} }

108
webrtc/modules/rtp_rtcp/source/rtp_utility.cc
View File

@ -10,38 +10,10 @@
#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
#include <assert.h> #include <string.h>
#include <math.h> // ceil
#include <string.h> // memcpy
#if defined(_WIN32)
// Order for these headers are important
#include <winsock2.h> // timeval
#include <windows.h> // FILETIME NOLINT(build/include_alpha)
#include <MMSystem.h> // timeGetTime
#elif ((defined WEBRTC_LINUX) || (defined WEBRTC_MAC))
#include <sys/time.h> // gettimeofday
#include <time.h>
#endif
#if (!defined(NDEBUG) && defined(_WIN32) && (_MSC_VER >= 1400))
#include <stdio.h>
#endif
#include "webrtc/base/logging.h" #include "webrtc/base/logging.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#if (!defined(NDEBUG) && defined(_WIN32) && (_MSC_VER >= 1400))
#define DEBUG_PRINT(...) \
{ \
char msg[256]; \
sprintf(msg, __VA_ARGS__); \
OutputDebugString(msg); \
}
#else
// special fix for visual 2003
#define DEBUG_PRINT(exp) ((void)0)
#endif // !defined(NDEBUG) && defined(_WIN32)
namespace webrtc { namespace webrtc {
@ -83,12 +55,12 @@ enum {
#if defined(_WIN32) #if defined(_WIN32)
bool StringCompare(const char* str1, const char* str2, bool StringCompare(const char* str1, const char* str2,
const uint32_t length) { const uint32_t length) {
return (_strnicmp(str1, str2, length) == 0) ? true : false; return _strnicmp(str1, str2, length) == 0;
} }
#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC) #elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
bool StringCompare(const char* str1, const char* str2, bool StringCompare(const char* str1, const char* str2,
const uint32_t length) { const uint32_t length) {
return (strncasecmp(str1, str2, length) == 0) ? true : false; return strncasecmp(str1, str2, length) == 0;
} }
#endif #endif
@ -99,10 +71,6 @@ size_t Word32Align(size_t size) {
return size; return size;
} }
uint32_t pow2(uint8_t exp) {
return 1 << exp;
}
RtpHeaderParser::RtpHeaderParser(const uint8_t* rtpData, RtpHeaderParser::RtpHeaderParser(const uint8_t* rtpData,
const size_t rtpDataLength) const size_t rtpDataLength)
: _ptrRTPDataBegin(rtpData), : _ptrRTPDataBegin(rtpData),
@ -212,7 +180,7 @@ bool RtpHeaderParser::ParseRtcp(RTPHeader* header) const {
return true; return true;
} }
bool RtpHeaderParser::Parse(RTPHeader& header, bool RtpHeaderParser::Parse(RTPHeader* header,
RtpHeaderExtensionMap* ptrExtensionMap) const { RtpHeaderExtensionMap* ptrExtensionMap) const {
const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin; const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
if (length < kRtpMinParseLength) { if (length < kRtpMinParseLength) {
@ -251,39 +219,39 @@ bool RtpHeaderParser::Parse(RTPHeader& header,
return false; return false;
} }
header.markerBit = M; header->markerBit = M;
header.payloadType = PT; header->payloadType = PT;
header.sequenceNumber = sequenceNumber; header->sequenceNumber = sequenceNumber;
header.timestamp = RTPTimestamp; header->timestamp = RTPTimestamp;
header.ssrc = SSRC; header->ssrc = SSRC;
header.numCSRCs = CC; header->numCSRCs = CC;
header.paddingLength = P ? *(_ptrRTPDataEnd - 1) : 0; header->paddingLength = P ? *(_ptrRTPDataEnd - 1) : 0;
for (uint8_t i = 0; i < CC; ++i) { for (uint8_t i = 0; i < CC; ++i) {
uint32_t CSRC = ByteReader<uint32_t>::ReadBigEndian(ptr); uint32_t CSRC = ByteReader<uint32_t>::ReadBigEndian(ptr);
ptr += 4; ptr += 4;
header.arrOfCSRCs[i] = CSRC; header->arrOfCSRCs[i] = CSRC;
} }
header.headerLength = 12 + CSRCocts; header->headerLength = 12 + CSRCocts;
// If in effect, MAY be omitted for those packets for which the offset // If in effect, MAY be omitted for those packets for which the offset
// is zero. // is zero.
header.extension.hasTransmissionTimeOffset = false; header->extension.hasTransmissionTimeOffset = false;
header.extension.transmissionTimeOffset = 0; header->extension.transmissionTimeOffset = 0;
// May not be present in packet. // May not be present in packet.
header.extension.hasAbsoluteSendTime = false; header->extension.hasAbsoluteSendTime = false;
header.extension.absoluteSendTime = 0; header->extension.absoluteSendTime = 0;
// May not be present in packet. // May not be present in packet.
header.extension.hasAudioLevel = false; header->extension.hasAudioLevel = false;
header.extension.voiceActivity = false; header->extension.voiceActivity = false;
header.extension.audioLevel = 0; header->extension.audioLevel = 0;
// May not be present in packet. // May not be present in packet.
header.extension.hasVideoRotation = false; header->extension.hasVideoRotation = false;
header.extension.videoRotation = 0; header->extension.videoRotation = 0;
if (X) { if (X) {
/* RTP header extension, RFC 3550. /* RTP header extension, RFC 3550.
@ -300,7 +268,7 @@ bool RtpHeaderParser::Parse(RTPHeader& header,
return false; return false;
} }
header.headerLength += 4; header->headerLength += 4;
uint16_t definedByProfile = ByteReader<uint16_t>::ReadBigEndian(ptr); uint16_t definedByProfile = ByteReader<uint16_t>::ReadBigEndian(ptr);
ptr += 2; ptr += 2;
@ -320,15 +288,16 @@ bool RtpHeaderParser::Parse(RTPHeader& header,
ptrRTPDataExtensionEnd, ptrRTPDataExtensionEnd,
ptr); ptr);
} }
header.headerLength += XLen; header->headerLength += XLen;
} }
if (header.headerLength + header.paddingLength > static_cast<size_t>(length)) if (header->headerLength + header->paddingLength >
static_cast<size_t>(length))
return false; return false;
return true; return true;
} }
void RtpHeaderParser::ParseOneByteExtensionHeader( void RtpHeaderParser::ParseOneByteExtensionHeader(
RTPHeader& header, RTPHeader* header,
const RtpHeaderExtensionMap* ptrExtensionMap, const RtpHeaderExtensionMap* ptrExtensionMap,
const uint8_t* ptrRTPDataExtensionEnd, const uint8_t* ptrRTPDataExtensionEnd,
const uint8_t* ptr) const { const uint8_t* ptr) const {
@ -374,9 +343,9 @@ void RtpHeaderParser::ParseOneByteExtensionHeader(
// | ID | len=2 | transmission offset | // | ID | len=2 | transmission offset |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
header.extension.transmissionTimeOffset = header->extension.transmissionTimeOffset =
ByteReader<int32_t, 3>::ReadBigEndian(ptr); ByteReader<int32_t, 3>::ReadBigEndian(ptr);
header.extension.hasTransmissionTimeOffset = true; header->extension.hasTransmissionTimeOffset = true;
break; break;
} }
case kRtpExtensionAudioLevel: { case kRtpExtensionAudioLevel: {
@ -390,9 +359,9 @@ void RtpHeaderParser::ParseOneByteExtensionHeader(
// | ID | len=0 |V| level | // | ID | len=0 |V| level |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// //
header.extension.audioLevel = ptr[0] & 0x7f; header->extension.audioLevel = ptr[0] & 0x7f;
header.extension.voiceActivity = (ptr[0] & 0x80) != 0; header->extension.voiceActivity = (ptr[0] & 0x80) != 0;
header.extension.hasAudioLevel = true; header->extension.hasAudioLevel = true;
break; break;
} }
case kRtpExtensionAbsoluteSendTime: { case kRtpExtensionAbsoluteSendTime: {
@ -406,9 +375,9 @@ void RtpHeaderParser::ParseOneByteExtensionHeader(
// | ID | len=2 | absolute send time | // | ID | len=2 | absolute send time |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
header.extension.absoluteSendTime = header->extension.absoluteSendTime =
ByteReader<uint32_t, 3>::ReadBigEndian(ptr); ByteReader<uint32_t, 3>::ReadBigEndian(ptr);
header.extension.hasAbsoluteSendTime = true; header->extension.hasAbsoluteSendTime = true;
break; break;
} }
case kRtpExtensionVideoRotation: { case kRtpExtensionVideoRotation: {
@ -422,8 +391,8 @@ void RtpHeaderParser::ParseOneByteExtensionHeader(
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | ID | len=0 |0 0 0 0 C F R R| // | ID | len=0 |0 0 0 0 C F R R|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
header.extension.hasVideoRotation = true; header->extension.hasVideoRotation = true;
header.extension.videoRotation = ptr[0]; header->extension.videoRotation = ptr[0];
break; break;
} }
case kRtpExtensionTransportSequenceNumber: { case kRtpExtensionTransportSequenceNumber: {
@ -440,8 +409,8 @@ void RtpHeaderParser::ParseOneByteExtensionHeader(
uint16_t sequence_number = ptr[0] << 8; uint16_t sequence_number = ptr[0] << 8;
sequence_number += ptr[1]; sequence_number += ptr[1];
header.extension.transportSequenceNumber = sequence_number; header->extension.transportSequenceNumber = sequence_number;
header.extension.hasTransportSequenceNumber = true; header->extension.hasTransportSequenceNumber = true;
break; break;
} }
default: { default: {
@ -470,5 +439,4 @@ uint8_t RtpHeaderParser::ParsePaddingBytes(
return num_zero_bytes; return num_zero_bytes;
} }
} // namespace RtpUtility } // namespace RtpUtility
} // namespace webrtc } // namespace webrtc

77
webrtc/modules/rtp_rtcp/source/rtp_utility.h
View File

@ -11,8 +11,6 @@
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_ #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_ #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_
#include <stddef.h> // size_t, ptrdiff_t
#include <map> #include <map>
#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h" #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
@ -31,62 +29,43 @@ RtpAudioFeedback* NullObjectRtpAudioFeedback();
ReceiveStatistics* NullObjectReceiveStatistics(); ReceiveStatistics* NullObjectReceiveStatistics();
namespace RtpUtility { namespace RtpUtility {
// January 1970, in NTP seconds.
const uint32_t NTP_JAN_1970 = 2208988800UL;
// Magic NTP fractional unit. struct Payload {
const double NTP_FRAC = 4.294967296E+9; char name[RTP_PAYLOAD_NAME_SIZE];
bool audio;
PayloadUnion typeSpecific;
};
struct Payload typedef std::map<int8_t, Payload*> PayloadTypeMap;
{
char name[RTP_PAYLOAD_NAME_SIZE];
bool audio;
PayloadUnion typeSpecific;
};
typedef std::map<int8_t, Payload*> PayloadTypeMap; bool StringCompare(const char* str1, const char* str2, const uint32_t length);
uint32_t pow2(uint8_t exp); // Round up to the nearest size that is a multiple of 4.
size_t Word32Align(size_t size);
// Returns true if |newTimestamp| is older than |existingTimestamp|. class RtpHeaderParser {
// |wrapped| will be set to true if there has been a wraparound between the public:
// two timestamps. RtpHeaderParser(const uint8_t* rtpData, size_t rtpDataLength);
bool OldTimestamp(uint32_t newTimestamp, ~RtpHeaderParser();
uint32_t existingTimestamp,
bool* wrapped);
bool StringCompare(const char* str1, bool RTCP() const;
const char* str2, bool ParseRtcp(RTPHeader* header) const;
const uint32_t length); bool Parse(RTPHeader* parsedPacket,
RtpHeaderExtensionMap* ptrExtensionMap = nullptr) const;
// Round up to the nearest size that is a multiple of 4. private:
size_t Word32Align(size_t size); void ParseOneByteExtensionHeader(RTPHeader* parsedPacket,
const RtpHeaderExtensionMap* ptrExtensionMap,
const uint8_t* ptrRTPDataExtensionEnd,
const uint8_t* ptr) const;
class RtpHeaderParser { uint8_t ParsePaddingBytes(const uint8_t* ptrRTPDataExtensionEnd,
public: const uint8_t* ptr) const;
RtpHeaderParser(const uint8_t* rtpData, size_t rtpDataLength);
~RtpHeaderParser();
bool RTCP() const; const uint8_t* const _ptrRTPDataBegin;
bool ParseRtcp(RTPHeader* header) const; const uint8_t* const _ptrRTPDataEnd;
bool Parse(RTPHeader& parsedPacket, };
RtpHeaderExtensionMap* ptrExtensionMap = NULL) const;
private:
void ParseOneByteExtensionHeader(
RTPHeader& parsedPacket,
const RtpHeaderExtensionMap* ptrExtensionMap,
const uint8_t* ptrRTPDataExtensionEnd,
const uint8_t* ptr) const;
uint8_t ParsePaddingBytes(
const uint8_t* ptrRTPDataExtensionEnd,
const uint8_t* ptr) const;
const uint8_t* const _ptrRTPDataBegin;
const uint8_t* const _ptrRTPDataEnd;
};
} // namespace RtpUtility } // namespace RtpUtility
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_ #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_

2
webrtc/test/layer_filtering_transport.cc
View File

@ -47,7 +47,7 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
bool set_marker_bit = false; bool set_marker_bit = false;
RtpUtility::RtpHeaderParser parser(packet, length); RtpUtility::RtpHeaderParser parser(packet, length);
RTPHeader header; RTPHeader header;
parser.Parse(header); parser.Parse(&header);
RTC_DCHECK_LE(length, static_cast<size_t>(IP_PACKET_SIZE)); RTC_DCHECK_LE(length, static_cast<size_t>(IP_PACKET_SIZE));
uint8_t temp_buffer[IP_PACKET_SIZE]; uint8_t temp_buffer[IP_PACKET_SIZE];

2
webrtc/test/rtp_file_reader.cc
View File

@ -458,7 +458,7 @@ class PcapReader : public RtpFileReaderImpl {
rtp_parser.ParseRtcp(&marker.rtp_header); rtp_parser.ParseRtcp(&marker.rtp_header);
packets_.push_back(marker); packets_.push_back(marker);
} else { } else {
if (!rtp_parser.Parse(marker.rtp_header, NULL)) { if (!rtp_parser.Parse(&marker.rtp_header, nullptr)) {
DEBUG_LOG("Not recognized as RTP/RTCP"); DEBUG_LOG("Not recognized as RTP/RTCP");
return kResultSkip; return kResultSkip;
} }

3
webrtc/test/rtp_file_reader_unittest.cc
View File

@ -85,7 +85,8 @@ class TestPcapFileReader : public ::testing::Test {
while (rtp_packet_source_->NextPacket(&packet)) { while (rtp_packet_source_->NextPacket(&packet)) {
RtpUtility::RtpHeaderParser rtp_header_parser(packet.data, packet.length); RtpUtility::RtpHeaderParser rtp_header_parser(packet.data, packet.length);
webrtc::RTPHeader header; webrtc::RTPHeader header;
if (!rtp_header_parser.RTCP() && rtp_header_parser.Parse(header, NULL)) { if (!rtp_header_parser.RTCP() &&
rtp_header_parser.Parse(&header, nullptr)) {
pps[header.ssrc]++; pps[header.ssrc]++;
} }
} }

4
webrtc/video/video_quality_test.cc
View File

@ -116,7 +116,7 @@ class VideoAnalyzer : public PacketReceiver,
const PacketTime& packet_time) override { const PacketTime& packet_time) override {
RtpUtility::RtpHeaderParser parser(packet, length); RtpUtility::RtpHeaderParser parser(packet, length);
RTPHeader header; RTPHeader header;
parser.Parse(header); parser.Parse(&header);
{ {
rtc::CritScope lock(&crit_); rtc::CritScope lock(&crit_);
recv_times_[header.timestamp - rtp_timestamp_delta_] = recv_times_[header.timestamp - rtp_timestamp_delta_] =
@ -152,7 +152,7 @@ class VideoAnalyzer : public PacketReceiver,
const PacketOptions& options) override { const PacketOptions& options) override {
RtpUtility::RtpHeaderParser parser(packet, length); RtpUtility::RtpHeaderParser parser(packet, length);
RTPHeader header; RTPHeader header;
parser.Parse(header); parser.Parse(&header);
int64_t current_time = int64_t current_time =
Clock::GetRealTimeClock()->CurrentNtpInMilliseconds(); Clock::GetRealTimeClock()->CurrentNtpInMilliseconds();