generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Some refactoring inside rtp_rtcp/.

Browse Source 
Renaming ModuleRTPUtility -> RtpUtility.
Renaming RTPHeaderParser -> RtpHeaderParser.
Making RtpHeaderParser accept size_t instead of int for packet length.
Making RtpUtility::RtpHeaderParser accept size_t for packet length.

BUG=
R=stefan@webrtc.org, tommi@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/19899004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6623 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pbos@webrtc.org 2014-07-08 12:10:51 +00:00
parent 241a9b0b65
commit 62bafae661
45 changed files with 384 additions and 400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h
View File

@ -23,13 +23,14 @@ class RtpHeaderParser {
virtual ~RtpHeaderParser() {}
// Returns true if the packet is an RTCP packet, false otherwise.
static bool IsRtcp(const uint8_t* packet, int length);
static bool IsRtcp(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, int length,
virtual bool Parse(const uint8_t* packet,
size_t length,
RTPHeader* header) const = 0;
// Registers an RTP header extension and binds it to |id|.

25
webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h
View File

@ -25,17 +25,15 @@ class RTPPayloadStrategy {
virtual bool CodecsMustBeUnique() const = 0;
virtual bool PayloadIsCompatible(
const ModuleRTPUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const = 0;
virtual bool PayloadIsCompatible(const RtpUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const = 0;
virtual void UpdatePayloadRate(
ModuleRTPUtility::Payload* payload,
const uint32_t rate) const = 0;
virtual void UpdatePayloadRate(RtpUtility::Payload* payload,
const uint32_t rate) const = 0;
virtual ModuleRTPUtility::Payload* CreatePayloadType(
virtual RtpUtility::Payload* CreatePayloadType(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t frequency,
@ -43,7 +41,7 @@ class RTPPayloadStrategy {
const uint32_t rate) const = 0;
virtual int GetPayloadTypeFrequency(
const ModuleRTPUtility::Payload& payload) const = 0;
const RtpUtility::Payload& payload) const = 0;
static RTPPayloadStrategy* CreateStrategy(const bool handling_audio);
@ -99,9 +97,8 @@ class RTPPayloadRegistry {
int GetPayloadTypeFrequency(uint8_t payload_type) const;
bool PayloadTypeToPayload(
const uint8_t payload_type,
ModuleRTPUtility::Payload*& payload) const;
bool PayloadTypeToPayload(const uint8_t payload_type,
RtpUtility::Payload*& payload) const;
void ResetLastReceivedPayloadTypes() {
CriticalSectionScoped cs(crit_sect_.get());
@ -151,7 +148,7 @@ class RTPPayloadRegistry {
bool IsRtxInternal(const RTPHeader& header) const;
scoped_ptr<CriticalSectionWrapper> crit_sect_;
ModuleRTPUtility::PayloadTypeMap payload_type_map_;
RtpUtility::PayloadTypeMap payload_type_map_;
scoped_ptr<RTPPayloadStrategy> rtp_payload_strategy_;
int8_t red_payload_type_;
int8_t ulpfec_payload_type_;

19
webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.cc
View File

@ -238,9 +238,14 @@ RTPSenderH264::SendH264FillerData(const WebRtcRTPHeader* rtpHeader,
dataBuffer[0] = static_cast<uint8_t>(0x80); // version 2
dataBuffer[1] = rtpHeader->header.payloadType;
ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer+2, _rtpSender.IncrementSequenceNumber()); // get the current SequenceNumber and add by 1 after returning
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer+4, rtpHeader->header.timestamp);
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer+8, rtpHeader->header.ssrc);
RtpUtility::AssignUWord16ToBuffer(
dataBuffer + 2,
_rtpSender.IncrementSequenceNumber()); // get the current
// SequenceNumber and add by 1
// after returning
RtpUtility::AssignUWord32ToBuffer(dataBuffer + 4,
rtpHeader->header.timestamp);
RtpUtility::AssignUWord32ToBuffer(dataBuffer + 8, rtpHeader->header.ssrc);
// set filler NALU type
dataBuffer[12] = 12; // NRI field = 0, type 12
@ -361,8 +366,12 @@ RTPSenderH264::SendH264SVCRelayPacket(const WebRtcRTPHeader* rtpHeader,
// _sequenceNumber will not work for re-ordering by NACK from original sender
// engine responsible for this
ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer+2, _rtpSender.IncrementSequenceNumber()); // get the current SequenceNumber and add by 1 after returning
//ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer+8, ssrc);
RtpUtility::AssignUWord16ToBuffer(
dataBuffer + 2,
_rtpSender.IncrementSequenceNumber()); // get the current
// SequenceNumber and add by 1
// after returning
// RtpUtility::AssignUWord32ToBuffer(dataBuffer+8, ssrc);
// how do we know it's the last relayed packet in a frame?
// 1) packets arrive in order, the engine manages that

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

@ -171,7 +171,7 @@ int32_t FecReceiverImpl::AddReceivedRedPacket(
payload_data_length - REDHeaderLength);
received_packet->pkt->length = payload_data_length - REDHeaderLength;
received_packet->ssrc =
ModuleRTPUtility::BufferToUWord32(&incoming_rtp_packet[8]);
RtpUtility::BufferToUWord32(&incoming_rtp_packet[8]);
} else {
// copy the RTP header

6
webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
View File

@ -86,9 +86,9 @@ void FrameGenerator::BuildRtpHeader(uint8_t* data, const RTPHeader* header) {
data[0] = 0x80; // Version 2.
data[1] = header->payloadType;
data[1] |= (header->markerBit ? kRtpMarkerBitMask : 0);
ModuleRTPUtility::AssignUWord16ToBuffer(data + 2, header->sequenceNumber);
ModuleRTPUtility::AssignUWord32ToBuffer(data + 4, header->timestamp);
ModuleRTPUtility::AssignUWord32ToBuffer(data + 8, header->ssrc);
RtpUtility::AssignUWord16ToBuffer(data + 2, header->sequenceNumber);
RtpUtility::AssignUWord32ToBuffer(data + 4, header->timestamp);
RtpUtility::AssignUWord32ToBuffer(data + 8, header->ssrc);
}
} // namespace webrtc

22
webrtc/modules/rtp_rtcp/source/forward_error_correction.cc
View File

@ -230,7 +230,7 @@ void ForwardErrorCorrection::GenerateFecBitStrings(
Packet* media_packet = *media_list_it;
// Assign network-ordered media payload length.
ModuleRTPUtility::AssignUWord16ToBuffer(
RtpUtility::AssignUWord16ToBuffer(
media_payload_length, media_packet->length - kRtpHeaderSize);
fec_packet_length = media_packet->length + fec_rtp_offset;
@ -432,7 +432,7 @@ void ForwardErrorCorrection::GenerateFecUlpHeaders(
// -- ULP header --
// Copy the payload size to the protection length field.
// (We protect the entire packet.)
ModuleRTPUtility::AssignUWord16ToBuffer(
RtpUtility::AssignUWord16ToBuffer(
&generated_fec_packets_[i].data[10],
generated_fec_packets_[i].length - kFecHeaderSize - ulp_header_size);
@ -537,7 +537,7 @@ void ForwardErrorCorrection::InsertFECPacket(
fec_packet->ssrc = rx_packet->ssrc;
const uint16_t seq_num_base =
ModuleRTPUtility::BufferToUWord16(&fec_packet->pkt->data[2]);
RtpUtility::BufferToUWord16(&fec_packet->pkt->data[2]);
const uint16_t maskSizeBytes =
(fec_packet->pkt->data[0] & 0x40) ? kMaskSizeLBitSet
: kMaskSizeLBitClear; // L bit set?
@ -650,7 +650,7 @@ void ForwardErrorCorrection::InitRecovery(const FecPacket* fec_packet,
// Copy FEC payload, skipping the ULP header.
memcpy(&recovered->pkt->data[kRtpHeaderSize],
&fec_packet->pkt->data[kFecHeaderSize + ulp_header_size],
ModuleRTPUtility::BufferToUWord16(protection_length));
RtpUtility::BufferToUWord16(protection_length));
// Copy the length recovery field.
memcpy(recovered->length_recovery, &fec_packet->pkt->data[8], 2);
// Copy the first 2 bytes of the FEC header.
@ -658,8 +658,7 @@ void ForwardErrorCorrection::InitRecovery(const FecPacket* fec_packet,
// Copy the 5th to 8th bytes of the FEC header.
memcpy(&recovered->pkt->data[4], &fec_packet->pkt->data[4], 4);
// Set the SSRC field.
ModuleRTPUtility::AssignUWord32ToBuffer(&recovered->pkt->data[8],
fec_packet->ssrc);
RtpUtility::AssignUWord32ToBuffer(&recovered->pkt->data[8], fec_packet->ssrc);
}
void ForwardErrorCorrection::FinishRecovery(RecoveredPacket* recovered) {
@ -668,12 +667,11 @@ void ForwardErrorCorrection::FinishRecovery(RecoveredPacket* recovered) {
recovered->pkt->data[0] &= 0xbf; // Clear the 2nd bit.
// Set the SN field.
ModuleRTPUtility::AssignUWord16ToBuffer(&recovered->pkt->data[2],
recovered->seq_num);
RtpUtility::AssignUWord16ToBuffer(&recovered->pkt->data[2],
recovered->seq_num);
// Recover the packet length.
recovered->pkt->length =
ModuleRTPUtility::BufferToUWord16(recovered->length_recovery) +
kRtpHeaderSize;
RtpUtility::BufferToUWord16(recovered->length_recovery) + kRtpHeaderSize;
}
void ForwardErrorCorrection::XorPackets(const Packet* src_packet,
@ -688,8 +686,8 @@ void ForwardErrorCorrection::XorPackets(const Packet* src_packet,
}
// XOR with the network-ordered payload size.
uint8_t media_payload_length[2];
ModuleRTPUtility::AssignUWord16ToBuffer(media_payload_length,
src_packet->length - kRtpHeaderSize);
RtpUtility::AssignUWord16ToBuffer(media_payload_length,
src_packet->length - kRtpHeaderSize);
dst_packet->length_recovery[0] ^= media_payload_length[0];
dst_packet->length_recovery[1] ^= media_payload_length[1];

28
webrtc/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h
View File

@ -21,21 +21,21 @@ class MockRTPPayloadStrategy : public RTPPayloadStrategy {
MOCK_CONST_METHOD0(CodecsMustBeUnique,
bool());
MOCK_CONST_METHOD4(PayloadIsCompatible,
bool(const ModuleRTPUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate));
bool(const RtpUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate));
MOCK_CONST_METHOD2(UpdatePayloadRate,
void(ModuleRTPUtility::Payload* payload, const uint32_t rate));
MOCK_CONST_METHOD1(GetPayloadTypeFrequency, int(
const ModuleRTPUtility::Payload& payload));
MOCK_CONST_METHOD5(CreatePayloadType,
ModuleRTPUtility::Payload*(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate));
void(RtpUtility::Payload* payload, const uint32_t rate));
MOCK_CONST_METHOD1(GetPayloadTypeFrequency,
int(const RtpUtility::Payload& payload));
MOCK_CONST_METHOD5(
CreatePayloadType,
RtpUtility::Payload*(const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate));
};
} // namespace webrtc

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

@ -61,7 +61,7 @@ void RedPacket::CreateHeader(const uint8_t* rtp_header, int header_length,
void RedPacket::SetSeqNum(int seq_num) {
assert(seq_num >= 0 && seq_num < (1<<16));
ModuleRTPUtility::AssignUWord16ToBuffer(&data_[2], seq_num);
RtpUtility::AssignUWord16ToBuffer(&data_[2], seq_num);
}
void RedPacket::AssignPayload(const uint8_t* payload, int length) {

11
webrtc/modules/rtp_rtcp/source/receive_statistics_impl.cc
View File

@ -133,11 +133,12 @@ void StreamStatisticianImpl::UpdateCounters(const RTPHeader& header,
void StreamStatisticianImpl::UpdateJitter(const RTPHeader& header,
uint32_t receive_time_secs,
uint32_t receive_time_frac) {
uint32_t receive_time_rtp = ModuleRTPUtility::ConvertNTPTimeToRTP(
receive_time_secs, receive_time_frac, header.payload_type_frequency);
uint32_t last_receive_time_rtp = ModuleRTPUtility::ConvertNTPTimeToRTP(
last_receive_time_secs_, last_receive_time_frac_,
header.payload_type_frequency);
uint32_t receive_time_rtp = RtpUtility::ConvertNTPTimeToRTP(
receive_time_secs, receive_time_frac, header.payload_type_frequency);
uint32_t last_receive_time_rtp =
RtpUtility::ConvertNTPTimeToRTP(last_receive_time_secs_,
last_receive_time_frac_,
header.payload_type_frequency);
int32_t time_diff_samples = (receive_time_rtp - last_receive_time_rtp) -
(header.timestamp - last_received_timestamp_);

6
webrtc/modules/rtp_rtcp/source/rtcp_packet.cc
View File

@ -61,15 +61,15 @@ void AssignUWord8(uint8_t* buffer, size_t* offset, uint8_t value) {
buffer[(*offset)++] = value;
}
void AssignUWord16(uint8_t* buffer, size_t* offset, uint16_t value) {
ModuleRTPUtility::AssignUWord16ToBuffer(buffer + *offset, value);
RtpUtility::AssignUWord16ToBuffer(buffer + *offset, value);
*offset += 2;
}
void AssignUWord24(uint8_t* buffer, size_t* offset, uint32_t value) {
ModuleRTPUtility::AssignUWord24ToBuffer(buffer + *offset, value);
RtpUtility::AssignUWord24ToBuffer(buffer + *offset, value);
*offset += 3;
}
void AssignUWord32(uint8_t* buffer, size_t* offset, uint32_t value) {
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + *offset, value);
RtpUtility::AssignUWord32ToBuffer(buffer + *offset, value);
*offset += 4;
}

125
webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -708,24 +708,24 @@ int32_t RTCPSender::BuildSR(const FeedbackState& feedback_state,
pos++;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// NTP
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, NTPsec);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, NTPsec);
pos += 4;
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, NTPfrac);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, NTPfrac);
pos += 4;
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, RTPtime);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, RTPtime);
pos += 4;
//sender's packet count
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos,
feedback_state.packet_count_sent);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos,
feedback_state.packet_count_sent);
pos += 4;
//sender's octet count
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos,
feedback_state.byte_count_sent);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos,
feedback_state.byte_count_sent);
pos += 4;
uint8_t numberOfReportBlocks = 0;
@ -741,7 +741,7 @@ int32_t RTCPSender::BuildSR(const FeedbackState& feedback_state,
rtcpbuffer[posNumberOfReportBlocks] += numberOfReportBlocks;
uint16_t len = uint16_t((pos/4) -1);
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer+2, len);
RtpUtility::AssignUWord16ToBuffer(rtcpbuffer + 2, len);
return 0;
}
@ -767,7 +767,7 @@ int32_t RTCPSender::BuildSDEC(uint8_t* rtcpbuffer, int& pos) {
pos++;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// CNAME = 1
@ -802,7 +802,7 @@ int32_t RTCPSender::BuildSDEC(uint8_t* rtcpbuffer, int& pos) {
uint32_t SSRC = it->first;
// Add SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, SSRC);
pos += 4;
// CNAME = 1
@ -833,8 +833,7 @@ int32_t RTCPSender::BuildSDEC(uint8_t* rtcpbuffer, int& pos) {
}
// in 32-bit words minus one and we don't count the header
uint16_t buffer_length = (SDESLength / 4) - 1;
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer + SDESLengthPos,
buffer_length);
RtpUtility::AssignUWord16ToBuffer(rtcpbuffer + SDESLengthPos, buffer_length);
return 0;
}
@ -859,7 +858,7 @@ RTCPSender::BuildRR(uint8_t* rtcpbuffer,
pos++;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
uint8_t numberOfReportBlocks = 0;
@ -874,7 +873,7 @@ RTCPSender::BuildRR(uint8_t* rtcpbuffer,
rtcpbuffer[posNumberOfReportBlocks] += numberOfReportBlocks;
uint16_t len = uint16_t((pos)/4 -1);
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer+2, len);
RtpUtility::AssignUWord16ToBuffer(rtcpbuffer + 2, len);
return 0;
}
@ -925,8 +924,8 @@ RTCPSender::BuildExtendedJitterReport(
rtcpbuffer[pos++]=(uint8_t)(1);
// Add inter-arrival jitter
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer + pos,
jitterTransmissionTimeOffset);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos,
jitterTransmissionTimeOffset);
pos += 4;
return 0;
}
@ -949,11 +948,11 @@ RTCPSender::BuildPLI(uint8_t* rtcpbuffer, int& pos)
rtcpbuffer[pos++]=(uint8_t)(2);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// Add the remote SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
return 0;
}
@ -979,7 +978,7 @@ int32_t RTCPSender::BuildFIR(uint8_t* rtcpbuffer,
rtcpbuffer[pos++] = (uint8_t)(4);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// RFC 5104 4.3.1.2. Semantics
@ -990,7 +989,7 @@ int32_t RTCPSender::BuildFIR(uint8_t* rtcpbuffer,
rtcpbuffer[pos++] = (uint8_t)0;
// Additional Feedback Control Information (FCI)
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
rtcpbuffer[pos++] = (uint8_t)(_sequenceNumberFIR);
@ -1025,18 +1024,18 @@ RTCPSender::BuildSLI(uint8_t* rtcpbuffer, int& pos, const uint8_t pictureID)
rtcpbuffer[pos++]=(uint8_t)(3);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// Add the remote SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
// Add first, number & picture ID 6 bits
// first = 0, 13 - bits
// number = 0x1fff, 13 - bits only ones for now
uint32_t sliField = (0x1fff << 6)+ (0x3f & pictureID);
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, sliField);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, sliField);
pos += 4;
return 0;
}
@ -1090,11 +1089,11 @@ RTCPSender::BuildRPSI(uint8_t* rtcpbuffer,
rtcpbuffer[pos++]=size;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// Add the remote SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
// calc padding length
@ -1147,11 +1146,11 @@ RTCPSender::BuildREMB(uint8_t* rtcpbuffer, int& pos)
rtcpbuffer[pos++]=_lengthRembSSRC + 4;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// Remote SSRC must be 0
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, 0);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, 0);
pos += 4;
rtcpbuffer[pos++]='R';
@ -1177,8 +1176,8 @@ RTCPSender::BuildREMB(uint8_t* rtcpbuffer, int& pos)
rtcpbuffer[pos++]=(uint8_t)(brMantissa);
for (int i = 0; i < _lengthRembSSRC; i++)
{
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _rembSSRC[i]);
{
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _rembSSRC[i]);
pos += 4;
}
return 0;
@ -1264,7 +1263,7 @@ int32_t RTCPSender::BuildTMMBR(ModuleRtpRtcpImpl* rtp_rtcp_module,
rtcpbuffer[pos++]=(uint8_t)(4);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// RFC 5104 4.2.1.2. Semantics
@ -1276,7 +1275,7 @@ int32_t RTCPSender::BuildTMMBR(ModuleRtpRtcpImpl* rtp_rtcp_module,
rtcpbuffer[pos++]=(uint8_t)0;
// Additional Feedback Control Information (FCI)
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
uint32_t bitRate = _tmmbr_Send*1000;
@ -1324,7 +1323,7 @@ RTCPSender::BuildTMMBN(uint8_t* rtcpbuffer, int& pos)
pos++;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// RFC 5104 4.2.2.2. Semantics
@ -1342,7 +1341,7 @@ RTCPSender::BuildTMMBN(uint8_t* rtcpbuffer, int& pos)
if (boundingSet->Tmmbr(n) > 0)
{
uint32_t tmmbrSSRC = boundingSet->Ssrc(n);
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, tmmbrSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, tmmbrSSRC);
pos += 4;
uint32_t bitRate = boundingSet->Tmmbr(n) * 1000;
@ -1395,11 +1394,11 @@ RTCPSender::BuildAPP(uint8_t* rtcpbuffer, int& pos)
rtcpbuffer[pos++]=(uint8_t)(length);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// Add our application name
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _appName);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _appName);
pos += 4;
// Add the data
@ -1433,11 +1432,11 @@ RTCPSender::BuildNACK(uint8_t* rtcpbuffer,
rtcpbuffer[pos++]=(uint8_t)(3); //setting it to one kNACK signal as default
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// Add the remote SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
NACKStringBuilder stringBuilder;
@ -1464,9 +1463,9 @@ RTCPSender::BuildNACK(uint8_t* rtcpbuffer,
}
// Write the sequence number and the bitmask to the packet.
assert(pos + 4 < IP_PACKET_SIZE);
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer + pos, nack);
RtpUtility::AssignUWord16ToBuffer(rtcpbuffer + pos, nack);
pos += 2;
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer + pos, bitmask);
RtpUtility::AssignUWord16ToBuffer(rtcpbuffer + pos, bitmask);
pos += 2;
numOfNackFields++;
}
@ -1497,13 +1496,13 @@ RTCPSender::BuildBYE(uint8_t* rtcpbuffer, int& pos)
rtcpbuffer[pos++]=(uint8_t)(1 + _CSRCs);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// add CSRCs
for(int i = 0; i < _CSRCs; i++)
{
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _CSRC[i]);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _CSRC[i]);
pos += 4;
}
} else
@ -1517,7 +1516,7 @@ RTCPSender::BuildBYE(uint8_t* rtcpbuffer, int& pos)
rtcpbuffer[pos++]=(uint8_t)1;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
}
return 0;
@ -1546,7 +1545,7 @@ int32_t RTCPSender::BuildReceiverReferenceTime(uint8_t* buffer,
buffer[pos++] = 4; // XR packet length.
// Add our own SSRC.
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(buffer + pos, _SSRC);
pos += 4;
// 0 1 2 3
@ -1566,9 +1565,9 @@ int32_t RTCPSender::BuildReceiverReferenceTime(uint8_t* buffer,
buffer[pos++] = 2; // Block length.
// NTP timestamp.
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + pos, ntp_sec);
RtpUtility::AssignUWord32ToBuffer(buffer + pos, ntp_sec);
pos += 4;
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + pos, ntp_frac);
RtpUtility::AssignUWord32ToBuffer(buffer + pos, ntp_frac);
pos += 4;
return 0;
@ -1589,7 +1588,7 @@ int32_t RTCPSender::BuildDlrr(uint8_t* buffer,
buffer[pos++] = 5; // XR packet length.
// Add our own SSRC.
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(buffer + pos, _SSRC);
pos += 4;
// 0 1 2 3
@ -1614,11 +1613,11 @@ int32_t RTCPSender::BuildDlrr(uint8_t* buffer,
buffer[pos++] = 3; // Block length.
// NTP timestamp.
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + pos, info.sourceSSRC);
RtpUtility::AssignUWord32ToBuffer(buffer + pos, info.sourceSSRC);
pos += 4;
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + pos, info.lastRR);
RtpUtility::AssignUWord32ToBuffer(buffer + pos, info.lastRR);
pos += 4;
ModuleRTPUtility::AssignUWord32ToBuffer(buffer + pos, info.delaySinceLastRR);
RtpUtility::AssignUWord32ToBuffer(buffer + pos, info.delaySinceLastRR);
pos += 4;
return 0;
@ -1644,7 +1643,7 @@ RTCPSender::BuildVoIPMetric(uint8_t* rtcpbuffer, int& pos)
pos++;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
pos += 4;
// Add a VoIP metrics block
@ -1654,7 +1653,7 @@ RTCPSender::BuildVoIPMetric(uint8_t* rtcpbuffer, int& pos)
rtcpbuffer[pos++]=8;
// Add the remote SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
rtcpbuffer[pos++] = _xrVoIPMetric.lossRate;
@ -2210,33 +2209,33 @@ int32_t RTCPSender::WriteReportBlocksToBuffer(
RTCPReportBlock* reportBlock = it->second;
if (reportBlock) {
// Remote SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+position, remoteSSRC);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + position, remoteSSRC);
position += 4;
// fraction lost
rtcpbuffer[position++] = reportBlock->fractionLost;
// cumulative loss
ModuleRTPUtility::AssignUWord24ToBuffer(rtcpbuffer+position,
reportBlock->cumulativeLost);
RtpUtility::AssignUWord24ToBuffer(rtcpbuffer + position,
reportBlock->cumulativeLost);
position += 3;
// extended highest seq_no, contain the highest sequence number received
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+position,
reportBlock->extendedHighSeqNum);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + position,
reportBlock->extendedHighSeqNum);
position += 4;
// Jitter
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+position,
reportBlock->jitter);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + position,
reportBlock->jitter);
position += 4;
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+position,
reportBlock->lastSR);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + position,
reportBlock->lastSR);
position += 4;
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+position,
reportBlock->delaySinceLastSR);
RtpUtility::AssignUWord32ToBuffer(rtcpbuffer + position,
reportBlock->delaySinceLastSR);
position += 4;
}
}

13
webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc
View File

@ -866,7 +866,7 @@ void RtpFecTest::ReceivedPackets(const PacketList& packet_list, int* loss_mask,
// For media packets, the sequence number and marker bit is
// obtained from RTP header. These were set in ConstructMediaPackets().
received_packet->seq_num =
webrtc::ModuleRTPUtility::BufferToUWord16(&packet->data[2]);
webrtc::RtpUtility::BufferToUWord16(&packet->data[2]);
} else {
// The sequence number, marker bit, and ssrc number are defined in the
// RTP header of the FEC packet, which is not constructed in this test.
@ -921,12 +921,11 @@ int RtpFecTest::ConstructMediaPacketsSeqNum(int num_media_packets,
// Only push one (fake) frame to the FEC.
media_packet->data[1] &= 0x7f;
webrtc::ModuleRTPUtility::AssignUWord16ToBuffer(&media_packet->data[2],
sequence_number);
webrtc::ModuleRTPUtility::AssignUWord32ToBuffer(&media_packet->data[4],
time_stamp);
webrtc::ModuleRTPUtility::AssignUWord32ToBuffer(&media_packet->data[8],
ssrc_);
webrtc::RtpUtility::AssignUWord16ToBuffer(&media_packet->data[2],
sequence_number);
webrtc::RtpUtility::AssignUWord32ToBuffer(&media_packet->data[4],
time_stamp);
webrtc::RtpUtility::AssignUWord32ToBuffer(&media_packet->data[8], ssrc_);
// Generate random values for payload.
for (int j = 12; j < media_packet->length; ++j) {

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

@ -21,7 +21,8 @@ class RtpHeaderParserImpl : public RtpHeaderParser {
RtpHeaderParserImpl();
virtual ~RtpHeaderParserImpl() {}
virtual bool Parse(const uint8_t* packet, int length,
virtual bool Parse(const uint8_t* packet,
size_t length,
RTPHeader* header) const OVERRIDE;
virtual bool RegisterRtpHeaderExtension(RTPExtensionType type,
@ -31,7 +32,7 @@ class RtpHeaderParserImpl : public RtpHeaderParser {
private:
scoped_ptr<CriticalSectionWrapper> critical_section_;
RtpHeaderExtensionMap rtp_header_extension_map_;
RtpHeaderExtensionMap rtp_header_extension_map_ GUARDED_BY(critical_section_);
};
RtpHeaderParser* RtpHeaderParser::Create() {
@ -41,14 +42,15 @@ RtpHeaderParser* RtpHeaderParser::Create() {
RtpHeaderParserImpl::RtpHeaderParserImpl()
: critical_section_(CriticalSectionWrapper::CreateCriticalSection()) {}
bool RtpHeaderParser::IsRtcp(const uint8_t* packet, int length) {
ModuleRTPUtility::RTPHeaderParser rtp_parser(packet, length);
bool RtpHeaderParser::IsRtcp(const uint8_t* packet, size_t length) {
RtpUtility::RtpHeaderParser rtp_parser(packet, length);
return rtp_parser.RTCP();
}
bool RtpHeaderParserImpl::Parse(const uint8_t* packet, int length,
RTPHeader* header) const {
ModuleRTPUtility::RTPHeaderParser rtp_parser(packet, length);
bool RtpHeaderParserImpl::Parse(const uint8_t* packet,
size_t length,
RTPHeader* header) const {
RtpUtility::RtpHeaderParser rtp_parser(packet, length);
memset(header, 0, sizeof(*header));
RtpHeaderExtensionMap map;

112
webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
View File

@ -29,7 +29,7 @@ RTPPayloadRegistry::RTPPayloadRegistry(
RTPPayloadRegistry::~RTPPayloadRegistry() {
while (!payload_type_map_.empty()) {
ModuleRTPUtility::PayloadTypeMap::iterator it = payload_type_map_.begin();
RtpUtility::PayloadTypeMap::iterator it = payload_type_map_.begin();
delete it->second;
payload_type_map_.erase(it);
}
@ -69,12 +69,12 @@ int32_t RTPPayloadRegistry::RegisterReceivePayload(
CriticalSectionScoped cs(crit_sect_.get());
ModuleRTPUtility::PayloadTypeMap::iterator it =
payload_type_map_.find(payload_type);
RtpUtility::PayloadTypeMap::iterator it =
payload_type_map_.find(payload_type);
if (it != payload_type_map_.end()) {
// We already use this payload type.
ModuleRTPUtility::Payload* payload = it->second;
RtpUtility::Payload* payload = it->second;
assert(payload);
@ -83,7 +83,7 @@ int32_t RTPPayloadRegistry::RegisterReceivePayload(
// Check if it's the same as we already have.
// If same, ignore sending an error.
if (payload_name_length == name_length &&
ModuleRTPUtility::StringCompare(
RtpUtility::StringCompare(
payload->name, payload_name, payload_name_length)) {
if (rtp_payload_strategy_->PayloadIsCompatible(*payload, frequency,
channels, rate)) {
@ -100,18 +100,18 @@ int32_t RTPPayloadRegistry::RegisterReceivePayload(
payload_name, payload_name_length, frequency, channels, rate);
}
ModuleRTPUtility::Payload* payload = NULL;
RtpUtility::Payload* payload = NULL;
// Save the RED payload type. Used in both audio and video.
if (ModuleRTPUtility::StringCompare(payload_name, "red", 3)) {
if (RtpUtility::StringCompare(payload_name, "red", 3)) {
red_payload_type_ = payload_type;
payload = new ModuleRTPUtility::Payload;
payload = new RtpUtility::Payload;
memset(payload, 0, sizeof(*payload));
payload->audio = false;
strncpy(payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1);
} else if (ModuleRTPUtility::StringCompare(payload_name, "ulpfec", 3)) {
} else if (RtpUtility::StringCompare(payload_name, "ulpfec", 3)) {
ulpfec_payload_type_ = payload_type;
payload = new ModuleRTPUtility::Payload;
payload = new RtpUtility::Payload;
memset(payload, 0, sizeof(*payload));
payload->audio = false;
strncpy(payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1);
@ -132,7 +132,7 @@ int32_t RTPPayloadRegistry::RegisterReceivePayload(
int32_t RTPPayloadRegistry::DeRegisterReceivePayload(
const int8_t payload_type) {
CriticalSectionScoped cs(crit_sect_.get());
ModuleRTPUtility::PayloadTypeMap::iterator it =
RtpUtility::PayloadTypeMap::iterator it =
payload_type_map_.find(payload_type);
assert(it != payload_type_map_.end());
delete it->second;
@ -149,15 +149,14 @@ void RTPPayloadRegistry::DeregisterAudioCodecOrRedTypeRegardlessOfPayloadType(
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) {
ModuleRTPUtility::PayloadTypeMap::iterator iterator =
payload_type_map_.begin();
RtpUtility::PayloadTypeMap::iterator iterator = payload_type_map_.begin();
for (; iterator != payload_type_map_.end(); ++iterator) {
ModuleRTPUtility::Payload* payload = iterator->second;
RtpUtility::Payload* payload = iterator->second;
size_t name_length = strlen(payload->name);
if (payload_name_length == name_length
&& ModuleRTPUtility::StringCompare(payload->name, payload_name,
payload_name_length)) {
if (payload_name_length == name_length &&
RtpUtility::StringCompare(
payload->name, payload_name, payload_name_length)) {
// We found the payload name in the list.
// If audio, check frequency and rate.
if (payload->audio) {
@ -168,7 +167,7 @@ void RTPPayloadRegistry::DeregisterAudioCodecOrRedTypeRegardlessOfPayloadType(
payload_type_map_.erase(iterator);
break;
}
} else if (ModuleRTPUtility::StringCompare(payload_name, "red", 3)) {
} else if (RtpUtility::StringCompare(payload_name, "red", 3)) {
delete payload;
payload_type_map_.erase(iterator);
break;
@ -188,16 +187,15 @@ int32_t RTPPayloadRegistry::ReceivePayloadType(
CriticalSectionScoped cs(crit_sect_.get());
ModuleRTPUtility::PayloadTypeMap::const_iterator it =
payload_type_map_.begin();
RtpUtility::PayloadTypeMap::const_iterator it = payload_type_map_.begin();
for (; it != payload_type_map_.end(); ++it) {
ModuleRTPUtility::Payload* payload = it->second;
RtpUtility::Payload* payload = it->second;
assert(payload);
size_t name_length = strlen(payload->name);
if (payload_name_length == name_length &&
ModuleRTPUtility::StringCompare(
RtpUtility::StringCompare(
payload->name, payload_name, payload_name_length)) {
// Name matches.
if (payload->audio) {
@ -261,9 +259,9 @@ bool RTPPayloadRegistry::RestoreOriginalPacket(uint8_t** restored_packet,
*packet_length -= kRtxHeaderSize;
// Replace the SSRC and the sequence number with the originals.
ModuleRTPUtility::AssignUWord16ToBuffer(*restored_packet + 2,
original_sequence_number);
ModuleRTPUtility::AssignUWord32ToBuffer(*restored_packet + 8, original_ssrc);
RtpUtility::AssignUWord16ToBuffer(*restored_packet + 2,
original_sequence_number);
RtpUtility::AssignUWord32ToBuffer(*restored_packet + 8, original_ssrc);
CriticalSectionScoped cs(crit_sect_.get());
@ -307,8 +305,8 @@ bool RTPPayloadRegistry::IsEncapsulated(const RTPHeader& header) const {
bool RTPPayloadRegistry::GetPayloadSpecifics(uint8_t payload_type,
PayloadUnion* payload) const {
CriticalSectionScoped cs(crit_sect_.get());
ModuleRTPUtility::PayloadTypeMap::const_iterator it =
payload_type_map_.find(payload_type);
RtpUtility::PayloadTypeMap::const_iterator it =
payload_type_map_.find(payload_type);
// Check that this is a registered payload type.
if (it == payload_type_map_.end()) {
@ -320,7 +318,7 @@ bool RTPPayloadRegistry::GetPayloadSpecifics(uint8_t payload_type,
int RTPPayloadRegistry::GetPayloadTypeFrequency(
uint8_t payload_type) const {
ModuleRTPUtility::Payload* payload;
RtpUtility::Payload* payload;
if (!PayloadTypeToPayload(payload_type, payload)) {
return -1;
}
@ -329,12 +327,12 @@ int RTPPayloadRegistry::GetPayloadTypeFrequency(
}
bool RTPPayloadRegistry::PayloadTypeToPayload(
const uint8_t payload_type,
ModuleRTPUtility::Payload*& payload) const {
const uint8_t payload_type,
RtpUtility::Payload*& payload) const {
CriticalSectionScoped cs(crit_sect_.get());
ModuleRTPUtility::PayloadTypeMap::const_iterator it =
payload_type_map_.find(payload_type);
RtpUtility::PayloadTypeMap::const_iterator it =
payload_type_map_.find(payload_type);
// Check that this is a registered payload type.
if (it == payload_type_map_.end()) {
@ -365,11 +363,10 @@ class RTPPayloadAudioStrategy : public RTPPayloadStrategy {
public:
virtual bool CodecsMustBeUnique() const OVERRIDE { return true; }
virtual bool PayloadIsCompatible(
const ModuleRTPUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const OVERRIDE {
virtual bool PayloadIsCompatible(const RtpUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const OVERRIDE {
return
payload.audio &&
payload.typeSpecific.Audio.frequency == frequency &&
@ -378,19 +375,18 @@ class RTPPayloadAudioStrategy : public RTPPayloadStrategy {
payload.typeSpecific.Audio.rate == 0 || rate == 0);
}
virtual void UpdatePayloadRate(
ModuleRTPUtility::Payload* payload,
const uint32_t rate) const OVERRIDE {
virtual void UpdatePayloadRate(RtpUtility::Payload* payload,
const uint32_t rate) const OVERRIDE {
payload->typeSpecific.Audio.rate = rate;
}
virtual ModuleRTPUtility::Payload* CreatePayloadType(
virtual RtpUtility::Payload* CreatePayloadType(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const OVERRIDE {
ModuleRTPUtility::Payload* payload = new ModuleRTPUtility::Payload;
RtpUtility::Payload* payload = new RtpUtility::Payload;
payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
strncpy(payload->name, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
assert(frequency >= 1000);
@ -401,8 +397,7 @@ class RTPPayloadAudioStrategy : public RTPPayloadStrategy {
return payload;
}
int GetPayloadTypeFrequency(
const ModuleRTPUtility::Payload& payload) const {
int GetPayloadTypeFrequency(const RtpUtility::Payload& payload) const {
return payload.typeSpecific.Audio.frequency;
}
};
@ -411,39 +406,37 @@ class RTPPayloadVideoStrategy : public RTPPayloadStrategy {
public:
virtual bool CodecsMustBeUnique() const OVERRIDE { return false; }
virtual bool PayloadIsCompatible(
const ModuleRTPUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const OVERRIDE {
virtual bool PayloadIsCompatible(const RtpUtility::Payload& payload,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const OVERRIDE {
return !payload.audio;
}
virtual void UpdatePayloadRate(
ModuleRTPUtility::Payload* payload,
const uint32_t rate) const OVERRIDE {
virtual void UpdatePayloadRate(RtpUtility::Payload* payload,
const uint32_t rate) const OVERRIDE {
payload->typeSpecific.Video.maxRate = rate;
}
virtual ModuleRTPUtility::Payload* CreatePayloadType(
virtual RtpUtility::Payload* CreatePayloadType(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate) const OVERRIDE {
RtpVideoCodecTypes videoType = kRtpVideoGeneric;
if (ModuleRTPUtility::StringCompare(payloadName, "VP8", 3)) {
if (RtpUtility::StringCompare(payloadName, "VP8", 3)) {
videoType = kRtpVideoVp8;
} else if (ModuleRTPUtility::StringCompare(payloadName, "H264", 4)) {
} else if (RtpUtility::StringCompare(payloadName, "H264", 4)) {
videoType = kRtpVideoH264;
} else if (ModuleRTPUtility::StringCompare(payloadName, "I420", 4)) {
} else if (RtpUtility::StringCompare(payloadName, "I420", 4)) {
videoType = kRtpVideoGeneric;
} else if (ModuleRTPUtility::StringCompare(payloadName, "ULPFEC", 6)) {
} else if (RtpUtility::StringCompare(payloadName, "ULPFEC", 6)) {
videoType = kRtpVideoNone;
} else {
videoType = kRtpVideoGeneric;
}
ModuleRTPUtility::Payload* payload = new ModuleRTPUtility::Payload;
RtpUtility::Payload* payload = new RtpUtility::Payload;
payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
strncpy(payload->name, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
@ -453,8 +446,7 @@ class RTPPayloadVideoStrategy : public RTPPayloadStrategy {
return payload;
}
int GetPayloadTypeFrequency(
const ModuleRTPUtility::Payload& payload) const {
int GetPayloadTypeFrequency(const RtpUtility::Payload& payload) const {
return kVideoPayloadTypeFrequency;
}
};

31
webrtc/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
View File

@ -36,18 +36,19 @@ class RtpPayloadRegistryTest : public ::testing::Test {
}
protected:
ModuleRTPUtility::Payload* ExpectReturnOfTypicalAudioPayload(
uint8_t payload_type, uint32_t rate) {
RtpUtility::Payload* ExpectReturnOfTypicalAudioPayload(uint8_t payload_type,
uint32_t rate) {
bool audio = true;
ModuleRTPUtility::Payload returned_payload = { "name", audio, {
// Initialize the audio struct in this case.
{ kTypicalFrequency, kTypicalChannels, rate }
}};
RtpUtility::Payload returned_payload = {
"name",
audio,
{// Initialize the audio struct in this case.
{kTypicalFrequency, kTypicalChannels, rate}}};
// Note: we return a new payload since the payload registry takes ownership
// of the created object.
ModuleRTPUtility::Payload* returned_payload_on_heap =
new ModuleRTPUtility::Payload(returned_payload);
RtpUtility::Payload* returned_payload_on_heap =
new RtpUtility::Payload(returned_payload);
EXPECT_CALL(*mock_payload_strategy_,
CreatePayloadType(kTypicalPayloadName, payload_type,
kTypicalFrequency,
@ -62,7 +63,7 @@ class RtpPayloadRegistryTest : public ::testing::Test {
TEST_F(RtpPayloadRegistryTest, RegistersAndRemembersPayloadsUntilDeregistered) {
uint8_t payload_type = 97;
ModuleRTPUtility::Payload* returned_payload_on_heap =
RtpUtility::Payload* returned_payload_on_heap =
ExpectReturnOfTypicalAudioPayload(payload_type, kTypicalRate);
bool new_payload_created = false;
@ -72,7 +73,7 @@ TEST_F(RtpPayloadRegistryTest, RegistersAndRemembersPayloadsUntilDeregistered) {
EXPECT_TRUE(new_payload_created) << "A new payload WAS created.";
ModuleRTPUtility::Payload* retrieved_payload = NULL;
RtpUtility::Payload* retrieved_payload = NULL;
EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type,
retrieved_payload));
@ -99,7 +100,7 @@ TEST_F(RtpPayloadRegistryTest, DoesNotCreateNewPayloadTypeIfRed) {
ASSERT_EQ(red_type_of_the_day, rtp_payload_registry_->red_payload_type());
ModuleRTPUtility::Payload* retrieved_payload = NULL;
RtpUtility::Payload* retrieved_payload = NULL;
EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(red_type_of_the_day,
retrieved_payload));
EXPECT_FALSE(retrieved_payload->audio);
@ -111,7 +112,7 @@ TEST_F(RtpPayloadRegistryTest,
uint8_t payload_type = 97;
bool ignored = false;
ModuleRTPUtility::Payload* first_payload_on_heap =
RtpUtility::Payload* first_payload_on_heap =
ExpectReturnOfTypicalAudioPayload(payload_type, kTypicalRate);
EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload(
kTypicalPayloadName, payload_type, kTypicalFrequency, kTypicalChannels,
@ -121,7 +122,7 @@ TEST_F(RtpPayloadRegistryTest,
kTypicalPayloadName, payload_type, kTypicalFrequency, kTypicalChannels,
kTypicalRate, &ignored)) << "Adding same codec twice = bad.";
ModuleRTPUtility::Payload* second_payload_on_heap =
RtpUtility::Payload* second_payload_on_heap =
ExpectReturnOfTypicalAudioPayload(payload_type - 1, kTypicalRate);
EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload(
kTypicalPayloadName, payload_type - 1, kTypicalFrequency,
@ -129,7 +130,7 @@ TEST_F(RtpPayloadRegistryTest,
"With a different payload type is fine though.";
// Ensure both payloads are preserved.
ModuleRTPUtility::Payload* retrieved_payload = NULL;
RtpUtility::Payload* retrieved_payload = NULL;
EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type,
retrieved_payload));
EXPECT_EQ(first_payload_on_heap, retrieved_payload);
@ -168,7 +169,7 @@ TEST_F(RtpPayloadRegistryTest,
kTypicalPayloadName, payload_type - 1, kTypicalFrequency,
kTypicalChannels, kTypicalRate, &ignored));
ModuleRTPUtility::Payload* retrieved_payload = NULL;
RtpUtility::Payload* retrieved_payload = NULL;
EXPECT_FALSE(rtp_payload_registry_->PayloadTypeToPayload(
payload_type, retrieved_payload)) << "The first payload should be "
"deregistered because the only thing that differs is payload type.";

4
webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc
View File

@ -159,10 +159,10 @@ int32_t RTPReceiverAudio::OnNewPayloadTypeCreated(
uint32_t frequency) {
CriticalSectionScoped lock(crit_sect_.get());
if (ModuleRTPUtility::StringCompare(payload_name, "telephone-event", 15)) {
if (RtpUtility::StringCompare(payload_name, "telephone-event", 15)) {
telephone_event_payload_type_ = payload_type;
}
if (ModuleRTPUtility::StringCompare(payload_name, "cn", 2)) {
if (RtpUtility::StringCompare(payload_name, "cn", 2)) {
// we can have three CNG on 8000Hz, 16000Hz and 32000Hz
if (frequency == 8000) {
cng_nb_payload_type_ = payload_type;

2
webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
View File

@ -83,7 +83,7 @@ class RTPReceiverAudio : public RTPReceiverStrategy,
// We do not allow codecs to have multiple payload types for audio, so we
// need to override the default behavior (which is to do nothing).
void PossiblyRemoveExistingPayloadType(
ModuleRTPUtility::PayloadTypeMap* payload_type_map,
RtpUtility::PayloadTypeMap* payload_type_map,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
size_t payload_name_length,
uint32_t frequency,

8
webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.cc
View File

@ -22,10 +22,10 @@
namespace webrtc {
using ModuleRTPUtility::GetCurrentRTP;
using ModuleRTPUtility::Payload;
using ModuleRTPUtility::RTPPayloadParser;
using ModuleRTPUtility::StringCompare;
using RtpUtility::GetCurrentRTP;
using RtpUtility::Payload;
using RtpUtility::RTPPayloadParser;
using RtpUtility::StringCompare;
RtpReceiver* RtpReceiver::CreateVideoReceiver(
int id, Clock* clock,

25
webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc
View File

@ -129,12 +129,11 @@ int32_t RTPReceiverVideo::BuildRTPheader(
if (rtp_header->header.markerBit) {
data_buffer[1] |= kRtpMarkerBitMask; // MarkerBit is 1
}
ModuleRTPUtility::AssignUWord16ToBuffer(data_buffer + 2,
rtp_header->header.sequenceNumber);
ModuleRTPUtility::AssignUWord32ToBuffer(data_buffer + 4,
rtp_header->header.timestamp);
ModuleRTPUtility::AssignUWord32ToBuffer(data_buffer + 8,
rtp_header->header.ssrc);
RtpUtility::AssignUWord16ToBuffer(data_buffer + 2,
rtp_header->header.sequenceNumber);
RtpUtility::AssignUWord32ToBuffer(data_buffer + 4,
rtp_header->header.timestamp);
RtpUtility::AssignUWord32ToBuffer(data_buffer + 8, rtp_header->header.ssrc);
int32_t rtp_header_length = 12;
@ -146,8 +145,7 @@ int32_t RTPReceiverVideo::BuildRTPheader(
}
uint8_t* ptr = &data_buffer[rtp_header_length];
for (uint32_t i = 0; i < rtp_header->header.numCSRCs; ++i) {
ModuleRTPUtility::AssignUWord32ToBuffer(ptr,
rtp_header->header.arrOfCSRCs[i]);
RtpUtility::AssignUWord32ToBuffer(ptr, rtp_header->header.arrOfCSRCs[i]);
ptr += 4;
}
data_buffer[0] = (data_buffer[0] & 0xf0) | rtp_header->header.numCSRCs;
@ -160,8 +158,8 @@ int32_t RTPReceiverVideo::BuildRTPheader(
int32_t RTPReceiverVideo::ReceiveVp8Codec(WebRtcRTPHeader* rtp_header,
const uint8_t* payload_data,
uint16_t payload_data_length) {
ModuleRTPUtility::RTPPayload parsed_packet;
ModuleRTPUtility::RTPPayloadParser rtp_payload_parser(
RtpUtility::RTPPayload parsed_packet;
RtpUtility::RTPPayloadParser rtp_payload_parser(
kRtpVideoVp8, payload_data, payload_data_length);
if (!rtp_payload_parser.Parse(parsed_packet))
@ -170,11 +168,12 @@ int32_t RTPReceiverVideo::ReceiveVp8Codec(WebRtcRTPHeader* rtp_header,
if (parsed_packet.info.VP8.dataLength == 0)
return 0;
rtp_header->frameType = (parsed_packet.frameType == ModuleRTPUtility::kIFrame)
? kVideoFrameKey : kVideoFrameDelta;
rtp_header->frameType = (parsed_packet.frameType == RtpUtility::kIFrame)
? kVideoFrameKey
: kVideoFrameDelta;
RTPVideoHeaderVP8* to_header = &rtp_header->type.Video.codecHeader.VP8;
ModuleRTPUtility::RTPPayloadVP8* from_header = &parsed_packet.info.VP8;
RtpUtility::RTPPayloadVP8* from_header = &parsed_packet.info.VP8;
rtp_header->type.Video.isFirstPacket =
from_header->beginningOfPartition && (from_header->partitionID == 0);

5
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -232,8 +232,9 @@ class RtpSendingTestTransport : public Transport {
virtual int SendPacket(int channel, const void* data, int length) {
RTPHeader header;
scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
EXPECT_TRUE(
parser->Parse(static_cast<const uint8_t*>(data), length, &header));
EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data),
static_cast<size_t>(length),
&header));
bytes_received_[header.ssrc] += length;
++packets_received_[header.ssrc];
return length;

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

@ -119,7 +119,7 @@ RTPSender::~RTPSender() {
SSRCDatabase::ReturnSSRCDatabase();
delete send_critsect_;
while (!payload_type_map_.empty()) {
std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
std::map<int8_t, RtpUtility::Payload*>::iterator it =
payload_type_map_.begin();
delete it->second;
payload_type_map_.erase(it);
@ -224,17 +224,17 @@ int32_t RTPSender::RegisterPayload(
assert(payload_name);
CriticalSectionScoped cs(send_critsect_);
std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
std::map<int8_t, RtpUtility::Payload*>::iterator it =
payload_type_map_.find(payload_number);
if (payload_type_map_.end() != it) {
// We already use this payload type.
ModuleRTPUtility::Payload *payload = it->second;
RtpUtility::Payload* payload = it->second;
assert(payload);
// Check if it's the same as we already have.
if (ModuleRTPUtility::StringCompare(payload->name, payload_name,
RTP_PAYLOAD_NAME_SIZE - 1)) {
if (RtpUtility::StringCompare(
payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1)) {
if (audio_configured_ && payload->audio &&
payload->typeSpecific.Audio.frequency == frequency &&
(payload->typeSpecific.Audio.rate == rate ||
@ -250,7 +250,7 @@ int32_t RTPSender::RegisterPayload(
return -1;
}
int32_t ret_val = -1;
ModuleRTPUtility::Payload *payload = NULL;
RtpUtility::Payload* payload = NULL;
if (audio_configured_) {
ret_val = audio_->RegisterAudioPayload(payload_name, payload_number,
frequency, channels, rate, payload);
@ -268,13 +268,13 @@ int32_t RTPSender::DeRegisterSendPayload(
const int8_t payload_type) {
CriticalSectionScoped lock(send_critsect_);
std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
std::map<int8_t, RtpUtility::Payload*>::iterator it =
payload_type_map_.find(payload_type);
if (payload_type_map_.end() == it) {
return -1;
}
ModuleRTPUtility::Payload *payload = it->second;
RtpUtility::Payload* payload = it->second;
delete payload;
payload_type_map_.erase(it);
return 0;
@ -376,14 +376,14 @@ int32_t RTPSender::CheckPayloadType(const int8_t payload_type,
}
return 0;
}
std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
std::map<int8_t, RtpUtility::Payload*>::iterator it =
payload_type_map_.find(payload_type);
if (it == payload_type_map_.end()) {
LOG(LS_WARNING) << "Payload type " << payload_type << " not registered.";
return -1;
}
payload_type_ = payload_type;
ModuleRTPUtility::Payload *payload = it->second;
RtpUtility::Payload* payload = it->second;
assert(payload);
if (!payload->audio && !audio_configured_) {
video_->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType);
@ -465,7 +465,7 @@ int RTPSender::SendRedundantPayloads(int payload_type, int bytes_to_send) {
}
if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false))
return -1;
ModuleRTPUtility::RTPHeaderParser rtp_parser(buffer, length);
RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
RTPHeader rtp_header;
rtp_parser.Parse(rtp_header);
bytes_left -= length - rtp_header.headerLength;
@ -614,7 +614,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, uint32_t min_resend_time) {
}
if (paced_sender_) {
ModuleRTPUtility::RTPHeaderParser rtp_parser(data_buffer, length);
RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length);
RTPHeader header;
if (!rtp_parser.Parse(header)) {
assert(false);
@ -813,7 +813,7 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
bool is_retransmit) {
uint8_t *buffer_to_send_ptr = buffer;
ModuleRTPUtility::RTPHeaderParser rtp_parser(buffer, length);
RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
RTPHeader rtp_header;
rtp_parser.Parse(rtp_header);
TRACE_EVENT_INSTANT2("webrtc_rtp", "PrepareAndSendPacket",
@ -925,13 +925,13 @@ int RTPSender::TimeToSendPadding(int bytes) {
return bytes_sent;
}
// TODO(pwestin): send in the RTPHeaderParser to avoid parsing it again.
// TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
int32_t RTPSender::SendToNetwork(
uint8_t *buffer, int payload_length, int rtp_header_length,
int64_t capture_time_ms, StorageType storage,
PacedSender::Priority priority) {
ModuleRTPUtility::RTPHeaderParser rtp_parser(
buffer, payload_length + rtp_header_length);
RtpUtility::RtpHeaderParser rtp_parser(buffer,
payload_length + rtp_header_length);
RTPHeader rtp_header;
rtp_parser.Parse(rtp_header);
@ -1046,9 +1046,9 @@ int RTPSender::CreateRTPHeader(
if (marker_bit) {
header[1] |= kRtpMarkerBitMask; // Marker bit is set.
}
ModuleRTPUtility::AssignUWord16ToBuffer(header + 2, sequence_number);
ModuleRTPUtility::AssignUWord32ToBuffer(header + 4, timestamp);
ModuleRTPUtility::AssignUWord32ToBuffer(header + 8, ssrc);
RtpUtility::AssignUWord16ToBuffer(header + 2, sequence_number);
RtpUtility::AssignUWord32ToBuffer(header + 4, timestamp);
RtpUtility::AssignUWord32ToBuffer(header + 8, ssrc);
int32_t rtp_header_length = 12;
// Add the CSRCs if any.
@ -1060,7 +1060,7 @@ int RTPSender::CreateRTPHeader(
}
uint8_t *ptr = &header[rtp_header_length];
for (int i = 0; i < num_csrcs; ++i) {
ModuleRTPUtility::AssignUWord32ToBuffer(ptr, csrcs[i]);
RtpUtility::AssignUWord32ToBuffer(ptr, csrcs[i]);
ptr += 4;
}
header[0] = (header[0] & 0xf0) | num_csrcs;
@ -1123,8 +1123,7 @@ uint16_t RTPSender::BuildRTPHeaderExtension(uint8_t* data_buffer) const {
const uint32_t kHeaderLength = kRtpOneByteHeaderLength;
// Add extension ID (0xBEDE).
ModuleRTPUtility::AssignUWord16ToBuffer(data_buffer,
kRtpOneByteHeaderExtensionId);
RtpUtility::AssignUWord16ToBuffer(data_buffer, kRtpOneByteHeaderExtensionId);
// Add extensions.
uint16_t total_block_length = 0;
@ -1157,8 +1156,8 @@ uint16_t RTPSender::BuildRTPHeaderExtension(uint8_t* data_buffer) const {
}
// Set header length (in number of Word32, header excluded).
assert(total_block_length % 4 == 0);
ModuleRTPUtility::AssignUWord16ToBuffer(data_buffer + kPosLength,
total_block_length / 4);
RtpUtility::AssignUWord16ToBuffer(data_buffer + kPosLength,
total_block_length / 4);
// Total added length.
return kHeaderLength + total_block_length;
}
@ -1192,8 +1191,8 @@ uint8_t RTPSender::BuildTransmissionTimeOffsetExtension(
size_t pos = 0;
const uint8_t len = 2;
data_buffer[pos++] = (id << 4) + len;
ModuleRTPUtility::AssignUWord24ToBuffer(data_buffer + pos,
transmission_time_offset_);
RtpUtility::AssignUWord24ToBuffer(data_buffer + pos,
transmission_time_offset_);
pos += 3;
assert(pos == kTransmissionTimeOffsetLength);
return kTransmissionTimeOffsetLength;
@ -1261,8 +1260,7 @@ uint8_t RTPSender::BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const {
size_t pos = 0;
const uint8_t len = 2;
data_buffer[pos++] = (id << 4) + len;
ModuleRTPUtility::AssignUWord24ToBuffer(data_buffer + pos,
absolute_send_time_);
RtpUtility::AssignUWord24ToBuffer(data_buffer + pos, absolute_send_time_);
pos += 3;
assert(pos == kAbsoluteSendTimeLength);
return kAbsoluteSendTimeLength;
@ -1310,8 +1308,8 @@ void RTPSender::UpdateTransmissionTimeOffset(
return;
}
// Update transmission offset field (converting to a 90 kHz timestamp).
ModuleRTPUtility::AssignUWord24ToBuffer(rtp_packet + block_pos + 1,
time_diff_ms * 90); // RTP timestamp.
RtpUtility::AssignUWord24ToBuffer(rtp_packet + block_pos + 1,
time_diff_ms * 90); // RTP timestamp.
}
bool RTPSender::UpdateAudioLevel(uint8_t *rtp_packet,
@ -1398,14 +1396,14 @@ void RTPSender::UpdateAbsoluteSendTime(
}
// Update absolute send time field (convert ms to 24-bit unsigned with 18 bit
// fractional part).
ModuleRTPUtility::AssignUWord24ToBuffer(rtp_packet + block_pos + 1,
((now_ms << 18) / 1000) & 0x00ffffff);
RtpUtility::AssignUWord24ToBuffer(rtp_packet + block_pos + 1,
((now_ms << 18) / 1000) & 0x00ffffff);
}
void RTPSender::SetSendingStatus(bool enabled) {
if (enabled) {
uint32_t frequency_hz = SendPayloadFrequency();
uint32_t RTPtime = ModuleRTPUtility::GetCurrentRTP(clock_, frequency_hz);
uint32_t RTPtime = RtpUtility::GetCurrentRTP(clock_, frequency_hz);
// Will be ignored if it's already configured via API.
SetStartTimestamp(RTPtime, false);
@ -1630,8 +1628,8 @@ void RTPSender::BuildRtxPacket(uint8_t* buffer, uint16_t* length,
CriticalSectionScoped cs(send_critsect_);
uint8_t* data_buffer_rtx = buffer_rtx;
// Add RTX header.
ModuleRTPUtility::RTPHeaderParser rtp_parser(
reinterpret_cast<const uint8_t *>(buffer), *length);
RtpUtility::RtpHeaderParser rtp_parser(
reinterpret_cast<const uint8_t*>(buffer), *length);
RTPHeader rtp_header;
rtp_parser.Parse(rtp_header);
@ -1648,15 +1646,15 @@ void RTPSender::BuildRtxPacket(uint8_t* buffer, uint16_t* length,
// Replace sequence number.
uint8_t *ptr = data_buffer_rtx + 2;
ModuleRTPUtility::AssignUWord16ToBuffer(ptr, sequence_number_rtx_++);
RtpUtility::AssignUWord16ToBuffer(ptr, sequence_number_rtx_++);
// Replace SSRC.
ptr += 6;
ModuleRTPUtility::AssignUWord32ToBuffer(ptr, ssrc_rtx_);
RtpUtility::AssignUWord32ToBuffer(ptr, ssrc_rtx_);
// Add OSN (original sequence number).
ptr = data_buffer_rtx + rtp_header.headerLength;
ModuleRTPUtility::AssignUWord16ToBuffer(ptr, rtp_header.sequenceNumber);
RtpUtility::AssignUWord16ToBuffer(ptr, rtp_header.sequenceNumber);
ptr += 2;
// Add original payload data.

2
webrtc/modules/rtp_rtcp/source/rtp_sender.h
View File

@ -359,7 +359,7 @@ class RTPSender : public RTPSenderInterface, public Bitrate::Observer {
uint16_t packet_over_head_;
int8_t payload_type_ GUARDED_BY(send_critsect_);
std::map<int8_t, ModuleRTPUtility::Payload *> payload_type_map_;
std::map<int8_t, RtpUtility::Payload*> payload_type_map_;
RtpHeaderExtensionMap rtp_header_extension_map_;
int32_t transmission_time_offset_;

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

@ -89,10 +89,10 @@ int32_t RTPSenderAudio::RegisterAudioPayload(
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate,
ModuleRTPUtility::Payload*& payload) {
RtpUtility::Payload*& payload) {
CriticalSectionScoped cs(_sendAudioCritsect);
if (ModuleRTPUtility::StringCompare(payloadName, "cn", 2)) {
if (RtpUtility::StringCompare(payloadName, "cn", 2)) {
// we can have multiple CNG payload types
if (frequency == 8000) {
_cngNBPayloadType = payloadType;
@ -110,14 +110,14 @@ int32_t RTPSenderAudio::RegisterAudioPayload(
return -1;
}
}
if (ModuleRTPUtility::StringCompare(payloadName, "telephone-event", 15)) {
if (RtpUtility::StringCompare(payloadName, "telephone-event", 15)) {
// Don't add it to the list
// we dont want to allow send with a DTMF payloadtype
_dtmfPayloadType = payloadType;
return 0;
// The default timestamp rate is 8000 Hz, but other rates may be defined.
}
payload = new ModuleRTPUtility::Payload;
payload = new RtpUtility::Payload;
payload->typeSpecific.Audio.frequency = frequency;
payload->typeSpecific.Audio.channels = channels;
payload->typeSpecific.Audio.rate = rate;
@ -388,8 +388,8 @@ int32_t RTPSenderAudio::SendAudio(
return -1;
}
uint32_t REDheader = (timestampOffset << 10) + blockLength;
ModuleRTPUtility::AssignUWord24ToBuffer(dataBuffer + rtpHeaderLength,
REDheader);
RtpUtility::AssignUWord24ToBuffer(dataBuffer + rtpHeaderLength,
REDheader);
rtpHeaderLength += 3;
dataBuffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
@ -436,7 +436,7 @@ int32_t RTPSenderAudio::SendAudio(
// Update audio level extension, if included.
{
uint16_t packetSize = payloadSize + rtpHeaderLength;
ModuleRTPUtility::RTPHeaderParser rtp_parser(dataBuffer, packetSize);
RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize);
RTPHeader rtp_header;
rtp_parser.Parse(rtp_header);
_rtpSender->UpdateAudioLevel(dataBuffer, packetSize, rtp_header,
@ -558,7 +558,7 @@ RTPSenderAudio::SendTelephoneEventPacket(const bool ended,
// First byte is Event number, equals key number
dtmfbuffer[12] = _dtmfKey;
dtmfbuffer[13] = E|R|volume;
ModuleRTPUtility::AssignUWord16ToBuffer(dtmfbuffer+14, duration);
RtpUtility::AssignUWord16ToBuffer(dtmfbuffer + 14, duration);
_sendAudioCritsect->Leave();
TRACE_EVENT_INSTANT2("webrtc_rtp",

13
webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h
View File

@ -26,13 +26,12 @@ public:
RTPSender* rtpSender);
virtual ~RTPSenderAudio();
int32_t RegisterAudioPayload(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate,
ModuleRTPUtility::Payload*& payload);
int32_t RegisterAudioPayload(const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t frequency,
const uint8_t channels,
const uint32_t rate,
RtpUtility::Payload*& payload);
int32_t SendAudio(const FrameType frameType,
const int8_t payloadType,

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

@ -204,7 +204,7 @@ TEST_F(RtpSenderTest, BuildRTPPacket) {
EXPECT_EQ(kRtpHeaderSize, length);
// Verify
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header;
const bool valid_rtp_header = rtp_parser.Parse(rtp_header, NULL);
@ -235,7 +235,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) {
length);
// Verify
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header;
RtpHeaderExtensionMap map;
@ -276,7 +276,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
length);
// Verify
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header;
RtpHeaderExtensionMap map;
@ -306,7 +306,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) {
length);
// Verify
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header;
RtpHeaderExtensionMap map;
@ -344,7 +344,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithAudioLevelExtension) {
length);
// Verify
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header;
// Updating audio level is done in RTPSenderAudio, so simulate it here.
@ -394,7 +394,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
length);
// Verify
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
webrtc::RTPHeader rtp_header;
// Updating audio level is done in RTPSenderAudio, so simulate it here.
@ -471,8 +471,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
EXPECT_EQ(1, transport_.packets_sent_);
EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
// Parse sent packet.
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
transport_.last_sent_packet_, rtp_length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
rtp_length);
webrtc::RTPHeader rtp_header;
RtpHeaderExtensionMap map;
map.Register(kRtpExtensionTransmissionTimeOffset,
@ -533,8 +533,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
// Parse sent packet.
webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
transport_.last_sent_packet_, rtp_length);
webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
rtp_length);
webrtc::RTPHeader rtp_header;
RtpHeaderExtensionMap map;
map.Register(kRtpExtensionTransmissionTimeOffset,
@ -744,8 +744,8 @@ TEST_F(RtpSenderTest, SendGenericVideo) {
4321, payload, sizeof(payload),
NULL));
ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header));
@ -770,8 +770,8 @@ TEST_F(RtpSenderTest, SendGenericVideo) {
1234, 4321, payload,
sizeof(payload), NULL));
ModuleRTPUtility::RTPHeaderParser rtp_parser2(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
ASSERT_TRUE(rtp_parser.Parse(rtp_header));
payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
@ -1018,8 +1018,8 @@ TEST_F(RtpSenderAudioTest, SendAudio) {
4321, payload, sizeof(payload),
NULL));
ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header));
@ -1047,8 +1047,8 @@ TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
4321, payload, sizeof(payload),
NULL));
ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
transport_.last_sent_packet_len_);
webrtc::RTPHeader rtp_header;
ASSERT_TRUE(rtp_parser.Parse(rtp_header));

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

@ -84,20 +84,20 @@ int32_t RTPSenderVideo::RegisterVideoPayload(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t maxBitRate,
ModuleRTPUtility::Payload*& payload) {
RtpUtility::Payload*& payload) {
CriticalSectionScoped cs(_sendVideoCritsect);
RtpVideoCodecTypes videoType = kRtpVideoGeneric;
if (ModuleRTPUtility::StringCompare(payloadName, "VP8",3)) {
if (RtpUtility::StringCompare(payloadName, "VP8", 3)) {
videoType = kRtpVideoVp8;
} else if (ModuleRTPUtility::StringCompare(payloadName, "H264", 4)) {
} else if (RtpUtility::StringCompare(payloadName, "H264", 4)) {
videoType = kRtpVideoH264;
} else if (ModuleRTPUtility::StringCompare(payloadName, "I420", 4)) {
} else if (RtpUtility::StringCompare(payloadName, "I420", 4)) {
videoType = kRtpVideoGeneric;
} else {
videoType = kRtpVideoGeneric;
}
payload = new ModuleRTPUtility::Payload;
payload = new RtpUtility::Payload;
payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
strncpy(payload->name, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
payload->typeSpecific.Video.videoCodecType = videoType;
@ -213,7 +213,7 @@ RTPSenderVideo::SendRTPIntraRequest()
data[2] = 0;
data[3] = 1; // length
ModuleRTPUtility::AssignUWord32ToBuffer(data+4, _rtpSender.SSRC());
RtpUtility::AssignUWord32ToBuffer(data + 4, _rtpSender.SSRC());
TRACE_EVENT_INSTANT1("webrtc_rtp",
"Video::IntraRequest",

9
webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -39,11 +39,10 @@ public:
uint16_t FECPacketOverhead() const;
int32_t RegisterVideoPayload(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t maxBitRate,
ModuleRTPUtility::Payload*& payload);
int32_t RegisterVideoPayload(const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int8_t payloadType,
const uint32_t maxBitRate,
RtpUtility::Payload*& payload);
int32_t SendVideo(const RtpVideoCodecTypes videoType,
const FrameType frameType,

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

@ -66,7 +66,7 @@ ReceiveStatistics* NullObjectReceiveStatistics() {
return &null_receive_statistics;
}
namespace ModuleRTPUtility {
namespace RtpUtility {
enum {
kRtcpExpectedVersion = 2,
@ -215,16 +215,16 @@ void RTPPayload::SetType(RtpVideoCodecTypes videoType) {
}
}
RTPHeaderParser::RTPHeaderParser(const uint8_t* rtpData,
const uint32_t rtpDataLength)
: _ptrRTPDataBegin(rtpData),
_ptrRTPDataEnd(rtpData ? (rtpData + rtpDataLength) : NULL) {
RtpHeaderParser::RtpHeaderParser(const uint8_t* rtpData,
const size_t rtpDataLength)
: _ptrRTPDataBegin(rtpData),
_ptrRTPDataEnd(rtpData ? (rtpData + rtpDataLength) : NULL) {
}
RTPHeaderParser::~RTPHeaderParser() {
RtpHeaderParser::~RtpHeaderParser() {
}
bool RTPHeaderParser::RTCP() const {
bool RtpHeaderParser::RTCP() const {
// 72 to 76 is reserved for RTP
// 77 to 79 is not reserver but they are not assigned we will block them
// for RTCP 200 SR == marker bit + 72
@ -299,7 +299,7 @@ bool RTPHeaderParser::RTCP() const {
return RTCP;
}
bool RTPHeaderParser::ParseRtcp(RTPHeader* header) const {
bool RtpHeaderParser::ParseRtcp(RTPHeader* header) const {
assert(header != NULL);
const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
@ -328,7 +328,7 @@ bool RTPHeaderParser::ParseRtcp(RTPHeader* header) const {
return true;
}
bool RTPHeaderParser::Parse(RTPHeader& header,
bool RtpHeaderParser::Parse(RTPHeader& header,
RtpHeaderExtensionMap* ptrExtensionMap) const {
const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
if (length < kRtpMinParseLength) {
@ -441,7 +441,7 @@ bool RTPHeaderParser::Parse(RTPHeader& header,
return true;
}
void RTPHeaderParser::ParseOneByteExtensionHeader(
void RtpHeaderParser::ParseOneByteExtensionHeader(
RTPHeader& header,
const RtpHeaderExtensionMap* ptrExtensionMap,
const uint8_t* ptrRTPDataExtensionEnd,
@ -552,10 +552,9 @@ void RTPHeaderParser::ParseOneByteExtensionHeader(
}
}
uint8_t RTPHeaderParser::ParsePaddingBytes(
const uint8_t* ptrRTPDataExtensionEnd,
const uint8_t* ptr) const {
uint8_t RtpHeaderParser::ParsePaddingBytes(
const uint8_t* ptrRTPDataExtensionEnd,
const uint8_t* ptr) const {
uint8_t num_zero_bytes = 0;
while (ptrRTPDataExtensionEnd - ptr > 0) {
if (*ptr != 0) {
@ -768,6 +767,6 @@ int RTPPayloadParser::ParseVP8TIDAndKeyIdx(RTPPayloadVP8* vp8,
return 0;
}
} // namespace ModuleRTPUtility
} // namespace RtpUtility
} // namespace webrtc

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

@ -28,8 +28,7 @@ RtpFeedback* NullObjectRtpFeedback();
RtpAudioFeedback* NullObjectRtpAudioFeedback();
ReceiveStatistics* NullObjectReceiveStatistics();
namespace ModuleRTPUtility
{
namespace RtpUtility {
// January 1970, in NTP seconds.
const uint32_t NTP_JAN_1970 = 2208988800UL;
@ -92,12 +91,10 @@ namespace ModuleRTPUtility
*/
uint32_t BufferToUWord32(const uint8_t* dataBuffer);
class RTPHeaderParser
{
class RtpHeaderParser {
public:
RTPHeaderParser(const uint8_t* rtpData,
const uint32_t rtpDataLength);
~RTPHeaderParser();
RtpHeaderParser(const uint8_t* rtpData, size_t rtpDataLength);
~RtpHeaderParser();
bool RTCP() const;
bool ParseRtcp(RTPHeader* header) const;
@ -207,7 +204,7 @@ namespace ModuleRTPUtility
const RtpVideoCodecTypes _videoType;
};
} // namespace ModuleRTPUtility
} // namespace RtpUtility
} // namespace webrtc

23
webrtc/modules/rtp_rtcp/source/rtp_utility_unittest.cc
View File

@ -8,9 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
/*
* This file conatins unit tests for the ModuleRTPUtility.
* This file conatins unit tests for the RtpUtility.
*/
#include "testing/gtest/include/gtest/gtest.h"
@ -20,9 +19,9 @@
namespace webrtc {
using ModuleRTPUtility::RTPPayloadParser;
using ModuleRTPUtility::RTPPayload;
using ModuleRTPUtility::RTPPayloadVP8;
using RtpUtility::RTPPayloadParser;
using RtpUtility::RTPPayload;
using RtpUtility::RTPPayloadVP8;
// Payload descriptor
// 0 1 2 3 4 5 6 7
@ -81,7 +80,7 @@ TEST(ParseVP8Test, BasicHeader) {
RTPPayload parsedPacket;
ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 1 /*S*/, 4 /*PartID*/);
@ -102,7 +101,7 @@ TEST(ParseVP8Test, PictureID) {
RTPPayload parsedPacket;
ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
VerifyBasicHeader(parsedPacket.info.VP8, 1 /*N*/, 0 /*S*/, 0 /*PartID*/);
@ -141,7 +140,7 @@ TEST(ParseVP8Test, Tl0PicIdx) {
RTPPayload parsedPacket;
ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
EXPECT_EQ(ModuleRTPUtility::kIFrame, parsedPacket.frameType);
EXPECT_EQ(RtpUtility::kIFrame, parsedPacket.frameType);
EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 1 /*S*/, 0 /*PartID*/);
@ -164,7 +163,7 @@ TEST(ParseVP8Test, TIDAndLayerSync) {
RTPPayload parsedPacket;
ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
@ -188,7 +187,7 @@ TEST(ParseVP8Test, KeyIdx) {
RTPPayload parsedPacket;
ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
@ -214,7 +213,7 @@ TEST(ParseVP8Test, MultipleExtensions) {
RTPPayload parsedPacket;
ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
@ -263,7 +262,7 @@ TEST(ParseVP8Test, TestWithPacketizer) {
RTPPayload parsedPacket;
ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
EXPECT_EQ(ModuleRTPUtility::kIFrame, parsedPacket.frameType);
EXPECT_EQ(RtpUtility::kIFrame, parsedPacket.frameType);
EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
VerifyBasicHeader(parsedPacket.info.VP8,

4
webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
View File

@ -52,7 +52,9 @@ class LoopBackTransport : public webrtc::Transport {
}
RTPHeader header;
scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
if (!parser->Parse(static_cast<const uint8_t*>(data), len, &header)) {
if (!parser->Parse(static_cast<const uint8_t*>(data),
static_cast<size_t>(len),
&header)) {
return -1;
}
PayloadUnion payload_specific;

8
webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc
View File

@ -83,11 +83,9 @@ class RtpRtcpVideoTest : public ::testing::Test {
uint32_t sequence_number) {
dataBuffer[0] = static_cast<uint8_t>(0x80); // version 2
dataBuffer[1] = static_cast<uint8_t>(kPayloadType);
ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer + 2,
sequence_number);
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer + 4, timestamp);
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer + 8,
0x1234); // SSRC.
RtpUtility::AssignUWord16ToBuffer(dataBuffer + 2, sequence_number);
RtpUtility::AssignUWord32ToBuffer(dataBuffer + 4, timestamp);
RtpUtility::AssignUWord32ToBuffer(dataBuffer + 8, 0x1234); // SSRC.
int32_t rtpHeaderLength = 12;
return rtpHeaderLength;
}

12
webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
View File

@ -259,12 +259,10 @@ TEST(FecTest, FecTest) {
// Only push one (fake) frame to the FEC.
mediaPacket->data[1] &= 0x7f;
ModuleRTPUtility::AssignUWord16ToBuffer(&mediaPacket->data[2],
seqNum);
ModuleRTPUtility::AssignUWord32ToBuffer(&mediaPacket->data[4],
timeStamp);
ModuleRTPUtility::AssignUWord32ToBuffer(&mediaPacket->data[8],
ssrc);
RtpUtility::AssignUWord16ToBuffer(&mediaPacket->data[2], seqNum);
RtpUtility::AssignUWord32ToBuffer(&mediaPacket->data[4],
timeStamp);
RtpUtility::AssignUWord32ToBuffer(&mediaPacket->data[8], ssrc);
// Generate random values for payload
for (int32_t j = 12; j < mediaPacket->length; ++j) {
mediaPacket->data[j] = static_cast<uint8_t>(rand() % 256);
@ -303,7 +301,7 @@ TEST(FecTest, FecTest) {
memcpy(receivedPacket->pkt->data, mediaPacket->data,
mediaPacket->length);
receivedPacket->seq_num =
ModuleRTPUtility::BufferToUWord16(&mediaPacket->data[2]);
RtpUtility::BufferToUWord16(&mediaPacket->data[2]);
receivedPacket->is_fec = false;
}
mediaPacketIdx++;

2
webrtc/modules/utility/source/rtp_dump_impl.h
View File

@ -35,7 +35,7 @@ private:
inline uint16_t RtpDumpHtons(uint16_t x) const;
// Return true if the packet starts with a valid RTCP header.
// Note: See ModuleRTPUtility::RTPHeaderParser::RTCP() for details on how
// Note: See RtpUtility::RtpHeaderParser::RTCP() for details on how
// to determine if the packet is an RTCP packet.
bool RTCP(const uint8_t* packet) const;

3
webrtc/modules/video_coding/main/test/pcap_file_reader.cc
View File

@ -268,8 +268,7 @@ class PcapFileReaderImpl : public RtpPacketSourceInterface {
}
TRY(Read(read_buffer_, marker.payload_length));
ModuleRTPUtility::RTPHeaderParser rtp_parser(read_buffer_,
marker.payload_length);
RtpUtility::RtpHeaderParser rtp_parser(read_buffer_, marker.payload_length);
if (rtp_parser.RTCP()) {
rtp_parser.ParseRtcp(&marker.rtp_header);
packets_.push_back(marker);

2
webrtc/modules/video_coding/main/test/pcap_file_reader_unittest.cc
View File

@ -55,7 +55,7 @@ class TestPcapFileReader : public ::testing::Test {
EXPECT_GE(kBufferSize, length);
length = kBufferSize;
ModuleRTPUtility::RTPHeaderParser rtp_header_parser(data, length);
RtpUtility::RtpHeaderParser rtp_header_parser(data, length);
webrtc::RTPHeader header;
if (!rtp_header_parser.RTCP() && rtp_header_parser.Parse(header, NULL)) {
pps[header.ssrc]++;

4
webrtc/test/rtp_rtcp_observer.h
View File

@ -129,7 +129,7 @@ class RtpRtcpObserver {
private:
virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)));
EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, length));
Action action;
{
CriticalSectionScoped lock(crit_);
@ -146,7 +146,7 @@ class RtpRtcpObserver {
}
virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)));
EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, length));
Action action;
{
CriticalSectionScoped lock(crit_);

5
webrtc/video/call.cc
View File

@ -100,8 +100,6 @@ class Call : public webrtc::Call, public PacketReceiver {
std::map<uint32_t, VideoSendStream*> send_ssrcs_ GUARDED_BY(send_lock_);
scoped_ptr<RWLockWrapper> send_lock_;
scoped_ptr<RtpHeaderParser> rtp_header_parser_;
scoped_ptr<CpuOveruseObserverProxy> overuse_observer_proxy_;
VideoSendStream::RtpStateMap suspended_send_ssrcs_;
@ -133,7 +131,6 @@ Call::Call(webrtc::VideoEngine* video_engine, const Call::Config& config)
: config_(config),
receive_lock_(RWLockWrapper::CreateRWLock()),
send_lock_(RWLockWrapper::CreateRWLock()),
rtp_header_parser_(RtpHeaderParser::Create()),
video_engine_(video_engine),
base_channel_id_(-1) {
assert(video_engine != NULL);
@ -339,7 +336,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(const uint8_t* packet,
PacketReceiver::DeliveryStatus Call::DeliverPacket(const uint8_t* packet,
size_t length) {
if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)))
if (RtpHeaderParser::IsRtcp(packet, length))
return DeliverRtcp(packet, length);
return DeliverRtp(packet, length);

2
webrtc/video/call_perf_tests.cc
View File

@ -354,7 +354,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
if (!rtp_start_timestamp_set_) {
// Calculate the rtp timestamp offset in order to calculate the real

17
webrtc/video/end_to_end_tests.cc
View File

@ -254,8 +254,7 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(
rtp_parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
// Never drop retransmitted packets.
if (dropped_packets_.find(header.sequenceNumber) !=
@ -342,7 +341,7 @@ TEST_F(EndToEndTest, DISABLED_CanReceiveFec) {
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE
EXCLUSIVE_LOCKS_REQUIRED(crit_) {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
EXPECT_EQ(kRedPayloadType, header.payloadType);
int encapsulated_payload_type =
@ -445,7 +444,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) {
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
if (header.timestamp == retransmitted_timestamp_) {
EXPECT_EQ(retransmission_ssrc_, header.ssrc);
@ -632,7 +631,7 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
// Drop all retransmitted packets to force a PLI.
if (header.timestamp <= highest_dropped_timestamp_)
@ -724,7 +723,7 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
private:
virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
size_t length) OVERRIDE {
if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length))) {
if (RtpHeaderParser::IsRtcp(packet, length)) {
return receiver_->DeliverPacket(packet, length);
} else {
DeliveryStatus delivery_status =
@ -1188,7 +1187,7 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
EXPECT_TRUE(valid_ssrcs_[header.ssrc])
<< "Received unknown SSRC: " << header.ssrc;
@ -1557,7 +1556,7 @@ TEST_F(EndToEndTest, RedundantPayloadsTransmittedOnAllSsrcs) {
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
if (!registered_rtx_ssrc_[header.ssrc])
return SEND_PACKET;
@ -1642,7 +1641,7 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
const uint32_t ssrc = header.ssrc;
const uint16_t sequence_number = header.sequenceNumber;
const uint32_t timestamp = header.timestamp;

4
webrtc/video/full_stack.cc
View File

@ -104,7 +104,7 @@ class VideoAnalyzer : public PacketReceiver,
size_t length) OVERRIDE {
scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
RTPHeader header;
parser->Parse(packet, static_cast<int>(length), &header);
parser->Parse(packet, length, &header);
{
CriticalSectionScoped lock(crit_.get());
recv_times_[header.timestamp - rtp_timestamp_delta_] =
@ -143,7 +143,7 @@ class VideoAnalyzer : public PacketReceiver,
virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
RTPHeader header;
parser->Parse(packet, static_cast<int>(length), &header);
parser->Parse(packet, length, &header);
{
CriticalSectionScoped lock(crit_.get());

7
webrtc/video/rampup_tests.cc
View File

@ -125,7 +125,7 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
CriticalSectionScoped lock(crit_.get());
RTPHeader header;
EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
receive_stats_->IncomingPacket(header, length, false);
payload_registry_->SetIncomingPayloadType(header);
remote_bitrate_estimator_->IncomingPacket(
@ -151,8 +151,7 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
rtx_media_ssrcs_[header.ssrc],
header);
length = restored_length;
EXPECT_TRUE(rtp_parser_->Parse(
restored_packet, static_cast<int>(length), &header));
EXPECT_TRUE(rtp_parser_->Parse(restored_packet, length, &header));
} else {
rtp_rtcp_->SetRemoteSSRC(header.ssrc);
}
@ -291,7 +290,7 @@ class LowRateStreamObserver : public test::DirectTransport,
size_t length) OVERRIDE {
CriticalSectionScoped lock(crit_.get());
RTPHeader header;
EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
receive_stats_->IncomingPacket(header, length, false);
remote_bitrate_estimator_->IncomingPacket(
clock_->TimeInMilliseconds(), static_cast<int>(length - 12), header);

14
webrtc/video/video_send_stream_tests.cc
View File

@ -137,7 +137,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
@ -178,7 +178,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
EXPECT_TRUE(header.extension.hasTransmissionTimeOffset);
EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
@ -323,7 +323,7 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
// Send lossy receive reports to trigger FEC enabling.
if (send_count_++ % 2 != 0) {
@ -398,7 +398,7 @@ void VideoSendStreamTest::TestNackRetransmission(
private:
virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
// Nack second packet after receiving the third one.
if (++send_count_ == 3) {
@ -724,7 +724,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
CriticalSectionScoped lock(crit_.get());
++rtp_count_;
RTPHeader header;
EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
EXPECT_TRUE(parser_->Parse(packet, length, &header));
last_sequence_number_ = header.sequenceNumber;
if (test_state_ == kBeforeSuspend) {
@ -1041,11 +1041,11 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
private:
virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
size_t length) OVERRIDE {
if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)))
if (RtpHeaderParser::IsRtcp(packet, length))
return DELIVERY_OK;
RTPHeader header;
if (!parser_->Parse(packet, static_cast<int>(length), &header))
if (!parser_->Parse(packet, length, &header))
return DELIVERY_PACKET_ERROR;
assert(stream_ != NULL);
VideoSendStream::Stats stats = stream_->GetStats();

2
webrtc/video_engine/test/auto_test/automated/vie_network_test.cc
View File

@ -31,7 +31,7 @@ class RtcpCollectorTransport : public webrtc::Transport {
}
virtual int SendRTCPPacket(int channel, const void* data, int len) {
const uint8_t* buf = static_cast<const uint8_t*>(data);
webrtc::ModuleRTPUtility::RTPHeaderParser parser(buf, len);
webrtc::RtpUtility::RtpHeaderParser parser(buf, len);
if (parser.RTCP()) {
Packet p;
p.channel = channel;

4
webrtc/voice_engine/test/auto_test/standard/rtp_rtcp_extensions.cc
View File

@ -31,7 +31,9 @@ class ExtensionVerifyTransport : public webrtc::Transport {
virtual int SendPacket(int channel, const void* data, int len) {
webrtc::RTPHeader header;
if (parser_->Parse(static_cast<const uint8_t*>(data), len, &header)) {
if (parser_->Parse(reinterpret_cast<const uint8_t*>(data),
static_cast<size_t>(len),
&header)) {
bool ok = true;
if (audio_level_id_ >= 0 &&
!header.extension.hasAudioLevel) {