WebRtc_Word32 => int32_t for rtp_rtcp/
BUG=314
Review URL: https://webrtc-codereview.appspot.com/1279007
git-svn-id: http://webrtc.googlecode.com/svn/trunk@3777 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
index 648b1b0..3855204 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
@@ -89,9 +89,9 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetPacketTimeout(
- const WebRtc_UWord32 RTPtimeoutMS,
- const WebRtc_UWord32 RTCPtimeoutMS) = 0;
+ virtual int32_t SetPacketTimeout(
+ const uint32_t RTPtimeoutMS,
+ const uint32_t RTCPtimeoutMS) = 0;
/*
* Set periodic dead or alive notification
@@ -102,9 +102,9 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetPeriodicDeadOrAliveStatus(
+ virtual int32_t SetPeriodicDeadOrAliveStatus(
const bool enable,
- const WebRtc_UWord8 sampleTimeSeconds) = 0;
+ const uint8_t sampleTimeSeconds) = 0;
/*
* Get periodic dead or alive notification status
@@ -115,16 +115,16 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 PeriodicDeadOrAliveStatus(
+ virtual int32_t PeriodicDeadOrAliveStatus(
bool& enable,
- WebRtc_UWord8& sampleTimeSeconds) = 0;
+ uint8_t& sampleTimeSeconds) = 0;
/*
* set voice codec name and payload type
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RegisterReceivePayload(
+ virtual int32_t RegisterReceivePayload(
const CodecInst& voiceCodec) = 0;
/*
@@ -132,7 +132,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RegisterReceivePayload(
+ virtual int32_t RegisterReceivePayload(
const VideoCodec& videoCodec) = 0;
/*
@@ -140,18 +140,18 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 ReceivePayloadType(
+ virtual int32_t ReceivePayloadType(
const CodecInst& voiceCodec,
- WebRtc_Word8* plType) = 0;
+ int8_t* plType) = 0;
/*
* get payload type for a video codec
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 ReceivePayloadType(
+ virtual int32_t ReceivePayloadType(
const VideoCodec& videoCodec,
- WebRtc_Word8* plType) = 0;
+ int8_t* plType) = 0;
/*
* Remove a registered payload type from list of accepted payloads
@@ -160,25 +160,25 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 DeRegisterReceivePayload(
- const WebRtc_Word8 payloadType) = 0;
+ virtual int32_t DeRegisterReceivePayload(
+ const int8_t payloadType) = 0;
/*
* (De)register RTP header extension type and id.
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RegisterReceiveRtpHeaderExtension(
+ virtual int32_t RegisterReceiveRtpHeaderExtension(
const RTPExtensionType type,
- const WebRtc_UWord8 id) = 0;
+ const uint8_t id) = 0;
- virtual WebRtc_Word32 DeregisterReceiveRtpHeaderExtension(
+ virtual int32_t DeregisterReceiveRtpHeaderExtension(
const RTPExtensionType type) = 0;
/*
* Get last received remote timestamp
*/
- virtual WebRtc_UWord32 RemoteTimestamp() const = 0;
+ virtual uint32_t RemoteTimestamp() const = 0;
/*
* Get the local time of the last received remote timestamp
@@ -192,13 +192,13 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 EstimatedRemoteTimeStamp(
- WebRtc_UWord32& timestamp) const = 0;
+ virtual int32_t EstimatedRemoteTimeStamp(
+ uint32_t& timestamp) const = 0;
/*
* Get incoming SSRC
*/
- virtual WebRtc_UWord32 RemoteSSRC() const = 0;
+ virtual uint32_t RemoteSSRC() const = 0;
/*
* Get remote CSRC
@@ -207,8 +207,8 @@
*
* return -1 on failure else the number of valid entries in the list
*/
- virtual WebRtc_Word32 RemoteCSRCs(
- WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]) const = 0;
+ virtual int32_t RemoteCSRCs(
+ uint32_t arrOfCSRC[kRtpCsrcSize]) const = 0;
/*
* get the currently configured SSRC filter
@@ -217,7 +217,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SSRCFilter(WebRtc_UWord32& allowedSSRC) const = 0;
+ virtual int32_t SSRCFilter(uint32_t& allowedSSRC) const = 0;
/*
* set a SSRC to be used as a filter for incoming RTP streams
@@ -226,20 +226,20 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetSSRCFilter(const bool enable,
- const WebRtc_UWord32 allowedSSRC) = 0;
+ virtual int32_t SetSSRCFilter(const bool enable,
+ const uint32_t allowedSSRC) = 0;
/*
* Turn on/off receiving RTX (RFC 4588) on a specific SSRC.
*/
- virtual WebRtc_Word32 SetRTXReceiveStatus(const bool enable,
- const WebRtc_UWord32 SSRC) = 0;
+ virtual int32_t SetRTXReceiveStatus(const bool enable,
+ const uint32_t SSRC) = 0;
/*
* Get status of receiving RTX (RFC 4588) on a specific SSRC.
*/
- virtual WebRtc_Word32 RTXReceiveStatus(bool* enable,
- WebRtc_UWord32* SSRC) const = 0;
+ virtual int32_t RTXReceiveStatus(bool* enable,
+ uint32_t* SSRC) const = 0;
/*
* called by the network module when we receive a packet
@@ -249,8 +249,8 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 IncomingPacket(const WebRtc_UWord8* incomingPacket,
- const WebRtc_UWord16 packetLength) = 0;
+ virtual int32_t IncomingPacket(const uint8_t* incomingPacket,
+ const uint16_t packetLength) = 0;
/**************************************************************************
*
@@ -265,7 +265,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetMaxTransferUnit(const WebRtc_UWord16 size) = 0;
+ virtual int32_t SetMaxTransferUnit(const uint16_t size) = 0;
/*
* set transtport overhead
@@ -278,10 +278,10 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetTransportOverhead(
+ virtual int32_t SetTransportOverhead(
const bool TCP,
const bool IPV6,
- const WebRtc_UWord8 authenticationOverhead = 0) = 0;
+ const uint8_t authenticationOverhead = 0) = 0;
/*
* Get max payload length
@@ -291,7 +291,7 @@
* Does not account FEC/ULP/RED overhead if FEC is enabled.
* Does not account for RTP headers
*/
- virtual WebRtc_UWord16 MaxPayloadLength() const = 0;
+ virtual uint16_t MaxPayloadLength() const = 0;
/*
* Get max data payload length
@@ -301,14 +301,14 @@
* Takes into account FEC/ULP/RED overhead if FEC is enabled.
* Takes into account RTP headers
*/
- virtual WebRtc_UWord16 MaxDataPayloadLength() const = 0;
+ virtual uint16_t MaxDataPayloadLength() const = 0;
/*
* set codec name and payload type
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RegisterSendPayload(
+ virtual int32_t RegisterSendPayload(
const CodecInst& voiceCodec) = 0;
/*
@@ -316,7 +316,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RegisterSendPayload(
+ virtual int32_t RegisterSendPayload(
const VideoCodec& videoCodec) = 0;
/*
@@ -326,25 +326,25 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 DeRegisterSendPayload(
- const WebRtc_Word8 payloadType) = 0;
+ virtual int32_t DeRegisterSendPayload(
+ const int8_t payloadType) = 0;
/*
* (De)register RTP header extension type and id.
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RegisterSendRtpHeaderExtension(
+ virtual int32_t RegisterSendRtpHeaderExtension(
const RTPExtensionType type,
- const WebRtc_UWord8 id) = 0;
+ const uint8_t id) = 0;
- virtual WebRtc_Word32 DeregisterSendRtpHeaderExtension(
+ virtual int32_t DeregisterSendRtpHeaderExtension(
const RTPExtensionType type) = 0;
/*
* get start timestamp
*/
- virtual WebRtc_UWord32 StartTimestamp() const = 0;
+ virtual uint32_t StartTimestamp() const = 0;
/*
* configure start timestamp, default is a random number
@@ -353,32 +353,32 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetStartTimestamp(
- const WebRtc_UWord32 timestamp) = 0;
+ virtual int32_t SetStartTimestamp(
+ const uint32_t timestamp) = 0;
/*
* Get SequenceNumber
*/
- virtual WebRtc_UWord16 SequenceNumber() const = 0;
+ virtual uint16_t SequenceNumber() const = 0;
/*
* Set SequenceNumber, default is a random number
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetSequenceNumber(const WebRtc_UWord16 seq) = 0;
+ virtual int32_t SetSequenceNumber(const uint16_t seq) = 0;
/*
* Get SSRC
*/
- virtual WebRtc_UWord32 SSRC() const = 0;
+ virtual uint32_t SSRC() const = 0;
/*
* configure SSRC, default is a random number
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetSSRC(const WebRtc_UWord32 ssrc) = 0;
+ virtual int32_t SetSSRC(const uint32_t ssrc) = 0;
/*
* Get CSRC
@@ -387,8 +387,8 @@
*
* return -1 on failure else number of valid entries in the array
*/
- virtual WebRtc_Word32 CSRCs(
- WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]) const = 0;
+ virtual int32_t CSRCs(
+ uint32_t arrOfCSRC[kRtpCsrcSize]) const = 0;
/*
* Set CSRC
@@ -398,9 +398,9 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetCSRCs(
- const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize],
- const WebRtc_UWord8 arrLength) = 0;
+ virtual int32_t SetCSRCs(
+ const uint32_t arrOfCSRC[kRtpCsrcSize],
+ const uint8_t arrLength) = 0;
/*
* includes CSRCs in RTP header if enabled
@@ -411,20 +411,20 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetCSRCStatus(const bool include) = 0;
+ virtual int32_t SetCSRCStatus(const bool include) = 0;
/*
* Turn on/off sending RTX (RFC 4588) on a specific SSRC.
*/
- virtual WebRtc_Word32 SetRTXSendStatus(const RtxMode mode,
- const bool setSSRC,
- const WebRtc_UWord32 SSRC) = 0;
+ virtual int32_t SetRTXSendStatus(const RtxMode mode,
+ const bool setSSRC,
+ const uint32_t SSRC) = 0;
/*
* Get status of sending RTX (RFC 4588) on a specific SSRC.
*/
- virtual WebRtc_Word32 RTXSendStatus(RtxMode* mode,
- WebRtc_UWord32* SSRC) const = 0;
+ virtual int32_t RTXSendStatus(RtxMode* mode,
+ uint32_t* SSRC) const = 0;
/*
* sends kRtcpByeCode when going from true to false
@@ -433,7 +433,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetSendingStatus(const bool sending) = 0;
+ virtual int32_t SetSendingStatus(const bool sending) = 0;
/*
* get send status
@@ -447,7 +447,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetSendingMediaStatus(const bool sending) = 0;
+ virtual int32_t SetSendingMediaStatus(const bool sending) = 0;
/*
* get send status
@@ -457,10 +457,10 @@
/*
* get sent bitrate in Kbit/s
*/
- virtual void BitrateSent(WebRtc_UWord32* totalRate,
- WebRtc_UWord32* videoRate,
- WebRtc_UWord32* fecRate,
- WebRtc_UWord32* nackRate) const = 0;
+ virtual void BitrateSent(uint32_t* totalRate,
+ uint32_t* videoRate,
+ uint32_t* fecRate,
+ uint32_t* nackRate) const = 0;
/*
* Used by the codec module to deliver a video or audio frame for
@@ -476,13 +476,13 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SendOutgoingData(
+ virtual int32_t SendOutgoingData(
const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 timeStamp,
+ const int8_t payloadType,
+ const uint32_t timeStamp,
int64_t capture_time_ms,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
const RTPFragmentationHeader* fragmentation = NULL,
const RTPVideoHeader* rtpVideoHdr = NULL) = 0;
@@ -507,29 +507,29 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetRTCPStatus(const RTCPMethod method) = 0;
+ virtual int32_t SetRTCPStatus(const RTCPMethod method) = 0;
/*
* Set RTCP CName (i.e unique identifier)
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetCNAME(const char cName[RTCP_CNAME_SIZE]) = 0;
+ virtual int32_t SetCNAME(const char cName[RTCP_CNAME_SIZE]) = 0;
/*
* Get RTCP CName (i.e unique identifier)
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 CNAME(char cName[RTCP_CNAME_SIZE]) = 0;
+ virtual int32_t CNAME(char cName[RTCP_CNAME_SIZE]) = 0;
/*
* Get remote CName
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RemoteCNAME(
- const WebRtc_UWord32 remoteSSRC,
+ virtual int32_t RemoteCNAME(
+ const uint32_t remoteSSRC,
char cName[RTCP_CNAME_SIZE]) const = 0;
/*
@@ -537,20 +537,20 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RemoteNTP(
- WebRtc_UWord32 *ReceivedNTPsecs,
- WebRtc_UWord32 *ReceivedNTPfrac,
- WebRtc_UWord32 *RTCPArrivalTimeSecs,
- WebRtc_UWord32 *RTCPArrivalTimeFrac,
- WebRtc_UWord32 *rtcp_timestamp) const = 0;
+ virtual int32_t RemoteNTP(
+ uint32_t *ReceivedNTPsecs,
+ uint32_t *ReceivedNTPfrac,
+ uint32_t *RTCPArrivalTimeSecs,
+ uint32_t *RTCPArrivalTimeFrac,
+ uint32_t *rtcp_timestamp) const = 0;
/*
* AddMixedCNAME
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 AddMixedCNAME(
- const WebRtc_UWord32 SSRC,
+ virtual int32_t AddMixedCNAME(
+ const uint32_t SSRC,
const char cName[RTCP_CNAME_SIZE]) = 0;
/*
@@ -558,25 +558,25 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RemoveMixedCNAME(const WebRtc_UWord32 SSRC) = 0;
+ virtual int32_t RemoveMixedCNAME(const uint32_t SSRC) = 0;
/*
* Get RoundTripTime
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RTT(const WebRtc_UWord32 remoteSSRC,
- WebRtc_UWord16* RTT,
- WebRtc_UWord16* avgRTT,
- WebRtc_UWord16* minRTT,
- WebRtc_UWord16* maxRTT) const = 0 ;
+ virtual int32_t RTT(const uint32_t remoteSSRC,
+ uint16_t* RTT,
+ uint16_t* avgRTT,
+ uint16_t* minRTT,
+ uint16_t* maxRTT) const = 0 ;
/*
* Reset RoundTripTime statistics
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 ResetRTT(const WebRtc_UWord32 remoteSSRC)= 0 ;
+ virtual int32_t ResetRTT(const uint32_t remoteSSRC)= 0 ;
/*
* Sets the estimated RTT, to be used for receive only modules without
@@ -590,86 +590,86 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SendRTCP(
- WebRtc_UWord32 rtcpPacketType = kRtcpReport) = 0;
+ virtual int32_t SendRTCP(
+ uint32_t rtcpPacketType = kRtcpReport) = 0;
/*
* Good state of RTP receiver inform sender
*/
- virtual WebRtc_Word32 SendRTCPReferencePictureSelection(
- const WebRtc_UWord64 pictureID) = 0;
+ virtual int32_t SendRTCPReferencePictureSelection(
+ const uint64_t pictureID) = 0;
/*
* Send a RTCP Slice Loss Indication (SLI)
* 6 least significant bits of pictureID
*/
- virtual WebRtc_Word32 SendRTCPSliceLossIndication(
- const WebRtc_UWord8 pictureID) = 0;
+ virtual int32_t SendRTCPSliceLossIndication(
+ const uint8_t pictureID) = 0;
/*
* Reset RTP statistics
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 ResetStatisticsRTP() = 0;
+ virtual int32_t ResetStatisticsRTP() = 0;
/*
* statistics of our localy created statistics of the received RTP stream
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 StatisticsRTP(
- WebRtc_UWord8* fraction_lost, // scale 0 to 255
- WebRtc_UWord32* cum_lost, // number of lost packets
- WebRtc_UWord32* ext_max, // highest sequence number received
- WebRtc_UWord32* jitter,
- WebRtc_UWord32* max_jitter = NULL) const = 0;
+ virtual int32_t StatisticsRTP(
+ uint8_t* fraction_lost, // scale 0 to 255
+ uint32_t* cum_lost, // number of lost packets
+ uint32_t* ext_max, // highest sequence number received
+ uint32_t* jitter,
+ uint32_t* max_jitter = NULL) const = 0;
/*
* Reset RTP data counters for the receiving side
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 ResetReceiveDataCountersRTP() = 0;
+ virtual int32_t ResetReceiveDataCountersRTP() = 0;
/*
* Reset RTP data counters for the sending side
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 ResetSendDataCountersRTP() = 0;
+ virtual int32_t ResetSendDataCountersRTP() = 0;
/*
* statistics of the amount of data sent and received
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 DataCountersRTP(
- WebRtc_UWord32* bytesSent,
- WebRtc_UWord32* packetsSent,
- WebRtc_UWord32* bytesReceived,
- WebRtc_UWord32* packetsReceived) const = 0;
+ virtual int32_t DataCountersRTP(
+ uint32_t* bytesSent,
+ uint32_t* packetsSent,
+ uint32_t* bytesReceived,
+ uint32_t* packetsReceived) const = 0;
/*
* Get received RTCP sender info
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RemoteRTCPStat(RTCPSenderInfo* senderInfo) = 0;
+ virtual int32_t RemoteRTCPStat(RTCPSenderInfo* senderInfo) = 0;
/*
* Get received RTCP report block
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RemoteRTCPStat(
+ virtual int32_t RemoteRTCPStat(
std::vector<RTCPReportBlock>* receiveBlocks) const = 0;
/*
* Set received RTCP report block
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 AddRTCPReportBlock(
- const WebRtc_UWord32 SSRC,
+ virtual int32_t AddRTCPReportBlock(
+ const uint32_t SSRC,
const RTCPReportBlock* receiveBlock) = 0;
/*
@@ -677,24 +677,24 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RemoveRTCPReportBlock(const WebRtc_UWord32 SSRC) = 0;
+ virtual int32_t RemoveRTCPReportBlock(const uint32_t SSRC) = 0;
/*
* (APP) Application specific data
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetRTCPApplicationSpecificData(
- const WebRtc_UWord8 subType,
- const WebRtc_UWord32 name,
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 length) = 0;
+ virtual int32_t SetRTCPApplicationSpecificData(
+ const uint8_t subType,
+ const uint32_t name,
+ const uint8_t* data,
+ const uint16_t length) = 0;
/*
* (XR) VOIP metric
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetRTCPVoIPMetrics(
+ virtual int32_t SetRTCPVoIPMetrics(
const RTCPVoIPMetric* VoIPMetric) = 0;
/*
@@ -702,18 +702,18 @@
*/
virtual bool REMB() const = 0;
- virtual WebRtc_Word32 SetREMBStatus(const bool enable) = 0;
+ virtual int32_t SetREMBStatus(const bool enable) = 0;
- virtual WebRtc_Word32 SetREMBData(const WebRtc_UWord32 bitrate,
- const WebRtc_UWord8 numberOfSSRC,
- const WebRtc_UWord32* SSRC) = 0;
+ virtual int32_t SetREMBData(const uint32_t bitrate,
+ const uint8_t numberOfSSRC,
+ const uint32_t* SSRC) = 0;
/*
* (IJ) Extended jitter report.
*/
virtual bool IJ() const = 0;
- virtual WebRtc_Word32 SetIJStatus(const bool enable) = 0;
+ virtual int32_t SetIJStatus(const bool enable) = 0;
/*
* (TMMBR) Temporary Max Media Bit Rate
@@ -724,7 +724,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetTMMBRStatus(const bool enable) = 0;
+ virtual int32_t SetTMMBRStatus(const bool enable) = 0;
/*
* (NACK)
@@ -739,8 +739,8 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetNACKStatus(const NACKMethod method,
- int max_reordering_threshold) = 0;
+ virtual int32_t SetNACKStatus(const NACKMethod method,
+ int max_reordering_threshold) = 0;
/*
* TODO(holmer): Propagate this API to VideoEngine.
@@ -767,8 +767,8 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SendNACK(const WebRtc_UWord16* nackList,
- const WebRtc_UWord16 size) = 0;
+ virtual int32_t SendNACK(const uint16_t* nackList,
+ const uint16_t size) = 0;
/*
* Store the sent packets, needed to answer to a Negative acknowledgement
@@ -776,9 +776,9 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetStorePacketsStatus(
+ virtual int32_t SetStorePacketsStatus(
const bool enable,
- const WebRtc_UWord16 numberToStore) = 0;
+ const uint16_t numberToStore) = 0;
/**************************************************************************
*
@@ -792,8 +792,8 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetAudioPacketSize(
- const WebRtc_UWord16 packetSizeSamples) = 0;
+ virtual int32_t SetAudioPacketSize(
+ const uint16_t packetSizeSamples) = 0;
/*
* Forward DTMF to decoder for playout.
@@ -816,33 +816,33 @@
* by the microphone and send inband just after the tone has ended.
*/
virtual bool SendTelephoneEventActive(
- WebRtc_Word8& telephoneEvent) const = 0;
+ int8_t& telephoneEvent) const = 0;
/*
* Send a TelephoneEvent tone using RFC 2833 (4733)
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SendTelephoneEventOutband(
- const WebRtc_UWord8 key,
- const WebRtc_UWord16 time_ms,
- const WebRtc_UWord8 level) = 0;
+ virtual int32_t SendTelephoneEventOutband(
+ const uint8_t key,
+ const uint16_t time_ms,
+ const uint8_t level) = 0;
/*
* Set payload type for Redundant Audio Data RFC 2198
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetSendREDPayloadType(
- const WebRtc_Word8 payloadType) = 0;
+ virtual int32_t SetSendREDPayloadType(
+ const int8_t payloadType) = 0;
/*
* Get payload type for Redundant Audio Data RFC 2198
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SendREDPayloadType(
- WebRtc_Word8& payloadType) const = 0;
+ virtual int32_t SendREDPayloadType(
+ int8_t& payloadType) const = 0;
/*
* Set status and ID for header-extension-for-audio-level-indication.
@@ -850,18 +850,18 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetRTPAudioLevelIndicationStatus(
+ virtual int32_t SetRTPAudioLevelIndicationStatus(
const bool enable,
- const WebRtc_UWord8 ID) = 0;
+ const uint8_t ID) = 0;
/*
* Get status and ID for header-extension-for-audio-level-indication.
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 GetRTPAudioLevelIndicationStatus(
+ virtual int32_t GetRTPAudioLevelIndicationStatus(
bool& enable,
- WebRtc_UWord8& ID) const = 0;
+ uint8_t& ID) const = 0;
/*
* Store the audio level in dBov for header-extension-for-audio-level-
@@ -871,7 +871,7 @@
*
* return -1 on failure else 0.
*/
- virtual WebRtc_Word32 SetAudioLevel(const WebRtc_UWord8 level_dBov) = 0;
+ virtual int32_t SetAudioLevel(const uint8_t level_dBov) = 0;
/**************************************************************************
*
@@ -884,34 +884,34 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetCameraDelay(const WebRtc_Word32 delayMS) = 0;
+ virtual int32_t SetCameraDelay(const int32_t delayMS) = 0;
/*
* Set the target send bitrate
*/
- virtual void SetTargetSendBitrate(const WebRtc_UWord32 bitrate) = 0;
+ virtual void SetTargetSendBitrate(const uint32_t bitrate) = 0;
/*
* Turn on/off generic FEC
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetGenericFECStatus(
+ virtual int32_t SetGenericFECStatus(
const bool enable,
- const WebRtc_UWord8 payloadTypeRED,
- const WebRtc_UWord8 payloadTypeFEC) = 0;
+ const uint8_t payloadTypeRED,
+ const uint8_t payloadTypeFEC) = 0;
/*
* Get generic FEC setting
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 GenericFECStatus(bool& enable,
- WebRtc_UWord8& payloadTypeRED,
- WebRtc_UWord8& payloadTypeFEC) = 0;
+ virtual int32_t GenericFECStatus(bool& enable,
+ uint8_t& payloadTypeRED,
+ uint8_t& payloadTypeFEC) = 0;
- virtual WebRtc_Word32 SetFecParameters(
+ virtual int32_t SetFecParameters(
const FecProtectionParams* delta_params,
const FecProtectionParams* key_params) = 0;
@@ -920,7 +920,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 SetKeyFrameRequestMethod(
+ virtual int32_t SetKeyFrameRequestMethod(
const KeyFrameRequestMethod method) = 0;
/*
@@ -928,7 +928,7 @@
*
* return -1 on failure else 0
*/
- virtual WebRtc_Word32 RequestKeyFrame() = 0;
+ virtual int32_t RequestKeyFrame() = 0;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index f0ef84f..616e5345 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -26,7 +26,7 @@
namespace webrtc{
-const WebRtc_Word32 kDefaultVideoFrequency = 90000;
+const int32_t kDefaultVideoFrequency = 90000;
enum RTCPMethod
{
@@ -115,32 +115,32 @@
struct RTCPSenderInfo
{
- WebRtc_UWord32 NTPseconds;
- WebRtc_UWord32 NTPfraction;
- WebRtc_UWord32 RTPtimeStamp;
- WebRtc_UWord32 sendPacketCount;
- WebRtc_UWord32 sendOctetCount;
+ uint32_t NTPseconds;
+ uint32_t NTPfraction;
+ uint32_t RTPtimeStamp;
+ uint32_t sendPacketCount;
+ uint32_t sendOctetCount;
};
struct RTCPReportBlock
{
// Fields as described by RFC 3550 6.4.2.
- WebRtc_UWord32 remoteSSRC; // SSRC of sender of this report.
- WebRtc_UWord32 sourceSSRC; // SSRC of the RTP packet sender.
- WebRtc_UWord8 fractionLost;
- WebRtc_UWord32 cumulativeLost; // 24 bits valid
- WebRtc_UWord32 extendedHighSeqNum;
- WebRtc_UWord32 jitter;
- WebRtc_UWord32 lastSR;
- WebRtc_UWord32 delaySinceLastSR;
+ uint32_t remoteSSRC; // SSRC of sender of this report.
+ uint32_t sourceSSRC; // SSRC of the RTP packet sender.
+ uint8_t fractionLost;
+ uint32_t cumulativeLost; // 24 bits valid
+ uint32_t extendedHighSeqNum;
+ uint32_t jitter;
+ uint32_t lastSR;
+ uint32_t delaySinceLastSR;
};
class RtpData
{
public:
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* payloadData,
+ const uint16_t payloadSize,
const WebRtcRTPHeader* rtpHeader) = 0;
protected:
virtual ~RtpData() {}
@@ -149,29 +149,29 @@
class RtcpFeedback
{
public:
- virtual void OnApplicationDataReceived(const WebRtc_Word32 /*id*/,
- const WebRtc_UWord8 /*subType*/,
- const WebRtc_UWord32 /*name*/,
- const WebRtc_UWord16 /*length*/,
- const WebRtc_UWord8* /*data*/) {};
+ virtual void OnApplicationDataReceived(const int32_t /*id*/,
+ const uint8_t /*subType*/,
+ const uint32_t /*name*/,
+ const uint16_t /*length*/,
+ const uint8_t* /*data*/) {};
virtual void OnXRVoIPMetricReceived(
- const WebRtc_Word32 /*id*/,
+ const int32_t /*id*/,
const RTCPVoIPMetric* /*metric*/) {};
- virtual void OnRTCPPacketTimeout(const WebRtc_Word32 /*id*/) {};
+ virtual void OnRTCPPacketTimeout(const int32_t /*id*/) {};
// |ntp_secs|, |ntp_frac| and |timestamp| are the NTP time and RTP timestamp
// parsed from the RTCP sender report from the sender with ssrc
// |senderSSRC|.
- virtual void OnSendReportReceived(const WebRtc_Word32 id,
- const WebRtc_UWord32 senderSSRC,
+ virtual void OnSendReportReceived(const int32_t id,
+ const uint32_t senderSSRC,
uint32_t ntp_secs,
uint32_t ntp_frac,
uint32_t timestamp) {};
- virtual void OnReceiveReportReceived(const WebRtc_Word32 id,
- const WebRtc_UWord32 senderSSRC) {};
+ virtual void OnReceiveReportReceived(const int32_t id,
+ const uint32_t senderSSRC) {};
protected:
virtual ~RtcpFeedback() {}
@@ -184,27 +184,27 @@
/*
* channels - number of channels in codec (1 = mono, 2 = stereo)
*/
- virtual WebRtc_Word32 OnInitializeDecoder(
- const WebRtc_Word32 id,
- const WebRtc_Word8 payloadType,
+ virtual int32_t OnInitializeDecoder(
+ const int32_t id,
+ const int8_t payloadType,
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) = 0;
+ const uint8_t channels,
+ const uint32_t rate) = 0;
- virtual void OnPacketTimeout(const WebRtc_Word32 id) = 0;
+ virtual void OnPacketTimeout(const int32_t id) = 0;
- virtual void OnReceivedPacket(const WebRtc_Word32 id,
+ virtual void OnReceivedPacket(const int32_t id,
const RtpRtcpPacketType packetType) = 0;
- virtual void OnPeriodicDeadOrAlive(const WebRtc_Word32 id,
+ virtual void OnPeriodicDeadOrAlive(const int32_t id,
const RTPAliveType alive) = 0;
- virtual void OnIncomingSSRCChanged( const WebRtc_Word32 id,
- const WebRtc_UWord32 SSRC) = 0;
+ virtual void OnIncomingSSRCChanged( const int32_t id,
+ const uint32_t SSRC) = 0;
- virtual void OnIncomingCSRCChanged( const WebRtc_Word32 id,
- const WebRtc_UWord32 CSRC,
+ virtual void OnIncomingCSRCChanged( const int32_t id,
+ const uint32_t CSRC,
const bool added) = 0;
protected:
@@ -214,10 +214,10 @@
class RtpAudioFeedback {
public:
- virtual void OnPlayTelephoneEvent(const WebRtc_Word32 id,
- const WebRtc_UWord8 event,
- const WebRtc_UWord16 lengthMs,
- const WebRtc_UWord8 volume) = 0;
+ virtual void OnPlayTelephoneEvent(const int32_t id,
+ const uint8_t event,
+ const uint16_t lengthMs,
+ const uint8_t volume) = 0;
protected:
virtual ~RtpAudioFeedback() {}
};
@@ -264,29 +264,29 @@
public:
virtual ~NullRtpFeedback() {}
- virtual WebRtc_Word32 OnInitializeDecoder(
- const WebRtc_Word32 id,
- const WebRtc_Word8 payloadType,
+ virtual int32_t OnInitializeDecoder(
+ const int32_t id,
+ const int8_t payloadType,
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) {
+ const uint8_t channels,
+ const uint32_t rate) {
return 0;
}
- virtual void OnPacketTimeout(const WebRtc_Word32 id) {}
+ virtual void OnPacketTimeout(const int32_t id) {}
- virtual void OnReceivedPacket(const WebRtc_Word32 id,
+ virtual void OnReceivedPacket(const int32_t id,
const RtpRtcpPacketType packetType) {}
- virtual void OnPeriodicDeadOrAlive(const WebRtc_Word32 id,
+ virtual void OnPeriodicDeadOrAlive(const int32_t id,
const RTPAliveType alive) {}
- virtual void OnIncomingSSRCChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 SSRC) {}
+ virtual void OnIncomingSSRCChanged(const int32_t id,
+ const uint32_t SSRC) {}
- virtual void OnIncomingCSRCChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 CSRC,
+ virtual void OnIncomingCSRCChanged(const int32_t id,
+ const uint32_t CSRC,
const bool added) {}
};
@@ -294,9 +294,9 @@
class NullRtpData : public RtpData {
public:
virtual ~NullRtpData() {}
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* payloadData,
+ const uint16_t payloadSize,
const WebRtcRTPHeader* rtpHeader) {
return 0;
}
@@ -307,10 +307,10 @@
public:
virtual ~NullRtpAudioFeedback() {}
- virtual void OnPlayTelephoneEvent(const WebRtc_Word32 id,
- const WebRtc_UWord8 event,
- const WebRtc_UWord16 lengthMs,
- const WebRtc_UWord8 volume) {}
+ virtual void OnPlayTelephoneEvent(const int32_t id,
+ const uint8_t event,
+ const uint16_t lengthMs,
+ const uint8_t volume) {}
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
index 53670f9..76cc316 100644
--- a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
@@ -22,137 +22,137 @@
class MockRtpRtcp : public RtpRtcp {
public:
MOCK_METHOD1(ChangeUniqueId,
- WebRtc_Word32(const WebRtc_Word32 id));
+ int32_t(const int32_t id));
MOCK_METHOD1(RegisterDefaultModule,
- WebRtc_Word32(RtpRtcp* module));
+ int32_t(RtpRtcp* module));
MOCK_METHOD0(DeRegisterDefaultModule,
- WebRtc_Word32());
+ int32_t());
MOCK_METHOD0(DefaultModuleRegistered,
bool());
MOCK_METHOD0(NumberChildModules,
- WebRtc_UWord32());
+ uint32_t());
MOCK_METHOD1(RegisterSyncModule,
- WebRtc_Word32(RtpRtcp* module));
+ int32_t(RtpRtcp* module));
MOCK_METHOD0(DeRegisterSyncModule,
- WebRtc_Word32());
+ int32_t());
MOCK_METHOD0(InitReceiver,
- WebRtc_Word32());
+ int32_t());
MOCK_METHOD1(RegisterIncomingDataCallback,
- WebRtc_Word32(RtpData* incomingDataCallback));
+ int32_t(RtpData* incomingDataCallback));
MOCK_METHOD1(RegisterIncomingRTPCallback,
- WebRtc_Word32(RtpFeedback* incomingMessagesCallback));
+ int32_t(RtpFeedback* incomingMessagesCallback));
MOCK_METHOD2(SetPacketTimeout,
- WebRtc_Word32(const WebRtc_UWord32 RTPtimeoutMS, const WebRtc_UWord32 RTCPtimeoutMS));
+ int32_t(const uint32_t RTPtimeoutMS, const uint32_t RTCPtimeoutMS));
MOCK_METHOD2(SetPeriodicDeadOrAliveStatus,
- WebRtc_Word32(const bool enable, const WebRtc_UWord8 sampleTimeSeconds));
+ int32_t(const bool enable, const uint8_t sampleTimeSeconds));
MOCK_METHOD2(PeriodicDeadOrAliveStatus,
- WebRtc_Word32(bool &enable, WebRtc_UWord8 &sampleTimeSeconds));
+ int32_t(bool &enable, uint8_t &sampleTimeSeconds));
MOCK_METHOD1(RegisterReceivePayload,
- WebRtc_Word32(const CodecInst& voiceCodec));
+ int32_t(const CodecInst& voiceCodec));
MOCK_METHOD1(RegisterReceivePayload,
- WebRtc_Word32(const VideoCodec& videoCodec));
+ int32_t(const VideoCodec& videoCodec));
MOCK_METHOD2(ReceivePayloadType,
- WebRtc_Word32(const CodecInst& voiceCodec, WebRtc_Word8* plType));
+ int32_t(const CodecInst& voiceCodec, int8_t* plType));
MOCK_METHOD2(ReceivePayloadType,
- WebRtc_Word32(const VideoCodec& videoCodec, WebRtc_Word8* plType));
+ int32_t(const VideoCodec& videoCodec, int8_t* plType));
MOCK_METHOD1(DeRegisterReceivePayload,
- WebRtc_Word32(const WebRtc_Word8 payloadType));
+ int32_t(const int8_t payloadType));
MOCK_METHOD2(RegisterReceiveRtpHeaderExtension,
- WebRtc_Word32(const RTPExtensionType type, const WebRtc_UWord8 id));
+ int32_t(const RTPExtensionType type, const uint8_t id));
MOCK_METHOD1(DeregisterReceiveRtpHeaderExtension,
- WebRtc_Word32(const RTPExtensionType type));
+ int32_t(const RTPExtensionType type));
MOCK_CONST_METHOD0(RemoteTimestamp,
- WebRtc_UWord32());
+ uint32_t());
MOCK_CONST_METHOD0(LocalTimeOfRemoteTimeStamp,
int64_t());
MOCK_CONST_METHOD1(EstimatedRemoteTimeStamp,
- WebRtc_Word32(WebRtc_UWord32& timestamp));
+ int32_t(uint32_t& timestamp));
MOCK_CONST_METHOD0(RemoteSSRC,
- WebRtc_UWord32());
+ uint32_t());
MOCK_CONST_METHOD1(RemoteCSRCs,
- WebRtc_Word32(WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]));
+ int32_t(uint32_t arrOfCSRC[kRtpCsrcSize]));
MOCK_CONST_METHOD1(SSRCFilter,
- WebRtc_Word32(WebRtc_UWord32& allowedSSRC));
+ int32_t(uint32_t& allowedSSRC));
MOCK_METHOD2(SetSSRCFilter,
- WebRtc_Word32(const bool enable, const WebRtc_UWord32 allowedSSRC));
+ int32_t(const bool enable, const uint32_t allowedSSRC));
MOCK_METHOD2(SetRTXReceiveStatus,
- WebRtc_Word32(const bool enable, const WebRtc_UWord32 SSRC));
+ int32_t(const bool enable, const uint32_t SSRC));
MOCK_CONST_METHOD2(RTXReceiveStatus,
- WebRtc_Word32(bool* enable, WebRtc_UWord32* SSRC));
+ int32_t(bool* enable, uint32_t* SSRC));
MOCK_METHOD2(IncomingPacket,
- WebRtc_Word32(const WebRtc_UWord8* incomingPacket, const WebRtc_UWord16 packetLength));
+ int32_t(const uint8_t* incomingPacket, const uint16_t packetLength));
MOCK_METHOD4(IncomingAudioNTP,
- WebRtc_Word32(const WebRtc_UWord32 audioReceivedNTPsecs,
- const WebRtc_UWord32 audioReceivedNTPfrac,
- const WebRtc_UWord32 audioRTCPArrivalTimeSecs,
- const WebRtc_UWord32 audioRTCPArrivalTimeFrac));
+ int32_t(const uint32_t audioReceivedNTPsecs,
+ const uint32_t audioReceivedNTPfrac,
+ const uint32_t audioRTCPArrivalTimeSecs,
+ const uint32_t audioRTCPArrivalTimeFrac));
MOCK_METHOD0(InitSender,
- WebRtc_Word32());
+ int32_t());
MOCK_METHOD1(RegisterSendTransport,
- WebRtc_Word32(Transport* outgoingTransport));
+ int32_t(Transport* outgoingTransport));
MOCK_METHOD1(SetMaxTransferUnit,
- WebRtc_Word32(const WebRtc_UWord16 size));
+ int32_t(const uint16_t size));
MOCK_METHOD3(SetTransportOverhead,
- WebRtc_Word32(const bool TCP, const bool IPV6,
- const WebRtc_UWord8 authenticationOverhead));
+ int32_t(const bool TCP, const bool IPV6,
+ const uint8_t authenticationOverhead));
MOCK_CONST_METHOD0(MaxPayloadLength,
- WebRtc_UWord16());
+ uint16_t());
MOCK_CONST_METHOD0(MaxDataPayloadLength,
- WebRtc_UWord16());
+ uint16_t());
MOCK_METHOD1(RegisterSendPayload,
- WebRtc_Word32(const CodecInst& voiceCodec));
+ int32_t(const CodecInst& voiceCodec));
MOCK_METHOD1(RegisterSendPayload,
- WebRtc_Word32(const VideoCodec& videoCodec));
+ int32_t(const VideoCodec& videoCodec));
MOCK_METHOD1(DeRegisterSendPayload,
- WebRtc_Word32(const WebRtc_Word8 payloadType));
+ int32_t(const int8_t payloadType));
MOCK_METHOD2(RegisterSendRtpHeaderExtension,
- WebRtc_Word32(const RTPExtensionType type, const WebRtc_UWord8 id));
+ int32_t(const RTPExtensionType type, const uint8_t id));
MOCK_METHOD1(DeregisterSendRtpHeaderExtension,
- WebRtc_Word32(const RTPExtensionType type));
+ int32_t(const RTPExtensionType type));
MOCK_CONST_METHOD0(StartTimestamp,
- WebRtc_UWord32());
+ uint32_t());
MOCK_METHOD1(SetStartTimestamp,
- WebRtc_Word32(const WebRtc_UWord32 timestamp));
+ int32_t(const uint32_t timestamp));
MOCK_CONST_METHOD0(SequenceNumber,
- WebRtc_UWord16());
+ uint16_t());
MOCK_METHOD1(SetSequenceNumber,
- WebRtc_Word32(const WebRtc_UWord16 seq));
+ int32_t(const uint16_t seq));
MOCK_CONST_METHOD0(SSRC,
- WebRtc_UWord32());
+ uint32_t());
MOCK_METHOD1(SetSSRC,
- WebRtc_Word32(const WebRtc_UWord32 ssrc));
+ int32_t(const uint32_t ssrc));
MOCK_CONST_METHOD1(CSRCs,
- WebRtc_Word32(WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]));
+ int32_t(uint32_t arrOfCSRC[kRtpCsrcSize]));
MOCK_METHOD2(SetCSRCs,
- WebRtc_Word32(const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize], const WebRtc_UWord8 arrLength));
+ int32_t(const uint32_t arrOfCSRC[kRtpCsrcSize], const uint8_t arrLength));
MOCK_METHOD1(SetCSRCStatus,
- WebRtc_Word32(const bool include));
+ int32_t(const bool include));
MOCK_METHOD3(SetRTXSendStatus,
- WebRtc_Word32(const RtxMode mode, const bool setSSRC,
- const WebRtc_UWord32 SSRC));
+ int32_t(const RtxMode mode, const bool setSSRC,
+ const uint32_t SSRC));
MOCK_CONST_METHOD2(RTXSendStatus,
- WebRtc_Word32(RtxMode* mode, WebRtc_UWord32* SSRC));
+ int32_t(RtxMode* mode, uint32_t* SSRC));
MOCK_METHOD1(SetSendingStatus,
- WebRtc_Word32(const bool sending));
+ int32_t(const bool sending));
MOCK_CONST_METHOD0(Sending,
bool());
MOCK_METHOD1(SetSendingMediaStatus,
- WebRtc_Word32(const bool sending));
+ int32_t(const bool sending));
MOCK_CONST_METHOD0(SendingMedia,
bool());
MOCK_CONST_METHOD4(BitrateSent,
- void(WebRtc_UWord32* totalRate, WebRtc_UWord32* videoRate, WebRtc_UWord32* fecRate, WebRtc_UWord32* nackRate));
+ void(uint32_t* totalRate, uint32_t* videoRate, uint32_t* fecRate, uint32_t* nackRate));
MOCK_CONST_METHOD1(EstimatedReceiveBandwidth,
- int(WebRtc_UWord32* available_bandwidth));
+ int(uint32_t* available_bandwidth));
MOCK_METHOD8(SendOutgoingData,
- WebRtc_Word32(const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 timeStamp,
- int64_t capture_time_ms,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
- const RTPFragmentationHeader* fragmentation,
- const RTPVideoHeader* rtpVideoHdr));
+ int32_t(const FrameType frameType,
+ const int8_t payloadType,
+ const uint32_t timeStamp,
+ int64_t capture_time_ms,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
+ const RTPFragmentationHeader* fragmentation,
+ const RTPVideoHeader* rtpVideoHdr));
MOCK_METHOD3(TimeToSendPacket,
void(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms));
MOCK_METHOD3(RegisterRtcpObservers,
@@ -162,124 +162,124 @@
MOCK_CONST_METHOD0(RTCP,
RTCPMethod());
MOCK_METHOD1(SetRTCPStatus,
- WebRtc_Word32(const RTCPMethod method));
+ int32_t(const RTCPMethod method));
MOCK_METHOD1(SetCNAME,
- WebRtc_Word32(const char cName[RTCP_CNAME_SIZE]));
+ int32_t(const char cName[RTCP_CNAME_SIZE]));
MOCK_METHOD1(CNAME,
- WebRtc_Word32(char cName[RTCP_CNAME_SIZE]));
+ int32_t(char cName[RTCP_CNAME_SIZE]));
MOCK_CONST_METHOD2(RemoteCNAME,
- WebRtc_Word32(const WebRtc_UWord32 remoteSSRC,
- char cName[RTCP_CNAME_SIZE]));
+ int32_t(const uint32_t remoteSSRC,
+ char cName[RTCP_CNAME_SIZE]));
MOCK_CONST_METHOD5(RemoteNTP,
- WebRtc_Word32(WebRtc_UWord32 *ReceivedNTPsecs,
- WebRtc_UWord32 *ReceivedNTPfrac,
- WebRtc_UWord32 *RTCPArrivalTimeSecs,
- WebRtc_UWord32 *RTCPArrivalTimeFrac,
- WebRtc_UWord32 *rtcp_timestamp));
+ int32_t(uint32_t *ReceivedNTPsecs,
+ uint32_t *ReceivedNTPfrac,
+ uint32_t *RTCPArrivalTimeSecs,
+ uint32_t *RTCPArrivalTimeFrac,
+ uint32_t *rtcp_timestamp));
MOCK_METHOD2(AddMixedCNAME,
- WebRtc_Word32(const WebRtc_UWord32 SSRC,
- const char cName[RTCP_CNAME_SIZE]));
+ int32_t(const uint32_t SSRC,
+ const char cName[RTCP_CNAME_SIZE]));
MOCK_METHOD1(RemoveMixedCNAME,
- WebRtc_Word32(const WebRtc_UWord32 SSRC));
+ int32_t(const uint32_t SSRC));
MOCK_CONST_METHOD5(RTT,
- WebRtc_Word32(const WebRtc_UWord32 remoteSSRC, WebRtc_UWord16* RTT, WebRtc_UWord16* avgRTT, WebRtc_UWord16* minRTT, WebRtc_UWord16* maxRTT));
+ int32_t(const uint32_t remoteSSRC, uint16_t* RTT, uint16_t* avgRTT, uint16_t* minRTT, uint16_t* maxRTT));
MOCK_METHOD1(ResetRTT,
- WebRtc_Word32(const WebRtc_UWord32 remoteSSRC));
+ int32_t(const uint32_t remoteSSRC));
MOCK_METHOD1(SetRtt, void(uint32_t rtt));
MOCK_METHOD1(SendRTCP,
- WebRtc_Word32(WebRtc_UWord32 rtcpPacketType));
+ int32_t(uint32_t rtcpPacketType));
MOCK_METHOD1(SendRTCPReferencePictureSelection,
- WebRtc_Word32(const WebRtc_UWord64 pictureID));
+ int32_t(const uint64_t pictureID));
MOCK_METHOD1(SendRTCPSliceLossIndication,
- WebRtc_Word32(const WebRtc_UWord8 pictureID));
+ int32_t(const uint8_t pictureID));
MOCK_METHOD0(ResetStatisticsRTP,
- WebRtc_Word32());
+ int32_t());
MOCK_CONST_METHOD5(StatisticsRTP,
- WebRtc_Word32(WebRtc_UWord8 *fraction_lost, WebRtc_UWord32 *cum_lost, WebRtc_UWord32 *ext_max, WebRtc_UWord32 *jitter, WebRtc_UWord32 *max_jitter));
+ int32_t(uint8_t *fraction_lost, uint32_t *cum_lost, uint32_t *ext_max, uint32_t *jitter, uint32_t *max_jitter));
MOCK_METHOD0(ResetReceiveDataCountersRTP,
- WebRtc_Word32());
+ int32_t());
MOCK_METHOD0(ResetSendDataCountersRTP,
- WebRtc_Word32());
+ int32_t());
MOCK_CONST_METHOD4(DataCountersRTP,
- WebRtc_Word32(WebRtc_UWord32 *bytesSent, WebRtc_UWord32 *packetsSent, WebRtc_UWord32 *bytesReceived, WebRtc_UWord32 *packetsReceived));
+ int32_t(uint32_t *bytesSent, uint32_t *packetsSent, uint32_t *bytesReceived, uint32_t *packetsReceived));
MOCK_METHOD1(RemoteRTCPStat,
- WebRtc_Word32(RTCPSenderInfo* senderInfo));
+ int32_t(RTCPSenderInfo* senderInfo));
MOCK_CONST_METHOD1(RemoteRTCPStat,
- WebRtc_Word32(std::vector<RTCPReportBlock>* receiveBlocks));
+ int32_t(std::vector<RTCPReportBlock>* receiveBlocks));
MOCK_METHOD2(AddRTCPReportBlock,
- WebRtc_Word32(const WebRtc_UWord32 SSRC, const RTCPReportBlock* receiveBlock));
+ int32_t(const uint32_t SSRC, const RTCPReportBlock* receiveBlock));
MOCK_METHOD1(RemoveRTCPReportBlock,
- WebRtc_Word32(const WebRtc_UWord32 SSRC));
+ int32_t(const uint32_t SSRC));
MOCK_METHOD4(SetRTCPApplicationSpecificData,
- WebRtc_Word32(const WebRtc_UWord8 subType, const WebRtc_UWord32 name, const WebRtc_UWord8* data, const WebRtc_UWord16 length));
+ int32_t(const uint8_t subType, const uint32_t name, const uint8_t* data, const uint16_t length));
MOCK_METHOD1(SetRTCPVoIPMetrics,
- WebRtc_Word32(const RTCPVoIPMetric* VoIPMetric));
+ int32_t(const RTCPVoIPMetric* VoIPMetric));
MOCK_CONST_METHOD0(REMB,
bool());
MOCK_METHOD1(SetREMBStatus,
- WebRtc_Word32(const bool enable));
+ int32_t(const bool enable));
MOCK_METHOD3(SetREMBData,
- WebRtc_Word32(const WebRtc_UWord32 bitrate, const WebRtc_UWord8 numberOfSSRC, const WebRtc_UWord32* SSRC));
+ int32_t(const uint32_t bitrate, const uint8_t numberOfSSRC, const uint32_t* SSRC));
MOCK_METHOD1(SetRemoteBitrateObserver,
bool(RemoteBitrateObserver*));
MOCK_CONST_METHOD0(IJ,
bool());
MOCK_METHOD1(SetIJStatus,
- WebRtc_Word32(const bool));
+ int32_t(const bool));
MOCK_CONST_METHOD0(TMMBR,
bool());
MOCK_METHOD1(SetTMMBRStatus,
- WebRtc_Word32(const bool enable));
+ int32_t(const bool enable));
MOCK_METHOD1(OnBandwidthEstimateUpdate,
- void(WebRtc_UWord16 bandWidthKbit));
+ void(uint16_t bandWidthKbit));
MOCK_CONST_METHOD0(NACK,
NACKMethod());
MOCK_METHOD2(SetNACKStatus,
- WebRtc_Word32(const NACKMethod method, int oldestSequenceNumberToNack));
+ int32_t(const NACKMethod method, int oldestSequenceNumberToNack));
MOCK_CONST_METHOD0(SelectiveRetransmissions,
int());
MOCK_METHOD1(SetSelectiveRetransmissions,
int(uint8_t settings));
MOCK_METHOD2(SendNACK,
- WebRtc_Word32(const WebRtc_UWord16* nackList, const WebRtc_UWord16 size));
+ int32_t(const uint16_t* nackList, const uint16_t size));
MOCK_METHOD2(SetStorePacketsStatus,
- WebRtc_Word32(const bool enable, const WebRtc_UWord16 numberToStore));
+ int32_t(const bool enable, const uint16_t numberToStore));
MOCK_METHOD1(RegisterAudioCallback,
- WebRtc_Word32(RtpAudioFeedback* messagesCallback));
+ int32_t(RtpAudioFeedback* messagesCallback));
MOCK_METHOD1(SetAudioPacketSize,
- WebRtc_Word32(const WebRtc_UWord16 packetSizeSamples));
+ int32_t(const uint16_t packetSizeSamples));
MOCK_METHOD1(SetTelephoneEventForwardToDecoder, int(bool forwardToDecoder));
MOCK_CONST_METHOD0(TelephoneEventForwardToDecoder,
bool());
MOCK_CONST_METHOD1(SendTelephoneEventActive,
- bool(WebRtc_Word8& telephoneEvent));
+ bool(int8_t& telephoneEvent));
MOCK_METHOD3(SendTelephoneEventOutband,
- WebRtc_Word32(const WebRtc_UWord8 key, const WebRtc_UWord16 time_ms, const WebRtc_UWord8 level));
+ int32_t(const uint8_t key, const uint16_t time_ms, const uint8_t level));
MOCK_METHOD1(SetSendREDPayloadType,
- WebRtc_Word32(const WebRtc_Word8 payloadType));
+ int32_t(const int8_t payloadType));
MOCK_CONST_METHOD1(SendREDPayloadType,
- WebRtc_Word32(WebRtc_Word8& payloadType));
+ int32_t(int8_t& payloadType));
MOCK_METHOD2(SetRTPAudioLevelIndicationStatus,
- WebRtc_Word32(const bool enable, const WebRtc_UWord8 ID));
+ int32_t(const bool enable, const uint8_t ID));
MOCK_CONST_METHOD2(GetRTPAudioLevelIndicationStatus,
- WebRtc_Word32(bool& enable, WebRtc_UWord8& ID));
+ int32_t(bool& enable, uint8_t& ID));
MOCK_METHOD1(SetAudioLevel,
- WebRtc_Word32(const WebRtc_UWord8 level_dBov));
+ int32_t(const uint8_t level_dBov));
MOCK_METHOD1(SetCameraDelay,
- WebRtc_Word32(const WebRtc_Word32 delayMS));
+ int32_t(const int32_t delayMS));
MOCK_METHOD1(SetTargetSendBitrate,
- void(const WebRtc_UWord32 bitrate));
+ void(const uint32_t bitrate));
MOCK_METHOD3(SetGenericFECStatus,
- WebRtc_Word32(const bool enable, const WebRtc_UWord8 payloadTypeRED, const WebRtc_UWord8 payloadTypeFEC));
+ int32_t(const bool enable, const uint8_t payloadTypeRED, const uint8_t payloadTypeFEC));
MOCK_METHOD3(GenericFECStatus,
- WebRtc_Word32(bool& enable, WebRtc_UWord8& payloadTypeRED, WebRtc_UWord8& payloadTypeFEC));
+ int32_t(bool& enable, uint8_t& payloadTypeRED, uint8_t& payloadTypeFEC));
MOCK_METHOD2(SetFecParameters,
- WebRtc_Word32(const FecProtectionParams* delta_params,
- const FecProtectionParams* key_params));
+ int32_t(const FecProtectionParams* delta_params,
+ const FecProtectionParams* key_params));
MOCK_METHOD1(SetKeyFrameRequestMethod,
- WebRtc_Word32(const KeyFrameRequestMethod method));
+ int32_t(const KeyFrameRequestMethod method));
MOCK_METHOD0(RequestKeyFrame,
- WebRtc_Word32());
+ int32_t());
MOCK_CONST_METHOD3(Version,
int32_t(char* version, uint32_t& remaining_buffer_in_bytes, uint32_t& position));
MOCK_METHOD0(TimeUntilNextProcess,
diff --git a/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.cc b/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.cc
index 05b7e2f..7909f88 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.cc
+++ b/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.cc
@@ -13,7 +13,7 @@
#include <string.h>
namespace webrtc {
-BitstreamBuilder::BitstreamBuilder(WebRtc_UWord8* data, const WebRtc_UWord32 dataSize) :
+BitstreamBuilder::BitstreamBuilder(uint8_t* data, const uint32_t dataSize) :
_data(data),
_dataSize(dataSize),
_byteOffset(0),
@@ -22,14 +22,14 @@
memset(data, 0, dataSize);
}
-WebRtc_UWord32
+uint32_t
BitstreamBuilder::Length() const
{
return _byteOffset+ (_bitOffset?1:0);
}
-WebRtc_Word32
-BitstreamBuilder::Add1Bit(const WebRtc_UWord8 bit)
+int32_t
+BitstreamBuilder::Add1Bit(const uint8_t bit)
{
// sanity
if(_bitOffset + 1 > 8)
@@ -45,7 +45,7 @@
}
void
-BitstreamBuilder::Add1BitWithoutSanity(const WebRtc_UWord8 bit)
+BitstreamBuilder::Add1BitWithoutSanity(const uint8_t bit)
{
if(bit & 0x1)
{
@@ -63,8 +63,8 @@
}
}
-WebRtc_Word32
-BitstreamBuilder::Add2Bits(const WebRtc_UWord8 bits)
+int32_t
+BitstreamBuilder::Add2Bits(const uint8_t bits)
{
// sanity
if(_bitOffset + 2 > 8)
@@ -80,8 +80,8 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add3Bits(const WebRtc_UWord8 bits)
+int32_t
+BitstreamBuilder::Add3Bits(const uint8_t bits)
{
// sanity
if(_bitOffset + 3 > 8)
@@ -98,8 +98,8 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add4Bits(const WebRtc_UWord8 bits)
+int32_t
+BitstreamBuilder::Add4Bits(const uint8_t bits)
{
// sanity
if(_bitOffset + 4 > 8)
@@ -117,8 +117,8 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add5Bits(const WebRtc_UWord8 bits)
+int32_t
+BitstreamBuilder::Add5Bits(const uint8_t bits)
{
// sanity
if(_bitOffset + 5 > 8)
@@ -137,8 +137,8 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add6Bits(const WebRtc_UWord8 bits)
+int32_t
+BitstreamBuilder::Add6Bits(const uint8_t bits)
{
// sanity
if(_bitOffset + 6 > 8)
@@ -158,8 +158,8 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add7Bits(const WebRtc_UWord8 bits)
+int32_t
+BitstreamBuilder::Add7Bits(const uint8_t bits)
{
// sanity
if(_bitOffset + 7 > 8)
@@ -180,8 +180,8 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add8Bits(const WebRtc_UWord8 bits)
+int32_t
+BitstreamBuilder::Add8Bits(const uint8_t bits)
{
// sanity
if(_dataSize < Length()+1)
@@ -201,8 +201,8 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add16Bits(const WebRtc_UWord16 bits)
+int32_t
+BitstreamBuilder::Add16Bits(const uint16_t bits)
{
// sanity
if(_dataSize < Length()+2)
@@ -212,20 +212,20 @@
}
if(_bitOffset == 0)
{
- _data[_byteOffset] = (WebRtc_UWord8)(bits >> 8);
- _data[_byteOffset+1] = (WebRtc_UWord8)(bits);
+ _data[_byteOffset] = (uint8_t)(bits >> 8);
+ _data[_byteOffset+1] = (uint8_t)(bits);
} else
{
- _data[_byteOffset] += (WebRtc_UWord8)(bits >> (_bitOffset + 8));
- _data[_byteOffset+1] += (WebRtc_UWord8)(bits >> _bitOffset);
- _data[_byteOffset+2] += (WebRtc_UWord8)(bits << (8-_bitOffset));
+ _data[_byteOffset] += (uint8_t)(bits >> (_bitOffset + 8));
+ _data[_byteOffset+1] += (uint8_t)(bits >> _bitOffset);
+ _data[_byteOffset+2] += (uint8_t)(bits << (8-_bitOffset));
}
_byteOffset += 2;
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add24Bits(const WebRtc_UWord32 bits)
+int32_t
+BitstreamBuilder::Add24Bits(const uint32_t bits)
{
// sanity
if(_dataSize < Length()+3)
@@ -235,22 +235,22 @@
}
if(_bitOffset == 0)
{
- _data[_byteOffset] = (WebRtc_UWord8)(bits >> 16);
- _data[_byteOffset+1] = (WebRtc_UWord8)(bits >> 8);
- _data[_byteOffset+2] = (WebRtc_UWord8)(bits);
+ _data[_byteOffset] = (uint8_t)(bits >> 16);
+ _data[_byteOffset+1] = (uint8_t)(bits >> 8);
+ _data[_byteOffset+2] = (uint8_t)(bits);
} else
{
- _data[_byteOffset] += (WebRtc_UWord8)(bits >> (_bitOffset+16));
- _data[_byteOffset+1] += (WebRtc_UWord8)(bits >> (_bitOffset+8));
- _data[_byteOffset+2] += (WebRtc_UWord8)(bits >> (_bitOffset));
- _data[_byteOffset+3] += (WebRtc_UWord8)(bits << (8-_bitOffset));
+ _data[_byteOffset] += (uint8_t)(bits >> (_bitOffset+16));
+ _data[_byteOffset+1] += (uint8_t)(bits >> (_bitOffset+8));
+ _data[_byteOffset+2] += (uint8_t)(bits >> (_bitOffset));
+ _data[_byteOffset+3] += (uint8_t)(bits << (8-_bitOffset));
}
_byteOffset += 3;
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::Add32Bits(const WebRtc_UWord32 bits)
+int32_t
+BitstreamBuilder::Add32Bits(const uint32_t bits)
{
// sanity
if(_dataSize < Length()+4)
@@ -260,17 +260,17 @@
}
if(_bitOffset == 0)
{
- _data[_byteOffset] = (WebRtc_UWord8)(bits >> 24);
- _data[_byteOffset+1] = (WebRtc_UWord8)(bits >> 16);
- _data[_byteOffset+2] = (WebRtc_UWord8)(bits >> 8);
- _data[_byteOffset+3] = (WebRtc_UWord8)(bits);
+ _data[_byteOffset] = (uint8_t)(bits >> 24);
+ _data[_byteOffset+1] = (uint8_t)(bits >> 16);
+ _data[_byteOffset+2] = (uint8_t)(bits >> 8);
+ _data[_byteOffset+3] = (uint8_t)(bits);
} else
{
- _data[_byteOffset] += (WebRtc_UWord8)(bits >> (_bitOffset+24));
- _data[_byteOffset+1] += (WebRtc_UWord8)(bits >> (_bitOffset+16));
- _data[_byteOffset+2] += (WebRtc_UWord8)(bits >> (_bitOffset+8));
- _data[_byteOffset+3] += (WebRtc_UWord8)(bits >> (_bitOffset));
- _data[_byteOffset+4] += (WebRtc_UWord8)(bits << (8-_bitOffset));
+ _data[_byteOffset] += (uint8_t)(bits >> (_bitOffset+24));
+ _data[_byteOffset+1] += (uint8_t)(bits >> (_bitOffset+16));
+ _data[_byteOffset+2] += (uint8_t)(bits >> (_bitOffset+8));
+ _data[_byteOffset+3] += (uint8_t)(bits >> (_bitOffset));
+ _data[_byteOffset+4] += (uint8_t)(bits << (8-_bitOffset));
}
_byteOffset += 4;
return 0;
@@ -287,8 +287,8 @@
0 0 0 0 1 x3 x2 x1 x0 15..30
0 0 0 0 0 1 x4 x3 x2 x1 x0 31..62
*/
-WebRtc_Word32
-BitstreamBuilder::AddUE(const WebRtc_UWord32 value)
+int32_t
+BitstreamBuilder::AddUE(const uint32_t value)
{
// un-rolled on 8 bit base to avoid too deep if else chain
if(value < 0x0000ffff)
@@ -543,18 +543,18 @@
return 0;
}
-WebRtc_Word32
-BitstreamBuilder::AddPrefix(const WebRtc_UWord8 numZeros)
+int32_t
+BitstreamBuilder::AddPrefix(const uint8_t numZeros)
{
// sanity for the sufix too
- WebRtc_UWord32 numBitsToAdd = numZeros * 2 + 1;
+ uint32_t numBitsToAdd = numZeros * 2 + 1;
if(((_dataSize - _byteOffset) *8 + 8-_bitOffset) < numBitsToAdd)
{
return -1;
}
// add numZeros
- for (WebRtc_UWord32 i = 0; i < numZeros; i++)
+ for (uint32_t i = 0; i < numZeros; i++)
{
Add1Bit(0);
}
@@ -563,10 +563,10 @@
}
void
-BitstreamBuilder::AddSuffix(const WebRtc_UWord8 numBits, const WebRtc_UWord32 rest)
+BitstreamBuilder::AddSuffix(const uint8_t numBits, const uint32_t rest)
{
// most significant bit first
- for(WebRtc_Word32 i = numBits - 1; i >= 0; i--)
+ for(int32_t i = numBits - 1; i >= 0; i--)
{
if(( rest >> i) & 0x1)
{
diff --git a/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.h b/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.h
index c88ef8f..edfe677 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.h
+++ b/webrtc/modules/rtp_rtcp/source/H264/bitstream_builder.h
@@ -17,35 +17,35 @@
class BitstreamBuilder
{
public:
- BitstreamBuilder(WebRtc_UWord8* data, const WebRtc_UWord32 dataSize);
+ BitstreamBuilder(uint8_t* data, const uint32_t dataSize);
- WebRtc_UWord32 Length() const;
+ uint32_t Length() const;
- WebRtc_Word32 Add1Bit(const WebRtc_UWord8 bit);
- WebRtc_Word32 Add2Bits(const WebRtc_UWord8 bits);
- WebRtc_Word32 Add3Bits(const WebRtc_UWord8 bits);
- WebRtc_Word32 Add4Bits(const WebRtc_UWord8 bits);
- WebRtc_Word32 Add5Bits(const WebRtc_UWord8 bits);
- WebRtc_Word32 Add6Bits(const WebRtc_UWord8 bits);
- WebRtc_Word32 Add7Bits(const WebRtc_UWord8 bits);
- WebRtc_Word32 Add8Bits(const WebRtc_UWord8 bits);
- WebRtc_Word32 Add16Bits(const WebRtc_UWord16 bits);
- WebRtc_Word32 Add24Bits(const WebRtc_UWord32 bits);
- WebRtc_Word32 Add32Bits(const WebRtc_UWord32 bits);
+ int32_t Add1Bit(const uint8_t bit);
+ int32_t Add2Bits(const uint8_t bits);
+ int32_t Add3Bits(const uint8_t bits);
+ int32_t Add4Bits(const uint8_t bits);
+ int32_t Add5Bits(const uint8_t bits);
+ int32_t Add6Bits(const uint8_t bits);
+ int32_t Add7Bits(const uint8_t bits);
+ int32_t Add8Bits(const uint8_t bits);
+ int32_t Add16Bits(const uint16_t bits);
+ int32_t Add24Bits(const uint32_t bits);
+ int32_t Add32Bits(const uint32_t bits);
// Exp-Golomb codes
- WebRtc_Word32 AddUE(const WebRtc_UWord32 value);
+ int32_t AddUE(const uint32_t value);
private:
- WebRtc_Word32 AddPrefix(const WebRtc_UWord8 numZeros);
- void AddSuffix(const WebRtc_UWord8 numBits, const WebRtc_UWord32 rest);
- void Add1BitWithoutSanity(const WebRtc_UWord8 bit);
+ int32_t AddPrefix(const uint8_t numZeros);
+ void AddSuffix(const uint8_t numBits, const uint32_t rest);
+ void Add1BitWithoutSanity(const uint8_t bit);
- WebRtc_UWord8* _data;
- WebRtc_UWord32 _dataSize;
+ uint8_t* _data;
+ uint32_t _dataSize;
- WebRtc_UWord32 _byteOffset;
- WebRtc_UWord8 _bitOffset;
+ uint32_t _byteOffset;
+ uint8_t _bitOffset;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.cc b/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.cc
index 79ec967..43b1398 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.cc
+++ b/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.cc
@@ -11,7 +11,7 @@
#include "bitstream_parser.h"
namespace webrtc {
-BitstreamParser::BitstreamParser(const WebRtc_UWord8* data, const WebRtc_UWord32 dataLength) :
+BitstreamParser::BitstreamParser(const uint8_t* data, const uint32_t dataLength) :
_data(data),
_dataLength(dataLength),
_byteOffset(0),
@@ -20,10 +20,10 @@
}
// todo should we have any error codes from this?
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get1Bit()
{
- WebRtc_UWord8 retVal = 0x1 & (_data[_byteOffset] >> (7-_bitOffset++));
+ uint8_t retVal = 0x1 & (_data[_byteOffset] >> (7-_bitOffset++));
// prepare next byte
if(_bitOffset == 8)
@@ -34,37 +34,37 @@
return retVal;
}
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get2Bits()
{
- WebRtc_UWord8 retVal = (Get1Bit() << 1);
+ uint8_t retVal = (Get1Bit() << 1);
retVal += Get1Bit();
return retVal;
}
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get3Bits()
{
- WebRtc_UWord8 retVal = (Get1Bit() << 2);
+ uint8_t retVal = (Get1Bit() << 2);
retVal += (Get1Bit() << 1);
retVal += Get1Bit();
return retVal;
}
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get4Bits()
{
- WebRtc_UWord8 retVal = (Get1Bit() << 3);
+ uint8_t retVal = (Get1Bit() << 3);
retVal += (Get1Bit() << 2);
retVal += (Get1Bit() << 1);
retVal += Get1Bit();
return retVal;
}
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get5Bits()
{
- WebRtc_UWord8 retVal = (Get1Bit() << 4);
+ uint8_t retVal = (Get1Bit() << 4);
retVal += (Get1Bit() << 3);
retVal += (Get1Bit() << 2);
retVal += (Get1Bit() << 1);
@@ -72,10 +72,10 @@
return retVal;
}
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get6Bits()
{
- WebRtc_UWord8 retVal = (Get1Bit() << 5);
+ uint8_t retVal = (Get1Bit() << 5);
retVal += (Get1Bit() << 4);
retVal += (Get1Bit() << 3);
retVal += (Get1Bit() << 2);
@@ -84,10 +84,10 @@
return retVal;
}
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get7Bits()
{
- WebRtc_UWord8 retVal = (Get1Bit() << 6);
+ uint8_t retVal = (Get1Bit() << 6);
retVal += (Get1Bit() << 5);
retVal += (Get1Bit() << 4);
retVal += (Get1Bit() << 3);
@@ -97,10 +97,10 @@
return retVal;
}
-WebRtc_UWord8
+uint8_t
BitstreamParser::Get8Bits()
{
- WebRtc_UWord16 retVal;
+ uint16_t retVal;
if(_bitOffset != 0)
{
@@ -112,13 +112,13 @@
retVal = _data[_byteOffset];
}
_byteOffset++;
- return (WebRtc_UWord8)retVal;
+ return (uint8_t)retVal;
}
-WebRtc_UWord16
+uint16_t
BitstreamParser::Get16Bits()
{
- WebRtc_UWord32 retVal;
+ uint32_t retVal;
if(_bitOffset != 0)
{
@@ -131,13 +131,13 @@
retVal = (_data[_byteOffset] << 8) + (_data[_byteOffset+1]) ;
}
_byteOffset += 2;
- return (WebRtc_UWord16)retVal;
+ return (uint16_t)retVal;
}
-WebRtc_UWord32
+uint32_t
BitstreamParser::Get24Bits()
{
- WebRtc_UWord32 retVal;
+ uint32_t retVal;
if(_bitOffset != 0)
{
@@ -153,15 +153,15 @@
return retVal & 0x00ffffff; // we need to clean up the high 8 bits
}
-WebRtc_UWord32
+uint32_t
BitstreamParser::Get32Bits()
{
- WebRtc_UWord32 retVal;
+ uint32_t retVal;
if(_bitOffset != 0)
{
// read 40 bits
- WebRtc_UWord64 tempVal = _data[_byteOffset];
+ uint64_t tempVal = _data[_byteOffset];
tempVal <<= 8;
tempVal += _data[_byteOffset+1];
tempVal <<= 8;
@@ -172,7 +172,7 @@
tempVal += _data[_byteOffset+4];
tempVal >>= (8-_bitOffset);
- retVal = WebRtc_UWord32(tempVal);
+ retVal = uint32_t(tempVal);
}else
{
// read 32 bits
@@ -194,11 +194,11 @@
0 0 0 0 0 1 x4 x3 x2 x1 x0 31..62
*/
-WebRtc_UWord32
+uint32_t
BitstreamParser::GetUE()
{
- WebRtc_UWord32 retVal = 0;
- WebRtc_UWord8 numLeadingZeros = 0;
+ uint32_t retVal = 0;
+ uint8_t numLeadingZeros = 0;
while (Get1Bit() != 1)
{
diff --git a/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.h b/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.h
index 3d8f9ef..31c66c6 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.h
+++ b/webrtc/modules/rtp_rtcp/source/H264/bitstream_parser.h
@@ -17,29 +17,29 @@
class BitstreamParser
{
public:
- BitstreamParser(const WebRtc_UWord8* data, const WebRtc_UWord32 dataLength);
+ BitstreamParser(const uint8_t* data, const uint32_t dataLength);
- WebRtc_UWord8 Get1Bit();
- WebRtc_UWord8 Get2Bits();
- WebRtc_UWord8 Get3Bits();
- WebRtc_UWord8 Get4Bits();
- WebRtc_UWord8 Get5Bits();
- WebRtc_UWord8 Get6Bits();
- WebRtc_UWord8 Get7Bits();
- WebRtc_UWord8 Get8Bits();
- WebRtc_UWord16 Get16Bits();
- WebRtc_UWord32 Get24Bits();
- WebRtc_UWord32 Get32Bits();
+ uint8_t Get1Bit();
+ uint8_t Get2Bits();
+ uint8_t Get3Bits();
+ uint8_t Get4Bits();
+ uint8_t Get5Bits();
+ uint8_t Get6Bits();
+ uint8_t Get7Bits();
+ uint8_t Get8Bits();
+ uint16_t Get16Bits();
+ uint32_t Get24Bits();
+ uint32_t Get32Bits();
// Exp-Golomb codes
- WebRtc_UWord32 GetUE();
+ uint32_t GetUE();
private:
- const WebRtc_UWord8* _data;
- const WebRtc_UWord32 _dataLength;
+ const uint8_t* _data;
+ const uint32_t _dataLength;
- WebRtc_UWord32 _byteOffset;
- WebRtc_UWord8 _bitOffset;
+ uint32_t _byteOffset;
+ uint8_t _bitOffset;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/H264/h264_information.cc b/webrtc/modules/rtp_rtcp/source/H264/h264_information.cc
index cf6b549..e75ddf5 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/h264_information.cc
+++ b/webrtc/modules/rtp_rtcp/source/H264/h264_information.cc
@@ -18,9 +18,9 @@
#include <stdio.h>
#include <math.h>
- WebRtc_UWord32 BitRateBPS(WebRtc_UWord16 x )
+ uint32_t BitRateBPS(uint16_t x )
{
- return (x & 0x3fff) * WebRtc_UWord32(pow(10.0f,(2 + (x >> 14))));
+ return (x & 0x3fff) * uint32_t(pow(10.0f,(2 + (x >> 14))));
}
#endif
@@ -52,7 +52,7 @@
memset(_info.type, 0, sizeof(_info.type));
memset(_info.accLayerSize, 0, sizeof(_info.accLayerSize));
- for (WebRtc_Word32 i = 0; i < KMaxNumberOfNALUs; i++)
+ for (int32_t i = 0; i < KMaxNumberOfNALUs; i++)
{
_info.SVCheader[i].idr = 0;
_info.SVCheader[i].priorityID = 0;
@@ -81,8 +81,8 @@
}
/*******************************************************************************
- * WebRtc_Word32 GetInfo(const WebRtc_UWord8* ptrEncodedBuffer,
- * const WebRtc_UWord32 length,
+ * int32_t GetInfo(const uint8_t* ptrEncodedBuffer,
+ * const uint32_t length,
* const H264Info*& ptrInfo);
*
* Gets information from an encoded stream.
@@ -98,9 +98,9 @@
* - 0 : ok
* - (-1) : Error
*/
-WebRtc_Word32
-H264Information::GetInfo(const WebRtc_UWord8* ptrEncodedBuffer,
- const WebRtc_UWord32 length,
+int32_t
+H264Information::GetInfo(const uint8_t* ptrEncodedBuffer,
+ const uint32_t length,
const H264Info*& ptrInfo)
{
if (!ptrEncodedBuffer || length < 4)
@@ -132,7 +132,7 @@
/*******************************************************************************
- * bool HasInfo(const WebRtc_UWord32 length);
+ * bool HasInfo(const uint32_t length);
*
* Checks if information has already been stored for this encoded stream.
*
@@ -144,7 +144,7 @@
*/
bool
-H264Information::HasInfo(const WebRtc_UWord32 length)
+H264Information::HasInfo(const uint32_t length)
{
if (!_info.numNALUs)
{
@@ -162,8 +162,8 @@
}
/*******************************************************************************
- * WebRtc_Word32 FindInfo(const WebRtc_UWord8* ptrEncodedBuffer,
- * const WebRtc_UWord32 length);
+ * int32_t FindInfo(const uint8_t* ptrEncodedBuffer,
+ * const uint32_t length);
*
* Parses the encoded stream.
*
@@ -175,8 +175,8 @@
* - 0 : ok
* - (-1) : Error
*/
-WebRtc_Word32
-H264Information::FindInfo(const WebRtc_UWord8* ptrEncodedBuffer, const WebRtc_UWord32 length)
+int32_t
+H264Information::FindInfo(const uint8_t* ptrEncodedBuffer, const uint32_t length)
{
_ptrData = ptrEncodedBuffer;
_length = length;
@@ -193,7 +193,7 @@
}
// Get NAL unit payload size
- WebRtc_Word32 foundLast = FindNALU();
+ int32_t foundLast = FindNALU();
if (foundLast == -1)
{
Reset();
@@ -251,7 +251,7 @@
}
/*******************************************************************************
- * WebRtc_Word32 FindNALUStartCodeSize();
+ * int32_t FindNALUStartCodeSize();
*
* Finds the start code length of the current NAL unit.
*
@@ -262,15 +262,15 @@
* - 0 : ok
* - (-1) : Error
*/
-WebRtc_Word32
+int32_t
H264Information::FindNALUStartCodeSize()
{
// NAL unit start code. Ex. {0,0,1} or {0,0,0,1}
- for (WebRtc_UWord32 i = 2; i < _remLength; i++)
+ for (uint32_t i = 2; i < _remLength; i++)
{
if (_ptrData[i] == 1 && _ptrData[i - 1] == 0 && _ptrData[i - 2] == 0)
{
- _info.startCodeSize[_info.numNALUs] = WebRtc_UWord8(i + 1);
+ _info.startCodeSize[_info.numNALUs] = uint8_t(i + 1);
return 0;
}
}
@@ -278,7 +278,7 @@
}
/*******************************************************************************
- * WebRtc_Word32 FindNALU();
+ * int32_t FindNALU();
*
* Finds the length of the current NAL unit.
*
@@ -292,14 +292,14 @@
* - 0 : ok
* - (-1) : Error
*/
-WebRtc_Word32
+int32_t
H264Information::FindNALU()
{
- for (WebRtc_UWord32 i = _info.startCodeSize[_info.numNALUs]; i < _remLength - 2; i += 2)
+ for (uint32_t i = _info.startCodeSize[_info.numNALUs]; i < _remLength - 2; i += 2)
{
if (_ptrData[i] == 0)
{
- WebRtc_Word32 size = 0;
+ int32_t size = 0;
if ((_ptrData[i + 1] == 1 && _ptrData[i - 1] == 0) ||
(_ptrData[i + 2] == 1 && _ptrData[i + 1] == 0))
{
@@ -354,7 +354,7 @@
// in the same layer, or contains a parameter set.
- const WebRtc_UWord8 type = _ptrData[_info.startCodeSize[_info.numNALUs]] & 0x1f;
+ const uint8_t type = _ptrData[_info.startCodeSize[_info.numNALUs]] & 0x1f;
// NALU type of 5, 7 and 8 shoud have NRI to b011
if( type == 5 ||
@@ -370,7 +370,7 @@
/*******************************************************************************
- * WebRtc_Word32 FindNALUType();
+ * int32_t FindNALUType();
*
* Finds the type of the current NAL unit.
*
@@ -381,7 +381,7 @@
* - 0 : ok
* - (-1) : Error
*/
-WebRtc_Word32
+int32_t
H264Information::FindNALUType()
{
// NAL unit header (1 byte)
@@ -406,7 +406,7 @@
}
/*******************************************************************************
- * WebRtc_Word32 ParseSVCNALUHeader();
+ * int32_t ParseSVCNALUHeader();
*
* Finds the extended header of the current NAL unit. Included for NAL unit types 14 and 20.
*
@@ -417,7 +417,7 @@
* - 0 : ok
* - (-1) : Error
*/
-WebRtc_Word32
+int32_t
H264Information::ParseSVCNALUHeader()
{
if (_info.type[_info.numNALUs] == 5)
@@ -426,16 +426,16 @@
}
if (_info.type[_info.numNALUs] == 6)
{
- WebRtc_UWord32 seiPayloadSize;
+ uint32_t seiPayloadSize;
do
{
// SEI message
seiPayloadSize = 0;
- WebRtc_UWord32 curByte = _info.startCodeSize[_info.numNALUs] + 1;
- const WebRtc_UWord32 seiStartOffset = curByte;
+ uint32_t curByte = _info.startCodeSize[_info.numNALUs] + 1;
+ const uint32_t seiStartOffset = curByte;
- WebRtc_UWord32 seiPayloadType = 0;
+ uint32_t seiPayloadType = 0;
while(_ptrData[curByte] == 0xff)
{
seiPayloadType += 255;
@@ -466,27 +466,27 @@
{
_info.PACSI[0].seiMessageLength[0] = seiPayloadSize;
delete [] _info.PACSI[0].seiMessageData[0];
- _info.PACSI[0].seiMessageData[0] = new WebRtc_UWord8[seiPayloadSize];
+ _info.PACSI[0].seiMessageData[0] = new uint8_t[seiPayloadSize];
}
memcpy(_info.PACSI[0].seiMessageData[0], _ptrData+seiStartOffset, seiPayloadSize);
_info.PACSI[0].NALlength += seiPayloadSize + 2; // additional 2 is the length
#ifdef DEBUG_SEI_MESSAGE
- const WebRtc_UWord8 numberOfLayers = 10;
- WebRtc_UWord16 avgBitrate[numberOfLayers]= {0,0,0,0,0,0,0,0,0,0};
- WebRtc_UWord16 maxBitrateLayer[numberOfLayers]= {0,0,0,0,0,0,0,0,0,0};
- WebRtc_UWord16 maxBitrateLayerRepresentation[numberOfLayers] = {0,0,0,0,0,0,0,0,0,0};
- WebRtc_UWord16 maxBitrareCalcWindow[numberOfLayers] = {0,0,0,0,0,0,0,0,0,0};
+ const uint8_t numberOfLayers = 10;
+ uint16_t avgBitrate[numberOfLayers]= {0,0,0,0,0,0,0,0,0,0};
+ uint16_t maxBitrateLayer[numberOfLayers]= {0,0,0,0,0,0,0,0,0,0};
+ uint16_t maxBitrateLayerRepresentation[numberOfLayers] = {0,0,0,0,0,0,0,0,0,0};
+ uint16_t maxBitrareCalcWindow[numberOfLayers] = {0,0,0,0,0,0,0,0,0,0};
BitstreamParser parserScalabilityInfo(_ptrData+curByte, seiPayloadSize);
parserScalabilityInfo.Get1Bit(); // not used in futher parsing
- const WebRtc_UWord8 priority_layer_info_present = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 priority_id_setting_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t priority_layer_info_present = parserScalabilityInfo.Get1Bit();
+ const uint8_t priority_id_setting_flag = parserScalabilityInfo.Get1Bit();
- WebRtc_UWord32 numberOfLayersMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 j = 0; j<= numberOfLayersMinusOne; j++)
+ uint32_t numberOfLayersMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t j = 0; j<= numberOfLayersMinusOne; j++)
{
printf("\nLayer ID:%d \n",parserScalabilityInfo.GetUE());
printf("Priority ID:%d \n", parserScalabilityInfo.Get6Bits());
@@ -496,24 +496,24 @@
printf("Quality ID:%d \n", parserScalabilityInfo.Get4Bits());
printf("Temporal ID:%d \n", parserScalabilityInfo.Get3Bits());
- const WebRtc_UWord8 sub_pic_layer_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 sub_region_layer_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 iroi_division_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 profile_level_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 bitrate_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 frm_rate_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 frm_size_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 layer_dependency_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 parameter_sets_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 bitstream_restriction_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 exact_inter_layer_pred_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
+ const uint8_t sub_pic_layer_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t sub_region_layer_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t iroi_division_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t profile_level_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t bitrate_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t frm_rate_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t frm_size_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t layer_dependency_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t parameter_sets_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t bitstream_restriction_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t exact_inter_layer_pred_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
if(sub_pic_layer_flag || iroi_division_info_present_flag)
{
parserScalabilityInfo.Get1Bit();
}
- const WebRtc_UWord8 layer_conversion_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 layer_output_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
+ const uint8_t layer_conversion_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t layer_output_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
if(profile_level_info_present_flag)
{
@@ -565,8 +565,8 @@
parserScalabilityInfo.GetUE();
}else
{
- const WebRtc_UWord32 numRoisMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <= numRoisMinusOne; k++)
+ const uint32_t numRoisMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k <= numRoisMinusOne; k++)
{
parserScalabilityInfo.GetUE();
parserScalabilityInfo.GetUE();
@@ -576,8 +576,8 @@
}
if(layer_dependency_info_present_flag)
{
- const WebRtc_UWord32 numDirectlyDependentLayers = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k < numDirectlyDependentLayers; k++)
+ const uint32_t numDirectlyDependentLayers = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k < numDirectlyDependentLayers; k++)
{
parserScalabilityInfo.GetUE();
}
@@ -587,18 +587,18 @@
}
if(parameter_sets_info_present_flag)
{
- const WebRtc_UWord32 numSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <= numSeqParameterSetMinusOne; k++)
+ const uint32_t numSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k <= numSeqParameterSetMinusOne; k++)
{
parserScalabilityInfo.GetUE();
}
- const WebRtc_UWord32 numSubsetSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 l = 0; l <= numSubsetSeqParameterSetMinusOne; l++)
+ const uint32_t numSubsetSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t l = 0; l <= numSubsetSeqParameterSetMinusOne; l++)
{
parserScalabilityInfo.GetUE();
}
- const WebRtc_UWord32 numPicParameterSetMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 m = 0; m <= numPicParameterSetMinusOne; m++)
+ const uint32_t numPicParameterSetMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t m = 0; m <= numPicParameterSetMinusOne; m++)
{
parserScalabilityInfo.GetUE();
}
@@ -619,7 +619,7 @@
if(layer_conversion_flag)
{
parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <2;k++)
+ for(uint32_t k = 0; k <2;k++)
{
if(parserScalabilityInfo.Get1Bit())
{
@@ -632,12 +632,12 @@
}
if(priority_layer_info_present)
{
- const WebRtc_UWord32 prNumDidMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <= prNumDidMinusOne;k++)
+ const uint32_t prNumDidMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k <= prNumDidMinusOne;k++)
{
parserScalabilityInfo.Get3Bits();
- const WebRtc_UWord32 prNumMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 l = 0; l <= prNumMinusOne; l++)
+ const uint32_t prNumMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t l = 0; l <= prNumMinusOne; l++)
{
parserScalabilityInfo.GetUE();
parserScalabilityInfo.Get24Bits();
@@ -648,8 +648,8 @@
}
if(priority_id_setting_flag)
{
- WebRtc_UWord8 priorityIdSettingUri;
- WebRtc_UWord32 priorityIdSettingUriIdx = 0;
+ uint8_t priorityIdSettingUri;
+ uint32_t priorityIdSettingUriIdx = 0;
do
{
priorityIdSettingUri = parserScalabilityInfo.Get8Bits();
@@ -686,7 +686,7 @@
if (_info.type[_info.numNALUs] == 14 ||
_info.type[_info.numNALUs] == 20)
{
- WebRtc_UWord32 curByte = _info.startCodeSize[_info.numNALUs] + 1;
+ uint32_t curByte = _info.startCodeSize[_info.numNALUs] + 1;
if (_remLength < curByte + 3)
{
@@ -726,7 +726,7 @@
*
*/
void
-H264Information::SetLayerSEBit(WebRtc_Word32 foundLast)
+H264Information::SetLayerSEBit(int32_t foundLast)
{
if (_info.numNALUs == 0)
{
@@ -766,7 +766,7 @@
}
/*******************************************************************************
- * WebRtc_Word32 SetLayerLengths();
+ * int32_t SetLayerLengths();
*
* Sets the accumulated layer length.
*
@@ -778,17 +778,17 @@
* - (-1) : Error
*
*/
-WebRtc_Word32
+int32_t
H264Information::SetLayerLengths()
{
- for (WebRtc_UWord32 curNALU = 0; curNALU < _info.numNALUs; curNALU++)
+ for (uint32_t curNALU = 0; curNALU < _info.numNALUs; curNALU++)
{
_info.accLayerSize[_info.numLayers] += _info.startCodeSize[curNALU] + _info.payloadSize[curNALU];
if (_info.PACSI[curNALU].E == 1)
{
_info.numLayers++;
- if (curNALU == WebRtc_UWord32(_info.numNALUs - 1))
+ if (curNALU == uint32_t(_info.numNALUs - 1))
{
break;
}
@@ -807,7 +807,7 @@
return -1;
}
- if (_info.accLayerSize[_info.numLayers - 1] != WebRtc_Word32(_length))
+ if (_info.accLayerSize[_info.numLayers - 1] != int32_t(_length))
{
Reset();
return -1;
diff --git a/webrtc/modules/rtp_rtcp/source/H264/h264_information.h b/webrtc/modules/rtp_rtcp/source/H264/h264_information.h
index c7f5214..e51b9e1 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/h264_information.h
+++ b/webrtc/modules/rtp_rtcp/source/H264/h264_information.h
@@ -40,18 +40,18 @@
length(3)
{
}
- const WebRtc_UWord8 r;
- WebRtc_UWord8 idr;
- WebRtc_UWord8 priorityID;
- WebRtc_UWord8 interLayerPred;
- WebRtc_UWord8 dependencyID;
- WebRtc_UWord8 qualityID;
- WebRtc_UWord8 temporalID;
- WebRtc_UWord8 useRefBasePic;
- WebRtc_UWord8 discardable;
- WebRtc_UWord8 output;
- const WebRtc_UWord8 rr;
- const WebRtc_UWord8 length;
+ const uint8_t r;
+ uint8_t idr;
+ uint8_t priorityID;
+ uint8_t interLayerPred;
+ uint8_t dependencyID;
+ uint8_t qualityID;
+ uint8_t temporalID;
+ uint8_t useRefBasePic;
+ uint8_t discardable;
+ uint8_t output;
+ const uint8_t rr;
+ const uint8_t length;
};
class H264_PACSI_NALU
@@ -87,22 +87,22 @@
}
}
- WebRtc_UWord32 NALlength;
- const WebRtc_UWord8 type;
- WebRtc_UWord8 X;
- WebRtc_UWord8 Y;
-// WebRtc_UWord8 T;
- WebRtc_UWord8 A;
- WebRtc_UWord8 P;
- WebRtc_UWord8 C;
- WebRtc_UWord8 S;
- WebRtc_UWord8 E;
- WebRtc_UWord8 TL0picIDx;
- WebRtc_UWord16 IDRpicID;
- WebRtc_UWord16 DONC;
- WebRtc_UWord32 numSEINALUs;
- WebRtc_UWord32 seiMessageLength[KMaxNumberOfSEINALUs]; // we allow KMaxNumberOfSEINALUs SEI messages
- WebRtc_UWord8* seiMessageData[KMaxNumberOfSEINALUs];
+ uint32_t NALlength;
+ const uint8_t type;
+ uint8_t X;
+ uint8_t Y;
+// uint8_t T;
+ uint8_t A;
+ uint8_t P;
+ uint8_t C;
+ uint8_t S;
+ uint8_t E;
+ uint8_t TL0picIDx;
+ uint16_t IDRpicID;
+ uint16_t DONC;
+ uint32_t numSEINALUs;
+ uint32_t seiMessageLength[KMaxNumberOfSEINALUs]; // we allow KMaxNumberOfSEINALUs SEI messages
+ uint8_t* seiMessageData[KMaxNumberOfSEINALUs];
};
struct H264Info
@@ -118,15 +118,15 @@
memset(type, 0, sizeof(type));
memset(accLayerSize, 0, sizeof(accLayerSize));
}
- WebRtc_UWord16 numNALUs;
- WebRtc_UWord8 numLayers;
- WebRtc_UWord8 startCodeSize[KMaxNumberOfNALUs];
- WebRtc_UWord32 payloadSize[KMaxNumberOfNALUs];
- WebRtc_UWord8 NRI[KMaxNumberOfNALUs];
- WebRtc_UWord8 type[KMaxNumberOfNALUs];
+ uint16_t numNALUs;
+ uint8_t numLayers;
+ uint8_t startCodeSize[KMaxNumberOfNALUs];
+ uint32_t payloadSize[KMaxNumberOfNALUs];
+ uint8_t NRI[KMaxNumberOfNALUs];
+ uint8_t type[KMaxNumberOfNALUs];
H264_SVC_NALUHeader SVCheader[KMaxNumberOfNALUs];
H264_PACSI_NALU PACSI[KMaxNumberOfNALUs];
- WebRtc_Word32 accLayerSize[KMaxNumberOfLayers];
+ int32_t accLayerSize[KMaxNumberOfLayers];
};
@@ -140,29 +140,29 @@
virtual RtpVideoCodecTypes Type();
- virtual WebRtc_Word32 GetInfo(const WebRtc_UWord8* ptrEncodedBuffer, const WebRtc_UWord32 length, const H264Info*& ptrInfo);
+ virtual int32_t GetInfo(const uint8_t* ptrEncodedBuffer, const uint32_t length, const H264Info*& ptrInfo);
protected:
- bool HasInfo(const WebRtc_UWord32 length);
- WebRtc_Word32 FindInfo(const WebRtc_UWord8* ptrEncodedBuffer, const WebRtc_UWord32 length);
+ bool HasInfo(const uint32_t length);
+ int32_t FindInfo(const uint8_t* ptrEncodedBuffer, const uint32_t length);
void GetNRI();
- WebRtc_Word32 FindNALU();
- WebRtc_Word32 FindNALUStartCodeSize();
- WebRtc_Word32 FindNALUType();
+ int32_t FindNALU();
+ int32_t FindNALUStartCodeSize();
+ int32_t FindNALUType();
- WebRtc_Word32 ParseSVCNALUHeader();
+ int32_t ParseSVCNALUHeader();
- void SetLayerSEBit(WebRtc_Word32 foundLast);
- WebRtc_Word32 SetLayerLengths();
+ void SetLayerSEBit(int32_t foundLast);
+ int32_t SetLayerLengths();
private:
const bool _SVC;
- const WebRtc_UWord8* _ptrData;
- WebRtc_UWord32 _length;
- WebRtc_UWord32 _parsedLength;
- WebRtc_UWord32 _remLength;
+ const uint8_t* _ptrData;
+ uint32_t _length;
+ uint32_t _parsedLength;
+ uint32_t _remLength;
H264Info _info;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.cc b/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.cc
index 1f35526..f121a41 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.cc
+++ b/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.cc
@@ -36,7 +36,7 @@
{
}
-WebRtc_Word32
+int32_t
RTPSenderH264::Init()
{
_h264SendPPS_SPS = true;
@@ -71,8 +71,8 @@
bool
RTPSenderH264::AddH264SVCNALUHeader(const H264_SVC_NALUHeader& svc,
- WebRtc_UWord8* databuffer,
- WebRtc_Word32& curByte) const
+ uint8_t* databuffer,
+ int32_t& curByte) const
{
// +---------------+---------------+---------------+
// |0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|
@@ -100,14 +100,14 @@
return true;
}
-WebRtc_Word32
+int32_t
RTPSenderH264::AddH264PACSINALU(const bool firstPacketInNALU,
const bool lastPacketInNALU,
const H264_PACSI_NALU& pacsi,
const H264_SVC_NALUHeader& svc,
- const WebRtc_UWord16 DONC,
- WebRtc_UWord8* databuffer,
- WebRtc_Word32& curByte) const
+ const uint16_t DONC,
+ uint8_t* databuffer,
+ int32_t& curByte) const
{
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -144,7 +144,7 @@
return 0;
}
- WebRtc_Word32 startByte = curByte;
+ int32_t startByte = curByte;
// NAL unit header
databuffer[curByte++] = 30; // NRI will be added later
@@ -166,25 +166,25 @@
if (pacsi.Y)
{
databuffer[curByte++] = pacsi.TL0picIDx;
- databuffer[curByte++] = (WebRtc_UWord8)(pacsi.IDRpicID >> 8);
- databuffer[curByte++] = (WebRtc_UWord8)(pacsi.IDRpicID);
+ databuffer[curByte++] = (uint8_t)(pacsi.IDRpicID >> 8);
+ databuffer[curByte++] = (uint8_t)(pacsi.IDRpicID);
}
// Decoding order number
if (addDONC) // pacsi.T
{
- databuffer[curByte++] = (WebRtc_UWord8)(DONC >> 8);
- databuffer[curByte++] = (WebRtc_UWord8)(DONC);
+ databuffer[curByte++] = (uint8_t)(DONC >> 8);
+ databuffer[curByte++] = (uint8_t)(DONC);
}
// SEI NALU
if(firstPacketInNALU) // IMPROVEMENT duplicate it to make sure it arrives...
{
// we only set this for NALU 0 to make sure we send it only once per frame
- for (WebRtc_UWord32 i = 0; i < pacsi.numSEINALUs; i++)
+ for (uint32_t i = 0; i < pacsi.numSEINALUs; i++)
{
// NALU size
- databuffer[curByte++] = (WebRtc_UWord8)(pacsi.seiMessageLength[i] >> 8);
- databuffer[curByte++] = (WebRtc_UWord8)(pacsi.seiMessageLength[i]);
+ databuffer[curByte++] = (uint8_t)(pacsi.seiMessageLength[i] >> 8);
+ databuffer[curByte++] = (uint8_t)(pacsi.seiMessageLength[i]);
// NALU data
memcpy(databuffer + curByte, pacsi.seiMessageData[i], pacsi.seiMessageLength[i]);
@@ -194,14 +194,14 @@
return curByte - startByte;
}
-WebRtc_Word32
-RTPSenderH264::SetH264RelaySequenceNumber(const WebRtc_UWord16 seqNum)
+int32_t
+RTPSenderH264::SetH264RelaySequenceNumber(const uint16_t seqNum)
{
_h264SVCRelaySequenceNumber = seqNum;
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderH264::SetH264RelayCompleteLayer(const bool complete)
{
_h264SVCRelayLayerComplete = complete;
@@ -215,12 +215,12 @@
access unit is that they shall not precede the first VCL
NAL unit with the same access unit.
*/
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264FillerData(const WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord16 bytesToSend,
- const WebRtc_UWord32 ssrc)
+ const uint16_t bytesToSend,
+ const uint32_t ssrc)
{
- WebRtc_UWord16 fillerLength = bytesToSend - 12 - 1;
+ uint16_t fillerLength = bytesToSend - 12 - 1;
if (fillerLength > WEBRTC_IP_PACKET_SIZE - 12 - 1)
{
@@ -234,9 +234,9 @@
}
// send codec valid data, H.264 has defined data which is binary 1111111
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
- dataBuffer[0] = static_cast<WebRtc_UWord8>(0x80); // version 2
+ 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);
@@ -253,27 +253,27 @@
12 + 1);
}
-WebRtc_Word32
-RTPSenderH264::SendH264FillerData(const WebRtc_UWord32 captureTimestamp,
- const WebRtc_UWord8 payloadType,
- const WebRtc_UWord32 bytes
+int32_t
+RTPSenderH264::SendH264FillerData(const uint32_t captureTimestamp,
+ const uint8_t payloadType,
+ const uint32_t bytes
)
{
- const WebRtc_UWord16 rtpHeaderLength = _rtpSender.RTPHeaderLength();
- WebRtc_UWord16 maxLength = _rtpSender.MaxPayloadLength() - FECPacketOverhead() - _rtpSender.RTPHeaderLength();
+ const uint16_t rtpHeaderLength = _rtpSender.RTPHeaderLength();
+ uint16_t maxLength = _rtpSender.MaxPayloadLength() - FECPacketOverhead() - _rtpSender.RTPHeaderLength();
- WebRtc_Word32 bytesToSend=bytes;
- WebRtc_UWord16 fillerLength=0;
+ int32_t bytesToSend=bytes;
+ uint16_t fillerLength=0;
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
while(bytesToSend>0)
{
fillerLength=maxLength;
if(fillerLength<maxLength)
{
- fillerLength = (WebRtc_UWord16) bytesToSend;
+ fillerLength = (uint16_t) bytesToSend;
}
bytesToSend-=fillerLength;
@@ -311,14 +311,14 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264SVCRelayPacket(const WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord8* incomingRTPPacket,
- const WebRtc_UWord16 incomingRTPPacketSize,
- const WebRtc_UWord32 ssrc,
+ const uint8_t* incomingRTPPacket,
+ const uint16_t incomingRTPPacketSize,
+ const uint32_t ssrc,
const bool higestLayer)
{
- if (rtpHeader->header.sequenceNumber != (WebRtc_UWord16)(_h264SVCRelaySequenceNumber + 1))
+ if (rtpHeader->header.sequenceNumber != (uint16_t)(_h264SVCRelaySequenceNumber + 1))
{
// not continous, signal loss
_rtpSender.IncrementSequenceNumber();
@@ -346,7 +346,7 @@
// we keep the timestap unchanged
// make a copy and only change the SSRC and seqNum
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
memcpy(dataBuffer, incomingRTPPacket, incomingRTPPacketSize);
// _sequenceNumber initiated in Init()
@@ -382,28 +382,28 @@
rtpHeader->header.headerLength);
}
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264_STAP_A(const FrameType frameType,
const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
bool& switchToFUA,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLength)
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLength)
{
- const WebRtc_Word32 H264_NALU_LENGTH = 2;
+ const int32_t H264_NALU_LENGTH = 2;
- WebRtc_UWord16 h264HeaderLength = 1; // normal header length
- WebRtc_UWord16 maxPayloadLengthSTAP_A = _rtpSender.MaxPayloadLength() -
+ uint16_t h264HeaderLength = 1; // normal header length
+ uint16_t maxPayloadLengthSTAP_A = _rtpSender.MaxPayloadLength() -
FECPacketOverhead() - rtpHeaderLength -
h264HeaderLength - H264_NALU_LENGTH;
- WebRtc_Word32 dataOffset = rtpHeaderLength + h264HeaderLength;
- WebRtc_UWord8 NRI = 0;
- WebRtc_UWord16 payloadBytesInPacket = 0;
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ int32_t dataOffset = rtpHeaderLength + h264HeaderLength;
+ uint8_t NRI = 0;
+ uint16_t payloadBytesInPacket = 0;
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
if (ptrH264Info->payloadSize[idxNALU] > maxPayloadLengthSTAP_A)
{
@@ -432,15 +432,15 @@
NRI = ptrH264Info->NRI[idxNALU];
}
// put NAL size into packet
- dataBuffer[dataOffset] = (WebRtc_UWord8)(ptrH264Info->payloadSize[idxNALU] >> 8);
+ dataBuffer[dataOffset] = (uint8_t)(ptrH264Info->payloadSize[idxNALU] >> 8);
dataOffset++;
- dataBuffer[dataOffset] = (WebRtc_UWord8)(ptrH264Info->payloadSize[idxNALU] & 0xff);
+ dataBuffer[dataOffset] = (uint8_t)(ptrH264Info->payloadSize[idxNALU] & 0xff);
dataOffset++;
// Put payload in packet
memcpy(&dataBuffer[dataOffset], &data[ptrH264Info->startCodeSize[idxNALU]], ptrH264Info->payloadSize[idxNALU]);
dataOffset += ptrH264Info->payloadSize[idxNALU];
data += ptrH264Info->payloadSize[idxNALU] + ptrH264Info->startCodeSize[idxNALU];
- payloadBytesInPacket += (WebRtc_UWord16)(ptrH264Info->payloadSize[idxNALU] + H264_NALU_LENGTH);
+ payloadBytesInPacket += (uint16_t)(ptrH264Info->payloadSize[idxNALU] + H264_NALU_LENGTH);
payloadBytesToSend -= ptrH264Info->payloadSize[idxNALU] + ptrH264Info->startCodeSize[idxNALU];
} else
{
@@ -458,7 +458,7 @@
// add RTP header
_rtpSender.BuildRTPheader(dataBuffer, payloadType, (payloadBytesToSend==0)?true:false, captureTimeStamp);
dataBuffer[rtpHeaderLength] = 24 + NRI; // STAP-A == 24
- WebRtc_UWord16 payloadLength = payloadBytesInPacket + h264HeaderLength;
+ uint16_t payloadLength = payloadBytesInPacket + h264HeaderLength;
if(-1 == SendVideoPacket(frameType, dataBuffer, payloadLength, rtpHeaderLength))
{
@@ -469,43 +469,43 @@
} // end STAP-A
// STAP-A for H.264 SVC
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType,
const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
bool& switchToFUA,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLength,
- WebRtc_UWord16& decodingOrderNumber)
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLength,
+ uint16_t& decodingOrderNumber)
{
- const WebRtc_Word32 H264_NALU_LENGTH = 2;
+ const int32_t H264_NALU_LENGTH = 2;
- WebRtc_UWord16 h264HeaderLength = 1; // normal header length
- WebRtc_UWord16 maxPayloadLengthSTAP_A = _rtpSender.MaxPayloadLength() - FECPacketOverhead() - rtpHeaderLength - h264HeaderLength - H264_NALU_LENGTH;
- WebRtc_Word32 dataOffset = rtpHeaderLength + h264HeaderLength;
- WebRtc_UWord8 NRI = 0;
- WebRtc_UWord16 payloadBytesInPacket = 0;
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ uint16_t h264HeaderLength = 1; // normal header length
+ uint16_t maxPayloadLengthSTAP_A = _rtpSender.MaxPayloadLength() - FECPacketOverhead() - rtpHeaderLength - h264HeaderLength - H264_NALU_LENGTH;
+ int32_t dataOffset = rtpHeaderLength + h264HeaderLength;
+ uint8_t NRI = 0;
+ uint16_t payloadBytesInPacket = 0;
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
bool firstNALUNotIDR = true; //delta
// Put PACSI NAL unit into packet
- WebRtc_Word32 lengthPACSI = 0;
- WebRtc_UWord32 PACSI_NALlength = ptrH264Info->PACSI[idxNALU].NALlength;
+ int32_t lengthPACSI = 0;
+ uint32_t PACSI_NALlength = ptrH264Info->PACSI[idxNALU].NALlength;
if (PACSI_NALlength > maxPayloadLengthSTAP_A)
{
return -1;
}
- dataBuffer[dataOffset++] = (WebRtc_UWord8)(PACSI_NALlength >> 8);
- dataBuffer[dataOffset++] = (WebRtc_UWord8)(PACSI_NALlength & 0xff);
+ dataBuffer[dataOffset++] = (uint8_t)(PACSI_NALlength >> 8);
+ dataBuffer[dataOffset++] = (uint8_t)(PACSI_NALlength & 0xff);
// end bit will be updated later, since another NALU in this packet might be the last
- WebRtc_Word32 lengthPASCINALU = AddH264PACSINALU(true,
- false,
- ptrH264Info->PACSI[idxNALU],
- ptrH264Info->SVCheader[idxNALU],
+ int32_t lengthPASCINALU = AddH264PACSINALU(true,
+ false,
+ ptrH264Info->PACSI[idxNALU],
+ ptrH264Info->SVCheader[idxNALU],
decodingOrderNumber,
dataBuffer,
dataOffset);
@@ -516,7 +516,7 @@
decodingOrderNumber++;
lengthPACSI = H264_NALU_LENGTH + lengthPASCINALU;
- maxPayloadLengthSTAP_A -= (WebRtc_UWord16)lengthPACSI;
+ maxPayloadLengthSTAP_A -= (uint16_t)lengthPACSI;
if (ptrH264Info->payloadSize[idxNALU] > maxPayloadLengthSTAP_A)
{
// we need to fragment NAL switch to mode FU-A
@@ -528,7 +528,7 @@
firstNALUNotIDR = true;
}
- WebRtc_UWord32 layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
+ uint32_t layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
(ptrH264Info->SVCheader[idxNALU].qualityID << 8) +
ptrH264Info->SVCheader[idxNALU].temporalID;
@@ -560,7 +560,7 @@
continue;
}
- const WebRtc_UWord32 layerNALU = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
+ const uint32_t layerNALU = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
(ptrH264Info->SVCheader[idxNALU].qualityID << 8) +
ptrH264Info->SVCheader[idxNALU].temporalID;
@@ -573,15 +573,15 @@
NRI = ptrH264Info->NRI[idxNALU];
}
// put NAL size into packet
- dataBuffer[dataOffset] = (WebRtc_UWord8)(ptrH264Info->payloadSize[idxNALU] >> 8);
+ dataBuffer[dataOffset] = (uint8_t)(ptrH264Info->payloadSize[idxNALU] >> 8);
dataOffset++;
- dataBuffer[dataOffset] = (WebRtc_UWord8)(ptrH264Info->payloadSize[idxNALU] & 0xff);
+ dataBuffer[dataOffset] = (uint8_t)(ptrH264Info->payloadSize[idxNALU] & 0xff);
dataOffset++;
// Put payload in packet
memcpy(&dataBuffer[dataOffset], &data[ptrH264Info->startCodeSize[idxNALU]], ptrH264Info->payloadSize[idxNALU]);
dataOffset += ptrH264Info->payloadSize[idxNALU];
data += ptrH264Info->payloadSize[idxNALU] + ptrH264Info->startCodeSize[idxNALU];
- payloadBytesInPacket += (WebRtc_UWord16)(ptrH264Info->payloadSize[idxNALU] + H264_NALU_LENGTH);
+ payloadBytesInPacket += (uint16_t)(ptrH264Info->payloadSize[idxNALU] + H264_NALU_LENGTH);
payloadBytesToSend -= ptrH264Info->payloadSize[idxNALU] + ptrH264Info->startCodeSize[idxNALU];
} else
{
@@ -595,7 +595,7 @@
{
// we don't send this NALU due to it's a new layer
// check if we should send the next or if this is the last
- const WebRtc_UWord8 dependencyQualityID = (ptrH264Info->SVCheader[idxNALU].dependencyID << 4) + ptrH264Info->SVCheader[idxNALU].qualityID;
+ const uint8_t dependencyQualityID = (ptrH264Info->SVCheader[idxNALU].dependencyID << 4) + ptrH264Info->SVCheader[idxNALU].qualityID;
bool highestLayer;
if(SendH264SVCLayer(frameType,
@@ -649,7 +649,7 @@
dataBuffer[rtpHeaderLength + H264_NALU_LENGTH + 2] |= 0x40;
}
}
- const WebRtc_UWord16 payloadLength = payloadBytesInPacket + h264HeaderLength + (WebRtc_UWord16)lengthPACSI;
+ const uint16_t payloadLength = payloadBytesInPacket + h264HeaderLength + (uint16_t)lengthPACSI;
if(-1 == SendVideoPacket(frameType,
dataBuffer,
payloadLength,
@@ -662,30 +662,30 @@
return 0;
} // end STAP-A
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264_FU_A(const FrameType frameType,
const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLength,
- WebRtc_UWord16& decodingOrderNumber,
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLength,
+ uint16_t& decodingOrderNumber,
const bool sendSVCPACSI)
{
// FUA for the rest of the frame
- WebRtc_UWord16 maxPayloadLength = _rtpSender.MaxPayloadLength() - FECPacketOverhead() - rtpHeaderLength;
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
- WebRtc_UWord32 payloadBytesRemainingInNALU = ptrH264Info->payloadSize[idxNALU];
+ uint16_t maxPayloadLength = _rtpSender.MaxPayloadLength() - FECPacketOverhead() - rtpHeaderLength;
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ uint32_t payloadBytesRemainingInNALU = ptrH264Info->payloadSize[idxNALU];
bool isBaseLayer=false;
if(payloadBytesRemainingInNALU > maxPayloadLength)
{
// we need to fragment NALU
- const WebRtc_UWord16 H264_FUA_LENGTH = 2; // FU-a H.264 header is 2 bytes
+ const uint16_t H264_FUA_LENGTH = 2; // FU-a H.264 header is 2 bytes
if(sendSVCPACSI)
{
@@ -697,7 +697,7 @@
true,
false);
- WebRtc_UWord32 layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
+ uint32_t layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
(ptrH264Info->SVCheader[idxNALU].qualityID << 8) +
ptrH264Info->SVCheader[idxNALU].temporalID;
isBaseLayer=(layer==0);
@@ -706,13 +706,13 @@
// First packet
_rtpSender.BuildRTPheader(dataBuffer,payloadType, false, captureTimeStamp);
- WebRtc_UWord16 maxPayloadLengthFU_A = maxPayloadLength - H264_FUA_LENGTH ;
- WebRtc_UWord8 fuaIndc = 28 + ptrH264Info->NRI[idxNALU];
+ uint16_t maxPayloadLengthFU_A = maxPayloadLength - H264_FUA_LENGTH ;
+ uint8_t fuaIndc = 28 + ptrH264Info->NRI[idxNALU];
dataBuffer[rtpHeaderLength] = fuaIndc; // FU-A indicator
- dataBuffer[rtpHeaderLength+1] = (WebRtc_UWord8)(ptrH264Info->type[idxNALU] + 0x80)/*start*/; // FU-A header
+ dataBuffer[rtpHeaderLength+1] = (uint8_t)(ptrH264Info->type[idxNALU] + 0x80)/*start*/; // FU-A header
memcpy(&dataBuffer[rtpHeaderLength + H264_FUA_LENGTH], &data[ptrH264Info->startCodeSize[idxNALU]+1], maxPayloadLengthFU_A);
- WebRtc_UWord16 payloadLength = maxPayloadLengthFU_A + H264_FUA_LENGTH;
+ uint16_t payloadLength = maxPayloadLengthFU_A + H264_FUA_LENGTH;
if(-1 == SendVideoPacket(frameType, dataBuffer, payloadLength, rtpHeaderLength, isBaseLayer))
{
return -1;
@@ -740,7 +740,7 @@
// prepare next header
_rtpSender.BuildRTPheader(dataBuffer, payloadType, false, captureTimeStamp);
- dataBuffer[rtpHeaderLength] = (WebRtc_UWord8)fuaIndc; // FU-A indicator
+ dataBuffer[rtpHeaderLength] = (uint8_t)fuaIndc; // FU-A indicator
dataBuffer[rtpHeaderLength+1] = ptrH264Info->type[idxNALU]; // FU-A header
memcpy(&dataBuffer[rtpHeaderLength+H264_FUA_LENGTH], data, maxPayloadLengthFU_A);
@@ -772,7 +772,7 @@
// check if it's the the next layer should not be sent
// check if we should send the next or if this is the last
- const WebRtc_UWord8 dependencyQualityID = (ptrH264Info->SVCheader[idxNALU+1].dependencyID << 4) +
+ const uint8_t dependencyQualityID = (ptrH264Info->SVCheader[idxNALU+1].dependencyID << 4) +
ptrH264Info->SVCheader[idxNALU+1].qualityID;
bool highestLayer;
@@ -787,11 +787,11 @@
}
}
// last packet in NALU
- _rtpSender.BuildRTPheader(dataBuffer, payloadType,(payloadBytesToSend == (WebRtc_Word32)payloadBytesRemainingInNALU)?true:false, captureTimeStamp);
+ _rtpSender.BuildRTPheader(dataBuffer, payloadType,(payloadBytesToSend == (int32_t)payloadBytesRemainingInNALU)?true:false, captureTimeStamp);
dataBuffer[rtpHeaderLength+1] = ptrH264Info->type[idxNALU] + 0x40/*stop*/; // FU-A header
memcpy(&dataBuffer[rtpHeaderLength+H264_FUA_LENGTH], data, payloadBytesRemainingInNALU);
- payloadLength = (WebRtc_UWord16)payloadBytesRemainingInNALU + H264_FUA_LENGTH;
+ payloadLength = (uint16_t)payloadBytesRemainingInNALU + H264_FUA_LENGTH;
payloadBytesToSend -= payloadBytesRemainingInNALU;
if(payloadBytesToSend != 0)
{
@@ -819,22 +819,22 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264_SingleMode(const FrameType frameType,
const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLength,
- WebRtc_UWord16& decodingOrderNumber,
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLength,
+ uint16_t& decodingOrderNumber,
const bool sendSVCPACSI)
{
// no H.264 header lenght in single mode
// we use WEBRTC_IP_PACKET_SIZE instead of the configured MTU since it's better to send fragmented UDP than not to send
- const WebRtc_UWord16 maxPayloadLength = WEBRTC_IP_PACKET_SIZE - _rtpSender.PacketOverHead() - FECPacketOverhead() - rtpHeaderLength;
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ const uint16_t maxPayloadLength = WEBRTC_IP_PACKET_SIZE - _rtpSender.PacketOverHead() - FECPacketOverhead() - rtpHeaderLength;
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
bool isBaseLayer=false;
if(ptrH264Info->payloadSize[idxNALU] > maxPayloadLength)
@@ -862,7 +862,7 @@
true,
true);
- WebRtc_UWord32 layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
+ uint32_t layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
(ptrH264Info->SVCheader[idxNALU].qualityID << 8) +
ptrH264Info->SVCheader[idxNALU].temporalID;
isBaseLayer=(layer==0);
@@ -871,7 +871,7 @@
// Put payload in packet
memcpy(&dataBuffer[rtpHeaderLength], &data[ptrH264Info->startCodeSize[idxNALU]], ptrH264Info->payloadSize[idxNALU]);
- WebRtc_UWord16 payloadBytesInPacket = (WebRtc_UWord16)ptrH264Info->payloadSize[idxNALU];
+ uint16_t payloadBytesInPacket = (uint16_t)ptrH264Info->payloadSize[idxNALU];
payloadBytesToSend -= ptrH264Info->payloadSize[idxNALU] + ptrH264Info->startCodeSize[idxNALU]; // left to send
//
@@ -891,27 +891,27 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264_SinglePACSI(const FrameType frameType,
const H264Info* ptrH264Info,
- const WebRtc_UWord16 idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
+ const uint16_t idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
const bool firstPacketInNALU,
const bool lastPacketInNALU);
{
// Send PACSI in single mode
- WebRtc_UWord8 dataBuffer[WEBRTC_IP_PACKET_SIZE];
- WebRtc_UWord16 rtpHeaderLength = (WebRtc_UWord16)_rtpSender.BuildRTPheader(dataBuffer, payloadType,false, captureTimeStamp);
- WebRtc_Word32 dataOffset = rtpHeaderLength;
+ uint8_t dataBuffer[WEBRTC_IP_PACKET_SIZE];
+ uint16_t rtpHeaderLength = (uint16_t)_rtpSender.BuildRTPheader(dataBuffer, payloadType,false, captureTimeStamp);
+ int32_t dataOffset = rtpHeaderLength;
- WebRtc_Word32 lengthPASCINALU = AddH264PACSINALU(firstPacketInNALU,
- lastPacketInNALU,
- ptrH264Info->PACSI[idxNALU],
- ptrH264Info->SVCheader[idxNALU],
- decodingOrderNumber,
- dataBuffer,
- dataOffset);
+ int32_t lengthPASCINALU = AddH264PACSINALU(firstPacketInNALU,
+ lastPacketInNALU,
+ ptrH264Info->PACSI[idxNALU],
+ ptrH264Info->SVCheader[idxNALU],
+ decodingOrderNumber,
+ dataBuffer,
+ dataOffset);
if (lengthPASCINALU <= 0)
{
@@ -919,13 +919,13 @@
}
decodingOrderNumber++;
- WebRtc_UWord16 payloadBytesInPacket = (WebRtc_UWord16)lengthPASCINALU;
+ uint16_t payloadBytesInPacket = (uint16_t)lengthPASCINALU;
// Set payload header (first payload byte co-serves as the payload header)
dataBuffer[rtpHeaderLength] &= 0x1f; // zero out NRI field
dataBuffer[rtpHeaderLength] |= ptrH264Info->NRI[idxNALU]; // nri
- const WebRtc_UWord32 layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
+ const uint32_t layer = (ptrH264Info->SVCheader[idxNALU].dependencyID << 16)+
(ptrH264Info->SVCheader[idxNALU].qualityID << 8) +
ptrH264Info->SVCheader[idxNALU].temporalID;
@@ -939,17 +939,17 @@
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264SVC(const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
H264Information& h264Information,
- WebRtc_UWord16& decodingOrderNumber)
+ uint16_t& decodingOrderNumber)
{
- WebRtc_Word32 payloadBytesToSend = payloadSize;
- const WebRtc_UWord16 rtpHeaderLength = _rtpSender.RTPHeaderLength();
+ int32_t payloadBytesToSend = payloadSize;
+ const uint16_t rtpHeaderLength = _rtpSender.RTPHeaderLength();
const H264Info* ptrH264Info = NULL;
if (h264Information.GetInfo(payloadData,payloadSize, ptrH264Info) == -1)
@@ -960,7 +960,7 @@
{
// we need to check if we should drop the frame
// it could be a temporal layer (aka a temporal frame)
- const WebRtc_UWord8 dependencyQualityID = (ptrH264Info->SVCheader[0].dependencyID << 4) + ptrH264Info->SVCheader[0].qualityID;
+ const uint8_t dependencyQualityID = (ptrH264Info->SVCheader[0].dependencyID << 4) + ptrH264Info->SVCheader[0].qualityID;
bool dummyHighestLayer;
if(SendH264SVCLayer(frameType,
@@ -973,7 +973,7 @@
}
}
- WebRtc_UWord16 idxNALU = 0;
+ uint16_t idxNALU = 0;
while (payloadBytesToSend > 0)
{
bool switchToFUA = false;
@@ -1010,14 +1010,14 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderH264::SetH264PacketizationMode(const H264PacketizationMode mode)
{
_h264Mode = mode;
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderH264::SetH264SendModeNALU_PPS_SPS(const bool dontSend)
{
_h264SendPPS_SPS = !dontSend;
@@ -1026,11 +1026,11 @@
bool
RTPSenderH264::SendH264SVCLayer(const FrameType frameType,
- const WebRtc_UWord8 temporalID,
- const WebRtc_UWord8 dependencyQualityID,
+ const uint8_t temporalID,
+ const uint8_t dependencyQualityID,
bool& higestLayer)
{
- WebRtc_UWord8 dependencyID = dependencyQualityID >> 4;
+ uint8_t dependencyID = dependencyQualityID >> 4;
// keyframe required to switch between dependency layers not quality and temporal
if( _highestDependencyLayer != _highestDependencyLayerOld)
@@ -1146,11 +1146,11 @@
return true;
}
-WebRtc_Word32
-RTPSenderH264::SetHighestSendLayer(const WebRtc_UWord8 dependencyQualityLayer,
- const WebRtc_UWord8 temporalLayer)
+int32_t
+RTPSenderH264::SetHighestSendLayer(const uint8_t dependencyQualityLayer,
+ const uint8_t temporalLayer)
{
- const WebRtc_UWord8 dependencyLayer = (dependencyQualityLayer >> 4);
+ const uint8_t dependencyLayer = (dependencyQualityLayer >> 4);
if(_highestDependencyLayerOld != _highestDependencyLayer)
{
@@ -1175,9 +1175,9 @@
return 0;
}
-WebRtc_Word32
-RTPSenderH264::HighestSendLayer(WebRtc_UWord8& dependencyQualityLayer,
- WebRtc_UWord8& temporalLayer)
+int32_t
+RTPSenderH264::HighestSendLayer(uint8_t& dependencyQualityLayer,
+ uint8_t& temporalLayer)
{
if (!_useHighestSendLayer)
{
@@ -1191,26 +1191,26 @@
/*
* H.264
*/
-WebRtc_Word32
+int32_t
RTPSenderH264::SendH264(const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
H264Information& h264Information)
{
- WebRtc_Word32 payloadBytesToSend = payloadSize;
- const WebRtc_UWord8* data = payloadData;
+ int32_t payloadBytesToSend = payloadSize;
+ const uint8_t* data = payloadData;
bool switchToFUA = false;
- const WebRtc_UWord16 rtpHeaderLength = _rtpSender.RTPHeaderLength();
+ const uint16_t rtpHeaderLength = _rtpSender.RTPHeaderLength();
const H264Info* ptrH264Info = NULL;
if (h264Information.GetInfo(payloadData,payloadSize, ptrH264Info) == -1)
{
return -1;
}
- WebRtc_UWord16 idxNALU = 0;
- WebRtc_UWord16 DONCdummy = 0;
+ uint16_t idxNALU = 0;
+ uint16_t DONCdummy = 0;
while (payloadBytesToSend > 0)
{
diff --git a/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.h b/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.h
index 564b870..60e71b2 100644
--- a/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.h
+++ b/webrtc/modules/rtp_rtcp/source/H264/rtp_sender_h264.h
@@ -22,154 +22,154 @@
class RTPSenderH264
{
public:
- WebRtc_Word32 SendH264(const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
- H264Information& h264Information);
+ int32_t SendH264(const FrameType frameType,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
+ H264Information& h264Information);
- WebRtc_Word32 SendH264SVC(const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
- H264Information& h264Information);
+ int32_t SendH264SVC(const FrameType frameType,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
+ H264Information& h264Information);
// H.264 AVC
- WebRtc_Word32 SetH264PacketizationMode(const H264PacketizationMode mode);
+ int32_t SetH264PacketizationMode(const H264PacketizationMode mode);
- WebRtc_Word32 SetH264SendModeNALU_PPS_SPS(const bool dontSend);
+ int32_t SetH264SendModeNALU_PPS_SPS(const bool dontSend);
// H.264 SVC
- WebRtc_Word32 SetHighestSendLayer(const WebRtc_UWord8 dependencyQualityLayer,
- const WebRtc_UWord8 temporalLayer);
+ int32_t SetHighestSendLayer(const uint8_t dependencyQualityLayer,
+ const uint8_t temporalLayer);
- WebRtc_Word32 HighestSendLayer(WebRtc_UWord8& dependencyQualityLayer,
- WebRtc_UWord8& temporalLayer);
+ int32_t HighestSendLayer(uint8_t& dependencyQualityLayer,
+ uint8_t& temporalLayer);
protected:
RTPSenderH264(RTPSenderInterface* rtpSender);
virtual ~RTPSenderH264();
- WebRtc_Word32 Init();
+ int32_t Init();
- virtual WebRtc_UWord16 FECPacketOverhead() const = 0;
+ virtual uint16_t FECPacketOverhead() const = 0;
virtual RtpVideoCodecTypes VideoCodecType() const = 0;
- virtual WebRtc_Word32 SendVideoPacket(const FrameType frameType,
- const WebRtc_UWord8* dataBuffer,
- const WebRtc_UWord16 payloadLength,
- const WebRtc_UWord16 rtpHeaderLength,
- bool baseLayerVideoPacket=false) = 0;
+ virtual int32_t SendVideoPacket(const FrameType frameType,
+ const uint8_t* dataBuffer,
+ const uint16_t payloadLength,
+ const uint16_t rtpHeaderLength,
+ bool baseLayerVideoPacket=false) = 0;
bool SendH264SVCLayer(const FrameType frameType,
- const WebRtc_UWord8 temporalID,
- const WebRtc_UWord8 dependencyQualityID,
+ const uint8_t temporalID,
+ const uint8_t dependencyQualityID,
bool& higestLayer);
// H.264 SVC
- WebRtc_Word32 AddH264PACSINALU(const bool firstPacketInNALU,
- const bool lastPacketInNALU,
- const H264_PACSI_NALU& paci,
- const H264_SVC_NALUHeader& svc,
- const WebRtc_UWord16 DONC,
- WebRtc_UWord8* databuffer,
- WebRtc_Word32& curByte) const;
+ int32_t AddH264PACSINALU(const bool firstPacketInNALU,
+ const bool lastPacketInNALU,
+ const H264_PACSI_NALU& paci,
+ const H264_SVC_NALUHeader& svc,
+ const uint16_t DONC,
+ uint8_t* databuffer,
+ int32_t& curByte) const;
- WebRtc_Word32 SendH264FillerData(const WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord16 bytesToSend,
- const WebRtc_UWord32 ssrc);
+ int32_t SendH264FillerData(const WebRtcRTPHeader* rtpHeader,
+ const uint16_t bytesToSend,
+ const uint32_t ssrc);
- WebRtc_Word32 SendH264FillerData(const WebRtc_UWord32 captureTimestamp,
- const WebRtc_UWord8 payloadType,
- const WebRtc_UWord32 bytesToSend);
+ int32_t SendH264FillerData(const uint32_t captureTimestamp,
+ const uint8_t payloadType,
+ const uint32_t bytesToSend);
- WebRtc_Word32 SendH264SVCRelayPacket(const WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord8* incomingRTPPacket,
- const WebRtc_UWord16 incomingRTPPacketSize,
- const WebRtc_UWord32 ssrc,
- const bool higestLayer);
+ int32_t SendH264SVCRelayPacket(const WebRtcRTPHeader* rtpHeader,
+ const uint8_t* incomingRTPPacket,
+ const uint16_t incomingRTPPacketSize,
+ const uint32_t ssrc,
+ const bool higestLayer);
- WebRtc_Word32 SetH264RelaySequenceNumber(const WebRtc_UWord16 seqNum);
+ int32_t SetH264RelaySequenceNumber(const uint16_t seqNum);
- WebRtc_Word32 SetH264RelayCompleteLayer(const bool complete);
+ int32_t SetH264RelayCompleteLayer(const bool complete);
// H.264
H264PacketizationMode _h264Mode;
bool _h264SendPPS_SPS;
// H.264-SVC
- WebRtc_Word8 _h264SVCPayloadType;
- WebRtc_UWord16 _h264SVCRelaySequenceNumber;
- WebRtc_UWord32 _h264SVCRelayTimeStamp;
+ int8_t _h264SVCPayloadType;
+ uint16_t _h264SVCRelaySequenceNumber;
+ uint32_t _h264SVCRelayTimeStamp;
bool _h264SVCRelayLayerComplete;
private:
// H.264
- WebRtc_Word32 SendH264_SingleMode(const FrameType frameType,
+ int32_t SendH264_SingleMode(const FrameType frameType,
const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLength,
- const bool sendSVCPACSI=false);
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLength,
+ const bool sendSVCPACSI=false);
- WebRtc_Word32 SendH264_FU_A(const FrameType frameType,
- const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLength,
- const bool sendSVCPACSI = false);
+ int32_t SendH264_FU_A(const FrameType frameType,
+ const H264Info* ptrH264Info,
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLength,
+ const bool sendSVCPACSI = false);
- WebRtc_Word32 SendH264_STAP_A(const FrameType frameType,
+ int32_t SendH264_STAP_A(const FrameType frameType,
const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- bool& switchToFUA,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLength);
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ bool& switchToFUA,
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLength);
- WebRtc_Word32 SendH264_STAP_A_PACSI(const FrameType frameType,
- const H264Info* ptrH264Info,
- WebRtc_UWord16 &idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- bool& switchToFUA,
- WebRtc_Word32 &payloadBytesToSend,
- const WebRtc_UWord8*& data,
- const WebRtc_UWord16 rtpHeaderLengh)
+ int32_t SendH264_STAP_A_PACSI(const FrameType frameType,
+ const H264Info* ptrH264Info,
+ uint16_t &idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ bool& switchToFUA,
+ int32_t &payloadBytesToSend,
+ const uint8_t*& data,
+ const uint16_t rtpHeaderLengh)
- WebRtc_Word32 SendH264_SinglePACSI(const FrameType frameType,
+ int32_t SendH264_SinglePACSI(const FrameType frameType,
const H264Info* ptrH264Info,
- const WebRtc_UWord16 idxNALU,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- const bool firstPacketInNALU,
- const bool lastPacketInNALU);
+ const uint16_t idxNALU,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ const bool firstPacketInNALU,
+ const bool lastPacketInNALU);
bool AddH264SVCNALUHeader(const H264_SVC_NALUHeader& svc,
- WebRtc_UWord8* databuffer,
- WebRtc_Word32& curByte) const;
+ uint8_t* databuffer,
+ int32_t& curByte) const;
RTPSenderInterface& _rtpSender;
// relay
bool _useHighestSendLayer;
- WebRtc_UWord8 _highestDependencyLayerOld;
- WebRtc_UWord8 _highestDependencyQualityIDOld;
- WebRtc_UWord8 _highestDependencyLayer;
- WebRtc_UWord8 _highestDependencyQualityID;
- WebRtc_UWord8 _highestTemporalLayer;
+ uint8_t _highestDependencyLayerOld;
+ uint8_t _highestDependencyQualityIDOld;
+ uint8_t _highestDependencyLayer;
+ uint8_t _highestDependencyQualityID;
+ uint8_t _highestTemporalLayer;
};
diff --git a/webrtc/modules/rtp_rtcp/source/bitrate.cc b/webrtc/modules/rtp_rtcp/source/bitrate.cc
index 69601d2..e3995ad 100644
--- a/webrtc/modules/rtp_rtcp/source/bitrate.cc
+++ b/webrtc/modules/rtp_rtcp/source/bitrate.cc
@@ -27,40 +27,40 @@
memset(bitrate_array_, 0, sizeof(bitrate_array_));
}
-void Bitrate::Update(const WebRtc_Word32 bytes) {
+void Bitrate::Update(const int32_t bytes) {
bytes_count_ += bytes;
packet_count_++;
}
-WebRtc_UWord32 Bitrate::PacketRate() const {
+uint32_t Bitrate::PacketRate() const {
return packet_rate_;
}
-WebRtc_UWord32 Bitrate::BitrateLast() const {
+uint32_t Bitrate::BitrateLast() const {
return bitrate_;
}
-WebRtc_UWord32 Bitrate::BitrateNow() const {
- WebRtc_Word64 now = clock_->TimeInMilliseconds();
- WebRtc_Word64 diff_ms = now - time_last_rate_update_;
+uint32_t Bitrate::BitrateNow() const {
+ int64_t now = clock_->TimeInMilliseconds();
+ int64_t diff_ms = now - time_last_rate_update_;
if (diff_ms > 10000) { // 10 seconds.
// Too high difference, ignore.
return bitrate_;
}
- WebRtc_Word64 bits_since_last_rate_update = 8 * bytes_count_ * 1000;
+ int64_t bits_since_last_rate_update = 8 * bytes_count_ * 1000;
// We have to consider the time when the measurement was done:
// ((bits/sec * sec) + (bits)) / sec.
- WebRtc_Word64 bitrate = (static_cast<WebRtc_UWord64>(bitrate_) * 1000 +
+ int64_t bitrate = (static_cast<uint64_t>(bitrate_) * 1000 +
bits_since_last_rate_update) / (1000 + diff_ms);
- return static_cast<WebRtc_UWord32>(bitrate);
+ return static_cast<uint32_t>(bitrate);
}
void Bitrate::Process() {
// Triggered by timer.
- WebRtc_Word64 now = clock_->TimeInMilliseconds();
- WebRtc_Word64 diff_ms = now - time_last_rate_update_;
+ int64_t now = clock_->TimeInMilliseconds();
+ int64_t diff_ms = now - time_last_rate_update_;
if (diff_ms < 100) {
// Not enough data, wait...
@@ -80,9 +80,9 @@
if (bitrate_next_idx_ >= 10) {
bitrate_next_idx_ = 0;
}
- WebRtc_Word64 sum_diffMS = 0;
- WebRtc_Word64 sum_bitrateMS = 0;
- WebRtc_Word64 sum_packetrateMS = 0;
+ int64_t sum_diffMS = 0;
+ int64_t sum_bitrateMS = 0;
+ int64_t sum_packetrateMS = 0;
for (int i = 0; i < 10; i++) {
sum_diffMS += bitrate_diff_ms_[i];
sum_bitrateMS += bitrate_array_[i] * bitrate_diff_ms_[i];
@@ -91,8 +91,8 @@
time_last_rate_update_ = now;
bytes_count_ = 0;
packet_count_ = 0;
- packet_rate_ = static_cast<WebRtc_UWord32>(sum_packetrateMS / sum_diffMS);
- bitrate_ = static_cast<WebRtc_UWord32>(sum_bitrateMS / sum_diffMS);
+ packet_rate_ = static_cast<uint32_t>(sum_packetrateMS / sum_diffMS);
+ bitrate_ = static_cast<uint32_t>(sum_bitrateMS / sum_diffMS);
}
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/bitrate.h b/webrtc/modules/rtp_rtcp/source/bitrate.h
index 9a0217f..708fd98 100644
--- a/webrtc/modules/rtp_rtcp/source/bitrate.h
+++ b/webrtc/modules/rtp_rtcp/source/bitrate.h
@@ -30,30 +30,30 @@
void Process();
// Update with a packet.
- void Update(const WebRtc_Word32 bytes);
+ void Update(const int32_t bytes);
// Packet rate last second, updated roughly every 100 ms.
- WebRtc_UWord32 PacketRate() const;
+ uint32_t PacketRate() const;
// Bitrate last second, updated roughly every 100 ms.
- WebRtc_UWord32 BitrateLast() const;
+ uint32_t BitrateLast() const;
// Bitrate last second, updated now.
- WebRtc_UWord32 BitrateNow() const;
+ uint32_t BitrateNow() const;
protected:
Clock* clock_;
private:
- WebRtc_UWord32 packet_rate_;
- WebRtc_UWord32 bitrate_;
- WebRtc_UWord8 bitrate_next_idx_;
- WebRtc_Word64 packet_rate_array_[10];
- WebRtc_Word64 bitrate_array_[10];
- WebRtc_Word64 bitrate_diff_ms_[10];
- WebRtc_Word64 time_last_rate_update_;
- WebRtc_UWord32 bytes_count_;
- WebRtc_UWord32 packet_count_;
+ uint32_t packet_rate_;
+ uint32_t bitrate_;
+ uint8_t bitrate_next_idx_;
+ int64_t packet_rate_array_[10];
+ int64_t bitrate_array_[10];
+ int64_t bitrate_diff_ms_[10];
+ int64_t time_last_rate_update_;
+ uint32_t bytes_count_;
+ uint32_t packet_count_;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/dtmf_queue.cc b/webrtc/modules/rtp_rtcp/source/dtmf_queue.cc
index 749309b..6fa6d65 100644
--- a/webrtc/modules/rtp_rtcp/source/dtmf_queue.cc
+++ b/webrtc/modules/rtp_rtcp/source/dtmf_queue.cc
@@ -27,8 +27,8 @@
delete _DTMFCritsect;
}
-WebRtc_Word32
-DTMFqueue::AddDTMF(WebRtc_UWord8 key, WebRtc_UWord16 len, WebRtc_UWord8 level)
+int32_t
+DTMFqueue::AddDTMF(uint8_t key, uint16_t len, uint8_t level)
{
CriticalSectionScoped lock(_DTMFCritsect);
@@ -36,7 +36,7 @@
{
return -1;
}
- WebRtc_Word32 index = _nextEmptyIndex;
+ int32_t index = _nextEmptyIndex;
_DTMFKey[index] = key;
_DTMFLen[index] = len;
_DTMFLevel[index] = level;
@@ -44,8 +44,8 @@
return 0;
}
-WebRtc_Word8
-DTMFqueue::NextDTMF(WebRtc_UWord8* DTMFKey, WebRtc_UWord16* len, WebRtc_UWord8* level)
+int8_t
+DTMFqueue::NextDTMF(uint8_t* DTMFKey, uint16_t* len, uint8_t* level)
{
CriticalSectionScoped lock(_DTMFCritsect);
@@ -57,9 +57,9 @@
*len=_DTMFLen[0];
*level=_DTMFLevel[0];
- memmove(&(_DTMFKey[0]), &(_DTMFKey[1]), _nextEmptyIndex*sizeof(WebRtc_UWord8));
- memmove(&(_DTMFLen[0]), &(_DTMFLen[1]), _nextEmptyIndex*sizeof(WebRtc_UWord16));
- memmove(&(_DTMFLevel[0]), &(_DTMFLevel[1]), _nextEmptyIndex*sizeof(WebRtc_UWord8));
+ memmove(&(_DTMFKey[0]), &(_DTMFKey[1]), _nextEmptyIndex*sizeof(uint8_t));
+ memmove(&(_DTMFLen[0]), &(_DTMFLen[1]), _nextEmptyIndex*sizeof(uint16_t));
+ memmove(&(_DTMFLevel[0]), &(_DTMFLevel[1]), _nextEmptyIndex*sizeof(uint8_t));
_nextEmptyIndex--;
return 0;
diff --git a/webrtc/modules/rtp_rtcp/source/dtmf_queue.h b/webrtc/modules/rtp_rtcp/source/dtmf_queue.h
index 8451a21..190f2ac 100644
--- a/webrtc/modules/rtp_rtcp/source/dtmf_queue.h
+++ b/webrtc/modules/rtp_rtcp/source/dtmf_queue.h
@@ -23,17 +23,17 @@
DTMFqueue();
virtual ~DTMFqueue();
- WebRtc_Word32 AddDTMF(WebRtc_UWord8 DTMFKey, WebRtc_UWord16 len, WebRtc_UWord8 level);
- WebRtc_Word8 NextDTMF(WebRtc_UWord8* DTMFKey, WebRtc_UWord16 * len, WebRtc_UWord8 * level);
+ int32_t AddDTMF(uint8_t DTMFKey, uint16_t len, uint8_t level);
+ int8_t NextDTMF(uint8_t* DTMFKey, uint16_t * len, uint8_t * level);
bool PendingDTMF();
void ResetDTMF();
private:
CriticalSectionWrapper* _DTMFCritsect;
- WebRtc_UWord8 _nextEmptyIndex;
- WebRtc_UWord8 _DTMFKey[DTMF_OUTBAND_MAX];
- WebRtc_UWord16 _DTMFLen[DTMF_OUTBAND_MAX];
- WebRtc_UWord8 _DTMFLevel[DTMF_OUTBAND_MAX];
+ uint8_t _nextEmptyIndex;
+ uint8_t _DTMFKey[DTMF_OUTBAND_MAX];
+ uint16_t _DTMFLen[DTMF_OUTBAND_MAX];
+ uint8_t _DTMFLevel[DTMF_OUTBAND_MAX];
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h b/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h
index 9acec28..855b911 100644
--- a/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h
+++ b/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h
@@ -22,18 +22,18 @@
bool());
MOCK_CONST_METHOD4(PayloadIsCompatible,
bool(const ModuleRTPUtility::Payload& payload,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate));
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate));
MOCK_CONST_METHOD2(UpdatePayloadRate,
- void(ModuleRTPUtility::Payload* payload, const WebRtc_UWord32 rate));
+ void(ModuleRTPUtility::Payload* payload, const uint32_t rate));
MOCK_CONST_METHOD5(CreatePayloadType,
ModuleRTPUtility::Payload*(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate));
+ const int8_t payloadType,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate));
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h b/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h
index 498c864..b9ad446 100644
--- a/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h
+++ b/webrtc/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h
@@ -19,27 +19,27 @@
public:
MockRTPReceiverVideo() : RTPReceiverVideo(0, NULL, NULL) {}
MOCK_METHOD1(ChangeUniqueId,
- void(const WebRtc_Word32 id));
+ void(const int32_t id));
MOCK_METHOD3(ReceiveRecoveredPacketCallback,
- WebRtc_Word32(WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadDataLength));
+ int32_t(WebRtcRTPHeader* rtpHeader,
+ const uint8_t* payloadData,
+ const uint16_t payloadDataLength));
MOCK_METHOD3(CallbackOfReceivedPayloadData,
- WebRtc_Word32(const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
- const WebRtcRTPHeader* rtpHeader));
+ int32_t(const uint8_t* payloadData,
+ const uint16_t payloadSize,
+ const WebRtcRTPHeader* rtpHeader));
MOCK_CONST_METHOD0(TimeStamp,
- WebRtc_UWord32());
+ uint32_t());
MOCK_CONST_METHOD0(SequenceNumber,
- WebRtc_UWord16());
+ uint16_t());
MOCK_CONST_METHOD2(PayloadTypeToPayload,
- WebRtc_UWord32(const WebRtc_UWord8 payloadType,
- ModuleRTPUtility::Payload*& payload));
+ uint32_t(const uint8_t payloadType,
+ ModuleRTPUtility::Payload*& payload));
MOCK_CONST_METHOD2(RetransmitOfOldPacket,
- bool(const WebRtc_UWord16 sequenceNumber,
- const WebRtc_UWord32 rtpTimeStamp));
+ bool(const uint16_t sequenceNumber,
+ const uint32_t rtpTimeStamp));
MOCK_CONST_METHOD0(REDPayloadType,
- WebRtc_Word8());
+ int8_t());
MOCK_CONST_METHOD0(HaveNotReceivedPackets,
bool());
};
diff --git a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
index 59d8f1c..925db94 100644
--- a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
@@ -19,18 +19,18 @@
namespace webrtc {
const int kVideoNackListSize = 10;
const int kTestId = 123;
-const WebRtc_UWord32 kTestSsrc = 3456;
-const WebRtc_UWord16 kTestSequenceNumber = 2345;
-const WebRtc_UWord32 kTestNumberOfPackets = 450;
+const uint32_t kTestSsrc = 3456;
+const uint16_t kTestSequenceNumber = 2345;
+const uint32_t kTestNumberOfPackets = 450;
const int kTestNumberOfRtxPackets = 49;
class VerifyingRtxReceiver : public RtpData {
public:
VerifyingRtxReceiver() {}
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 size,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* data,
+ const uint16_t size,
const webrtc::WebRtcRTPHeader* rtp_header) {
if (!sequence_numbers_.empty()) {
EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc);
@@ -38,7 +38,7 @@
sequence_numbers_.push_back(rtp_header->header.sequenceNumber);
return 0;
}
- std::vector<WebRtc_UWord16 > sequence_numbers_;
+ std::vector<uint16_t > sequence_numbers_;
};
class RtxLoopBackTransport : public webrtc::Transport {
@@ -66,13 +66,13 @@
return len;
}
}
- if (module_->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (module_->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
}
virtual int SendRTCPPacket(int channel, const void *data, int len) {
- if (module_->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (module_->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
@@ -133,14 +133,14 @@
RtpRtcp* rtp_rtcp_module_;
RtxLoopBackTransport transport_;
VerifyingRtxReceiver receiver_;
- WebRtc_UWord8 payload_data[65000];
+ uint8_t payload_data[65000];
int payload_data_length;
SimulatedClock fake_clock;
};
TEST_F(RtpRtcpRtxNackTest, RTCP) {
- WebRtc_UWord32 timestamp = 3000;
- WebRtc_UWord16 nack_list[kVideoNackListSize];
+ uint32_t timestamp = 3000;
+ uint16_t nack_list[kVideoNackListSize];
transport_.DropEveryNthPacket(10);
for (int frame = 0; frame < 10; ++frame) {
@@ -154,17 +154,17 @@
std::sort(receiver_.sequence_numbers_.begin(),
receiver_.sequence_numbers_.end());
- std::vector<WebRtc_UWord16> missing_sequence_numbers;
- std::vector<WebRtc_UWord16>::iterator it =
+ std::vector<uint16_t> missing_sequence_numbers;
+ std::vector<uint16_t>::iterator it =
receiver_.sequence_numbers_.begin();
while (it != receiver_.sequence_numbers_.end()) {
- WebRtc_UWord16 sequence_number_1 = *it;
+ uint16_t sequence_number_1 = *it;
++it;
if (it != receiver_.sequence_numbers_.end()) {
- WebRtc_UWord16 sequence_number_2 = *it;
+ uint16_t sequence_number_2 = *it;
// Add all missing sequence numbers to list.
- for (WebRtc_UWord16 i = sequence_number_1 + 1; i < sequence_number_2;
+ for (uint16_t i = sequence_number_1 + 1; i < sequence_number_2;
++i) {
missing_sequence_numbers.push_back(i);
}
@@ -198,8 +198,8 @@
transport_.DropEveryNthPacket(10);
- WebRtc_UWord32 timestamp = 3000;
- WebRtc_UWord16 nack_list[kVideoNackListSize];
+ uint32_t timestamp = 3000;
+ uint16_t nack_list[kVideoNackListSize];
for (int frame = 0; frame < 10; ++frame) {
EXPECT_EQ(0, rtp_rtcp_module_->SendOutgoingData(webrtc::kVideoFrameDelta,
@@ -212,10 +212,10 @@
std::sort(receiver_.sequence_numbers_.begin(),
receiver_.sequence_numbers_.end());
- std::vector<WebRtc_UWord16> missing_sequence_numbers;
+ std::vector<uint16_t> missing_sequence_numbers;
- std::vector<WebRtc_UWord16>::iterator it =
+ std::vector<uint16_t>::iterator it =
receiver_.sequence_numbers_.begin();
while (it != receiver_.sequence_numbers_.end()) {
int sequence_number_1 = *it;
@@ -255,7 +255,7 @@
true, kTestSsrc + 1));
transport_.DropEveryNthPacket(0);
- WebRtc_UWord32 timestamp = 3000;
+ uint32_t timestamp = 3000;
for (int frame = 0; frame < 10; ++frame) {
EXPECT_EQ(0, rtp_rtcp_module_->SendOutgoingData(webrtc::kVideoFrameDelta,
@@ -292,8 +292,8 @@
int loss = 10;
transport_.DropEveryNthPacket(loss);
- WebRtc_UWord32 timestamp = 3000;
- WebRtc_UWord16 nack_list[kVideoNackListSize];
+ uint32_t timestamp = 3000;
+ uint16_t nack_list[kVideoNackListSize];
for (int frame = 0; frame < 10; ++frame) {
EXPECT_EQ(0, rtp_rtcp_module_->SendOutgoingData(webrtc::kVideoFrameDelta,
@@ -304,9 +304,9 @@
payload_data_length));
std::sort(receiver_.sequence_numbers_.begin(),
receiver_.sequence_numbers_.end());
- std::vector<WebRtc_UWord16> missing_sequence_numbers;
+ std::vector<uint16_t> missing_sequence_numbers;
- std::vector<WebRtc_UWord16>::iterator it =
+ std::vector<uint16_t>::iterator it =
receiver_.sequence_numbers_.begin();
while (it != receiver_.sequence_numbers_.end()) {
int sequence_number_1 = *it;
diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec.cc b/webrtc/modules/rtp_rtcp/source/producer_fec.cc
index 52d5086..9d9a4b3 100644
--- a/webrtc/modules/rtp_rtcp/source/producer_fec.cc
+++ b/webrtc/modules/rtp_rtcp/source/producer_fec.cc
@@ -32,7 +32,7 @@
// media packets).
struct RtpPacket {
- WebRtc_UWord16 rtpHeaderLength;
+ uint16_t rtpHeaderLength;
ForwardErrorCorrection::Packet* pkt;
};
diff --git a/webrtc/modules/rtp_rtcp/source/receiver_fec.cc b/webrtc/modules/rtp_rtcp/source/receiver_fec.cc
index e86f578..bf640d6 100644
--- a/webrtc/modules/rtp_rtcp/source/receiver_fec.cc
+++ b/webrtc/modules/rtp_rtcp/source/receiver_fec.cc
@@ -19,7 +19,7 @@
// RFC 5109
namespace webrtc {
-ReceiverFEC::ReceiverFEC(const WebRtc_Word32 id, RTPReceiverVideo* owner)
+ReceiverFEC::ReceiverFEC(const int32_t id, RTPReceiverVideo* owner)
: _id(id),
_owner(owner),
_fec(new ForwardErrorCorrection(id)),
@@ -42,7 +42,7 @@
}
}
-void ReceiverFEC::SetPayloadTypeFEC(const WebRtc_Word8 payloadType) {
+void ReceiverFEC::SetPayloadTypeFEC(const int8_t payloadType) {
_payloadTypeFEC = payloadType;
}
@@ -76,16 +76,16 @@
block excluding header.
*/
-WebRtc_Word32 ReceiverFEC::AddReceivedFECPacket(
+int32_t ReceiverFEC::AddReceivedFECPacket(
const WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord8* incomingRtpPacket,
- const WebRtc_UWord16 payloadDataLength,
+ const uint8_t* incomingRtpPacket,
+ const uint16_t payloadDataLength,
bool& FECpacket) {
if (_payloadTypeFEC == -1) {
return -1;
}
- WebRtc_UWord8 REDHeaderLength = 1;
+ uint8_t REDHeaderLength = 1;
// Add to list without RED header, aka a virtual RTP packet
// we remove the RED header
@@ -95,7 +95,7 @@
receivedPacket->pkt = new ForwardErrorCorrection::Packet;
// get payload type from RED header
- WebRtc_UWord8 payloadType =
+ uint8_t payloadType =
incomingRtpPacket[rtpHeader->header.headerLength] & 0x7f;
// use the payloadType to decide if it's FEC or coded data
@@ -108,11 +108,11 @@
}
receivedPacket->seqNum = rtpHeader->header.sequenceNumber;
- WebRtc_UWord16 blockLength = 0;
+ uint16_t blockLength = 0;
if(incomingRtpPacket[rtpHeader->header.headerLength] & 0x80) {
// f bit set in RED header
REDHeaderLength = 4;
- WebRtc_UWord16 timestampOffset =
+ uint16_t timestampOffset =
(incomingRtpPacket[rtpHeader->header.headerLength + 1]) << 8;
timestampOffset += incomingRtpPacket[rtpHeader->header.headerLength+2];
timestampOffset = timestampOffset >> 2;
@@ -221,7 +221,7 @@
return 0;
}
-WebRtc_Word32 ReceiverFEC::ProcessReceivedFEC() {
+int32_t ReceiverFEC::ProcessReceivedFEC() {
if (!_receivedPacketList.empty()) {
// Send received media packet to VCM.
if (!_receivedPacketList.front()->isFec) {
diff --git a/webrtc/modules/rtp_rtcp/source/receiver_fec.h b/webrtc/modules/rtp_rtcp/source/receiver_fec.h
index 63aaa72..4ce2e97 100644
--- a/webrtc/modules/rtp_rtcp/source/receiver_fec.h
+++ b/webrtc/modules/rtp_rtcp/source/receiver_fec.h
@@ -23,17 +23,17 @@
class ReceiverFEC
{
public:
- ReceiverFEC(const WebRtc_Word32 id, RTPReceiverVideo* owner);
+ ReceiverFEC(const int32_t id, RTPReceiverVideo* owner);
virtual ~ReceiverFEC();
- WebRtc_Word32 AddReceivedFECPacket(const WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord8* incomingRtpPacket,
- const WebRtc_UWord16 payloadDataLength,
- bool& FECpacket);
+ int32_t AddReceivedFECPacket(const WebRtcRTPHeader* rtpHeader,
+ const uint8_t* incomingRtpPacket,
+ const uint16_t payloadDataLength,
+ bool& FECpacket);
- WebRtc_Word32 ProcessReceivedFEC();
+ int32_t ProcessReceivedFEC();
- void SetPayloadTypeFEC(const WebRtc_Word8 payloadType);
+ void SetPayloadTypeFEC(const int8_t payloadType);
private:
int ParseAndReceivePacket(const ForwardErrorCorrection::Packet* packet);
@@ -46,7 +46,7 @@
// arrives. We should remove the list.
ForwardErrorCorrection::ReceivedPacketList _receivedPacketList;
ForwardErrorCorrection::RecoveredPacketList _recoveredPacketList;
- WebRtc_Word8 _payloadTypeFEC;
+ int8_t _payloadTypeFEC;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
index cdf334d..3d0c3fa 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
@@ -36,8 +36,8 @@
virtual int SendRTCPPacket(int /*channel*/,
const void *packet,
int packetLength) {
- RTCPUtility::RTCPParserV2 rtcpParser((WebRtc_UWord8*)packet,
- (WebRtc_Word32)packetLength,
+ RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet,
+ (int32_t)packetLength,
true); // Allow non-compound RTCP
EXPECT_TRUE(rtcpParser.IsValid());
@@ -45,9 +45,9 @@
EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation,
&rtcpParser));
- EXPECT_EQ((WebRtc_UWord32)kRtcpRemb,
+ EXPECT_EQ((uint32_t)kRtcpRemb,
rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRemb);
- EXPECT_EQ((WebRtc_UWord32)1234,
+ EXPECT_EQ((uint32_t)1234,
rtcpPacketInformation.receiverEstimatedMaxBitrate);
return packetLength;
}
@@ -113,14 +113,14 @@
}
TEST_F(RtcpFormatRembTest, TestNonCompund) {
- WebRtc_UWord32 SSRC = 456789;
+ uint32_t SSRC = 456789;
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpNonCompound));
EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 1, &SSRC));
EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRemb));
}
TEST_F(RtcpFormatRembTest, TestCompund) {
- WebRtc_UWord32 SSRCs[2] = {456789, 98765};
+ uint32_t SSRCs[2] = {456789, 98765};
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 2, SSRCs));
EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRemb));
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
index fba1818..d6bf092 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -30,7 +30,7 @@
// The number of RTCP time intervals needed to trigger a timeout.
const int kRrTimeoutIntervals = 3;
-RTCPReceiver::RTCPReceiver(const WebRtc_Word32 id, Clock* clock,
+RTCPReceiver::RTCPReceiver(const int32_t id, Clock* clock,
ModuleRtpRtcpImpl* owner)
: TMMBRHelp(),
_id(id),
@@ -64,19 +64,19 @@
delete _criticalSectionFeedbacks;
while (!_receivedReportBlockMap.empty()) {
- std::map<WebRtc_UWord32, RTCPReportBlockInformation*>::iterator first =
+ std::map<uint32_t, RTCPReportBlockInformation*>::iterator first =
_receivedReportBlockMap.begin();
delete first->second;
_receivedReportBlockMap.erase(first);
}
while (!_receivedInfoMap.empty()) {
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::iterator first =
+ std::map<uint32_t, RTCPReceiveInformation*>::iterator first =
_receivedInfoMap.begin();
delete first->second;
_receivedInfoMap.erase(first);
}
while (!_receivedCnameMap.empty()) {
- std::map<WebRtc_UWord32, RTCPCnameInformation*>::iterator first =
+ std::map<uint32_t, RTCPCnameInformation*>::iterator first =
_receivedCnameMap.begin();
delete first->second;
_receivedCnameMap.erase(first);
@@ -86,7 +86,7 @@
}
void
-RTCPReceiver::ChangeUniqueId(const WebRtc_Word32 id)
+RTCPReceiver::ChangeUniqueId(const int32_t id)
{
_id = id;
}
@@ -98,7 +98,7 @@
return _method;
}
-WebRtc_Word32
+int32_t
RTCPReceiver::SetRTCPStatus(const RTCPMethod method)
{
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
@@ -106,17 +106,17 @@
return 0;
}
-WebRtc_Word64
+int64_t
RTCPReceiver::LastReceived()
{
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
return _lastReceived;
}
-WebRtc_Word64
+int64_t
RTCPReceiver::LastReceivedReceiverReport() const {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- WebRtc_Word64 last_received_rr = -1;
+ int64_t last_received_rr = -1;
for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin();
it != _receivedInfoMap.end(); ++it) {
if (it->second->lastTimeReceived > last_received_rr) {
@@ -126,8 +126,8 @@
return last_received_rr;
}
-WebRtc_Word32
-RTCPReceiver::SetRemoteSSRC( const WebRtc_UWord32 ssrc)
+int32_t
+RTCPReceiver::SetRemoteSSRC( const uint32_t ssrc)
{
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
@@ -151,8 +151,8 @@
}
-void RTCPReceiver::SetSSRC(const WebRtc_UWord32 ssrc) {
- WebRtc_UWord32 old_ssrc = 0;
+void RTCPReceiver::SetSSRC(const uint32_t ssrc) {
+ uint32_t old_ssrc = 0;
{
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
old_ssrc = _SSRC;
@@ -166,7 +166,7 @@
}
}
-WebRtc_Word32 RTCPReceiver::ResetRTT(const WebRtc_UWord32 remoteSSRC) {
+int32_t RTCPReceiver::ResetRTT(const uint32_t remoteSSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
RTCPReportBlockInformation* reportBlock =
GetReportBlockInformation(remoteSSRC);
@@ -182,11 +182,11 @@
return 0;
}
-WebRtc_Word32 RTCPReceiver::RTT(const WebRtc_UWord32 remoteSSRC,
- WebRtc_UWord16* RTT,
- WebRtc_UWord16* avgRTT,
- WebRtc_UWord16* minRTT,
- WebRtc_UWord16* maxRTT) const {
+int32_t RTCPReceiver::RTT(const uint32_t remoteSSRC,
+ uint16_t* RTT,
+ uint16_t* avgRTT,
+ uint16_t* minRTT,
+ uint16_t* maxRTT) const {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
RTCPReportBlockInformation* reportBlock =
@@ -210,7 +210,7 @@
return 0;
}
-WebRtc_UWord16 RTCPReceiver::RTT() const {
+uint16_t RTCPReceiver::RTT() const {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
if (!_receivedReportBlockMap.empty()) {
return 0;
@@ -218,7 +218,7 @@
return _rtt;
}
-int RTCPReceiver::SetRTT(WebRtc_UWord16 rtt) {
+int RTCPReceiver::SetRTT(uint16_t rtt) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
if (!_receivedReportBlockMap.empty()) {
return -1;
@@ -227,12 +227,12 @@
return 0;
}
-WebRtc_Word32
-RTCPReceiver::NTP(WebRtc_UWord32 *ReceivedNTPsecs,
- WebRtc_UWord32 *ReceivedNTPfrac,
- WebRtc_UWord32 *RTCPArrivalTimeSecs,
- WebRtc_UWord32 *RTCPArrivalTimeFrac,
- WebRtc_UWord32 *rtcp_timestamp) const
+int32_t
+RTCPReceiver::NTP(uint32_t *ReceivedNTPsecs,
+ uint32_t *ReceivedNTPfrac,
+ uint32_t *RTCPArrivalTimeSecs,
+ uint32_t *RTCPArrivalTimeFrac,
+ uint32_t *rtcp_timestamp) const
{
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
if(ReceivedNTPsecs)
@@ -257,7 +257,7 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const
{
if(senderInfo == NULL)
@@ -277,12 +277,12 @@
// statistics
// we can get multiple receive reports when we receive the report from a CE
-WebRtc_Word32 RTCPReceiver::StatisticsReceived(
+int32_t RTCPReceiver::StatisticsReceived(
std::vector<RTCPReportBlock>* receiveBlocks) const {
assert(receiveBlocks);
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReportBlockInformation*>::const_iterator it =
+ std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
_receivedReportBlockMap.begin();
while (it != _receivedReportBlockMap.end()) {
@@ -292,7 +292,7 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
RTCPUtility::RTCPParserV2* rtcpParser)
{
@@ -383,8 +383,8 @@
// rtcpPacket.RR.SenderSSRC
// The source of the packet sender, same as of SR? or is this a CE?
- const WebRtc_UWord32 remoteSSRC = (rtcpPacketType == RTCPUtility::kRtcpRrCode) ? rtcpPacket.RR.SenderSSRC:rtcpPacket.SR.SenderSSRC;
- const WebRtc_UWord8 numberOfReportBlocks = (rtcpPacketType == RTCPUtility::kRtcpRrCode) ? rtcpPacket.RR.NumberOfReportBlocks:rtcpPacket.SR.NumberOfReportBlocks;
+ const uint32_t remoteSSRC = (rtcpPacketType == RTCPUtility::kRtcpRrCode) ? rtcpPacket.RR.SenderSSRC:rtcpPacket.SR.SenderSSRC;
+ const uint8_t numberOfReportBlocks = (rtcpPacketType == RTCPUtility::kRtcpRrCode) ? rtcpPacket.RR.NumberOfReportBlocks:rtcpPacket.SR.NumberOfReportBlocks;
rtcpPacketInformation.remoteSSRC = remoteSSRC;
@@ -447,8 +447,8 @@
void
RTCPReceiver::HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket,
RTCPPacketInformation& rtcpPacketInformation,
- const WebRtc_UWord32 remoteSSRC,
- const WebRtc_UWord8 numberOfReportBlocks) {
+ const uint32_t remoteSSRC,
+ const uint8_t numberOfReportBlocks) {
// This will be called once per report block in the RTCP packet.
// We filter out all report blocks that are not for us.
// Each packet has max 31 RR blocks.
@@ -467,7 +467,7 @@
// To avoid problem with acquiring _criticalSectionRTCPSender while holding
// _criticalSectionRTCPReceiver.
_criticalSectionRTCPReceiver->Leave();
- WebRtc_UWord32 sendTimeMS =
+ uint32_t sendTimeMS =
_rtpRtcp.SendTimeOfSendReport(rtcpPacket.ReportBlockItem.LastSR);
_criticalSectionRTCPReceiver->Enter();
@@ -502,25 +502,25 @@
reportBlock->remoteMaxJitter = rtcpPacket.ReportBlockItem.Jitter;
}
- WebRtc_UWord32 delaySinceLastSendReport =
+ uint32_t delaySinceLastSendReport =
rtcpPacket.ReportBlockItem.DelayLastSR;
// local NTP time when we received this
- WebRtc_UWord32 lastReceivedRRNTPsecs = 0;
- WebRtc_UWord32 lastReceivedRRNTPfrac = 0;
+ uint32_t lastReceivedRRNTPsecs = 0;
+ uint32_t lastReceivedRRNTPfrac = 0;
_clock->CurrentNtp(lastReceivedRRNTPsecs, lastReceivedRRNTPfrac);
// time when we received this in MS
- WebRtc_UWord32 receiveTimeMS = ModuleRTPUtility::ConvertNTPTimeToMS(
+ uint32_t receiveTimeMS = ModuleRTPUtility::ConvertNTPTimeToMS(
lastReceivedRRNTPsecs, lastReceivedRRNTPfrac);
// Estimate RTT
- WebRtc_UWord32 d = (delaySinceLastSendReport & 0x0000ffff) * 1000;
+ uint32_t d = (delaySinceLastSendReport & 0x0000ffff) * 1000;
d /= 65536;
d += ((delaySinceLastSendReport & 0xffff0000) >> 16) * 1000;
- WebRtc_Word32 RTT = 0;
+ int32_t RTT = 0;
if (sendTimeMS > 0) {
RTT = receiveTimeMS - d - sendTimeMS;
@@ -529,17 +529,17 @@
}
if (RTT > reportBlock->maxRTT) {
// store max RTT
- reportBlock->maxRTT = (WebRtc_UWord16) RTT;
+ reportBlock->maxRTT = (uint16_t) RTT;
}
if (reportBlock->minRTT == 0) {
// first RTT
- reportBlock->minRTT = (WebRtc_UWord16) RTT;
+ reportBlock->minRTT = (uint16_t) RTT;
} else if (RTT < reportBlock->minRTT) {
// Store min RTT
- reportBlock->minRTT = (WebRtc_UWord16) RTT;
+ reportBlock->minRTT = (uint16_t) RTT;
}
// store last RTT
- reportBlock->RTT = (WebRtc_UWord16) RTT;
+ reportBlock->RTT = (uint16_t) RTT;
// store average RTT
if (reportBlock->numAverageCalcs != 0) {
@@ -549,7 +549,7 @@
reportBlock->avgRTT = static_cast<int> (newAverage + 0.5f);
} else {
// first RTT
- reportBlock->avgRTT = (WebRtc_UWord16) RTT;
+ reportBlock->avgRTT = (uint16_t) RTT;
}
reportBlock->numAverageCalcs++;
}
@@ -560,16 +560,16 @@
// rtcpPacketInformation
rtcpPacketInformation.AddReportInfo(
- reportBlock->remoteReceiveBlock.fractionLost, (WebRtc_UWord16) RTT,
+ reportBlock->remoteReceiveBlock.fractionLost, (uint16_t) RTT,
reportBlock->remoteReceiveBlock.extendedHighSeqNum,
reportBlock->remoteReceiveBlock.jitter);
}
RTCPReportBlockInformation*
-RTCPReceiver::CreateReportBlockInformation(WebRtc_UWord32 remoteSSRC) {
+RTCPReceiver::CreateReportBlockInformation(uint32_t remoteSSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReportBlockInformation*>::iterator it =
+ std::map<uint32_t, RTCPReportBlockInformation*>::iterator it =
_receivedReportBlockMap.find(remoteSSRC);
RTCPReportBlockInformation* ptrReportBlockInfo = NULL;
@@ -583,10 +583,10 @@
}
RTCPReportBlockInformation*
-RTCPReceiver::GetReportBlockInformation(WebRtc_UWord32 remoteSSRC) const {
+RTCPReceiver::GetReportBlockInformation(uint32_t remoteSSRC) const {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReportBlockInformation*>::const_iterator it =
+ std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
_receivedReportBlockMap.find(remoteSSRC);
if (it == _receivedReportBlockMap.end()) {
@@ -596,10 +596,10 @@
}
RTCPCnameInformation*
-RTCPReceiver::CreateCnameInformation(WebRtc_UWord32 remoteSSRC) {
+RTCPReceiver::CreateCnameInformation(uint32_t remoteSSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPCnameInformation*>::iterator it =
+ std::map<uint32_t, RTCPCnameInformation*>::iterator it =
_receivedCnameMap.find(remoteSSRC);
if (it != _receivedCnameMap.end()) {
@@ -612,10 +612,10 @@
}
RTCPCnameInformation*
-RTCPReceiver::GetCnameInformation(WebRtc_UWord32 remoteSSRC) const {
+RTCPReceiver::GetCnameInformation(uint32_t remoteSSRC) const {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPCnameInformation*>::const_iterator it =
+ std::map<uint32_t, RTCPCnameInformation*>::const_iterator it =
_receivedCnameMap.find(remoteSSRC);
if (it == _receivedCnameMap.end()) {
@@ -625,10 +625,10 @@
}
RTCPReceiveInformation*
-RTCPReceiver::CreateReceiveInformation(WebRtc_UWord32 remoteSSRC) {
+RTCPReceiver::CreateReceiveInformation(uint32_t remoteSSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::iterator it =
+ std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
_receivedInfoMap.find(remoteSSRC);
if (it != _receivedInfoMap.end()) {
@@ -640,10 +640,10 @@
}
RTCPReceiveInformation*
-RTCPReceiver::GetReceiveInformation(WebRtc_UWord32 remoteSSRC) {
+RTCPReceiver::GetReceiveInformation(uint32_t remoteSSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::iterator it =
+ std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
_receivedInfoMap.find(remoteSSRC);
if (it == _receivedInfoMap.end()) {
return NULL;
@@ -690,9 +690,9 @@
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
bool updateBoundingSet = false;
- WebRtc_Word64 timeNow = _clock->TimeInMilliseconds();
+ int64_t timeNow = _clock->TimeInMilliseconds();
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::iterator receiveInfoIt =
+ std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
_receivedInfoMap.begin();
while (receiveInfoIt != _receivedInfoMap.end()) {
@@ -718,7 +718,7 @@
receiveInfoIt++;
} else if (receiveInfo->readyForDelete) {
// store our current receiveInfoItem
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::iterator
+ std::map<uint32_t, RTCPReceiveInformation*>::iterator
receiveInfoItemToBeErased = receiveInfoIt;
receiveInfoIt++;
delete receiveInfoItemToBeErased->second;
@@ -730,11 +730,10 @@
return updateBoundingSet;
}
-WebRtc_Word32 RTCPReceiver::BoundingSet(bool &tmmbrOwner,
- TMMBRSet* boundingSetRec) {
+int32_t RTCPReceiver::BoundingSet(bool &tmmbrOwner, TMMBRSet* boundingSetRec) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::iterator receiveInfoIt =
+ std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
_receivedInfoMap.find(_remoteSSRC);
if (receiveInfoIt == _receivedInfoMap.end()) {
@@ -750,7 +749,7 @@
if (receiveInfo->TmmbnBoundingSet.lengthOfSet() > 0) {
boundingSetRec->VerifyAndAllocateSet(
receiveInfo->TmmbnBoundingSet.lengthOfSet() + 1);
- for(WebRtc_UWord32 i=0; i< receiveInfo->TmmbnBoundingSet.lengthOfSet();
+ for(uint32_t i=0; i< receiveInfo->TmmbnBoundingSet.lengthOfSet();
i++) {
if(receiveInfo->TmmbnBoundingSet.Ssrc(i) == _SSRC) {
// owner of bounding set
@@ -817,7 +816,7 @@
{
rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID);
- WebRtc_UWord16 bitMask = rtcpPacket.NACKItem.BitMask;
+ uint16_t bitMask = rtcpPacket.NACKItem.BitMask;
if(bitMask)
{
for(int i=1; i <= 16; ++i)
@@ -839,7 +838,7 @@
// clear our lists
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReportBlockInformation*>::iterator
+ std::map<uint32_t, RTCPReportBlockInformation*>::iterator
reportBlockInfoIt = _receivedReportBlockMap.find(
rtcpPacket.BYE.SenderSSRC);
@@ -848,14 +847,14 @@
_receivedReportBlockMap.erase(reportBlockInfoIt);
}
// we can't delete it due to TMMBR
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::iterator receiveInfoIt =
+ std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
_receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC);
if (receiveInfoIt != _receivedInfoMap.end()) {
receiveInfoIt->second->readyForDelete = true;
}
- std::map<WebRtc_UWord32, RTCPCnameInformation*>::iterator cnameInfoIt =
+ std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt =
_receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC);
if (cnameInfoIt != _receivedCnameMap.end()) {
@@ -927,7 +926,7 @@
{
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
- WebRtc_UWord32 senderSSRC = rtcpPacket.TMMBR.SenderSSRC;
+ uint32_t senderSSRC = rtcpPacket.TMMBR.SenderSSRC;
RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC);
if (ptrReceiveInfo == NULL)
{
@@ -953,7 +952,7 @@
rtcpParser.Iterate();
return;
}
- ptrReceiveInfo->VerifyAndAllocateTMMBRSet((WebRtc_UWord32)maxNumOfTMMBRBlocks);
+ ptrReceiveInfo->VerifyAndAllocateTMMBRSet((uint32_t)maxNumOfTMMBRBlocks);
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpRtpfbTmmbrItemCode)
@@ -968,7 +967,7 @@
RTCPReceiver::HandleTMMBRItem(RTCPReceiveInformation& receiveInfo,
const RTCPUtility::RTCPPacket& rtcpPacket,
RTCPPacketInformation& rtcpPacketInformation,
- const WebRtc_UWord32 senderSSRC)
+ const uint32_t senderSSRC)
{
if (_SSRC == rtcpPacket.TMMBRItem.SSRC &&
rtcpPacket.TMMBRItem.MaxTotalMediaBitRate > 0)
@@ -1005,7 +1004,7 @@
return;
}
- ptrReceiveInfo->VerifyAndAllocateBoundingSet((WebRtc_UWord32)maxNumOfTMMBNBlocks);
+ ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks);
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpRtpfbTmmbnItemCode)
@@ -1078,8 +1077,8 @@
rtcpPacketInformation.rpsiPictureId = 0;
// convert NativeBitString to rpsiPictureId
- WebRtc_UWord8 numberOfBytes = rtcpPacket.RPSI.NumberOfValidBits /8;
- for(WebRtc_UWord8 n = 0; n < (numberOfBytes-1); n++)
+ uint8_t numberOfBytes = rtcpPacket.RPSI.NumberOfValidBits /8;
+ for(uint8_t n = 0; n < (numberOfBytes-1); n++)
{
rtcpPacketInformation.rpsiPictureId += (rtcpPacket.RPSI.NativeBitString[n] & 0x7f);
rtcpPacketInformation.rpsiPictureId <<= 7; // prepare next
@@ -1162,7 +1161,7 @@
// check if we have reported this FIRSequenceNumber before
if (rtcpPacket.FIRItem.CommandSequenceNumber !=
receiveInfo->lastFIRSequenceNumber) {
- WebRtc_Word64 now = _clock->TimeInMilliseconds();
+ int64_t now = _clock->TimeInMilliseconds();
// sanity; don't go crazy with the callbacks
if ((now - receiveInfo->lastFIRRequest) > RTCP_MIN_FRAME_LENGTH_MS) {
receiveInfo->lastFIRRequest = now;
@@ -1202,12 +1201,12 @@
rtcpParser.Iterate();
}
-WebRtc_Word32 RTCPReceiver::UpdateTMMBR() {
- WebRtc_Word32 numBoundingSet = 0;
- WebRtc_UWord32 bitrate = 0;
- WebRtc_UWord32 accNumCandidates = 0;
+int32_t RTCPReceiver::UpdateTMMBR() {
+ int32_t numBoundingSet = 0;
+ uint32_t bitrate = 0;
+ uint32_t accNumCandidates = 0;
- WebRtc_Word32 size = TMMBRReceived(0, 0, NULL);
+ int32_t size = TMMBRReceived(0, 0, NULL);
if (size > 0) {
TMMBRSet* candidateSet = VerifyAndAllocateCandidateSet(size);
// Get candidate set from receiver.
@@ -1318,7 +1317,7 @@
if ((rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr ||
rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr) &&
rtcpPacketInformation.reportBlock) {
- WebRtc_Word64 now = _clock->TimeInMilliseconds();
+ int64_t now = _clock->TimeInMilliseconds();
_cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
rtcpPacketInformation.remoteSSRC,
rtcpPacketInformation.fractionLost,
@@ -1353,8 +1352,8 @@
}
}
-WebRtc_Word32 RTCPReceiver::CNAME(const WebRtc_UWord32 remoteSSRC,
- char cName[RTCP_CNAME_SIZE]) const {
+int32_t RTCPReceiver::CNAME(const uint32_t remoteSSRC,
+ char cName[RTCP_CNAME_SIZE]) const {
assert(cName);
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
@@ -1368,24 +1367,24 @@
}
// no callbacks allowed inside this function
-WebRtc_Word32 RTCPReceiver::TMMBRReceived(const WebRtc_UWord32 size,
- const WebRtc_UWord32 accNumCandidates,
- TMMBRSet* candidateSet) const {
+int32_t RTCPReceiver::TMMBRReceived(const uint32_t size,
+ const uint32_t accNumCandidates,
+ TMMBRSet* candidateSet) const {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
- std::map<WebRtc_UWord32, RTCPReceiveInformation*>::const_iterator
+ std::map<uint32_t, RTCPReceiveInformation*>::const_iterator
receiveInfoIt = _receivedInfoMap.begin();
if (receiveInfoIt == _receivedInfoMap.end()) {
return -1;
}
- WebRtc_UWord32 num = accNumCandidates;
+ uint32_t num = accNumCandidates;
if (candidateSet) {
while( num < size && receiveInfoIt != _receivedInfoMap.end()) {
RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
if (receiveInfo == NULL) {
return 0;
}
- for (WebRtc_UWord32 i = 0;
+ for (uint32_t i = 0;
(num < size) && (i < receiveInfo->TmmbrSet.lengthOfSet()); i++) {
if (receiveInfo->GetTMMBRSet(i, num, candidateSet,
_clock->TimeInMilliseconds()) == 0) {
@@ -1410,8 +1409,8 @@
return num;
}
-WebRtc_Word32
-RTCPReceiver::SetPacketTimeout(const WebRtc_UWord32 timeoutMS)
+int32_t
+RTCPReceiver::SetPacketTimeout(const uint32_t timeoutMS)
{
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
_packetTimeOutMS = timeoutMS;
@@ -1435,7 +1434,7 @@
return;
}
- WebRtc_Word64 now = _clock->TimeInMilliseconds();
+ int64_t now = _clock->TimeInMilliseconds();
if(now - _lastReceived > _packetTimeOutMS)
{
packetTimeOut = true;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
index befe2df..0833b4a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -27,61 +27,62 @@
class RTCPReceiver : public TMMBRHelp
{
public:
- RTCPReceiver(const WebRtc_Word32 id, Clock* clock,
+ RTCPReceiver(const int32_t id, Clock* clock,
ModuleRtpRtcpImpl* owner);
virtual ~RTCPReceiver();
- void ChangeUniqueId(const WebRtc_Word32 id);
+ void ChangeUniqueId(const int32_t id);
RTCPMethod Status() const;
- WebRtc_Word32 SetRTCPStatus(const RTCPMethod method);
+ int32_t SetRTCPStatus(const RTCPMethod method);
- WebRtc_Word64 LastReceived();
- WebRtc_Word64 LastReceivedReceiverReport() const;
+ int64_t LastReceived();
+ int64_t LastReceivedReceiverReport() const;
- void SetSSRC( const WebRtc_UWord32 ssrc);
- void SetRelaySSRC( const WebRtc_UWord32 ssrc);
- WebRtc_Word32 SetRemoteSSRC( const WebRtc_UWord32 ssrc);
+ void SetSSRC( const uint32_t ssrc);
+ void SetRelaySSRC( const uint32_t ssrc);
+ int32_t SetRemoteSSRC( const uint32_t ssrc);
- WebRtc_UWord32 RelaySSRC() const;
+ uint32_t RelaySSRC() const;
void RegisterRtcpObservers(RtcpIntraFrameObserver* intra_frame_callback,
RtcpBandwidthObserver* bandwidth_callback,
RtcpFeedback* feedback_callback);
- WebRtc_Word32 IncomingRTCPPacket(RTCPHelp::RTCPPacketInformation& rtcpPacketInformation,
- RTCPUtility::RTCPParserV2 *rtcpParser);
+ int32_t IncomingRTCPPacket(
+ RTCPHelp::RTCPPacketInformation& rtcpPacketInformation,
+ RTCPUtility::RTCPParserV2 *rtcpParser);
void TriggerCallbacksFromRTCPPacket(RTCPHelp::RTCPPacketInformation& rtcpPacketInformation);
// get received cname
- WebRtc_Word32 CNAME(const WebRtc_UWord32 remoteSSRC,
- char cName[RTCP_CNAME_SIZE]) const;
+ int32_t CNAME(const uint32_t remoteSSRC,
+ char cName[RTCP_CNAME_SIZE]) const;
// get received NTP
- WebRtc_Word32 NTP(WebRtc_UWord32 *ReceivedNTPsecs,
- WebRtc_UWord32 *ReceivedNTPfrac,
- WebRtc_UWord32 *RTCPArrivalTimeSecs,
- WebRtc_UWord32 *RTCPArrivalTimeFrac,
- WebRtc_UWord32 *rtcp_timestamp) const;
+ int32_t NTP(uint32_t *ReceivedNTPsecs,
+ uint32_t *ReceivedNTPfrac,
+ uint32_t *RTCPArrivalTimeSecs,
+ uint32_t *RTCPArrivalTimeFrac,
+ uint32_t *rtcp_timestamp) const;
// get rtt
- WebRtc_Word32 RTT(const WebRtc_UWord32 remoteSSRC,
- WebRtc_UWord16* RTT,
- WebRtc_UWord16* avgRTT,
- WebRtc_UWord16* minRTT,
- WebRtc_UWord16* maxRTT) const;
+ int32_t RTT(const uint32_t remoteSSRC,
+ uint16_t* RTT,
+ uint16_t* avgRTT,
+ uint16_t* minRTT,
+ uint16_t* maxRTT) const;
- WebRtc_UWord16 RTT() const;
+ uint16_t RTT() const;
- int SetRTT(WebRtc_UWord16 rtt);
+ int SetRTT(uint16_t rtt);
- WebRtc_Word32 ResetRTT(const WebRtc_UWord32 remoteSSRC);
+ int32_t ResetRTT(const uint32_t remoteSSRC);
- WebRtc_Word32 SenderInfoReceived(RTCPSenderInfo* senderInfo) const;
+ int32_t SenderInfoReceived(RTCPSenderInfo* senderInfo) const;
// get statistics
- WebRtc_Word32 StatisticsReceived(
+ int32_t StatisticsReceived(
std::vector<RTCPReportBlock>* receiveBlocks) const;
// Returns true if we haven't received an RTCP RR for several RTCP
@@ -95,28 +96,28 @@
bool RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms);
// Get TMMBR
- WebRtc_Word32 TMMBRReceived(const WebRtc_UWord32 size,
- const WebRtc_UWord32 accNumCandidates,
- TMMBRSet* candidateSet) const;
+ int32_t TMMBRReceived(const uint32_t size,
+ const uint32_t accNumCandidates,
+ TMMBRSet* candidateSet) const;
bool UpdateRTCPReceiveInformationTimers();
- WebRtc_Word32 BoundingSet(bool &tmmbrOwner, TMMBRSet* boundingSetRec);
+ int32_t BoundingSet(bool &tmmbrOwner, TMMBRSet* boundingSetRec);
- WebRtc_Word32 UpdateTMMBR();
+ int32_t UpdateTMMBR();
- WebRtc_Word32 SetPacketTimeout(const WebRtc_UWord32 timeoutMS);
+ int32_t SetPacketTimeout(const uint32_t timeoutMS);
void PacketTimeout();
protected:
- RTCPHelp::RTCPReportBlockInformation* CreateReportBlockInformation(const WebRtc_UWord32 remoteSSRC);
- RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(const WebRtc_UWord32 remoteSSRC) const;
+ RTCPHelp::RTCPReportBlockInformation* CreateReportBlockInformation(const uint32_t remoteSSRC);
+ RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(const uint32_t remoteSSRC) const;
- RTCPUtility::RTCPCnameInformation* CreateCnameInformation(const WebRtc_UWord32 remoteSSRC);
- RTCPUtility::RTCPCnameInformation* GetCnameInformation(const WebRtc_UWord32 remoteSSRC) const;
+ RTCPUtility::RTCPCnameInformation* CreateCnameInformation(const uint32_t remoteSSRC);
+ RTCPUtility::RTCPCnameInformation* GetCnameInformation(const uint32_t remoteSSRC) const;
- RTCPHelp::RTCPReceiveInformation* CreateReceiveInformation(const WebRtc_UWord32 remoteSSRC);
- RTCPHelp::RTCPReceiveInformation* GetReceiveInformation(const WebRtc_UWord32 remoteSSRC);
+ RTCPHelp::RTCPReceiveInformation* CreateReceiveInformation(const uint32_t remoteSSRC);
+ RTCPHelp::RTCPReceiveInformation* GetReceiveInformation(const uint32_t remoteSSRC);
void UpdateReceiveInformation( RTCPHelp::RTCPReceiveInformation& receiveInformation);
@@ -125,8 +126,8 @@
void HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation,
- const WebRtc_UWord32 remoteSSRC,
- const WebRtc_UWord8 numberOfReportBlocks);
+ const uint32_t remoteSSRC,
+ const uint8_t numberOfReportBlocks);
void HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser);
@@ -173,7 +174,7 @@
void HandleTMMBRItem(RTCPHelp::RTCPReceiveInformation& receiveInfo,
const RTCPUtility::RTCPPacket& rtcpPacket,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation,
- const WebRtc_UWord32 senderSSRC);
+ const uint32_t senderSSRC);
void HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation);
@@ -198,12 +199,12 @@
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation);
private:
- typedef std::map<WebRtc_UWord32, RTCPHelp::RTCPReceiveInformation*>
+ typedef std::map<uint32_t, RTCPHelp::RTCPReceiveInformation*>
ReceivedInfoMap;
- WebRtc_Word32 _id;
+ int32_t _id;
Clock* _clock;
RTCPMethod _method;
- WebRtc_Word64 _lastReceived;
+ int64_t _lastReceived;
ModuleRtpRtcpImpl& _rtpRtcp;
CriticalSectionWrapper* _criticalSectionFeedbacks;
@@ -212,23 +213,23 @@
RtcpIntraFrameObserver* _cbRtcpIntraFrameObserver;
CriticalSectionWrapper* _criticalSectionRTCPReceiver;
- WebRtc_UWord32 _SSRC;
- WebRtc_UWord32 _remoteSSRC;
+ uint32_t _SSRC;
+ uint32_t _remoteSSRC;
// Received send report
RTCPSenderInfo _remoteSenderInfo;
// when did we receive the last send report
- WebRtc_UWord32 _lastReceivedSRNTPsecs;
- WebRtc_UWord32 _lastReceivedSRNTPfrac;
+ uint32_t _lastReceivedSRNTPsecs;
+ uint32_t _lastReceivedSRNTPfrac;
// Received report blocks.
- std::map<WebRtc_UWord32, RTCPHelp::RTCPReportBlockInformation*>
+ std::map<uint32_t, RTCPHelp::RTCPReportBlockInformation*>
_receivedReportBlockMap;
ReceivedInfoMap _receivedInfoMap;
- std::map<WebRtc_UWord32, RTCPUtility::RTCPCnameInformation*>
+ std::map<uint32_t, RTCPUtility::RTCPCnameInformation*>
_receivedCnameMap;
- WebRtc_UWord32 _packetTimeOutMS;
+ uint32_t _packetTimeOutMS;
// The last time we received an RTCP RR.
int64_t _lastReceivedRrMs;
@@ -239,7 +240,7 @@
// Externally set RTT. This value can only be used if there are no valid
// RTT estimates.
- WebRtc_UWord16 _rtt;
+ uint16_t _rtt;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
index 4115f5d..31b41ab 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
@@ -54,19 +54,19 @@
memcpy(VoIPMetric, metric, sizeof(RTCPVoIPMetric));
}
-void RTCPPacketInformation::AddApplicationData(const WebRtc_UWord8* data,
- const WebRtc_UWord16 size) {
- WebRtc_UWord8* oldData = applicationData;
- WebRtc_UWord16 oldLength = applicationLength;
+void RTCPPacketInformation::AddApplicationData(const uint8_t* data,
+ const uint16_t size) {
+ uint8_t* oldData = applicationData;
+ uint16_t oldLength = applicationLength;
// Don't copy more than kRtcpAppCode_DATA_SIZE bytes.
- WebRtc_UWord16 copySize = size;
+ uint16_t copySize = size;
if (size > kRtcpAppCode_DATA_SIZE) {
copySize = kRtcpAppCode_DATA_SIZE;
}
applicationLength += copySize;
- applicationData = new WebRtc_UWord8[applicationLength];
+ applicationData = new uint8_t[applicationLength];
if (oldData)
{
@@ -86,7 +86,7 @@
}
void
-RTCPPacketInformation::AddNACKPacket(const WebRtc_UWord16 packetID)
+RTCPPacketInformation::AddNACKPacket(const uint16_t packetID)
{
if (nackSequenceNumbers.size() >= kSendSideNackListSizeSanity) {
return;
@@ -95,10 +95,10 @@
}
void
-RTCPPacketInformation::AddReportInfo(const WebRtc_UWord8 fraction,
- const WebRtc_UWord16 rtt,
- const WebRtc_UWord32 extendedHighSeqNum,
- const WebRtc_UWord32 j)
+RTCPPacketInformation::AddReportInfo(const uint8_t fraction,
+ const uint16_t rtt,
+ const uint32_t extendedHighSeqNum,
+ const uint32_t j)
{
reportBlock = true;
fractionLost = fraction;
@@ -136,7 +136,7 @@
// Increase size of TMMBRSet if needed, and also take care of
// the _tmmbrSetTimeouts vector.
void RTCPReceiveInformation::VerifyAndAllocateTMMBRSet(
- const WebRtc_UWord32 minimumSize) {
+ const uint32_t minimumSize) {
if (minimumSize > TmmbrSet.sizeOfSet()) {
TmmbrSet.VerifyAndAllocateSetKeepingData(minimumSize);
// make sure that our buffers are big enough
@@ -145,11 +145,11 @@
}
void RTCPReceiveInformation::InsertTMMBRItem(
- const WebRtc_UWord32 senderSSRC,
+ const uint32_t senderSSRC,
const RTCPUtility::RTCPPacketRTPFBTMMBRItem& TMMBRItem,
- const WebRtc_Word64 currentTimeMS) {
+ const int64_t currentTimeMS) {
// serach to see if we have it in our list
- for (WebRtc_UWord32 i = 0; i < TmmbrSet.lengthOfSet(); i++) {
+ for (uint32_t i = 0; i < TmmbrSet.lengthOfSet(); i++) {
if (TmmbrSet.Ssrc(i) == senderSSRC) {
// we already have this SSRC in our list update it
TmmbrSet.SetEntry(i,
@@ -167,11 +167,11 @@
_tmmbrSetTimeouts.push_back(currentTimeMS);
}
-WebRtc_Word32 RTCPReceiveInformation::GetTMMBRSet(
- const WebRtc_UWord32 sourceIdx,
- const WebRtc_UWord32 targetIdx,
+int32_t RTCPReceiveInformation::GetTMMBRSet(
+ const uint32_t sourceIdx,
+ const uint32_t targetIdx,
TMMBRSet* candidateSet,
- const WebRtc_Word64 currentTimeMS) {
+ const int64_t currentTimeMS) {
if (sourceIdx >= TmmbrSet.lengthOfSet()) {
return -1;
}
@@ -194,7 +194,7 @@
}
void RTCPReceiveInformation::VerifyAndAllocateBoundingSet(
- const WebRtc_UWord32 minimumSize) {
+ const uint32_t minimumSize) {
TmmbnBoundingSet.VerifyAndAllocateSet(minimumSize);
}
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
index 1d538f0..2c2c375 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
@@ -32,38 +32,38 @@
void AddVoIPMetric(const RTCPVoIPMetric* metric);
- void AddApplicationData(const WebRtc_UWord8* data,
- const WebRtc_UWord16 size);
+ void AddApplicationData(const uint8_t* data,
+ const uint16_t size);
- void AddNACKPacket(const WebRtc_UWord16 packetID);
+ void AddNACKPacket(const uint16_t packetID);
void ResetNACKPacketIdArray();
- void AddReportInfo(const WebRtc_UWord8 fractionLost,
- const WebRtc_UWord16 rtt,
- const WebRtc_UWord32 extendedHighSeqNum,
- const WebRtc_UWord32 jitter);
+ void AddReportInfo(const uint8_t fractionLost,
+ const uint16_t rtt,
+ const uint32_t extendedHighSeqNum,
+ const uint32_t jitter);
- WebRtc_UWord32 rtcpPacketTypeFlags; // RTCPPacketTypeFlags bit field
- WebRtc_UWord32 remoteSSRC;
+ uint32_t rtcpPacketTypeFlags; // RTCPPacketTypeFlags bit field
+ uint32_t remoteSSRC;
std::list<uint16_t> nackSequenceNumbers;
- WebRtc_UWord8 applicationSubType;
- WebRtc_UWord32 applicationName;
- WebRtc_UWord8* applicationData;
- WebRtc_UWord16 applicationLength;
+ uint8_t applicationSubType;
+ uint32_t applicationName;
+ uint8_t* applicationData;
+ uint16_t applicationLength;
bool reportBlock;
- WebRtc_UWord8 fractionLost;
- WebRtc_UWord16 roundTripTime;
- WebRtc_UWord32 lastReceivedExtendedHighSeqNum;
- WebRtc_UWord32 jitter;
+ uint8_t fractionLost;
+ uint16_t roundTripTime;
+ uint32_t lastReceivedExtendedHighSeqNum;
+ uint32_t jitter;
- WebRtc_UWord32 interArrivalJitter;
+ uint32_t interArrivalJitter;
- WebRtc_UWord8 sliPictureId;
- WebRtc_UWord64 rpsiPictureId;
- WebRtc_UWord32 receiverEstimatedMaxBitrate;
+ uint8_t sliPictureId;
+ uint64_t rpsiPictureId;
+ uint32_t receiverEstimatedMaxBitrate;
uint32_t ntp_secs;
uint32_t ntp_frac;
@@ -84,14 +84,14 @@
// Statistics
RTCPReportBlock remoteReceiveBlock;
- WebRtc_UWord32 remoteMaxJitter;
+ uint32_t remoteMaxJitter;
// RTT
- WebRtc_UWord16 RTT;
- WebRtc_UWord16 minRTT;
- WebRtc_UWord16 maxRTT;
- WebRtc_UWord16 avgRTT;
- WebRtc_UWord32 numAverageCalcs;
+ uint16_t RTT;
+ uint16_t minRTT;
+ uint16_t maxRTT;
+ uint16_t avgRTT;
+ uint32_t numAverageCalcs;
};
class RTCPReceiveInformation
@@ -100,24 +100,24 @@
RTCPReceiveInformation();
~RTCPReceiveInformation();
- void VerifyAndAllocateBoundingSet(const WebRtc_UWord32 minimumSize);
- void VerifyAndAllocateTMMBRSet(const WebRtc_UWord32 minimumSize);
+ void VerifyAndAllocateBoundingSet(const uint32_t minimumSize);
+ void VerifyAndAllocateTMMBRSet(const uint32_t minimumSize);
- void InsertTMMBRItem(const WebRtc_UWord32 senderSSRC,
+ void InsertTMMBRItem(const uint32_t senderSSRC,
const RTCPUtility::RTCPPacketRTPFBTMMBRItem& TMMBRItem,
- const WebRtc_Word64 currentTimeMS);
+ const int64_t currentTimeMS);
// get
- WebRtc_Word32 GetTMMBRSet(const WebRtc_UWord32 sourceIdx,
- const WebRtc_UWord32 targetIdx,
- TMMBRSet* candidateSet,
- const WebRtc_Word64 currentTimeMS);
+ int32_t GetTMMBRSet(const uint32_t sourceIdx,
+ const uint32_t targetIdx,
+ TMMBRSet* candidateSet,
+ const int64_t currentTimeMS);
- WebRtc_Word64 lastTimeReceived;
+ int64_t lastTimeReceived;
// FIR
- WebRtc_Word32 lastFIRSequenceNumber;
- WebRtc_Word64 lastFIRRequest;
+ int32_t lastFIRSequenceNumber;
+ int64_t lastFIRRequest;
// TMMBN
TMMBRSet TmmbnBoundingSet;
@@ -127,7 +127,7 @@
bool readyForDelete;
private:
- std::vector<WebRtc_Word64> _tmmbrSetTimeouts;
+ std::vector<int64_t> _tmmbrSetTimeouts;
};
} // end namespace RTCPHelp
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index 6de2590..b0f5c20 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -39,25 +39,25 @@
}
- void Add8(WebRtc_UWord8 byte) {
+ void Add8(uint8_t byte) {
EXPECT_LT(pos_, kMaxPacketSize - 1);
buffer_[pos_] = byte;
++ pos_;
}
- void Add16(WebRtc_UWord16 word) {
+ void Add16(uint16_t word) {
Add8(word >> 8);
Add8(word & 0xFF);
}
- void Add32(WebRtc_UWord32 word) {
+ void Add32(uint32_t word) {
Add8(word >> 24);
Add8((word >> 16) & 0xFF);
Add8((word >> 8) & 0xFF);
Add8(word & 0xFF);
}
- void Add64(WebRtc_UWord32 upper_half, WebRtc_UWord32 lower_half) {
+ void Add64(uint32_t upper_half, uint32_t lower_half) {
Add32(upper_half);
Add32(lower_half);
}
@@ -76,14 +76,14 @@
void AddTmmbrBandwidth(int mantissa, int exponent, int overhead) {
// 6 bits exponent, 17 bits mantissa, 9 bits overhead.
- WebRtc_UWord32 word = 0;
+ uint32_t word = 0;
word |= (exponent << 26);
word |= ((mantissa & 0x1FFFF) << 9);
word |= (overhead & 0x1FF);
Add32(word);
}
- void AddSrPacket(WebRtc_UWord32 sender_ssrc) {
+ void AddSrPacket(uint32_t sender_ssrc) {
AddRtcpHeader(200, 0);
Add32(sender_ssrc);
Add64(0x10203, 0x4050607); // NTP timestamp
@@ -92,8 +92,8 @@
Add32(0); // Sender's octet count
}
- void AddRrPacket(WebRtc_UWord32 sender_ssrc, WebRtc_UWord32 rtp_ssrc,
- WebRtc_UWord32 extended_max) {
+ void AddRrPacket(uint32_t sender_ssrc, uint32_t rtp_ssrc,
+ uint32_t extended_max) {
AddRtcpHeader(201, 1);
Add32(sender_ssrc);
Add32(rtp_ssrc);
@@ -104,7 +104,7 @@
Add32(0); // Delay since last SR.
}
- const WebRtc_UWord8* packet() {
+ const uint8_t* packet() {
PatchLengthField();
return buffer_;
}
@@ -131,7 +131,7 @@
// Where the length field of the current packet is.
// Note that 0 is not a legal value, so is used for "uninitialized".
int pos_of_len_;
- WebRtc_UWord8 buffer_[kMaxPacketSize];
+ uint8_t buffer_[kMaxPacketSize];
};
// This test transport verifies that no functions get called.
@@ -155,8 +155,8 @@
return 0;
}
- virtual int OnReceivedPayloadData(const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int OnReceivedPayloadData(const uint8_t* payloadData,
+ const uint16_t payloadSize,
const WebRtcRTPHeader* rtpHeader) {
ADD_FAILURE();
return 0;
@@ -196,8 +196,8 @@
// Injects an RTCP packet into the receiver.
// Returns 0 for OK, non-0 for failure.
- int InjectRtcpPacket(const WebRtc_UWord8* packet,
- WebRtc_UWord16 packet_len) {
+ int InjectRtcpPacket(const uint8_t* packet,
+ uint16_t packet_len) {
RTCPUtility::RTCPParserV2 rtcpParser(packet,
packet_len,
true); // Allow non-compound RTCP
@@ -243,13 +243,13 @@
TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
- const WebRtc_UWord8 bad_packet[] = {0, 0, 0, 0};
+ const uint8_t bad_packet[] = {0, 0, 0, 0};
EXPECT_EQ(0, InjectRtcpPacket(bad_packet, sizeof(bad_packet)));
EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
}
TEST_F(RtcpReceiverTest, InjectSrPacket) {
- const WebRtc_UWord32 kSenderSsrc = 0x10203;
+ const uint32_t kSenderSsrc = 0x10203;
PacketBuilder p;
p.AddSrPacket(kSenderSsrc);
EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
@@ -326,9 +326,9 @@
}
TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
- const WebRtc_UWord32 kMediaFlowSsrc = 0x2040608;
- const WebRtc_UWord32 kSenderSsrc = 0x10203;
- const WebRtc_UWord32 kMediaRecipientSsrc = 0x101;
+ const uint32_t kMediaFlowSsrc = 0x2040608;
+ const uint32_t kSenderSsrc = 0x10203;
+ const uint32_t kMediaRecipientSsrc = 0x101;
rtcp_receiver_->SetSSRC(kMediaFlowSsrc); // Matches "media source" above.
PacketBuilder p;
@@ -350,10 +350,10 @@
}
TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
- const WebRtc_UWord32 kMediaFlowSsrc = 0x2040608;
- const WebRtc_UWord32 kSenderSsrc = 0x10203;
- const WebRtc_UWord32 kMediaRecipientSsrc = 0x101;
- const WebRtc_UWord32 kOtherMediaFlowSsrc = 0x9999;
+ const uint32_t kMediaFlowSsrc = 0x2040608;
+ const uint32_t kSenderSsrc = 0x10203;
+ const uint32_t kMediaRecipientSsrc = 0x101;
+ const uint32_t kOtherMediaFlowSsrc = 0x9999;
PacketBuilder p;
p.AddSrPacket(kSenderSsrc);
@@ -370,9 +370,9 @@
}
TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
- const WebRtc_UWord32 kMediaFlowSsrc = 0x2040608;
- const WebRtc_UWord32 kSenderSsrc = 0x10203;
- const WebRtc_UWord32 kMediaRecipientSsrc = 0x101;
+ const uint32_t kMediaFlowSsrc = 0x2040608;
+ const uint32_t kSenderSsrc = 0x10203;
+ const uint32_t kMediaRecipientSsrc = 0x101;
rtcp_receiver_->SetSSRC(kMediaFlowSsrc); // Matches "media source" above.
PacketBuilder p;
@@ -389,14 +389,14 @@
}
TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
- const WebRtc_UWord32 kMediaFlowSsrc = 0x2040608;
- const WebRtc_UWord32 kSenderSsrc = 0x10203;
- const WebRtc_UWord32 kMediaRecipientSsrc = 0x101;
+ const uint32_t kMediaFlowSsrc = 0x2040608;
+ const uint32_t kSenderSsrc = 0x10203;
+ const uint32_t kMediaRecipientSsrc = 0x101;
rtcp_receiver_->SetSSRC(kMediaFlowSsrc); // Matches "media source" above.
// Inject 3 packets "from" kMediaRecipientSsrc, Ssrc+1, Ssrc+2.
// The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
- for (WebRtc_UWord32 ssrc = kMediaRecipientSsrc;
+ for (uint32_t ssrc = kMediaRecipientSsrc;
ssrc < kMediaRecipientSsrc+3; ++ssrc) {
PacketBuilder p;
p.AddSrPacket(kSenderSsrc);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
index 92b0be6..ef97f85 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -30,7 +30,7 @@
// Empty.
}
-void NACKStringBuilder::PushNACK(WebRtc_UWord16 nack)
+void NACKStringBuilder::PushNACK(uint16_t nack)
{
if (_count == 0)
{
@@ -61,7 +61,7 @@
return _stream.str();
}
-RTCPSender::RTCPSender(const WebRtc_Word32 id,
+RTCPSender::RTCPSender(const int32_t id,
const bool audio,
Clock* clock,
ModuleRtpRtcpImpl* owner) :
@@ -134,13 +134,13 @@
delete [] _appData;
while (!_reportBlocks.empty()) {
- std::map<WebRtc_UWord32, RTCPReportBlock*>::iterator it =
+ std::map<uint32_t, RTCPReportBlock*>::iterator it =
_reportBlocks.begin();
delete it->second;
_reportBlocks.erase(it);
}
while (!_csrcCNAMEs.empty()) {
- std::map<WebRtc_UWord32, RTCPCnameInformation*>::iterator it =
+ std::map<uint32_t, RTCPCnameInformation*>::iterator it =
_csrcCNAMEs.begin();
delete it->second;
_csrcCNAMEs.erase(it);
@@ -151,7 +151,7 @@
WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, "%s deleted", __FUNCTION__);
}
-WebRtc_Word32
+int32_t
RTCPSender::Init()
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -201,12 +201,12 @@
}
void
-RTCPSender::ChangeUniqueId(const WebRtc_Word32 id)
+RTCPSender::ChangeUniqueId(const int32_t id)
{
_id = id;
}
-WebRtc_Word32
+int32_t
RTCPSender::RegisterSendTransport(Transport* outgoingTransport)
{
CriticalSectionScoped lock(_criticalSectionTransport);
@@ -221,7 +221,7 @@
return _method;
}
-WebRtc_Word32
+int32_t
RTCPSender::SetRTCPStatus(const RTCPMethod method)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -248,7 +248,7 @@
return _sending;
}
-WebRtc_Word32
+int32_t
RTCPSender::SetSendingStatus(const bool sending)
{
bool sendRTCPBye = false;
@@ -279,7 +279,7 @@
return _REMB;
}
-WebRtc_Word32
+int32_t
RTCPSender::SetREMBStatus(const bool enable)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -287,10 +287,10 @@
return 0;
}
-WebRtc_Word32
-RTCPSender::SetREMBData(const WebRtc_UWord32 bitrate,
- const WebRtc_UWord8 numberOfSSRC,
- const WebRtc_UWord32* SSRC)
+int32_t
+RTCPSender::SetREMBData(const uint32_t bitrate,
+ const uint8_t numberOfSSRC,
+ const uint32_t* SSRC)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
_rembBitrate = bitrate;
@@ -298,7 +298,7 @@
if(_sizeRembSSRC < numberOfSSRC)
{
delete [] _rembSSRC;
- _rembSSRC = new WebRtc_UWord32[numberOfSSRC];
+ _rembSSRC = new uint32_t[numberOfSSRC];
_sizeRembSSRC = numberOfSSRC;
}
@@ -318,7 +318,7 @@
return _TMMBR;
}
-WebRtc_Word32
+int32_t
RTCPSender::SetTMMBRStatus(const bool enable)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -333,7 +333,7 @@
return _IJ;
}
-WebRtc_Word32
+int32_t
RTCPSender::SetIJStatus(const bool enable)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -358,7 +358,7 @@
}
void
-RTCPSender::SetSSRC( const WebRtc_UWord32 ssrc)
+RTCPSender::SetSSRC( const uint32_t ssrc)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -372,16 +372,16 @@
_SSRC = ssrc;
}
-WebRtc_Word32
-RTCPSender::SetRemoteSSRC( const WebRtc_UWord32 ssrc)
+int32_t
+RTCPSender::SetRemoteSSRC( const uint32_t ssrc)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
_remoteSSRC = ssrc;
return 0;
}
-WebRtc_Word32
-RTCPSender::SetCameraDelay(const WebRtc_Word32 delayMS)
+int32_t
+RTCPSender::SetCameraDelay(const int32_t delayMS)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
if(delayMS > 1000 || delayMS < -1000)
@@ -393,7 +393,7 @@
return 0;
}
-WebRtc_Word32 RTCPSender::CNAME(char cName[RTCP_CNAME_SIZE]) {
+int32_t RTCPSender::CNAME(char cName[RTCP_CNAME_SIZE]) {
assert(cName);
CriticalSectionScoped lock(_criticalSectionRTCPSender);
cName[RTCP_CNAME_SIZE - 1] = 0;
@@ -401,7 +401,7 @@
return 0;
}
-WebRtc_Word32 RTCPSender::SetCNAME(const char cName[RTCP_CNAME_SIZE]) {
+int32_t RTCPSender::SetCNAME(const char cName[RTCP_CNAME_SIZE]) {
if (!cName)
return -1;
@@ -411,8 +411,8 @@
return 0;
}
-WebRtc_Word32 RTCPSender::AddMixedCNAME(const WebRtc_UWord32 SSRC,
- const char cName[RTCP_CNAME_SIZE]) {
+int32_t RTCPSender::AddMixedCNAME(const uint32_t SSRC,
+ const char cName[RTCP_CNAME_SIZE]) {
assert(cName);
CriticalSectionScoped lock(_criticalSectionRTCPSender);
if (_csrcCNAMEs.size() >= kRtpCsrcSize) {
@@ -425,9 +425,9 @@
return 0;
}
-WebRtc_Word32 RTCPSender::RemoveMixedCNAME(const WebRtc_UWord32 SSRC) {
+int32_t RTCPSender::RemoveMixedCNAME(const uint32_t SSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPSender);
- std::map<WebRtc_UWord32, RTCPCnameInformation*>::iterator it =
+ std::map<uint32_t, RTCPCnameInformation*>::iterator it =
_csrcCNAMEs.find(SSRC);
if (it == _csrcCNAMEs.end()) {
@@ -498,7 +498,7 @@
a value of the RTCP bandwidth below the intended average
*/
- WebRtc_Word64 now = _clock->TimeInMilliseconds();
+ int64_t now = _clock->TimeInMilliseconds();
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -526,8 +526,8 @@
return false;
}
-WebRtc_UWord32
-RTCPSender::LastSendReport( WebRtc_UWord32& lastRTCPTime)
+uint32_t
+RTCPSender::LastSendReport( uint32_t& lastRTCPTime)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -535,8 +535,8 @@
return _lastSendReport[0];
}
-WebRtc_UWord32
-RTCPSender::SendTimeOfSendReport(const WebRtc_UWord32 sendReport)
+uint32_t
+RTCPSender::SendTimeOfSendReport(const uint32_t sendReport)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -557,8 +557,8 @@
return 0;
}
-WebRtc_Word32 RTCPSender::AddReportBlock(const WebRtc_UWord32 SSRC,
- const RTCPReportBlock* reportBlock) {
+int32_t RTCPSender::AddReportBlock(const uint32_t SSRC,
+ const RTCPReportBlock* reportBlock) {
if (reportBlock == NULL) {
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id,
"%s invalid argument", __FUNCTION__);
@@ -571,7 +571,7 @@
"%s invalid argument", __FUNCTION__);
return -1;
}
- std::map<WebRtc_UWord32, RTCPReportBlock*>::iterator it =
+ std::map<uint32_t, RTCPReportBlock*>::iterator it =
_reportBlocks.find(SSRC);
if (it != _reportBlocks.end()) {
delete it->second;
@@ -583,10 +583,10 @@
return 0;
}
-WebRtc_Word32 RTCPSender::RemoveReportBlock(const WebRtc_UWord32 SSRC) {
+int32_t RTCPSender::RemoveReportBlock(const uint32_t SSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPSender);
- std::map<WebRtc_UWord32, RTCPReportBlock*>::iterator it =
+ std::map<uint32_t, RTCPReportBlock*>::iterator it =
_reportBlocks.find(SSRC);
if (it == _reportBlocks.end()) {
@@ -597,11 +597,11 @@
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildSR(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord32 NTPsec,
- const WebRtc_UWord32 NTPfrac,
+int32_t
+RTCPSender::BuildSR(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint32_t NTPsec,
+ const uint32_t NTPfrac,
const RTCPReportBlock* received)
{
// sanity
@@ -610,13 +610,13 @@
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__);
return -2;
}
- WebRtc_UWord32 RTPtime;
+ uint32_t RTPtime;
- WebRtc_UWord32 posNumberOfReportBlocks = pos;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80;
+ uint32_t posNumberOfReportBlocks = pos;
+ rtcpbuffer[pos++]=(uint8_t)0x80;
// Sender report
- rtcpbuffer[pos++]=(WebRtc_UWord8)200;
+ rtcpbuffer[pos++]=(uint8_t)200;
for(int i = (RTCP_NUMBER_OF_SR-2); i >= 0; i--)
{
@@ -628,7 +628,7 @@
_lastRTCPTime[0] = ModuleRTPUtility::ConvertNTPTimeToMS(NTPsec, NTPfrac);
_lastSendReport[0] = (NTPsec << 16) + (NTPfrac >> 16);
- WebRtc_UWord32 freqHz = 90000; // For video
+ uint32_t freqHz = 90000; // For video
if(_audio) {
freqHz = _rtpRtcp.CurrentSendFrequencyHz();
}
@@ -669,8 +669,8 @@
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _rtpRtcp.ByteCountSent());
pos += 4;
- WebRtc_UWord8 numberOfReportBlocks = 0;
- WebRtc_Word32 retVal = AddReportBlocks(rtcpbuffer, pos, numberOfReportBlocks, received, NTPsec, NTPfrac);
+ uint8_t numberOfReportBlocks = 0;
+ int32_t retVal = AddReportBlocks(rtcpbuffer, pos, numberOfReportBlocks, received, NTPsec, NTPfrac);
if(retVal < 0)
{
//
@@ -678,14 +678,14 @@
}
rtcpbuffer[posNumberOfReportBlocks] += numberOfReportBlocks;
- WebRtc_UWord16 len = WebRtc_UWord16((pos/4) -1);
+ uint16_t len = uint16_t((pos/4) -1);
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer+2, len);
return 0;
}
-WebRtc_Word32 RTCPSender::BuildSDEC(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos) {
+int32_t RTCPSender::BuildSDEC(uint8_t* rtcpbuffer,
+ uint32_t& pos) {
size_t lengthCname = strlen(_CNAME);
assert(lengthCname < RTCP_CNAME_SIZE);
@@ -698,11 +698,11 @@
// SDEC Source Description
// We always need to add SDES CNAME
- rtcpbuffer[pos++] = static_cast<WebRtc_UWord8>(0x80 + 1 + _csrcCNAMEs.size());
- rtcpbuffer[pos++] = static_cast<WebRtc_UWord8>(202);
+ rtcpbuffer[pos++] = static_cast<uint8_t>(0x80 + 1 + _csrcCNAMEs.size());
+ rtcpbuffer[pos++] = static_cast<uint8_t>(202);
// handle SDES length later on
- WebRtc_UWord32 SDESLengthPos = pos;
+ uint32_t SDESLengthPos = pos;
pos++;
pos++;
@@ -711,18 +711,18 @@
pos += 4;
// CNAME = 1
- rtcpbuffer[pos++] = static_cast<WebRtc_UWord8>(1);
+ rtcpbuffer[pos++] = static_cast<uint8_t>(1);
//
- rtcpbuffer[pos++] = static_cast<WebRtc_UWord8>(lengthCname);
+ rtcpbuffer[pos++] = static_cast<uint8_t>(lengthCname);
- WebRtc_UWord16 SDESLength = 10;
+ uint16_t SDESLength = 10;
memcpy(&rtcpbuffer[pos], _CNAME, lengthCname);
pos += lengthCname;
- SDESLength += (WebRtc_UWord16)lengthCname;
+ SDESLength += (uint16_t)lengthCname;
- WebRtc_UWord16 padding = 0;
+ uint16_t padding = 0;
// We must have a zero field even if we have an even multiple of 4 bytes
if ((pos % 4) == 0) {
padding++;
@@ -734,31 +734,31 @@
}
SDESLength += padding;
- std::map<WebRtc_UWord32, RTCPUtility::RTCPCnameInformation*>::iterator it =
+ std::map<uint32_t, RTCPUtility::RTCPCnameInformation*>::iterator it =
_csrcCNAMEs.begin();
for(; it != _csrcCNAMEs.end(); it++) {
RTCPCnameInformation* cname = it->second;
- WebRtc_UWord32 SSRC = it->first;
+ uint32_t SSRC = it->first;
// Add SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, SSRC);
pos += 4;
// CNAME = 1
- rtcpbuffer[pos++] = static_cast<WebRtc_UWord8>(1);
+ rtcpbuffer[pos++] = static_cast<uint8_t>(1);
size_t length = strlen(cname->name);
assert(length < RTCP_CNAME_SIZE);
- rtcpbuffer[pos++]= static_cast<WebRtc_UWord8>(length);
+ rtcpbuffer[pos++]= static_cast<uint8_t>(length);
SDESLength += 6;
memcpy(&rtcpbuffer[pos],cname->name, length);
pos += length;
SDESLength += length;
- WebRtc_UWord16 padding = 0;
+ uint16_t padding = 0;
// We must have a zero field even if we have an even multiple of 4 bytes
if((pos % 4) == 0){
@@ -772,17 +772,17 @@
SDESLength += padding;
}
// in 32-bit words minus one and we don't count the header
- WebRtc_UWord16 buffer_length = (SDESLength / 4) - 1;
+ uint16_t buffer_length = (SDESLength / 4) - 1;
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer + SDESLengthPos,
buffer_length);
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildRR(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord32 NTPsec,
- const WebRtc_UWord32 NTPfrac,
+int32_t
+RTCPSender::BuildRR(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint32_t NTPsec,
+ const uint32_t NTPfrac,
const RTCPReportBlock* received)
{
// sanity one block
@@ -790,10 +790,10 @@
{
return -2;
}
- WebRtc_UWord32 posNumberOfReportBlocks = pos;
+ uint32_t posNumberOfReportBlocks = pos;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80;
- rtcpbuffer[pos++]=(WebRtc_UWord8)201;
+ rtcpbuffer[pos++]=(uint8_t)0x80;
+ rtcpbuffer[pos++]=(uint8_t)201;
// Save for our length field
pos++;
@@ -803,15 +803,15 @@
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
pos += 4;
- WebRtc_UWord8 numberOfReportBlocks = 0;
- WebRtc_Word32 retVal = AddReportBlocks(rtcpbuffer, pos, numberOfReportBlocks, received, NTPsec, NTPfrac);
+ uint8_t numberOfReportBlocks = 0;
+ int32_t retVal = AddReportBlocks(rtcpbuffer, pos, numberOfReportBlocks, received, NTPsec, NTPfrac);
if(retVal < 0)
{
return retVal;
}
rtcpbuffer[posNumberOfReportBlocks] += numberOfReportBlocks;
- WebRtc_UWord16 len = WebRtc_UWord16((pos)/4 -1);
+ uint16_t len = uint16_t((pos)/4 -1);
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer+2, len);
return 0;
}
@@ -834,11 +834,11 @@
// (inside a compound RTCP packet), and MUST have the same value for RC
// (reception report count) as the receiver report.
-WebRtc_Word32
+int32_t
RTCPSender::BuildExtendedJitterReport(
- WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord32 jitterTransmissionTimeOffset)
+ uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint32_t jitterTransmissionTimeOffset)
{
if (_reportBlocks.size() > 0)
{
@@ -852,13 +852,13 @@
return -2;
}
// add picture loss indicator
- WebRtc_UWord8 RC = 1;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + RC;
- rtcpbuffer[pos++]=(WebRtc_UWord8)195;
+ uint8_t RC = 1;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + RC;
+ rtcpbuffer[pos++]=(uint8_t)195;
// Used fixed length of 2
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)(1);
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)(1);
// Add inter-arrival jitter
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer + pos,
@@ -867,8 +867,8 @@
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildPLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos)
+int32_t
+RTCPSender::BuildPLI(uint8_t* rtcpbuffer, uint32_t& pos)
{
// sanity
if(pos + 12 >= IP_PACKET_SIZE)
@@ -876,13 +876,13 @@
return -2;
}
// add picture loss indicator
- WebRtc_UWord8 FMT = 1;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++]=(WebRtc_UWord8)206;
+ uint8_t FMT = 1;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++]=(uint8_t)206;
//Used fixed length of 2
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)(2);
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)(2);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
@@ -894,9 +894,9 @@
return 0;
}
-WebRtc_Word32 RTCPSender::BuildFIR(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- bool repeat) {
+int32_t RTCPSender::BuildFIR(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ bool repeat) {
// sanity
if(pos + 20 >= IP_PACKET_SIZE) {
return -2;
@@ -906,13 +906,13 @@
}
// add full intra request indicator
- WebRtc_UWord8 FMT = 4;
- rtcpbuffer[pos++] = (WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++] = (WebRtc_UWord8)206;
+ uint8_t FMT = 4;
+ rtcpbuffer[pos++] = (uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++] = (uint8_t)206;
//Length of 4
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
- rtcpbuffer[pos++] = (WebRtc_UWord8)(4);
+ rtcpbuffer[pos++] = (uint8_t)0;
+ rtcpbuffer[pos++] = (uint8_t)(4);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _SSRC);
@@ -920,19 +920,19 @@
// RFC 5104 4.3.1.2. Semantics
// SSRC of media source
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
+ rtcpbuffer[pos++] = (uint8_t)0;
+ rtcpbuffer[pos++] = (uint8_t)0;
+ rtcpbuffer[pos++] = (uint8_t)0;
+ rtcpbuffer[pos++] = (uint8_t)0;
// Additional Feedback Control Information (FCI)
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer + pos, _remoteSSRC);
pos += 4;
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_sequenceNumberFIR);
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
- rtcpbuffer[pos++] = (WebRtc_UWord8)0;
+ rtcpbuffer[pos++] = (uint8_t)(_sequenceNumberFIR);
+ rtcpbuffer[pos++] = (uint8_t)0;
+ rtcpbuffer[pos++] = (uint8_t)0;
+ rtcpbuffer[pos++] = (uint8_t)0;
return 0;
}
@@ -943,8 +943,8 @@
| First | Number | PictureID |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
-WebRtc_Word32
-RTCPSender::BuildSLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos, const WebRtc_UWord8 pictureID)
+int32_t
+RTCPSender::BuildSLI(uint8_t* rtcpbuffer, uint32_t& pos, const uint8_t pictureID)
{
// sanity
if(pos + 16 >= IP_PACKET_SIZE)
@@ -952,13 +952,13 @@
return -2;
}
// add slice loss indicator
- WebRtc_UWord8 FMT = 2;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++]=(WebRtc_UWord8)206;
+ uint8_t FMT = 2;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++]=(uint8_t)206;
//Used fixed length of 3
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)(3);
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)(3);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
@@ -971,7 +971,7 @@
// Add first, number & picture ID 6 bits
// first = 0, 13 - bits
// number = 0x1fff, 13 - bits only ones for now
- WebRtc_UWord32 sliField = (0x1fff << 6)+ (0x3f & pictureID);
+ uint32_t sliField = (0x1fff << 6)+ (0x3f & pictureID);
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, sliField);
pos += 4;
return 0;
@@ -989,11 +989,11 @@
/*
* Note: not generic made for VP8
*/
-WebRtc_Word32
-RTCPSender::BuildRPSI(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord64 pictureID,
- const WebRtc_UWord8 payloadType)
+int32_t
+RTCPSender::BuildRPSI(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint64_t pictureID,
+ const uint8_t payloadType)
{
// sanity
if(pos + 24 >= IP_PACKET_SIZE)
@@ -1001,20 +1001,20 @@
return -2;
}
// add Reference Picture Selection Indication
- WebRtc_UWord8 FMT = 3;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++]=(WebRtc_UWord8)206;
+ uint8_t FMT = 3;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++]=(uint8_t)206;
// calc length
- WebRtc_UWord32 bitsRequired = 7;
- WebRtc_UWord8 bytesRequired = 1;
+ uint32_t bitsRequired = 7;
+ uint8_t bytesRequired = 1;
while((pictureID>>bitsRequired) > 0)
{
bitsRequired += 7;
bytesRequired++;
}
- WebRtc_UWord8 size = 3;
+ uint8_t size = 3;
if(bytesRequired > 6)
{
size = 5;
@@ -1022,7 +1022,7 @@
{
size = 4;
}
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
rtcpbuffer[pos++]=size;
// Add our own SSRC
@@ -1034,7 +1034,7 @@
pos += 4;
// calc padding length
- WebRtc_UWord8 paddingBytes = 4-((2+bytesRequired)%4);
+ uint8_t paddingBytes = 4-((2+bytesRequired)%4);
if(paddingBytes == 4)
{
paddingBytes = 0;
@@ -1050,11 +1050,11 @@
// add picture ID
for(int i = bytesRequired-1; i > 0; i--)
{
- rtcpbuffer[pos] = 0x80 | WebRtc_UWord8(pictureID >> (i*7));
+ rtcpbuffer[pos] = 0x80 | uint8_t(pictureID >> (i*7));
pos++;
}
// add last byte of picture ID
- rtcpbuffer[pos] = WebRtc_UWord8(pictureID & 0x7f);
+ rtcpbuffer[pos] = uint8_t(pictureID & 0x7f);
pos++;
// add padding
@@ -1066,8 +1066,8 @@
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildREMB(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos)
+int32_t
+RTCPSender::BuildREMB(uint8_t* rtcpbuffer, uint32_t& pos)
{
// sanity
if(pos + 20 + 4 * _lengthRembSSRC >= IP_PACKET_SIZE)
@@ -1075,11 +1075,11 @@
return -2;
}
// add application layer feedback
- WebRtc_UWord8 FMT = 15;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++]=(WebRtc_UWord8)206;
+ uint8_t FMT = 15;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++]=(uint8_t)206;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
rtcpbuffer[pos++]=_lengthRembSSRC + 4;
// Add our own SSRC
@@ -1098,19 +1098,19 @@
rtcpbuffer[pos++] = _lengthRembSSRC;
// 6 bit Exp
// 18 bit mantissa
- WebRtc_UWord8 brExp = 0;
- for(WebRtc_UWord32 i=0; i<64; i++)
+ uint8_t brExp = 0;
+ for(uint32_t i=0; i<64; i++)
{
- if(_rembBitrate <= ((WebRtc_UWord32)262143 << i))
+ if(_rembBitrate <= ((uint32_t)262143 << i))
{
brExp = i;
break;
}
}
- const WebRtc_UWord32 brMantissa = (_rembBitrate >> brExp);
- rtcpbuffer[pos++]=(WebRtc_UWord8)((brExp << 2) + ((brMantissa >> 16) & 0x03));
- rtcpbuffer[pos++]=(WebRtc_UWord8)(brMantissa >> 8);
- rtcpbuffer[pos++]=(WebRtc_UWord8)(brMantissa);
+ const uint32_t brMantissa = (_rembBitrate >> brExp);
+ rtcpbuffer[pos++]=(uint8_t)((brExp << 2) + ((brMantissa >> 16) & 0x03));
+ rtcpbuffer[pos++]=(uint8_t)(brMantissa >> 8);
+ rtcpbuffer[pos++]=(uint8_t)(brMantissa);
for (int i = 0; i < _lengthRembSSRC; i++)
{
@@ -1128,8 +1128,8 @@
_tmmbr_Send = target_bitrate / 1000;
}
-WebRtc_Word32
-RTCPSender::BuildTMMBR(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos)
+int32_t
+RTCPSender::BuildTMMBR(uint8_t* rtcpbuffer, uint32_t& pos)
{
// Before sending the TMMBR check the received TMMBN, only an owner is allowed to raise the bitrate
// If the sender is an owner of the TMMBN -> send TMMBR
@@ -1143,12 +1143,12 @@
// holding _criticalSectionRTCPSender while calling RTCPreceiver which
// will accuire _criticalSectionRTCPReceiver is a potental deadlock but
// since RTCPreceiver is not doing the reverse we should be fine
- WebRtc_Word32 lengthOfBoundingSet
+ int32_t lengthOfBoundingSet
= _rtpRtcp.BoundingSet(tmmbrOwner, candidateSet);
if(lengthOfBoundingSet > 0)
{
- for (WebRtc_Word32 i = 0; i < lengthOfBoundingSet; i++)
+ for (int32_t i = 0; i < lengthOfBoundingSet; i++)
{
if( candidateSet->Tmmbr(i) == _tmmbr_Send &&
candidateSet->PacketOH(i) == _packetOH_Send)
@@ -1190,13 +1190,13 @@
return -2;
}
// add TMMBR indicator
- WebRtc_UWord8 FMT = 3;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++]=(WebRtc_UWord8)205;
+ uint8_t FMT = 3;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++]=(uint8_t)205;
//Length of 4
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)(4);
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)(4);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
@@ -1205,37 +1205,37 @@
// RFC 5104 4.2.1.2. Semantics
// SSRC of media source
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
// Additional Feedback Control Information (FCI)
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
pos += 4;
- WebRtc_UWord32 bitRate = _tmmbr_Send*1000;
- WebRtc_UWord32 mmbrExp = 0;
- for(WebRtc_UWord32 i=0;i<64;i++)
+ uint32_t bitRate = _tmmbr_Send*1000;
+ uint32_t mmbrExp = 0;
+ for(uint32_t i=0;i<64;i++)
{
- if(bitRate <= ((WebRtc_UWord32)131071 << i))
+ if(bitRate <= ((uint32_t)131071 << i))
{
mmbrExp = i;
break;
}
}
- WebRtc_UWord32 mmbrMantissa = (bitRate >> mmbrExp);
+ uint32_t mmbrMantissa = (bitRate >> mmbrExp);
- rtcpbuffer[pos++]=(WebRtc_UWord8)((mmbrExp << 2) + ((mmbrMantissa >> 15) & 0x03));
- rtcpbuffer[pos++]=(WebRtc_UWord8)(mmbrMantissa >> 7);
- rtcpbuffer[pos++]=(WebRtc_UWord8)((mmbrMantissa << 1) + ((_packetOH_Send >> 8)& 0x01));
- rtcpbuffer[pos++]=(WebRtc_UWord8)(_packetOH_Send);
+ rtcpbuffer[pos++]=(uint8_t)((mmbrExp << 2) + ((mmbrMantissa >> 15) & 0x03));
+ rtcpbuffer[pos++]=(uint8_t)(mmbrMantissa >> 7);
+ rtcpbuffer[pos++]=(uint8_t)((mmbrMantissa << 1) + ((_packetOH_Send >> 8)& 0x01));
+ rtcpbuffer[pos++]=(uint8_t)(_packetOH_Send);
}
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildTMMBN(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos)
+int32_t
+RTCPSender::BuildTMMBN(uint8_t* rtcpbuffer, uint32_t& pos)
{
TMMBRSet* boundingSet = _tmmbrHelp.BoundingSetToSend();
if(boundingSet == NULL)
@@ -1248,10 +1248,10 @@
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__);
return -2;
}
- WebRtc_UWord8 FMT = 4;
+ uint8_t FMT = 4;
// add TMMBN indicator
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++]=(WebRtc_UWord8)205;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++]=(uint8_t)205;
//Add length later
int posLength = pos;
@@ -1265,49 +1265,49 @@
// RFC 5104 4.2.2.2. Semantics
// SSRC of media source
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
// Additional Feedback Control Information (FCI)
int numBoundingSet = 0;
- for(WebRtc_UWord32 n=0; n< boundingSet->lengthOfSet(); n++)
+ for(uint32_t n=0; n< boundingSet->lengthOfSet(); n++)
{
if (boundingSet->Tmmbr(n) > 0)
{
- WebRtc_UWord32 tmmbrSSRC = boundingSet->Ssrc(n);
+ uint32_t tmmbrSSRC = boundingSet->Ssrc(n);
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, tmmbrSSRC);
pos += 4;
- WebRtc_UWord32 bitRate = boundingSet->Tmmbr(n) * 1000;
- WebRtc_UWord32 mmbrExp = 0;
+ uint32_t bitRate = boundingSet->Tmmbr(n) * 1000;
+ uint32_t mmbrExp = 0;
for(int i=0; i<64; i++)
{
- if(bitRate <= ((WebRtc_UWord32)131071 << i))
+ if(bitRate <= ((uint32_t)131071 << i))
{
mmbrExp = i;
break;
}
}
- WebRtc_UWord32 mmbrMantissa = (bitRate >> mmbrExp);
- WebRtc_UWord32 measuredOH = boundingSet->PacketOH(n);
+ uint32_t mmbrMantissa = (bitRate >> mmbrExp);
+ uint32_t measuredOH = boundingSet->PacketOH(n);
- rtcpbuffer[pos++]=(WebRtc_UWord8)((mmbrExp << 2) + ((mmbrMantissa >> 15) & 0x03));
- rtcpbuffer[pos++]=(WebRtc_UWord8)(mmbrMantissa >> 7);
- rtcpbuffer[pos++]=(WebRtc_UWord8)((mmbrMantissa << 1) + ((measuredOH >> 8)& 0x01));
- rtcpbuffer[pos++]=(WebRtc_UWord8)(measuredOH);
+ rtcpbuffer[pos++]=(uint8_t)((mmbrExp << 2) + ((mmbrMantissa >> 15) & 0x03));
+ rtcpbuffer[pos++]=(uint8_t)(mmbrMantissa >> 7);
+ rtcpbuffer[pos++]=(uint8_t)((mmbrMantissa << 1) + ((measuredOH >> 8)& 0x01));
+ rtcpbuffer[pos++]=(uint8_t)(measuredOH);
numBoundingSet++;
}
}
- WebRtc_UWord16 length= (WebRtc_UWord16)(2+2*numBoundingSet);
- rtcpbuffer[posLength++]=(WebRtc_UWord8)(length>>8);
- rtcpbuffer[posLength]=(WebRtc_UWord8)(length);
+ uint16_t length= (uint16_t)(2+2*numBoundingSet);
+ rtcpbuffer[posLength++]=(uint8_t)(length>>8);
+ rtcpbuffer[posLength]=(uint8_t)(length);
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildAPP(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos)
+int32_t
+RTCPSender::BuildAPP(uint8_t* rtcpbuffer, uint32_t& pos)
{
// sanity
if(_appData == NULL)
@@ -1320,14 +1320,14 @@
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__);
return -2;
}
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + _appSubType;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + _appSubType;
// Add APP ID
- rtcpbuffer[pos++]=(WebRtc_UWord8)204;
+ rtcpbuffer[pos++]=(uint8_t)204;
- WebRtc_UWord16 length = (_appLength>>2) + 2; // include SSRC and name
- rtcpbuffer[pos++]=(WebRtc_UWord8)(length>>8);
- rtcpbuffer[pos++]=(WebRtc_UWord8)(length);
+ uint16_t length = (_appLength>>2) + 2; // include SSRC and name
+ rtcpbuffer[pos++]=(uint8_t)(length>>8);
+ rtcpbuffer[pos++]=(uint8_t)(length);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
@@ -1343,11 +1343,11 @@
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_Word32 nackSize,
- const WebRtc_UWord16* nackList,
+int32_t
+RTCPSender::BuildNACK(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const int32_t nackSize,
+ const uint16_t* nackList,
std::string* nackString)
{
// sanity
@@ -1357,15 +1357,15 @@
return -2;
}
- // int size, WebRtc_UWord16* nackList
+ // int size, uint16_t* nackList
// add nack list
- WebRtc_UWord8 FMT = 1;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + FMT;
- rtcpbuffer[pos++]=(WebRtc_UWord8)205;
+ uint8_t FMT = 1;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + FMT;
+ rtcpbuffer[pos++]=(uint8_t)205;
- rtcpbuffer[pos++]=(WebRtc_UWord8) 0;
+ rtcpbuffer[pos++]=(uint8_t) 0;
int nackSizePos = pos;
- rtcpbuffer[pos++]=(WebRtc_UWord8)(3); //setting it to one kNACK signal as default
+ rtcpbuffer[pos++]=(uint8_t)(3); //setting it to one kNACK signal as default
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
@@ -1381,7 +1381,7 @@
NACKStringBuilder stringBuilder;
while (nackSize > i && numOfNackFields < kRtcpMaxNackFields)
{
- WebRtc_UWord16 nack = nackList[i];
+ uint16_t nack = nackList[i];
// put dow our sequence number
ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer+pos, nack);
pos += 2;
@@ -1391,11 +1391,11 @@
numOfNackFields++;
if(nackSize > i)
{
- bool moreThan16Away = (WebRtc_UWord16(nack+16) < nackList[i])?true: false;
+ bool moreThan16Away = (uint16_t(nack+16) < nackList[i])?true: false;
if(!moreThan16Away)
{
// check for a wrap
- if(WebRtc_UWord16(nack+16) > 0xff00 && nackList[i] < 0x0fff)
+ if(uint16_t(nack+16) > 0xff00 && nackList[i] < 0x0fff)
{
// wrap
moreThan16Away = true;
@@ -1404,18 +1404,18 @@
if(moreThan16Away)
{
// next is more than 16 away
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
} else
{
// build our bitmask
- WebRtc_UWord16 bitmask = 0;
+ uint16_t bitmask = 0;
- bool within16Away = (WebRtc_UWord16(nack+16) > nackList[i])?true: false;
+ bool within16Away = (uint16_t(nack+16) > nackList[i])?true: false;
if(within16Away)
{
// check for a wrap
- if(WebRtc_UWord16(nack+16) > 0xff00 && nackList[i] < 0x0fff)
+ if(uint16_t(nack+16) > 0xff00 && nackList[i] < 0x0fff)
{
// wrap
within16Away = false;
@@ -1424,7 +1424,7 @@
while( nackSize > i && within16Away)
{
- WebRtc_Word16 shift = (nackList[i]-nack)-1;
+ int16_t shift = (nackList[i]-nack)-1;
assert(!(shift > 15) && !(shift < 0));
bitmask += (1<< shift);
@@ -1432,11 +1432,11 @@
i++;
if(nackSize > i)
{
- within16Away = (WebRtc_UWord16(nack+16) > nackList[i])?true: false;
+ within16Away = (uint16_t(nack+16) > nackList[i])?true: false;
if(within16Away)
{
// check for a wrap
- if(WebRtc_UWord16(nack+16) > 0xff00 && nackList[i] < 0x0fff)
+ if(uint16_t(nack+16) > 0xff00 && nackList[i] < 0x0fff)
{
// wrap
within16Away = false;
@@ -1455,17 +1455,17 @@
} else
{
// no more in the list
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)0;
}
}
- rtcpbuffer[nackSizePos]=(WebRtc_UWord8)(2+numOfNackFields);
+ rtcpbuffer[nackSizePos]=(uint8_t)(2+numOfNackFields);
*nackString = stringBuilder.GetResult();
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildBYE(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos)
+int32_t
+RTCPSender::BuildBYE(uint8_t* rtcpbuffer, uint32_t& pos)
{
// sanity
if(pos + 8 >= IP_PACKET_SIZE)
@@ -1475,12 +1475,12 @@
if(_includeCSRCs)
{
// Add a bye packet
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + 1 + _CSRCs; // number of SSRC+CSRCs
- rtcpbuffer[pos++]=(WebRtc_UWord8)203;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + 1 + _CSRCs; // number of SSRC+CSRCs
+ rtcpbuffer[pos++]=(uint8_t)203;
// length
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)(1 + _CSRCs);
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)(1 + _CSRCs);
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
@@ -1495,12 +1495,12 @@
} else
{
// Add a bye packet
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + 1; // number of SSRC+CSRCs
- rtcpbuffer[pos++]=(WebRtc_UWord8)203;
+ rtcpbuffer[pos++]=(uint8_t)0x80 + 1; // number of SSRC+CSRCs
+ rtcpbuffer[pos++]=(uint8_t)203;
// length
- rtcpbuffer[pos++]=(WebRtc_UWord8)0;
- rtcpbuffer[pos++]=(WebRtc_UWord8)1;
+ rtcpbuffer[pos++]=(uint8_t)0;
+ rtcpbuffer[pos++]=(uint8_t)1;
// Add our own SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC);
@@ -1509,8 +1509,8 @@
return 0;
}
-WebRtc_Word32
-RTCPSender::BuildVoIPMetric(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos)
+int32_t
+RTCPSender::BuildVoIPMetric(uint8_t* rtcpbuffer, uint32_t& pos)
{
// sanity
if(pos + 44 >= IP_PACKET_SIZE)
@@ -1519,10 +1519,10 @@
}
// Add XR header
- rtcpbuffer[pos++]=(WebRtc_UWord8)0x80;
- rtcpbuffer[pos++]=(WebRtc_UWord8)207;
+ rtcpbuffer[pos++]=(uint8_t)0x80;
+ rtcpbuffer[pos++]=(uint8_t)207;
- WebRtc_UWord32 XRLengthPos = pos;
+ uint32_t XRLengthPos = pos;
// handle length later on
pos++;
@@ -1547,15 +1547,15 @@
rtcpbuffer[pos++] = _xrVoIPMetric.burstDensity;
rtcpbuffer[pos++] = _xrVoIPMetric.gapDensity;
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.burstDuration >> 8);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.burstDuration);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.gapDuration >> 8);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.gapDuration);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.burstDuration >> 8);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.burstDuration);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.gapDuration >> 8);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.gapDuration);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.roundTripDelay >> 8);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.roundTripDelay);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.endSystemDelay >> 8);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.endSystemDelay);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.roundTripDelay >> 8);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.roundTripDelay);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.endSystemDelay >> 8);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.endSystemDelay);
rtcpbuffer[pos++] = _xrVoIPMetric.signalLevel;
rtcpbuffer[pos++] = _xrVoIPMetric.noiseLevel;
@@ -1569,39 +1569,39 @@
rtcpbuffer[pos++] = _xrVoIPMetric.RXconfig;
rtcpbuffer[pos++] = 0; // reserved
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.JBnominal >> 8);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.JBnominal);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.JBnominal >> 8);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.JBnominal);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.JBmax >> 8);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.JBmax);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.JBabsMax >> 8);
- rtcpbuffer[pos++] = (WebRtc_UWord8)(_xrVoIPMetric.JBabsMax);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.JBmax >> 8);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.JBmax);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.JBabsMax >> 8);
+ rtcpbuffer[pos++] = (uint8_t)(_xrVoIPMetric.JBabsMax);
- rtcpbuffer[XRLengthPos]=(WebRtc_UWord8)(0);
- rtcpbuffer[XRLengthPos+1]=(WebRtc_UWord8)(10);
+ rtcpbuffer[XRLengthPos]=(uint8_t)(0);
+ rtcpbuffer[XRLengthPos+1]=(uint8_t)(10);
return 0;
}
-WebRtc_Word32
-RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags,
- const WebRtc_Word32 nackSize, // NACK
- const WebRtc_UWord16* nackList, // NACK
+int32_t
+RTCPSender::SendRTCP(const uint32_t packetTypeFlags,
+ const int32_t nackSize, // NACK
+ const uint16_t* nackList, // NACK
const bool repeat, // FIR
- const WebRtc_UWord64 pictureID) // SLI & RPSI
+ const uint64_t pictureID) // SLI & RPSI
{
- WebRtc_UWord32 rtcpPacketTypeFlags = packetTypeFlags;
- WebRtc_UWord32 pos = 0;
- WebRtc_UWord8 rtcpbuffer[IP_PACKET_SIZE];
+ uint32_t rtcpPacketTypeFlags = packetTypeFlags;
+ uint32_t pos = 0;
+ uint8_t rtcpbuffer[IP_PACKET_SIZE];
do // only to be able to use break :) (and the critsect must be inside its own scope)
{
// collect the received information
RTCPReportBlock received;
bool hasReceived = false;
- WebRtc_UWord32 NTPsec = 0;
- WebRtc_UWord32 NTPfrac = 0;
+ uint32_t NTPsec = 0;
+ uint32_t NTPfrac = 0;
bool rtcpCompound = false;
- WebRtc_UWord32 jitterTransmissionOffset = 0;
+ uint32_t jitterTransmissionOffset = 0;
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -1628,9 +1628,9 @@
{
hasReceived = true;
- WebRtc_UWord32 lastReceivedRRNTPsecs = 0;
- WebRtc_UWord32 lastReceivedRRNTPfrac = 0;
- WebRtc_UWord32 remoteSR = 0;
+ uint32_t lastReceivedRRNTPsecs = 0;
+ uint32_t lastReceivedRRNTPfrac = 0;
+ uint32_t remoteSR = 0;
// ok even if we have not received a SR, we will send 0 in that case
_rtpRtcp.LastReceivedNTP(lastReceivedRRNTPsecs,
@@ -1641,15 +1641,15 @@
_clock->CurrentNtp(NTPsec, NTPfrac);
// Delay since last received report
- WebRtc_UWord32 delaySinceLastReceivedSR = 0;
+ uint32_t delaySinceLastReceivedSR = 0;
if((lastReceivedRRNTPsecs !=0) || (lastReceivedRRNTPfrac !=0))
{
// get the 16 lowest bits of seconds and the 16 higest bits of fractions
- WebRtc_UWord32 now=NTPsec&0x0000FFFF;
+ uint32_t now=NTPsec&0x0000FFFF;
now <<=16;
now += (NTPfrac&0xffff0000)>>16;
- WebRtc_UWord32 receiveTime = lastReceivedRRNTPsecs&0x0000FFFF;
+ uint32_t receiveTime = lastReceivedRRNTPsecs&0x0000FFFF;
receiveTime <<=16;
receiveTime += (lastReceivedRRNTPfrac&0xffff0000)>>16;
@@ -1723,22 +1723,22 @@
{
// generate next time to send a RTCP report
// seeded from RTP constructor
- WebRtc_Word32 random = rand() % 1000;
- WebRtc_Word32 timeToNext = RTCP_INTERVAL_AUDIO_MS;
+ int32_t random = rand() % 1000;
+ int32_t timeToNext = RTCP_INTERVAL_AUDIO_MS;
if(_audio)
{
timeToNext = (RTCP_INTERVAL_AUDIO_MS/2) + (RTCP_INTERVAL_AUDIO_MS*random/1000);
}else
{
- WebRtc_UWord32 minIntervalMs = RTCP_INTERVAL_AUDIO_MS;
+ uint32_t minIntervalMs = RTCP_INTERVAL_AUDIO_MS;
if(_sending)
{
// calc bw for video 360/sendBW in kbit/s
- WebRtc_UWord32 sendBitrateKbit = 0;
- WebRtc_UWord32 videoRate = 0;
- WebRtc_UWord32 fecRate = 0;
- WebRtc_UWord32 nackRate = 0;
+ uint32_t sendBitrateKbit = 0;
+ uint32_t videoRate = 0;
+ uint32_t fecRate = 0;
+ uint32_t nackRate = 0;
_rtpRtcp.BitrateSent(&sendBitrateKbit,
&videoRate,
&fecRate,
@@ -1759,7 +1759,7 @@
}
// if the data does not fitt in the packet we fill it as much as possible
- WebRtc_Word32 buildVal = 0;
+ int32_t buildVal = 0;
if(rtcpPacketTypeFlags & kRtcpSr)
{
@@ -1863,7 +1863,7 @@
}
if(rtcpPacketTypeFlags & kRtcpSli)
{
- buildVal = BuildSLI(rtcpbuffer, pos, (WebRtc_UWord8)pictureID);
+ buildVal = BuildSLI(rtcpbuffer, pos, (uint8_t)pictureID);
if(buildVal == -1)
{
return -1; // error
@@ -1875,12 +1875,12 @@
}
if(rtcpPacketTypeFlags & kRtcpRpsi)
{
- const WebRtc_Word8 payloadType = _rtpRtcp.SendPayloadType();
+ const int8_t payloadType = _rtpRtcp.SendPayloadType();
if(payloadType == -1)
{
return -1;
}
- buildVal = BuildRPSI(rtcpbuffer, pos, pictureID, (WebRtc_UWord8)payloadType);
+ buildVal = BuildRPSI(rtcpbuffer, pos, pictureID, (uint8_t)payloadType);
if(buildVal == -1)
{
return -1; // error
@@ -1988,12 +1988,12 @@
{
return -1;
}
- return SendToNetwork(rtcpbuffer, (WebRtc_UWord16)pos);
+ return SendToNetwork(rtcpbuffer, (uint16_t)pos);
}
-WebRtc_Word32
-RTCPSender::SendToNetwork(const WebRtc_UWord8* dataBuffer,
- const WebRtc_UWord16 length)
+int32_t
+RTCPSender::SendToNetwork(const uint8_t* dataBuffer,
+ const uint16_t length)
{
CriticalSectionScoped lock(_criticalSectionTransport);
if(_cbTransport)
@@ -2006,16 +2006,16 @@
return -1;
}
-WebRtc_Word32
+int32_t
RTCPSender::SetCSRCStatus(const bool include)
{
_includeCSRCs = include;
return 0;
}
-WebRtc_Word32
-RTCPSender::SetCSRCs(const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize],
- const WebRtc_UWord8 arrLength)
+int32_t
+RTCPSender::SetCSRCs(const uint32_t arrOfCSRC[kRtpCsrcSize],
+ const uint8_t arrLength)
{
if(arrLength > kRtpCsrcSize)
{
@@ -2034,11 +2034,11 @@
return 0;
}
-WebRtc_Word32
-RTCPSender::SetApplicationSpecificData(const WebRtc_UWord8 subType,
- const WebRtc_UWord32 name,
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 length)
+int32_t
+RTCPSender::SetApplicationSpecificData(const uint8_t subType,
+ const uint32_t name,
+ const uint8_t* data,
+ const uint16_t length)
{
if(length %4 != 0)
{
@@ -2055,13 +2055,13 @@
_appSend = true;
_appSubType = subType;
_appName = name;
- _appData = new WebRtc_UWord8[length];
+ _appData = new uint8_t[length];
_appLength = length;
memcpy(_appData, data, length);
return 0;
}
-WebRtc_Word32
+int32_t
RTCPSender::SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -2072,12 +2072,12 @@
}
// called under critsect _criticalSectionRTCPSender
-WebRtc_Word32 RTCPSender::AddReportBlocks(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- WebRtc_UWord8& numberOfReportBlocks,
- const RTCPReportBlock* received,
- const WebRtc_UWord32 NTPsec,
- const WebRtc_UWord32 NTPfrac) {
+int32_t RTCPSender::AddReportBlocks(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ uint8_t& numberOfReportBlocks,
+ const RTCPReportBlock* received,
+ const uint32_t NTPsec,
+ const uint32_t NTPfrac) {
// sanity one block
if(pos + 24 >= IP_PACKET_SIZE) {
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id,
@@ -2129,12 +2129,12 @@
"%s invalid argument", __FUNCTION__);
return -1;
}
- std::map<WebRtc_UWord32, RTCPReportBlock*>::iterator it =
+ std::map<uint32_t, RTCPReportBlock*>::iterator it =
_reportBlocks.begin();
for (; it != _reportBlocks.end(); it++) {
// we can have multiple report block in a conference
- WebRtc_UWord32 remoteSSRC = it->first;
+ uint32_t remoteSSRC = it->first;
RTCPReportBlock* reportBlock = it->second;
if (reportBlock) {
// Remote SSRC
@@ -2172,9 +2172,9 @@
}
// no callbacks allowed inside this function
-WebRtc_Word32
+int32_t
RTCPSender::SetTMMBN(const TMMBRSet* boundingSet,
- const WebRtc_UWord32 maxBitrateKbit)
+ const uint32_t maxBitrateKbit)
{
CriticalSectionScoped lock(_criticalSectionRTCPSender);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
index 5ca6a01..014b975 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
@@ -32,176 +32,173 @@
{
public:
NACKStringBuilder();
- void PushNACK(WebRtc_UWord16 nack);
+ void PushNACK(uint16_t nack);
std::string GetResult();
private:
std::ostringstream _stream;
int _count;
- WebRtc_UWord16 _prevNack;
+ uint16_t _prevNack;
bool _consecutive;
};
class RTCPSender
{
public:
- RTCPSender(const WebRtc_Word32 id, const bool audio,
+ RTCPSender(const int32_t id, const bool audio,
Clock* clock, ModuleRtpRtcpImpl* owner);
virtual ~RTCPSender();
- void ChangeUniqueId(const WebRtc_Word32 id);
+ void ChangeUniqueId(const int32_t id);
- WebRtc_Word32 Init();
+ int32_t Init();
- WebRtc_Word32 RegisterSendTransport(Transport* outgoingTransport);
+ int32_t RegisterSendTransport(Transport* outgoingTransport);
RTCPMethod Status() const;
- WebRtc_Word32 SetRTCPStatus(const RTCPMethod method);
+ int32_t SetRTCPStatus(const RTCPMethod method);
bool Sending() const;
- WebRtc_Word32 SetSendingStatus(const bool enabled); // combine the functions
+ int32_t SetSendingStatus(const bool enabled); // combine the functions
- WebRtc_Word32 SetNackStatus(const bool enable);
+ int32_t SetNackStatus(const bool enable);
void SetStartTimestamp(uint32_t start_timestamp);
void SetLastRtpTime(uint32_t rtp_timestamp,
int64_t capture_time_ms);
- void SetSSRC( const WebRtc_UWord32 ssrc);
+ void SetSSRC( const uint32_t ssrc);
- WebRtc_Word32 SetRemoteSSRC( const WebRtc_UWord32 ssrc);
+ int32_t SetRemoteSSRC( const uint32_t ssrc);
- WebRtc_Word32 SetCameraDelay(const WebRtc_Word32 delayMS);
+ int32_t SetCameraDelay(const int32_t delayMS);
- WebRtc_Word32 CNAME(char cName[RTCP_CNAME_SIZE]);
- WebRtc_Word32 SetCNAME(const char cName[RTCP_CNAME_SIZE]);
+ int32_t CNAME(char cName[RTCP_CNAME_SIZE]);
+ int32_t SetCNAME(const char cName[RTCP_CNAME_SIZE]);
- WebRtc_Word32 AddMixedCNAME(const WebRtc_UWord32 SSRC,
- const char cName[RTCP_CNAME_SIZE]);
+ int32_t AddMixedCNAME(const uint32_t SSRC,
+ const char cName[RTCP_CNAME_SIZE]);
- WebRtc_Word32 RemoveMixedCNAME(const WebRtc_UWord32 SSRC);
+ int32_t RemoveMixedCNAME(const uint32_t SSRC);
- WebRtc_UWord32 SendTimeOfSendReport(const WebRtc_UWord32 sendReport);
+ uint32_t SendTimeOfSendReport(const uint32_t sendReport);
bool TimeToSendRTCPReport(const bool sendKeyframeBeforeRTP = false) const;
- WebRtc_UWord32 LastSendReport(WebRtc_UWord32& lastRTCPTime);
+ uint32_t LastSendReport(uint32_t& lastRTCPTime);
- WebRtc_Word32 SendRTCP(const WebRtc_UWord32 rtcpPacketTypeFlags,
- const WebRtc_Word32 nackSize = 0,
- const WebRtc_UWord16* nackList = 0,
- const bool repeat = false,
- const WebRtc_UWord64 pictureID = 0);
+ int32_t SendRTCP(const uint32_t rtcpPacketTypeFlags,
+ const int32_t nackSize = 0,
+ const uint16_t* nackList = 0,
+ const bool repeat = false,
+ const uint64_t pictureID = 0);
- WebRtc_Word32 AddReportBlock(const WebRtc_UWord32 SSRC,
- const RTCPReportBlock* receiveBlock);
+ int32_t AddReportBlock(const uint32_t SSRC,
+ const RTCPReportBlock* receiveBlock);
- WebRtc_Word32 RemoveReportBlock(const WebRtc_UWord32 SSRC);
+ int32_t RemoveReportBlock(const uint32_t SSRC);
/*
* REMB
*/
bool REMB() const;
- WebRtc_Word32 SetREMBStatus(const bool enable);
+ int32_t SetREMBStatus(const bool enable);
- WebRtc_Word32 SetREMBData(const WebRtc_UWord32 bitrate,
- const WebRtc_UWord8 numberOfSSRC,
- const WebRtc_UWord32* SSRC);
+ int32_t SetREMBData(const uint32_t bitrate,
+ const uint8_t numberOfSSRC,
+ const uint32_t* SSRC);
/*
* TMMBR
*/
bool TMMBR() const;
- WebRtc_Word32 SetTMMBRStatus(const bool enable);
+ int32_t SetTMMBRStatus(const bool enable);
- WebRtc_Word32 SetTMMBN(const TMMBRSet* boundingSet,
- const WebRtc_UWord32 maxBitrateKbit);
+ int32_t SetTMMBN(const TMMBRSet* boundingSet,
+ const uint32_t maxBitrateKbit);
/*
* Extended jitter report
*/
bool IJ() const;
- WebRtc_Word32 SetIJStatus(const bool enable);
+ int32_t SetIJStatus(const bool enable);
/*
*
*/
- WebRtc_Word32 SetApplicationSpecificData(const WebRtc_UWord8 subType,
- const WebRtc_UWord32 name,
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 length);
+ int32_t SetApplicationSpecificData(const uint8_t subType,
+ const uint32_t name,
+ const uint8_t* data,
+ const uint16_t length);
- WebRtc_Word32 SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric);
+ int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric);
- WebRtc_Word32 SetCSRCs(const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize],
- const WebRtc_UWord8 arrLength);
+ int32_t SetCSRCs(const uint32_t arrOfCSRC[kRtpCsrcSize],
+ const uint8_t arrLength);
- WebRtc_Word32 SetCSRCStatus(const bool include);
+ int32_t SetCSRCStatus(const bool include);
void SetTargetBitrate(unsigned int target_bitrate);
private:
- WebRtc_Word32 SendToNetwork(const WebRtc_UWord8* dataBuffer,
- const WebRtc_UWord16 length);
+ int32_t SendToNetwork(const uint8_t* dataBuffer, const uint16_t length);
void UpdatePacketRate();
- WebRtc_Word32 AddReportBlocks(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- WebRtc_UWord8& numberOfReportBlocks,
- const RTCPReportBlock* received,
- const WebRtc_UWord32 NTPsec,
- const WebRtc_UWord32 NTPfrac);
+ int32_t AddReportBlocks(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ uint8_t& numberOfReportBlocks,
+ const RTCPReportBlock* received,
+ const uint32_t NTPsec,
+ const uint32_t NTPfrac);
- WebRtc_Word32 BuildSR(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord32 NTPsec,
- const WebRtc_UWord32 NTPfrac,
- const RTCPReportBlock* received = NULL);
+ int32_t BuildSR(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint32_t NTPsec,
+ const uint32_t NTPfrac,
+ const RTCPReportBlock* received = NULL);
- WebRtc_Word32 BuildRR(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord32 NTPsec,
- const WebRtc_UWord32 NTPfrac,
- const RTCPReportBlock* received = NULL);
+ int32_t BuildRR(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint32_t NTPsec,
+ const uint32_t NTPfrac,
+ const RTCPReportBlock* received = NULL);
- WebRtc_Word32 BuildExtendedJitterReport(
- WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord32 jitterTransmissionTimeOffset);
+ int32_t BuildExtendedJitterReport(
+ uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint32_t jitterTransmissionTimeOffset);
- WebRtc_Word32 BuildSDEC(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildPLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildREMB(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildTMMBR(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildTMMBN(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildAPP(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildVoIPMetric(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildBYE(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos);
- WebRtc_Word32 BuildFIR(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- bool repeat);
- WebRtc_Word32 BuildSLI(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord8 pictureID);
- WebRtc_Word32 BuildRPSI(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_UWord64 pictureID,
- const WebRtc_UWord8 payloadType);
+ int32_t BuildSDEC(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildPLI(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildREMB(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildTMMBR(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildTMMBN(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildAPP(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildVoIPMetric(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildBYE(uint8_t* rtcpbuffer, uint32_t& pos);
+ int32_t BuildFIR(uint8_t* rtcpbuffer, uint32_t& pos, bool repeat);
+ int32_t BuildSLI(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint8_t pictureID);
+ int32_t BuildRPSI(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const uint64_t pictureID,
+ const uint8_t payloadType);
- WebRtc_Word32 BuildNACK(WebRtc_UWord8* rtcpbuffer,
- WebRtc_UWord32& pos,
- const WebRtc_Word32 nackSize,
- const WebRtc_UWord16* nackList,
+ int32_t BuildNACK(uint8_t* rtcpbuffer,
+ uint32_t& pos,
+ const int32_t nackSize,
+ const uint16_t* nackList,
std::string* nackString);
private:
- WebRtc_Word32 _id;
+ int32_t _id;
const bool _audio;
Clock* _clock;
RTCPMethod _method;
@@ -220,57 +217,57 @@
bool _TMMBR;
bool _IJ;
- WebRtc_Word64 _nextTimeToSendRTCP;
+ int64_t _nextTimeToSendRTCP;
uint32_t start_timestamp_;
uint32_t last_rtp_timestamp_;
int64_t last_frame_capture_time_ms_;
- WebRtc_UWord32 _SSRC;
- WebRtc_UWord32 _remoteSSRC; // SSRC that we receive on our RTP channel
+ uint32_t _SSRC;
+ uint32_t _remoteSSRC; // SSRC that we receive on our RTP channel
char _CNAME[RTCP_CNAME_SIZE];
- std::map<WebRtc_UWord32, RTCPReportBlock*> _reportBlocks;
- std::map<WebRtc_UWord32, RTCPUtility::RTCPCnameInformation*> _csrcCNAMEs;
+ std::map<uint32_t, RTCPReportBlock*> _reportBlocks;
+ std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _csrcCNAMEs;
- WebRtc_Word32 _cameraDelayMS;
+ int32_t _cameraDelayMS;
// Sent
- WebRtc_UWord32 _lastSendReport[RTCP_NUMBER_OF_SR]; // allow packet loss and RTT above 1 sec
- WebRtc_UWord32 _lastRTCPTime[RTCP_NUMBER_OF_SR];
+ uint32_t _lastSendReport[RTCP_NUMBER_OF_SR]; // allow packet loss and RTT above 1 sec
+ uint32_t _lastRTCPTime[RTCP_NUMBER_OF_SR];
// send CSRCs
- WebRtc_UWord8 _CSRCs;
- WebRtc_UWord32 _CSRC[kRtpCsrcSize];
+ uint8_t _CSRCs;
+ uint32_t _CSRC[kRtpCsrcSize];
bool _includeCSRCs;
// Full intra request
- WebRtc_UWord8 _sequenceNumberFIR;
+ uint8_t _sequenceNumberFIR;
// REMB
- WebRtc_UWord8 _lengthRembSSRC;
- WebRtc_UWord8 _sizeRembSSRC;
- WebRtc_UWord32* _rembSSRC;
- WebRtc_UWord32 _rembBitrate;
+ uint8_t _lengthRembSSRC;
+ uint8_t _sizeRembSSRC;
+ uint32_t* _rembSSRC;
+ uint32_t _rembBitrate;
TMMBRHelp _tmmbrHelp;
- WebRtc_UWord32 _tmmbr_Send;
- WebRtc_UWord32 _packetOH_Send;
+ uint32_t _tmmbr_Send;
+ uint32_t _packetOH_Send;
// APP
bool _appSend;
- WebRtc_UWord8 _appSubType;
- WebRtc_UWord32 _appName;
- WebRtc_UWord8* _appData;
- WebRtc_UWord16 _appLength;
+ uint8_t _appSubType;
+ uint32_t _appName;
+ uint8_t* _appData;
+ uint16_t _appLength;
// XR VoIP metric
bool _xrSendVoIPMetric;
RTCPVoIPMetric _xrVoIPMetric;
// Counters
- WebRtc_UWord32 _nackCount;
- WebRtc_UWord32 _pliCount;
- WebRtc_UWord32 _fullIntraRequestCount;
+ uint32_t _nackCount;
+ uint32_t _pliCount;
+ uint32_t _fullIntraRequestCount;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 2395130..74dd91d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -181,10 +181,10 @@
EXPECT_EQ(std::string("5-6,9"), builder.GetResult());
}
-void CreateRtpPacket(const bool marker_bit, const WebRtc_UWord8 payload,
- const WebRtc_UWord16 seq_num, const WebRtc_UWord32 timestamp,
- const WebRtc_UWord32 ssrc, WebRtc_UWord8* array,
- WebRtc_UWord16* cur_pos) {
+void CreateRtpPacket(const bool marker_bit, const uint8_t payload,
+ const uint16_t seq_num, const uint32_t timestamp,
+ const uint32_t ssrc, uint8_t* array,
+ uint16_t* cur_pos) {
ASSERT_TRUE(payload <= 127);
array[(*cur_pos)++] = 0x80;
array[(*cur_pos)++] = payload | (marker_bit ? 0x80 : 0);
@@ -228,8 +228,8 @@
}
virtual int SendRTCPPacket(int /*ch*/, const void *packet, int packet_len) {
- RTCPUtility::RTCPParserV2 rtcpParser((WebRtc_UWord8*)packet,
- (WebRtc_Word32)packet_len,
+ RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet,
+ (int32_t)packet_len,
true); // Allow non-compound RTCP
EXPECT_TRUE(rtcpParser.IsValid());
@@ -261,8 +261,8 @@
return packet_len;
}
- virtual int OnReceivedPayloadData(const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int OnReceivedPayloadData(const uint8_t* payloadData,
+ const uint16_t payloadSize,
const WebRtcRTPHeader* rtpHeader) {
return 0;
}
@@ -339,11 +339,11 @@
TEST_F(RtcpSenderTest, TestCompound) {
const bool marker_bit = false;
- const WebRtc_UWord8 payload = 100;
- const WebRtc_UWord16 seq_num = 11111;
- const WebRtc_UWord32 timestamp = 1234567;
- const WebRtc_UWord32 ssrc = 0x11111111;
- WebRtc_UWord16 packet_length = 0;
+ const uint8_t payload = 100;
+ const uint16_t seq_num = 11111;
+ const uint32_t timestamp = 1234567;
+ const uint32_t ssrc = 0x11111111;
+ uint16_t packet_length = 0;
CreateRtpPacket(marker_bit, payload, seq_num, timestamp, ssrc, packet_,
&packet_length);
EXPECT_EQ(25, packet_length);
@@ -404,7 +404,7 @@
EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
TMMBRSet bounding_set;
bounding_set.VerifyAndAllocateSet(1);
- const WebRtc_UWord32 kSourceSsrc = 12345;
+ const uint32_t kSourceSsrc = 12345;
bounding_set.AddEntry(32768, 0, kSourceSsrc);
EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3));
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc b/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
index 8673e87..b330e18 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
@@ -17,7 +17,7 @@
namespace webrtc {
// RTCPParserV2 : currently read only
-RTCPUtility::RTCPParserV2::RTCPParserV2(const WebRtc_UWord8* rtcpData,
+RTCPUtility::RTCPParserV2::RTCPParserV2(const uint8_t* rtcpData,
size_t rtcpDataLength,
bool rtcpReducedSizeEnable)
: _ptrRTCPDataBegin(rtcpData),
@@ -411,8 +411,8 @@
}
bool
-RTCPUtility::RTCPParseCommonHeader( const WebRtc_UWord8* ptrDataBegin,
- const WebRtc_UWord8* ptrDataEnd,
+RTCPUtility::RTCPParseCommonHeader( const uint8_t* ptrDataBegin,
+ const uint8_t* ptrDataEnd,
RTCPCommonHeader& parsedHeader)
{
if (!ptrDataBegin || !ptrDataEnd)
@@ -689,7 +689,7 @@
return false;
}
- WebRtc_UWord32 SSRC = *_ptrRTCPData++ << 24;
+ uint32_t SSRC = *_ptrRTCPData++ << 24;
SSRC += *_ptrRTCPData++ << 16;
SSRC += *_ptrRTCPData++ << 8;
SSRC += *_ptrRTCPData++;
@@ -717,7 +717,7 @@
size_t itemOctetsRead = 0;
while (_ptrRTCPData < _ptrRTCPBlockEnd)
{
- const WebRtc_UWord8 tag = *_ptrRTCPData++;
+ const uint8_t tag = *_ptrRTCPData++;
++itemOctetsRead;
if (tag == 0)
@@ -732,7 +732,7 @@
if (_ptrRTCPData < _ptrRTCPBlockEnd)
{
- const WebRtc_UWord8 len = *_ptrRTCPData++;
+ const uint8_t len = *_ptrRTCPData++;
++itemOctetsRead;
if (tag == 1)
@@ -747,10 +747,10 @@
EndCurrentBlock();
return false;
}
- WebRtc_UWord8 i = 0;
+ uint8_t i = 0;
for (; i < len; ++i)
{
- const WebRtc_UWord8 c = _ptrRTCPData[i];
+ const uint8_t c = _ptrRTCPData[i];
if ((c < ' ') || (c > '{') || (c == '%') || (c == '\\'))
{
// Illegal char
@@ -870,10 +870,10 @@
return false;
}
- WebRtc_UWord8 blockType = *_ptrRTCPData++;
- WebRtc_UWord8 typeSpecific = *_ptrRTCPData++;
+ uint8_t blockType = *_ptrRTCPData++;
+ uint8_t typeSpecific = *_ptrRTCPData++;
- WebRtc_UWord16 blockLength = *_ptrRTCPData++ << 8;
+ uint16_t blockLength = *_ptrRTCPData++ << 8;
blockLength = *_ptrRTCPData++;
if(blockType == 7 && typeSpecific == 0)
@@ -985,12 +985,12 @@
_ptrRTCPData += 4; // Skip RTCP header
- WebRtc_UWord32 senderSSRC = *_ptrRTCPData++ << 24;
+ uint32_t senderSSRC = *_ptrRTCPData++ << 24;
senderSSRC += *_ptrRTCPData++ << 16;
senderSSRC += *_ptrRTCPData++ << 8;
senderSSRC += *_ptrRTCPData++;
- WebRtc_UWord32 mediaSSRC = *_ptrRTCPData++ << 24;
+ uint32_t mediaSSRC = *_ptrRTCPData++ << 24;
mediaSSRC += *_ptrRTCPData++ << 16;
mediaSSRC += *_ptrRTCPData++ << 8;
mediaSSRC += *_ptrRTCPData++;
@@ -1149,12 +1149,12 @@
_packetType = kRtcpPsfbRpsiCode;
- WebRtc_UWord8 paddingBits = *_ptrRTCPData++;
+ uint8_t paddingBits = *_ptrRTCPData++;
_packet.RPSI.PayloadType = *_ptrRTCPData++;
memcpy(_packet.RPSI.NativeBitString, _ptrRTCPData, length-2);
- _packet.RPSI.NumberOfValidBits = WebRtc_UWord16(length-2)*8 - paddingBits;
+ _packet.RPSI.NumberOfValidBits = uint16_t(length-2)*8 - paddingBits;
return true;
}
@@ -1243,9 +1243,9 @@
}
_packet.REMBItem.NumberOfSSRCs = *_ptrRTCPData++;
- const WebRtc_UWord8 brExp = (_ptrRTCPData[0] >> 2) & 0x3F;
+ const uint8_t brExp = (_ptrRTCPData[0] >> 2) & 0x3F;
- WebRtc_UWord32 brMantissa = (_ptrRTCPData[0] & 0x03) << 16;
+ uint32_t brMantissa = (_ptrRTCPData[0] & 0x03) << 16;
brMantissa += (_ptrRTCPData[1] << 8);
brMantissa += (_ptrRTCPData[2]);
@@ -1295,13 +1295,13 @@
_packet.TMMBRItem.SSRC += *_ptrRTCPData++ << 8;
_packet.TMMBRItem.SSRC += *_ptrRTCPData++;
- WebRtc_UWord8 mxtbrExp = (_ptrRTCPData[0] >> 2) & 0x3F;
+ uint8_t mxtbrExp = (_ptrRTCPData[0] >> 2) & 0x3F;
- WebRtc_UWord32 mxtbrMantissa = (_ptrRTCPData[0] & 0x03) << 15;
+ uint32_t mxtbrMantissa = (_ptrRTCPData[0] & 0x03) << 15;
mxtbrMantissa += (_ptrRTCPData[1] << 7);
mxtbrMantissa += (_ptrRTCPData[2] >> 1) & 0x7F;
- WebRtc_UWord32 measuredOH = (_ptrRTCPData[2] & 0x01) << 8;
+ uint32_t measuredOH = (_ptrRTCPData[2] & 0x01) << 8;
measuredOH += _ptrRTCPData[3];
_ptrRTCPData += 4; // Fwd read data
@@ -1334,13 +1334,13 @@
_packet.TMMBNItem.SSRC += *_ptrRTCPData++ << 8;
_packet.TMMBNItem.SSRC += *_ptrRTCPData++;
- WebRtc_UWord8 mxtbrExp = (_ptrRTCPData[0] >> 2) & 0x3F;
+ uint8_t mxtbrExp = (_ptrRTCPData[0] >> 2) & 0x3F;
- WebRtc_UWord32 mxtbrMantissa = (_ptrRTCPData[0] & 0x03) << 15;
+ uint32_t mxtbrMantissa = (_ptrRTCPData[0] & 0x03) << 15;
mxtbrMantissa += (_ptrRTCPData[1] << 7);
mxtbrMantissa += (_ptrRTCPData[2] >> 1) & 0x7F;
- WebRtc_UWord32 measuredOH = (_ptrRTCPData[2] & 0x01) << 8;
+ uint32_t measuredOH = (_ptrRTCPData[2] & 0x01) << 8;
measuredOH += _ptrRTCPData[3];
_ptrRTCPData += 4; // Fwd read data
@@ -1374,15 +1374,15 @@
}
_packetType = kRtcpPsfbSliItemCode;
- WebRtc_UWord32 buffer;
+ uint32_t buffer;
buffer = *_ptrRTCPData++ << 24;
buffer += *_ptrRTCPData++ << 16;
buffer += *_ptrRTCPData++ << 8;
buffer += *_ptrRTCPData++;
- _packet.SLIItem.FirstMB = WebRtc_UWord16((buffer>>19) & 0x1fff);
- _packet.SLIItem.NumberOfMB = WebRtc_UWord16((buffer>>6) & 0x1fff);
- _packet.SLIItem.PictureId = WebRtc_UWord8(buffer & 0x3f);
+ _packet.SLIItem.FirstMB = uint16_t((buffer>>19) & 0x1fff);
+ _packet.SLIItem.NumberOfMB = uint16_t((buffer>>6) & 0x1fff);
+ _packet.SLIItem.PictureId = uint8_t(buffer & 0x3f);
return true;
}
@@ -1427,12 +1427,12 @@
_ptrRTCPData += 4; // Skip RTCP header
- WebRtc_UWord32 senderSSRC = *_ptrRTCPData++ << 24;
+ uint32_t senderSSRC = *_ptrRTCPData++ << 24;
senderSSRC += *_ptrRTCPData++ << 16;
senderSSRC += *_ptrRTCPData++ << 8;
senderSSRC += *_ptrRTCPData++;
- WebRtc_UWord32 name = *_ptrRTCPData++ << 24;
+ uint32_t name = *_ptrRTCPData++ << 24;
name += *_ptrRTCPData++ << 16;
name += *_ptrRTCPData++ << 8;
name += *_ptrRTCPData++;
@@ -1469,13 +1469,13 @@
}else
{
memcpy(_packet.APP.Data, _ptrRTCPData, length);
- _packet.APP.Size = (WebRtc_UWord16)length;
+ _packet.APP.Size = (uint16_t)length;
_ptrRTCPData += length;
}
return true;
}
-RTCPUtility::RTCPPacketIterator::RTCPPacketIterator(WebRtc_UWord8* rtcpData,
+RTCPUtility::RTCPPacketIterator::RTCPPacketIterator(uint8_t* rtcpData,
size_t rtcpDataLength)
: _ptrBegin(rtcpData),
_ptrEnd(rtcpData + rtcpDataLength),
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_utility.h b/webrtc/modules/rtp_rtcp/source/rtcp_utility.h
index cce1f0b..86b2efd 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_utility.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_utility.h
@@ -26,177 +26,177 @@
};
struct RTCPPacketRR
{
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord8 NumberOfReportBlocks;
+ uint32_t SenderSSRC;
+ uint8_t NumberOfReportBlocks;
};
struct RTCPPacketSR
{
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord8 NumberOfReportBlocks;
+ uint32_t SenderSSRC;
+ uint8_t NumberOfReportBlocks;
// sender info
- WebRtc_UWord32 NTPMostSignificant;
- WebRtc_UWord32 NTPLeastSignificant;
- WebRtc_UWord32 RTPTimestamp;
- WebRtc_UWord32 SenderPacketCount;
- WebRtc_UWord32 SenderOctetCount;
+ uint32_t NTPMostSignificant;
+ uint32_t NTPLeastSignificant;
+ uint32_t RTPTimestamp;
+ uint32_t SenderPacketCount;
+ uint32_t SenderOctetCount;
};
struct RTCPPacketReportBlockItem
{
// report block
- WebRtc_UWord32 SSRC;
- WebRtc_UWord8 FractionLost;
- WebRtc_UWord32 CumulativeNumOfPacketsLost;
- WebRtc_UWord32 ExtendedHighestSequenceNumber;
- WebRtc_UWord32 Jitter;
- WebRtc_UWord32 LastSR;
- WebRtc_UWord32 DelayLastSR;
+ uint32_t SSRC;
+ uint8_t FractionLost;
+ uint32_t CumulativeNumOfPacketsLost;
+ uint32_t ExtendedHighestSequenceNumber;
+ uint32_t Jitter;
+ uint32_t LastSR;
+ uint32_t DelayLastSR;
};
struct RTCPPacketSDESCName
{
// RFC3550
- WebRtc_UWord32 SenderSSRC;
+ uint32_t SenderSSRC;
char CName[RTCP_CNAME_SIZE];
};
struct RTCPPacketExtendedJitterReportItem
{
// RFC 5450
- WebRtc_UWord32 Jitter;
+ uint32_t Jitter;
};
struct RTCPPacketBYE
{
- WebRtc_UWord32 SenderSSRC;
+ uint32_t SenderSSRC;
};
struct RTCPPacketXR
{
// RFC 3611
- WebRtc_UWord32 OriginatorSSRC;
+ uint32_t OriginatorSSRC;
};
struct RTCPPacketXRVOIPMetricItem
{
// RFC 3611 4.7
- WebRtc_UWord32 SSRC;
- WebRtc_UWord8 lossRate;
- WebRtc_UWord8 discardRate;
- WebRtc_UWord8 burstDensity;
- WebRtc_UWord8 gapDensity;
- WebRtc_UWord16 burstDuration;
- WebRtc_UWord16 gapDuration;
- WebRtc_UWord16 roundTripDelay;
- WebRtc_UWord16 endSystemDelay;
- WebRtc_UWord8 signalLevel;
- WebRtc_UWord8 noiseLevel;
- WebRtc_UWord8 RERL;
- WebRtc_UWord8 Gmin;
- WebRtc_UWord8 Rfactor;
- WebRtc_UWord8 extRfactor;
- WebRtc_UWord8 MOSLQ;
- WebRtc_UWord8 MOSCQ;
- WebRtc_UWord8 RXconfig;
- WebRtc_UWord16 JBnominal;
- WebRtc_UWord16 JBmax;
- WebRtc_UWord16 JBabsMax;
+ uint32_t SSRC;
+ uint8_t lossRate;
+ uint8_t discardRate;
+ uint8_t burstDensity;
+ uint8_t gapDensity;
+ uint16_t burstDuration;
+ uint16_t gapDuration;
+ uint16_t roundTripDelay;
+ uint16_t endSystemDelay;
+ uint8_t signalLevel;
+ uint8_t noiseLevel;
+ uint8_t RERL;
+ uint8_t Gmin;
+ uint8_t Rfactor;
+ uint8_t extRfactor;
+ uint8_t MOSLQ;
+ uint8_t MOSCQ;
+ uint8_t RXconfig;
+ uint16_t JBnominal;
+ uint16_t JBmax;
+ uint16_t JBabsMax;
};
struct RTCPPacketRTPFBNACK
{
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC;
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC;
};
struct RTCPPacketRTPFBNACKItem
{
// RFC4585
- WebRtc_UWord16 PacketID;
- WebRtc_UWord16 BitMask;
+ uint16_t PacketID;
+ uint16_t BitMask;
};
struct RTCPPacketRTPFBTMMBR
{
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC; // zero!
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC; // zero!
};
struct RTCPPacketRTPFBTMMBRItem
{
// RFC5104
- WebRtc_UWord32 SSRC;
- WebRtc_UWord32 MaxTotalMediaBitRate; // In Kbit/s
- WebRtc_UWord32 MeasuredOverhead;
+ uint32_t SSRC;
+ uint32_t MaxTotalMediaBitRate; // In Kbit/s
+ uint32_t MeasuredOverhead;
};
struct RTCPPacketRTPFBTMMBN
{
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC; // zero!
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC; // zero!
};
struct RTCPPacketRTPFBTMMBNItem
{
// RFC5104
- WebRtc_UWord32 SSRC; // "Owner"
- WebRtc_UWord32 MaxTotalMediaBitRate;
- WebRtc_UWord32 MeasuredOverhead;
+ uint32_t SSRC; // "Owner"
+ uint32_t MaxTotalMediaBitRate;
+ uint32_t MeasuredOverhead;
};
struct RTCPPacketPSFBFIR
{
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC; // zero!
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC; // zero!
};
struct RTCPPacketPSFBFIRItem
{
// RFC5104
- WebRtc_UWord32 SSRC;
- WebRtc_UWord8 CommandSequenceNumber;
+ uint32_t SSRC;
+ uint8_t CommandSequenceNumber;
};
struct RTCPPacketPSFBPLI
{
// RFC4585
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC;
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC;
};
struct RTCPPacketPSFBSLI
{
// RFC4585
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC;
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC;
};
struct RTCPPacketPSFBSLIItem
{
// RFC4585
- WebRtc_UWord16 FirstMB;
- WebRtc_UWord16 NumberOfMB;
- WebRtc_UWord8 PictureId;
+ uint16_t FirstMB;
+ uint16_t NumberOfMB;
+ uint8_t PictureId;
};
struct RTCPPacketPSFBRPSI
{
// RFC4585
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC;
- WebRtc_UWord8 PayloadType;
- WebRtc_UWord16 NumberOfValidBits;
- WebRtc_UWord8 NativeBitString[RTCP_RPSI_DATA_SIZE];
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC;
+ uint8_t PayloadType;
+ uint16_t NumberOfValidBits;
+ uint8_t NativeBitString[RTCP_RPSI_DATA_SIZE];
};
struct RTCPPacketPSFBAPP
{
- WebRtc_UWord32 SenderSSRC;
- WebRtc_UWord32 MediaSSRC;
+ uint32_t SenderSSRC;
+ uint32_t MediaSSRC;
};
struct RTCPPacketPSFBREMBItem
{
- WebRtc_UWord32 BitRate;
- WebRtc_UWord8 NumberOfSSRCs;
- WebRtc_UWord32 SSRCs[MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS];
+ uint32_t BitRate;
+ uint8_t NumberOfSSRCs;
+ uint32_t SSRCs[MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS];
};
// generic name APP
struct RTCPPacketAPP
{
- WebRtc_UWord8 SubType;
- WebRtc_UWord32 Name;
- WebRtc_UWord8 Data[kRtcpAppCode_DATA_SIZE];
- WebRtc_UWord16 Size;
+ uint8_t SubType;
+ uint32_t Name;
+ uint8_t Data[kRtcpAppCode_DATA_SIZE];
+ uint16_t Size;
};
union RTCPPacket
@@ -282,23 +282,23 @@
struct RTCPRawPacket
{
- const WebRtc_UWord8* _ptrPacketBegin;
- const WebRtc_UWord8* _ptrPacketEnd;
+ const uint8_t* _ptrPacketBegin;
+ const uint8_t* _ptrPacketEnd;
};
struct RTCPModRawPacket
{
- WebRtc_UWord8* _ptrPacketBegin;
- WebRtc_UWord8* _ptrPacketEnd;
+ uint8_t* _ptrPacketBegin;
+ uint8_t* _ptrPacketEnd;
};
struct RTCPCommonHeader
{
- WebRtc_UWord8 V; // Version
+ uint8_t V; // Version
bool P; // Padding
- WebRtc_UWord8 IC; // Item count/subtype
- WebRtc_UWord8 PT; // Packet Type
- WebRtc_UWord16 LengthInOctets;
+ uint8_t IC; // Item count/subtype
+ uint8_t PT; // Packet Type
+ uint16_t LengthInOctets;
};
enum RTCPPT
@@ -314,14 +314,14 @@
PT_XR = 207
};
- bool RTCPParseCommonHeader( const WebRtc_UWord8* ptrDataBegin,
- const WebRtc_UWord8* ptrDataEnd,
+ bool RTCPParseCommonHeader( const uint8_t* ptrDataBegin,
+ const uint8_t* ptrDataEnd,
RTCPCommonHeader& parsedHeader);
class RTCPParserV2
{
public:
- RTCPParserV2(const WebRtc_UWord8* rtcpData,
+ RTCPParserV2(const uint8_t* rtcpData,
size_t rtcpDataLength,
bool rtcpReducedSizeEnable); // Set to true, to allow non-compound RTCP!
~RTCPParserV2();
@@ -407,16 +407,16 @@
bool ParseAPPItem();
private:
- const WebRtc_UWord8* const _ptrRTCPDataBegin;
+ const uint8_t* const _ptrRTCPDataBegin;
const bool _RTCPReducedSizeEnable;
- const WebRtc_UWord8* const _ptrRTCPDataEnd;
+ const uint8_t* const _ptrRTCPDataEnd;
bool _validPacket;
- const WebRtc_UWord8* _ptrRTCPData;
- const WebRtc_UWord8* _ptrRTCPBlockEnd;
+ const uint8_t* _ptrRTCPData;
+ const uint8_t* _ptrRTCPBlockEnd;
ParseState _state;
- WebRtc_UWord8 _numberOfBlocks;
+ uint8_t _numberOfBlocks;
RTCPPacketTypes _packetType;
RTCPPacket _packet;
@@ -425,7 +425,7 @@
class RTCPPacketIterator
{
public:
- RTCPPacketIterator(WebRtc_UWord8* rtcpData,
+ RTCPPacketIterator(uint8_t* rtcpData,
size_t rtcpDataLength);
~RTCPPacketIterator();
@@ -434,10 +434,10 @@
const RTCPCommonHeader* Current();
private:
- WebRtc_UWord8* const _ptrBegin;
- WebRtc_UWord8* const _ptrEnd;
+ uint8_t* const _ptrBegin;
+ uint8_t* const _ptrEnd;
- WebRtc_UWord8* _ptrBlock;
+ uint8_t* _ptrBlock;
RTCPCommonHeader _header;
};
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc
index 1b3c598..5f1a17c 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc
@@ -28,8 +28,8 @@
const bool RtpFormatVp8::separate_first_modes_[kNumModes] =
{ true, false, false };
-RtpFormatVp8::RtpFormatVp8(const WebRtc_UWord8* payload_data,
- WebRtc_UWord32 payload_size,
+RtpFormatVp8::RtpFormatVp8(const uint8_t* payload_data,
+ uint32_t payload_size,
const RTPVideoHeaderVP8& hdr_info,
int max_payload_len,
const RTPFragmentationHeader& fragmentation,
@@ -47,8 +47,8 @@
part_info_.CopyFrom(fragmentation);
}
-RtpFormatVp8::RtpFormatVp8(const WebRtc_UWord8* payload_data,
- WebRtc_UWord32 payload_size,
+RtpFormatVp8::RtpFormatVp8(const uint8_t* payload_data,
+ uint32_t payload_size,
const RTPVideoHeaderVP8& hdr_info,
int max_payload_len)
: payload_data_(payload_data),
@@ -67,7 +67,7 @@
part_info_.fragmentationOffset[0] = 0;
}
-int RtpFormatVp8::NextPacket(WebRtc_UWord8* buffer,
+int RtpFormatVp8::NextPacket(uint8_t* buffer,
int* bytes_to_send,
bool* last_packet) {
if (!packets_calculated_) {
@@ -297,7 +297,7 @@
}
int RtpFormatVp8::WriteHeaderAndPayload(const InfoStruct& packet_info,
- WebRtc_UWord8* buffer,
+ uint8_t* buffer,
int buffer_length) const {
// Write the VP8 payload descriptor.
// 0
@@ -331,11 +331,11 @@
+ extension_length;
}
-int RtpFormatVp8::WriteExtensionFields(WebRtc_UWord8* buffer,
+int RtpFormatVp8::WriteExtensionFields(uint8_t* buffer,
int buffer_length) const {
int extension_length = 0;
if (XFieldPresent()) {
- WebRtc_UWord8* x_field = buffer + vp8_fixed_payload_descriptor_bytes_;
+ uint8_t* x_field = buffer + vp8_fixed_payload_descriptor_bytes_;
*x_field = 0;
extension_length = 1; // One octet for the X field.
if (PictureIdPresent()) {
@@ -361,8 +361,8 @@
return extension_length;
}
-int RtpFormatVp8::WritePictureIDFields(WebRtc_UWord8* x_field,
- WebRtc_UWord8* buffer,
+int RtpFormatVp8::WritePictureIDFields(uint8_t* x_field,
+ uint8_t* buffer,
int buffer_length,
int* extension_length) const {
*x_field |= kIBit;
@@ -375,10 +375,10 @@
return 0;
}
-int RtpFormatVp8::WritePictureID(WebRtc_UWord8* buffer,
+int RtpFormatVp8::WritePictureID(uint8_t* buffer,
int buffer_length) const {
- const WebRtc_UWord16 pic_id =
- static_cast<WebRtc_UWord16> (hdr_info_.pictureId);
+ const uint16_t pic_id =
+ static_cast<uint16_t> (hdr_info_.pictureId);
int picture_id_len = PictureIdLength();
if (picture_id_len > buffer_length) return -1;
if (picture_id_len == 2) {
@@ -390,8 +390,8 @@
return picture_id_len;
}
-int RtpFormatVp8::WriteTl0PicIdxFields(WebRtc_UWord8* x_field,
- WebRtc_UWord8* buffer,
+int RtpFormatVp8::WriteTl0PicIdxFields(uint8_t* x_field,
+ uint8_t* buffer,
int buffer_length,
int* extension_length) const {
if (buffer_length < vp8_fixed_payload_descriptor_bytes_ + *extension_length
@@ -405,15 +405,15 @@
return 0;
}
-int RtpFormatVp8::WriteTIDAndKeyIdxFields(WebRtc_UWord8* x_field,
- WebRtc_UWord8* buffer,
+int RtpFormatVp8::WriteTIDAndKeyIdxFields(uint8_t* x_field,
+ uint8_t* buffer,
int buffer_length,
int* extension_length) const {
if (buffer_length < vp8_fixed_payload_descriptor_bytes_ + *extension_length
+ 1) {
return -1;
}
- WebRtc_UWord8* data_field =
+ uint8_t* data_field =
&buffer[vp8_fixed_payload_descriptor_bytes_ + *extension_length];
*data_field = 0;
if (TIDFieldPresent()) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
index f568f4d..2a62b40 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
@@ -48,8 +48,8 @@
public:
// Initialize with payload from encoder and fragmentation info.
// The payload_data must be exactly one encoded VP8 frame.
- RtpFormatVp8(const WebRtc_UWord8* payload_data,
- WebRtc_UWord32 payload_size,
+ RtpFormatVp8(const uint8_t* payload_data,
+ uint32_t payload_size,
const RTPVideoHeaderVP8& hdr_info,
int max_payload_len,
const RTPFragmentationHeader& fragmentation,
@@ -57,8 +57,8 @@
// Initialize without fragmentation info. Mode kEqualSize will be used.
// The payload_data must be exactly one encoded VP8 frame.
- RtpFormatVp8(const WebRtc_UWord8* payload_data,
- WebRtc_UWord32 payload_size,
+ RtpFormatVp8(const uint8_t* payload_data,
+ uint32_t payload_size,
const RTPVideoHeaderVP8& hdr_info,
int max_payload_len);
@@ -73,7 +73,7 @@
// the first payload byte in the packet is taken, with the first partition
// having index 0; returns negative on error.
// For the kEqualSize mode: returns 0 on success, return negative on error.
- int NextPacket(WebRtc_UWord8* buffer,
+ int NextPacket(uint8_t* buffer,
int* bytes_to_send,
bool* last_packet);
@@ -139,35 +139,35 @@
// The info in packet_info determines which part of the payload is written
// and what to write in the header fields.
int WriteHeaderAndPayload(const InfoStruct& packet_info,
- WebRtc_UWord8* buffer,
+ uint8_t* buffer,
int buffer_length) const;
// Write the X field and the appropriate extension fields to buffer.
// The function returns the extension length (including X field), or -1
// on error.
- int WriteExtensionFields(WebRtc_UWord8* buffer, int buffer_length) const;
+ int WriteExtensionFields(uint8_t* buffer, int buffer_length) const;
// Set the I bit in the x_field, and write PictureID to the appropriate
// position in buffer. The function returns 0 on success, -1 otherwise.
- int WritePictureIDFields(WebRtc_UWord8* x_field, WebRtc_UWord8* buffer,
+ int WritePictureIDFields(uint8_t* x_field, uint8_t* buffer,
int buffer_length, int* extension_length) const;
// Set the L bit in the x_field, and write Tl0PicIdx to the appropriate
// position in buffer. The function returns 0 on success, -1 otherwise.
- int WriteTl0PicIdxFields(WebRtc_UWord8* x_field, WebRtc_UWord8* buffer,
+ int WriteTl0PicIdxFields(uint8_t* x_field, uint8_t* buffer,
int buffer_length, int* extension_length) const;
// Set the T and K bits in the x_field, and write TID, Y and KeyIdx to the
// appropriate position in buffer. The function returns 0 on success,
// -1 otherwise.
- int WriteTIDAndKeyIdxFields(WebRtc_UWord8* x_field, WebRtc_UWord8* buffer,
+ int WriteTIDAndKeyIdxFields(uint8_t* x_field, uint8_t* buffer,
int buffer_length, int* extension_length) const;
// Write the PictureID from codec_specific_info_ to buffer. One or two
// bytes are written, depending on magnitude of PictureID. The function
// returns the number of bytes written.
- int WritePictureID(WebRtc_UWord8* buffer, int buffer_length) const;
+ int WritePictureID(uint8_t* buffer, int buffer_length) const;
// Calculate and return length (octets) of the variable header fields in
// the next header (i.e., header length in addition to vp8_header_bytes_).
@@ -184,7 +184,7 @@
bool TL0PicIdxFieldPresent() const;
bool PictureIdPresent() const { return (PictureIdLength() > 0); }
- const WebRtc_UWord8* payload_data_;
+ const uint8_t* payload_data_;
const int payload_size_;
RTPFragmentationHeader part_info_;
const int vp8_fixed_payload_descriptor_bytes_; // Length of VP8 payload
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
index 6c668dd..5bd4647 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
@@ -46,8 +46,8 @@
payload_size_ += partition_sizes[p];
}
buffer_size_ = payload_size_ + 6; // Add space for payload descriptor.
- payload_data_ = new WebRtc_UWord8[payload_size_];
- buffer_ = new WebRtc_UWord8[buffer_size_];
+ payload_data_ = new uint8_t[payload_size_];
+ buffer_ = new uint8_t[buffer_size_];
int j = 0;
// Loop through the partitions again.
for (int p = 0; p < num_partitions; ++p) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
index 13b9b77..cb689ee 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
@@ -15,7 +15,7 @@
namespace webrtc {
RTPPayloadRegistry::RTPPayloadRegistry(
- const WebRtc_Word32 id,
+ const int32_t id,
RTPPayloadStrategy* rtp_payload_strategy)
: id_(id),
rtp_payload_strategy_(rtp_payload_strategy),
@@ -32,12 +32,12 @@
}
}
-WebRtc_Word32 RTPPayloadRegistry::RegisterReceivePayload(
+int32_t RTPPayloadRegistry::RegisterReceivePayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
+ const int8_t payload_type,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
bool* created_new_payload) {
assert(payload_type >= 0);
assert(payload_name);
@@ -121,8 +121,8 @@
return 0;
}
-WebRtc_Word32 RTPPayloadRegistry::DeRegisterReceivePayload(
- const WebRtc_Word8 payload_type) {
+int32_t RTPPayloadRegistry::DeRegisterReceivePayload(
+ const int8_t payload_type) {
ModuleRTPUtility::PayloadTypeMap::iterator it =
payload_type_map_.find(payload_type);
@@ -142,9 +142,9 @@
void RTPPayloadRegistry::DeregisterAudioCodecOrRedTypeRegardlessOfPayloadType(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const size_t payload_name_length,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) {
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) {
ModuleRTPUtility::PayloadTypeMap::iterator iterator =
payload_type_map_.begin();
for (; iterator != payload_type_map_.end(); ++iterator) {
@@ -173,12 +173,12 @@
}
}
-WebRtc_Word32 RTPPayloadRegistry::ReceivePayloadType(
+int32_t RTPPayloadRegistry::ReceivePayloadType(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
- WebRtc_Word8* payload_type) const {
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
+ int8_t* payload_type) const {
if (payload_type == NULL) {
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
"%s invalid argument", __FUNCTION__);
@@ -226,8 +226,8 @@
return -1;
}
-WebRtc_Word32 RTPPayloadRegistry::PayloadTypeToPayload(
- const WebRtc_UWord8 payload_type,
+int32_t RTPPayloadRegistry::PayloadTypeToPayload(
+ const uint8_t payload_type,
ModuleRTPUtility::Payload*& payload) const {
ModuleRTPUtility::PayloadTypeMap::const_iterator it =
@@ -242,7 +242,7 @@
}
bool RTPPayloadRegistry::ReportMediaPayloadType(
- WebRtc_UWord8 media_payload_type) {
+ uint8_t media_payload_type) {
if (last_received_media_payload_type_ == media_payload_type) {
// Media type unchanged.
return true;
@@ -257,9 +257,9 @@
bool PayloadIsCompatible(
const ModuleRTPUtility::Payload& payload,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) const {
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) const {
return
payload.audio &&
payload.typeSpecific.Audio.frequency == frequency &&
@@ -270,16 +270,16 @@
void UpdatePayloadRate(
ModuleRTPUtility::Payload* payload,
- const WebRtc_UWord32 rate) const {
+ const uint32_t rate) const {
payload->typeSpecific.Audio.rate = rate;
}
ModuleRTPUtility::Payload* CreatePayloadType(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) const {
+ const int8_t payloadType,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) const {
ModuleRTPUtility::Payload* payload = new ModuleRTPUtility::Payload;
payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
strncpy(payload->name, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
@@ -297,24 +297,24 @@
bool PayloadIsCompatible(
const ModuleRTPUtility::Payload& payload,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) const {
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) const {
return !payload.audio;
}
void UpdatePayloadRate(
ModuleRTPUtility::Payload* payload,
- const WebRtc_UWord32 rate) const {
+ const uint32_t rate) const {
payload->typeSpecific.Video.maxRate = rate;
}
ModuleRTPUtility::Payload* CreatePayloadType(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) const {
+ const int8_t payloadType,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) const {
RtpVideoCodecTypes videoType = kRtpGenericVideo;
if (ModuleRTPUtility::StringCompare(payloadName, "VP8", 3)) {
videoType = kRtpVp8Video;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h
index 7153ba2..7ba4c25 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h
@@ -27,20 +27,20 @@
virtual bool PayloadIsCompatible(
const ModuleRTPUtility::Payload& payload,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) const = 0;
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) const = 0;
virtual void UpdatePayloadRate(
ModuleRTPUtility::Payload* payload,
- const WebRtc_UWord32 rate) const = 0;
+ const uint32_t rate) const = 0;
virtual ModuleRTPUtility::Payload* CreatePayloadType(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) const = 0;
+ const int8_t payloadType,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) const = 0;
static RTPPayloadStrategy* CreateStrategy(const bool handling_audio);
@@ -51,30 +51,30 @@
class RTPPayloadRegistry {
public:
// The registry takes ownership of the strategy.
- RTPPayloadRegistry(const WebRtc_Word32 id,
+ RTPPayloadRegistry(const int32_t id,
RTPPayloadStrategy* rtp_payload_strategy);
~RTPPayloadRegistry();
- WebRtc_Word32 RegisterReceivePayload(
+ int32_t RegisterReceivePayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
+ const int8_t payload_type,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
bool* created_new_payload_type);
- WebRtc_Word32 DeRegisterReceivePayload(
- const WebRtc_Word8 payload_type);
+ int32_t DeRegisterReceivePayload(
+ const int8_t payload_type);
- WebRtc_Word32 ReceivePayloadType(
+ int32_t ReceivePayloadType(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
- WebRtc_Word8* payload_type) const;
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
+ int8_t* payload_type) const;
- WebRtc_Word32 PayloadTypeToPayload(
- const WebRtc_UWord8 payload_type,
+ int32_t PayloadTypeToPayload(
+ const uint8_t payload_type,
ModuleRTPUtility::Payload*& payload) const;
void ResetLastReceivedPayloadTypes() {
@@ -83,13 +83,13 @@
}
// Returns true if the new media payload type has not changed.
- bool ReportMediaPayloadType(WebRtc_UWord8 media_payload_type);
+ bool ReportMediaPayloadType(uint8_t media_payload_type);
- WebRtc_Word8 red_payload_type() const { return red_payload_type_; }
- WebRtc_Word8 last_received_payload_type() const {
+ int8_t red_payload_type() const { return red_payload_type_; }
+ int8_t last_received_payload_type() const {
return last_received_payload_type_;
}
- void set_last_received_payload_type(WebRtc_Word8 last_received_payload_type) {
+ void set_last_received_payload_type(int8_t last_received_payload_type) {
last_received_payload_type_ = last_received_payload_type;
}
@@ -98,16 +98,16 @@
void DeregisterAudioCodecOrRedTypeRegardlessOfPayloadType(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const size_t payload_name_length,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate);
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate);
ModuleRTPUtility::PayloadTypeMap payload_type_map_;
- WebRtc_Word32 id_;
+ int32_t id_;
scoped_ptr<RTPPayloadStrategy> rtp_payload_strategy_;
- WebRtc_Word8 red_payload_type_;
- WebRtc_Word8 last_received_payload_type_;
- WebRtc_Word8 last_received_media_payload_type_;
+ int8_t red_payload_type_;
+ int8_t last_received_payload_type_;
+ int8_t last_received_media_payload_type_;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtp_receiver.cc
index eb34673..f18529c 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver.cc
@@ -32,7 +32,7 @@
using ModuleRTPUtility::StringCompare;
using ModuleRTPUtility::VideoPayload;
-RTPReceiver::RTPReceiver(const WebRtc_Word32 id,
+RTPReceiver::RTPReceiver(const int32_t id,
Clock* clock,
ModuleRtpRtcpImpl* owner,
RtpAudioFeedback* incoming_audio_messages_callback,
@@ -120,21 +120,21 @@
return media_specific.Video.videoCodecType;
}
-WebRtc_UWord32 RTPReceiver::MaxConfiguredBitrate() const {
+uint32_t RTPReceiver::MaxConfiguredBitrate() const {
ModuleRTPUtility::PayloadUnion media_specific;
rtp_media_receiver_->GetLastMediaSpecificPayload(&media_specific);
return media_specific.Video.maxRate;
}
-bool RTPReceiver::REDPayloadType(const WebRtc_Word8 payload_type) const {
+bool RTPReceiver::REDPayloadType(const int8_t payload_type) const {
return rtp_payload_registry_->red_payload_type() == payload_type;
}
-WebRtc_Word8 RTPReceiver::REDPayloadType() const {
+int8_t RTPReceiver::REDPayloadType() const {
return rtp_payload_registry_->red_payload_type();
}
-WebRtc_Word32 RTPReceiver::SetPacketTimeout(const WebRtc_UWord32 timeout_ms) {
+int32_t RTPReceiver::SetPacketTimeout(const uint32_t timeout_ms) {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
packet_timeout_ms_ = timeout_ms;
return 0;
@@ -158,7 +158,7 @@
return;
}
- WebRtc_Word64 now = clock_->TimeInMilliseconds();
+ int64_t now = clock_->TimeInMilliseconds();
if (now - last_receive_time_ > packet_timeout_ms_) {
packet_time_out = true;
@@ -172,7 +172,7 @@
}
void RTPReceiver::ProcessDeadOrAlive(const bool rtcp_alive,
- const WebRtc_Word64 now) {
+ const int64_t now) {
RTPAliveType alive = kRtpDead;
if (last_receive_time_ + 1000 > now) {
@@ -191,34 +191,34 @@
cb_rtp_feedback_->OnPeriodicDeadOrAlive(id_, alive);
}
-WebRtc_UWord16 RTPReceiver::PacketOHReceived() const {
+uint16_t RTPReceiver::PacketOHReceived() const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return received_packet_oh_;
}
-WebRtc_UWord32 RTPReceiver::PacketCountReceived() const {
+uint32_t RTPReceiver::PacketCountReceived() const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return received_inorder_packet_count_;
}
-WebRtc_UWord32 RTPReceiver::ByteCountReceived() const {
+uint32_t RTPReceiver::ByteCountReceived() const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return received_byte_count_;
}
-WebRtc_Word32 RTPReceiver::RegisterReceivePayload(
+int32_t RTPReceiver::RegisterReceivePayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) {
+ const int8_t payload_type,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
// TODO(phoglund): Try to streamline handling of the RED codec and some other
// cases which makes it necessary to keep track of whether we created a
// payload or not.
bool created_new_payload = false;
- WebRtc_Word32 result = rtp_payload_registry_->RegisterReceivePayload(
+ int32_t result = rtp_payload_registry_->RegisterReceivePayload(
payload_name, payload_type, frequency, channels, rate,
&created_new_payload);
if (created_new_payload) {
@@ -233,31 +233,31 @@
return result;
}
-WebRtc_Word32 RTPReceiver::DeRegisterReceivePayload(
- const WebRtc_Word8 payload_type) {
+int32_t RTPReceiver::DeRegisterReceivePayload(
+ const int8_t payload_type) {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return rtp_payload_registry_->DeRegisterReceivePayload(payload_type);
}
-WebRtc_Word32 RTPReceiver::ReceivePayloadType(
+int32_t RTPReceiver::ReceivePayloadType(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
- WebRtc_Word8* payload_type) const {
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
+ int8_t* payload_type) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return rtp_payload_registry_->ReceivePayloadType(
payload_name, frequency, channels, rate, payload_type);
}
-WebRtc_Word32 RTPReceiver::RegisterRtpHeaderExtension(
+int32_t RTPReceiver::RegisterRtpHeaderExtension(
const RTPExtensionType type,
- const WebRtc_UWord8 id) {
+ const uint8_t id) {
CriticalSectionScoped cs(critical_section_rtp_receiver_);
return rtp_header_extension_map_.Register(type, id);
}
-WebRtc_Word32 RTPReceiver::DeregisterRtpHeaderExtension(
+int32_t RTPReceiver::DeregisterRtpHeaderExtension(
const RTPExtensionType type) {
CriticalSectionScoped cs(critical_section_rtp_receiver_);
return rtp_header_extension_map_.Deregister(type);
@@ -274,8 +274,8 @@
}
// Turn negative acknowledgment requests on/off.
-WebRtc_Word32 RTPReceiver::SetNACKStatus(const NACKMethod method,
- int max_reordering_threshold) {
+int32_t RTPReceiver::SetNACKStatus(const NACKMethod method,
+ int max_reordering_threshold) {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
if (max_reordering_threshold < 0) {
return -1;
@@ -289,54 +289,54 @@
}
void RTPReceiver::SetRTXStatus(const bool enable,
- const WebRtc_UWord32 ssrc) {
+ const uint32_t ssrc) {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
rtx_ = enable;
ssrc_rtx_ = ssrc;
}
-void RTPReceiver::RTXStatus(bool* enable, WebRtc_UWord32* ssrc) const {
+void RTPReceiver::RTXStatus(bool* enable, uint32_t* ssrc) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
*enable = rtx_;
*ssrc = ssrc_rtx_;
}
-WebRtc_UWord32 RTPReceiver::SSRC() const {
+uint32_t RTPReceiver::SSRC() const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return ssrc_;
}
// Get remote CSRC.
-WebRtc_Word32 RTPReceiver::CSRCs(
- WebRtc_UWord32 array_of_csrcs[kRtpCsrcSize]) const {
+int32_t RTPReceiver::CSRCs(
+ uint32_t array_of_csrcs[kRtpCsrcSize]) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
assert(num_csrcs_ <= kRtpCsrcSize);
if (num_csrcs_ > 0) {
memcpy(array_of_csrcs, current_remote_csrc_,
- sizeof(WebRtc_UWord32)*num_csrcs_);
+ sizeof(uint32_t)*num_csrcs_);
}
return num_csrcs_;
}
-WebRtc_Word32 RTPReceiver::Energy(
- WebRtc_UWord8 array_of_energy[kRtpCsrcSize]) const {
+int32_t RTPReceiver::Energy(
+ uint8_t array_of_energy[kRtpCsrcSize]) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
assert(num_energy_ <= kRtpCsrcSize);
if (num_energy_ > 0) {
memcpy(array_of_energy, current_remote_energy_,
- sizeof(WebRtc_UWord8)*num_csrcs_);
+ sizeof(uint8_t)*num_csrcs_);
}
return num_energy_;
}
-WebRtc_Word32 RTPReceiver::IncomingRTPPacket(
+int32_t RTPReceiver::IncomingRTPPacket(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* packet,
- const WebRtc_UWord16 packet_length) {
+ const uint8_t* packet,
+ const uint16_t packet_length) {
// The rtp_header argument contains the parsed RTP header.
int length = packet_length - rtp_header->header.paddingLength;
@@ -378,7 +378,7 @@
cb_rtp_feedback_->OnReceivedPacket(id_, kPacketRtp);
}
}
- WebRtc_Word8 first_payload_byte = 0;
+ int8_t first_payload_byte = 0;
if (length > 0) {
first_payload_byte = packet[rtp_header->header.headerLength];
}
@@ -406,7 +406,7 @@
}
CheckCSRC(rtp_header);
- WebRtc_UWord16 payload_data_length =
+ uint16_t payload_data_length =
ModuleRTPUtility::GetPayloadDataLength(rtp_header, packet_length);
bool is_first_packet_in_frame =
@@ -414,7 +414,7 @@
TimeStamp() != rtp_header->header.timestamp;
bool is_first_packet = is_first_packet_in_frame || HaveNotReceivedPackets();
- WebRtc_Word32 ret_val = rtp_media_receiver_->ParseRtpPacket(
+ int32_t ret_val = rtp_media_receiver_->ParseRtpPacket(
rtp_header, specific_payload, is_red, packet, packet_length,
clock_->TimeInMilliseconds(), is_first_packet);
@@ -452,9 +452,9 @@
// Implementation note: we expect to have the critical_section_rtp_receiver_
// critsect when we call this.
void RTPReceiver::UpdateStatistics(const WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord16 bytes,
+ const uint16_t bytes,
const bool old_packet) {
- WebRtc_UWord32 frequency_hz = rtp_media_receiver_->GetFrequencyHz();
+ uint32_t frequency_hz = rtp_media_receiver_->GetFrequencyHz();
Bitrate::Update(bytes);
@@ -472,12 +472,12 @@
// Count only the new packets received.
if (InOrderPacket(rtp_header->header.sequenceNumber)) {
- const WebRtc_UWord32 RTPtime =
+ const uint32_t RTPtime =
GetCurrentRTP(clock_, frequency_hz); // Time in samples.
received_inorder_packet_count_++;
// Wrong if we use RetransmitOfOldPacket.
- WebRtc_Word32 seq_diff =
+ int32_t seq_diff =
rtp_header->header.sequenceNumber - received_seq_max_;
if (seq_diff < 0) {
// Wrap around detected.
@@ -488,7 +488,7 @@
if (rtp_header->header.timestamp != last_received_timestamp_ &&
received_inorder_packet_count_ > 1) {
- WebRtc_Word32 time_diff_samples =
+ int32_t time_diff_samples =
(RTPtime - local_time_last_received_timestamp_) -
(rtp_header->header.timestamp - last_received_timestamp_);
@@ -499,13 +499,13 @@
// as the treshold.
if (time_diff_samples < 450000) {
// Note we calculate in Q4 to avoid using float.
- WebRtc_Word32 jitter_diff_q4 = (time_diff_samples << 4) - jitter_q4_;
+ int32_t jitter_diff_q4 = (time_diff_samples << 4) - jitter_q4_;
jitter_q4_ += ((jitter_diff_q4 + 8) >> 4);
}
// Extended jitter report, RFC 5450.
// Actual network jitter, excluding the source-introduced jitter.
- WebRtc_Word32 time_diff_samples_ext =
+ int32_t time_diff_samples_ext =
(RTPtime - local_time_last_received_timestamp_) -
((rtp_header->header.timestamp +
rtp_header->extension.transmissionTimeOffset) -
@@ -515,7 +515,7 @@
time_diff_samples_ext = abs(time_diff_samples_ext);
if (time_diff_samples_ext < 450000) {
- WebRtc_Word32 jitter_diffQ4TransmissionTimeOffset =
+ int32_t jitter_diffQ4TransmissionTimeOffset =
(time_diff_samples_ext << 4) - jitter_q4_transmission_time_offset_;
jitter_q4_transmission_time_offset_ +=
((jitter_diffQ4TransmissionTimeOffset + 8) >> 4);
@@ -530,7 +530,7 @@
}
}
- WebRtc_UWord16 packet_oh =
+ uint16_t packet_oh =
rtp_header->header.headerLength + rtp_header->header.paddingLength;
// Our measured overhead. Filter from RFC 5104 4.2.1.2:
@@ -541,23 +541,23 @@
// Implementation note: we expect to have the critical_section_rtp_receiver_
// critsect when we call this.
bool RTPReceiver::RetransmitOfOldPacket(
- const WebRtc_UWord16 sequence_number,
- const WebRtc_UWord32 rtp_time_stamp) const {
+ const uint16_t sequence_number,
+ const uint32_t rtp_time_stamp) const {
if (InOrderPacket(sequence_number)) {
return false;
}
- WebRtc_UWord32 frequency_khz = rtp_media_receiver_->GetFrequencyHz() / 1000;
- WebRtc_Word64 time_diff_ms = clock_->TimeInMilliseconds() -
+ uint32_t frequency_khz = rtp_media_receiver_->GetFrequencyHz() / 1000;
+ int64_t time_diff_ms = clock_->TimeInMilliseconds() -
last_receive_time_;
// Diff in time stamp since last received in order.
- WebRtc_Word32 rtp_time_stamp_diff_ms =
- static_cast<WebRtc_Word32>(rtp_time_stamp - last_received_timestamp_) /
+ int32_t rtp_time_stamp_diff_ms =
+ static_cast<int32_t>(rtp_time_stamp - last_received_timestamp_) /
frequency_khz;
- WebRtc_UWord16 min_rtt = 0;
- WebRtc_Word32 max_delay_ms = 0;
+ uint16_t min_rtt = 0;
+ int32_t max_delay_ms = 0;
rtp_rtcp_.RTT(ssrc_, NULL, NULL, &min_rtt, NULL);
if (min_rtt == 0) {
// Jitter variance in samples.
@@ -568,7 +568,7 @@
// 2 times the standard deviation => 95% confidence.
// And transform to milliseconds by dividing by the frequency in kHz.
- max_delay_ms = static_cast<WebRtc_Word32>((2 * jitter_std) / frequency_khz);
+ max_delay_ms = static_cast<int32_t>((2 * jitter_std) / frequency_khz);
// Min max_delay_ms is 1.
if (max_delay_ms == 0) {
@@ -583,7 +583,7 @@
return false;
}
-bool RTPReceiver::InOrderPacket(const WebRtc_UWord16 sequence_number) const {
+bool RTPReceiver::InOrderPacket(const uint16_t sequence_number) const {
if (received_seq_max_ >= sequence_number) {
// Detect wrap-around.
if (!(received_seq_max_ > 0xff00 && sequence_number < 0x0ff)) {
@@ -608,12 +608,12 @@
return true;
}
-WebRtc_UWord16 RTPReceiver::SequenceNumber() const {
+uint16_t RTPReceiver::SequenceNumber() const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return last_received_sequence_number_;
}
-WebRtc_UWord32 RTPReceiver::TimeStamp() const {
+uint32_t RTPReceiver::TimeStamp() const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
return last_received_timestamp_;
}
@@ -625,10 +625,10 @@
// Compute time stamp of the last incoming packet that is the first packet of
// its frame.
-WebRtc_Word32 RTPReceiver::EstimatedRemoteTimeStamp(
- WebRtc_UWord32& timestamp) const {
+int32_t RTPReceiver::EstimatedRemoteTimeStamp(
+ uint32_t& timestamp) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
- WebRtc_UWord32 frequency_hz = rtp_media_receiver_->GetFrequencyHz();
+ uint32_t frequency_hz = rtp_media_receiver_->GetFrequencyHz();
if (local_time_last_received_timestamp_ == 0) {
WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
@@ -636,7 +636,7 @@
return -1;
}
// Time in samples.
- WebRtc_UWord32 diff = GetCurrentRTP(clock_, frequency_hz) -
+ uint32_t diff = GetCurrentRTP(clock_, frequency_hz) -
local_time_last_received_timestamp_;
timestamp = last_received_timestamp_ + diff;
@@ -644,7 +644,7 @@
}
// Get the currently configured SSRC filter.
-WebRtc_Word32 RTPReceiver::SSRCFilter(WebRtc_UWord32& allowed_ssrc) const {
+int32_t RTPReceiver::SSRCFilter(uint32_t& allowed_ssrc) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
if (use_ssrc_filter_) {
allowed_ssrc = ssrc_filter_;
@@ -656,8 +656,8 @@
}
// Set a SSRC to be used as a filter for incoming RTP streams.
-WebRtc_Word32 RTPReceiver::SetSSRCFilter(
- const bool enable, const WebRtc_UWord32 allowed_ssrc) {
+int32_t RTPReceiver::SetSSRCFilter(
+ const bool enable, const uint32_t allowed_ssrc) {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
use_ssrc_filter_ = enable;
@@ -674,14 +674,14 @@
bool new_ssrc = false;
bool re_initialize_decoder = false;
char payload_name[RTP_PAYLOAD_NAME_SIZE];
- WebRtc_UWord32 frequency = kDefaultVideoFrequency;
- WebRtc_UWord8 channels = 1;
- WebRtc_UWord32 rate = 0;
+ uint32_t frequency = kDefaultVideoFrequency;
+ uint8_t channels = 1;
+ uint32_t rate = 0;
{
CriticalSectionScoped lock(critical_section_rtp_receiver_);
- WebRtc_Word8 last_received_payload_type =
+ int8_t last_received_payload_type =
rtp_payload_registry_->last_received_payload_type();
if (ssrc_ != rtp_header->header.ssrc ||
(last_received_payload_type == -1 && ssrc_ == 0)) {
@@ -746,20 +746,20 @@
// this code path moves we can get rid of some of the rtp_receiver ->
// media_specific interface (such as CheckPayloadChange, possibly get/set
// last known payload).
-WebRtc_Word32 RTPReceiver::CheckPayloadChanged(
+int32_t RTPReceiver::CheckPayloadChanged(
const WebRtcRTPHeader* rtp_header,
- const WebRtc_Word8 first_payload_byte,
+ const int8_t first_payload_byte,
bool& is_red,
ModuleRTPUtility::PayloadUnion* specific_payload) {
bool re_initialize_decoder = false;
char payload_name[RTP_PAYLOAD_NAME_SIZE];
- WebRtc_Word8 payload_type = rtp_header->header.payloadType;
+ int8_t payload_type = rtp_header->header.payloadType;
{
CriticalSectionScoped lock(critical_section_rtp_receiver_);
- WebRtc_Word8 last_received_payload_type =
+ int8_t last_received_payload_type =
rtp_payload_registry_->last_received_payload_type();
if (payload_type != last_received_payload_type) {
if (REDPayloadType(payload_type)) {
@@ -846,9 +846,9 @@
// Implementation note: must not hold critsect when called.
void RTPReceiver::CheckCSRC(const WebRtcRTPHeader* rtp_header) {
- WebRtc_Word32 num_csrcs_diff = 0;
- WebRtc_UWord32 old_remote_csrc[kRtpCsrcSize];
- WebRtc_UWord8 old_num_csrcs = 0;
+ int32_t num_csrcs_diff = 0;
+ uint32_t old_remote_csrc[kRtpCsrcSize];
+ uint8_t old_num_csrcs = 0;
{
CriticalSectionScoped lock(critical_section_rtp_receiver_);
@@ -868,14 +868,14 @@
if (old_num_csrcs > 0) {
// Make a copy of old.
memcpy(old_remote_csrc, current_remote_csrc_,
- num_csrcs_ * sizeof(WebRtc_UWord32));
+ num_csrcs_ * sizeof(uint32_t));
}
- const WebRtc_UWord8 num_csrcs = rtp_header->header.numCSRCs;
+ const uint8_t num_csrcs = rtp_header->header.numCSRCs;
if ((num_csrcs > 0) && (num_csrcs <= kRtpCsrcSize)) {
// Copy new.
memcpy(current_remote_csrc_,
rtp_header->header.arrOfCSRCs,
- num_csrcs * sizeof(WebRtc_UWord32));
+ num_csrcs * sizeof(uint32_t));
}
if (num_csrcs > 0 || old_num_csrcs > 0) {
num_csrcs_diff = num_csrcs - old_num_csrcs;
@@ -888,11 +888,11 @@
bool have_called_callback = false;
// Search for new CSRC in old array.
- for (WebRtc_UWord8 i = 0; i < rtp_header->header.numCSRCs; ++i) {
- const WebRtc_UWord32 csrc = rtp_header->header.arrOfCSRCs[i];
+ for (uint8_t i = 0; i < rtp_header->header.numCSRCs; ++i) {
+ const uint32_t csrc = rtp_header->header.arrOfCSRCs[i];
bool found_match = false;
- for (WebRtc_UWord8 j = 0; j < old_num_csrcs; ++j) {
+ for (uint8_t j = 0; j < old_num_csrcs; ++j) {
if (csrc == old_remote_csrc[j]) { // old list
found_match = true;
break;
@@ -905,11 +905,11 @@
}
}
// Search for old CSRC in new array.
- for (WebRtc_UWord8 i = 0; i < old_num_csrcs; ++i) {
- const WebRtc_UWord32 csrc = old_remote_csrc[i];
+ for (uint8_t i = 0; i < old_num_csrcs; ++i) {
+ const uint32_t csrc = old_remote_csrc[i];
bool found_match = false;
- for (WebRtc_UWord8 j = 0; j < rtp_header->header.numCSRCs; ++j) {
+ for (uint8_t j = 0; j < rtp_header->header.numCSRCs; ++j) {
if (csrc == rtp_header->header.arrOfCSRCs[j]) {
found_match = true;
break;
@@ -933,7 +933,7 @@
}
}
-WebRtc_Word32 RTPReceiver::ResetStatistics() {
+int32_t RTPReceiver::ResetStatistics() {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
last_report_inorder_packets_ = 0;
@@ -957,7 +957,7 @@
return 0;
}
-WebRtc_Word32 RTPReceiver::ResetDataCounters() {
+int32_t RTPReceiver::ResetDataCounters() {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
received_byte_count_ = 0;
@@ -968,15 +968,15 @@
return 0;
}
-WebRtc_Word32 RTPReceiver::Statistics(
- WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter,
- WebRtc_UWord32* max_jitter,
- WebRtc_UWord32* jitter_transmission_time_offset,
+int32_t RTPReceiver::Statistics(
+ uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter,
+ uint32_t* max_jitter,
+ uint32_t* jitter_transmission_time_offset,
bool reset) const {
- WebRtc_Word32 missing;
+ int32_t missing;
return Statistics(fraction_lost,
cum_lost,
ext_max,
@@ -987,14 +987,14 @@
reset);
}
-WebRtc_Word32 RTPReceiver::Statistics(
- WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter,
- WebRtc_UWord32* max_jitter,
- WebRtc_UWord32* jitter_transmission_time_offset,
- WebRtc_Word32* missing,
+int32_t RTPReceiver::Statistics(
+ uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter,
+ uint32_t* max_jitter,
+ uint32_t* jitter_transmission_time_offset,
+ int32_t* missing,
bool reset) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
@@ -1039,7 +1039,7 @@
last_report_seq_max_ = received_seq_first_ - 1;
}
// Calculate fraction lost.
- WebRtc_UWord16 exp_since_last = (received_seq_max_ - last_report_seq_max_);
+ uint16_t exp_since_last = (received_seq_max_ - last_report_seq_max_);
if (last_report_seq_max_ > received_seq_max_) {
// Can we assume that the seq_num can't go decrease over a full RTCP period?
@@ -1048,12 +1048,12 @@
// Number of received RTP packets since last report, counts all packets but
// not re-transmissions.
- WebRtc_UWord32 rec_since_last =
+ uint32_t rec_since_last =
received_inorder_packet_count_ - last_report_inorder_packets_;
if (nack_method_ == kNackOff) {
// This is needed for re-ordered packets.
- WebRtc_UWord32 old_packets =
+ uint32_t old_packets =
received_old_packet_count_ - last_report_old_packets_;
rec_since_last += old_packets;
} else {
@@ -1072,10 +1072,10 @@
if (exp_since_last > rec_since_last) {
*missing = (exp_since_last - rec_since_last);
}
- WebRtc_UWord8 local_fraction_lost = 0;
+ uint8_t local_fraction_lost = 0;
if (exp_since_last) {
// Scale 0 to 255, where 255 is 100% loss.
- local_fraction_lost = (WebRtc_UWord8)((255 * (*missing)) / exp_since_last);
+ local_fraction_lost = (uint8_t)((255 * (*missing)) / exp_since_last);
}
if (fraction_lost) {
*fraction_lost = local_fraction_lost;
@@ -1122,9 +1122,9 @@
return 0;
}
-WebRtc_Word32 RTPReceiver::DataCounters(
- WebRtc_UWord32* bytes_received,
- WebRtc_UWord32* packets_received) const {
+int32_t RTPReceiver::DataCounters(
+ uint32_t* bytes_received,
+ uint32_t* packets_received) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_);
if (bytes_received) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver.h
index d859297..8d794ce 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver.h
@@ -37,7 +37,7 @@
// Callbacks passed in here may not be NULL (use Null Object callbacks if you
// want callbacks to do nothing). This class takes ownership of the media
// receiver but nothing else.
- RTPReceiver(const WebRtc_Word32 id,
+ RTPReceiver(const int32_t id,
Clock* clock,
ModuleRtpRtcpImpl* owner,
RtpAudioFeedback* incoming_audio_messages_callback,
@@ -49,193 +49,191 @@
virtual ~RTPReceiver();
RtpVideoCodecTypes VideoCodecType() const;
- WebRtc_UWord32 MaxConfiguredBitrate() const;
+ uint32_t MaxConfiguredBitrate() const;
- WebRtc_Word32 SetPacketTimeout(const WebRtc_UWord32 timeout_ms);
+ int32_t SetPacketTimeout(const uint32_t timeout_ms);
void PacketTimeout();
- void ProcessDeadOrAlive(const bool RTCPalive, const WebRtc_Word64 now);
+ void ProcessDeadOrAlive(const bool RTCPalive, const int64_t now);
void ProcessBitrate();
- WebRtc_Word32 RegisterReceivePayload(
+ int32_t RegisterReceivePayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate);
+ const int8_t payload_type,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate);
- WebRtc_Word32 DeRegisterReceivePayload(const WebRtc_Word8 payload_type);
+ int32_t DeRegisterReceivePayload(const int8_t payload_type);
- WebRtc_Word32 ReceivePayloadType(
+ int32_t ReceivePayloadType(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
- WebRtc_Word8* payload_type) const;
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
+ int8_t* payload_type) const;
- WebRtc_Word32 IncomingRTPPacket(
+ int32_t IncomingRTPPacket(
WebRtcRTPHeader* rtpheader,
- const WebRtc_UWord8* incoming_rtp_packet,
- const WebRtc_UWord16 incoming_rtp_packet_length);
+ const uint8_t* incoming_rtp_packet,
+ const uint16_t incoming_rtp_packet_length);
NACKMethod NACK() const ;
// Turn negative acknowledgement requests on/off.
- WebRtc_Word32 SetNACKStatus(const NACKMethod method,
- int max_reordering_threshold);
+ int32_t SetNACKStatus(const NACKMethod method, int max_reordering_threshold);
// Returns the last received timestamp.
- virtual WebRtc_UWord32 TimeStamp() const;
+ virtual uint32_t TimeStamp() const;
int32_t LastReceivedTimeMs() const;
- virtual WebRtc_UWord16 SequenceNumber() const;
+ virtual uint16_t SequenceNumber() const;
- WebRtc_Word32 EstimatedRemoteTimeStamp(WebRtc_UWord32& timestamp) const;
+ int32_t EstimatedRemoteTimeStamp(uint32_t& timestamp) const;
- WebRtc_UWord32 SSRC() const;
+ uint32_t SSRC() const;
- WebRtc_Word32 CSRCs(WebRtc_UWord32 array_of_csrc[kRtpCsrcSize]) const;
+ int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const;
- WebRtc_Word32 Energy(WebRtc_UWord8 array_of_energy[kRtpCsrcSize]) const;
+ int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const;
// Get the currently configured SSRC filter.
- WebRtc_Word32 SSRCFilter(WebRtc_UWord32& allowed_ssrc) const;
+ int32_t SSRCFilter(uint32_t& allowed_ssrc) const;
// Set a SSRC to be used as a filter for incoming RTP streams.
- WebRtc_Word32 SetSSRCFilter(const bool enable,
- const WebRtc_UWord32 allowed_ssrc);
+ int32_t SetSSRCFilter(const bool enable, const uint32_t allowed_ssrc);
- WebRtc_Word32 Statistics(WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter, // Will be moved from JB.
- WebRtc_UWord32* max_jitter,
- WebRtc_UWord32* jitter_transmission_time_offset,
- bool reset) const;
+ int32_t Statistics(uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter, // Will be moved from JB.
+ uint32_t* max_jitter,
+ uint32_t* jitter_transmission_time_offset,
+ bool reset) const;
- WebRtc_Word32 Statistics(WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter, // Will be moved from JB.
- WebRtc_UWord32* max_jitter,
- WebRtc_UWord32* jitter_transmission_time_offset,
- WebRtc_Word32* missing,
- bool reset) const;
+ int32_t Statistics(uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter, // Will be moved from JB.
+ uint32_t* max_jitter,
+ uint32_t* jitter_transmission_time_offset,
+ int32_t* missing,
+ bool reset) const;
- WebRtc_Word32 DataCounters(WebRtc_UWord32* bytes_received,
- WebRtc_UWord32* packets_received) const;
+ int32_t DataCounters(uint32_t* bytes_received,
+ uint32_t* packets_received) const;
- WebRtc_Word32 ResetStatistics();
+ int32_t ResetStatistics();
- WebRtc_Word32 ResetDataCounters();
+ int32_t ResetDataCounters();
- WebRtc_UWord16 PacketOHReceived() const;
+ uint16_t PacketOHReceived() const;
- WebRtc_UWord32 PacketCountReceived() const;
+ uint32_t PacketCountReceived() const;
- WebRtc_UWord32 ByteCountReceived() const;
+ uint32_t ByteCountReceived() const;
- WebRtc_Word32 RegisterRtpHeaderExtension(const RTPExtensionType type,
- const WebRtc_UWord8 id);
+ int32_t RegisterRtpHeaderExtension(const RTPExtensionType type,
+ const uint8_t id);
- WebRtc_Word32 DeregisterRtpHeaderExtension(const RTPExtensionType type);
+ int32_t DeregisterRtpHeaderExtension(const RTPExtensionType type);
void GetHeaderExtensionMapCopy(RtpHeaderExtensionMap* map) const;
// RTX.
- void SetRTXStatus(const bool enable, const WebRtc_UWord32 ssrc);
+ void SetRTXStatus(const bool enable, const uint32_t ssrc);
- void RTXStatus(bool* enable, WebRtc_UWord32* ssrc) const;
+ void RTXStatus(bool* enable, uint32_t* ssrc) const;
- virtual WebRtc_Word8 REDPayloadType() const;
+ virtual int8_t REDPayloadType() const;
bool HaveNotReceivedPackets() const;
- virtual bool RetransmitOfOldPacket(const WebRtc_UWord16 sequence_number,
- const WebRtc_UWord32 rtp_time_stamp) const;
+ virtual bool RetransmitOfOldPacket(const uint16_t sequence_number,
+ const uint32_t rtp_time_stamp) const;
void UpdateStatistics(const WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord16 bytes,
+ const uint16_t bytes,
const bool old_packet);
private:
// Returns whether RED is configured with payload_type.
- bool REDPayloadType(const WebRtc_Word8 payload_type) const;
+ bool REDPayloadType(const int8_t payload_type) const;
- bool InOrderPacket(const WebRtc_UWord16 sequence_number) const;
+ bool InOrderPacket(const uint16_t sequence_number) const;
void CheckSSRCChanged(const WebRtcRTPHeader* rtp_header);
void CheckCSRC(const WebRtcRTPHeader* rtp_header);
- WebRtc_Word32 CheckPayloadChanged(const WebRtcRTPHeader* rtp_header,
- const WebRtc_Word8 first_payload_byte,
- bool& isRED,
- ModuleRTPUtility::PayloadUnion* payload);
+ int32_t CheckPayloadChanged(const WebRtcRTPHeader* rtp_header,
+ const int8_t first_payload_byte,
+ bool& isRED,
+ ModuleRTPUtility::PayloadUnion* payload);
- void UpdateNACKBitRate(WebRtc_Word32 bytes, WebRtc_UWord32 now);
- bool ProcessNACKBitRate(WebRtc_UWord32 now);
+ void UpdateNACKBitRate(int32_t bytes, uint32_t now);
+ bool ProcessNACKBitRate(uint32_t now);
RTPPayloadRegistry* rtp_payload_registry_;
scoped_ptr<RTPReceiverStrategy> rtp_media_receiver_;
- WebRtc_Word32 id_;
+ int32_t id_;
ModuleRtpRtcpImpl& rtp_rtcp_;
RtpFeedback* cb_rtp_feedback_;
CriticalSectionWrapper* critical_section_rtp_receiver_;
- mutable WebRtc_Word64 last_receive_time_;
- WebRtc_UWord16 last_received_payload_length_;
+ mutable int64_t last_receive_time_;
+ uint16_t last_received_payload_length_;
- WebRtc_UWord32 packet_timeout_ms_;
+ uint32_t packet_timeout_ms_;
RtpHeaderExtensionMap rtp_header_extension_map_;
// SSRCs.
- WebRtc_UWord32 ssrc_;
- WebRtc_UWord8 num_csrcs_;
- WebRtc_UWord32 current_remote_csrc_[kRtpCsrcSize];
- WebRtc_UWord8 num_energy_;
- WebRtc_UWord8 current_remote_energy_[kRtpCsrcSize];
+ uint32_t ssrc_;
+ uint8_t num_csrcs_;
+ uint32_t current_remote_csrc_[kRtpCsrcSize];
+ uint8_t num_energy_;
+ uint8_t current_remote_energy_[kRtpCsrcSize];
bool use_ssrc_filter_;
- WebRtc_UWord32 ssrc_filter_;
+ uint32_t ssrc_filter_;
// Stats on received RTP packets.
- WebRtc_UWord32 jitter_q4_;
- mutable WebRtc_UWord32 jitter_max_q4_;
- mutable WebRtc_UWord32 cumulative_loss_;
- WebRtc_UWord32 jitter_q4_transmission_time_offset_;
+ uint32_t jitter_q4_;
+ mutable uint32_t jitter_max_q4_;
+ mutable uint32_t cumulative_loss_;
+ uint32_t jitter_q4_transmission_time_offset_;
- WebRtc_UWord32 local_time_last_received_timestamp_;
+ uint32_t local_time_last_received_timestamp_;
int64_t last_received_frame_time_ms_;
- WebRtc_UWord32 last_received_timestamp_;
- WebRtc_UWord16 last_received_sequence_number_;
- WebRtc_Word32 last_received_transmission_time_offset_;
- WebRtc_UWord16 received_seq_first_;
- WebRtc_UWord16 received_seq_max_;
- WebRtc_UWord16 received_seq_wraps_;
+ uint32_t last_received_timestamp_;
+ uint16_t last_received_sequence_number_;
+ int32_t last_received_transmission_time_offset_;
+ uint16_t received_seq_first_;
+ uint16_t received_seq_max_;
+ uint16_t received_seq_wraps_;
// Current counter values.
- WebRtc_UWord16 received_packet_oh_;
- WebRtc_UWord32 received_byte_count_;
- WebRtc_UWord32 received_old_packet_count_;
- WebRtc_UWord32 received_inorder_packet_count_;
+ uint16_t received_packet_oh_;
+ uint32_t received_byte_count_;
+ uint32_t received_old_packet_count_;
+ uint32_t received_inorder_packet_count_;
// Counter values when we sent the last report.
- mutable WebRtc_UWord32 last_report_inorder_packets_;
- mutable WebRtc_UWord32 last_report_old_packets_;
- mutable WebRtc_UWord16 last_report_seq_max_;
- mutable WebRtc_UWord8 last_report_fraction_lost_;
- mutable WebRtc_UWord32 last_report_cumulative_lost_; // 24 bits valid.
- mutable WebRtc_UWord32 last_report_extended_high_seq_num_;
- mutable WebRtc_UWord32 last_report_jitter_;
- mutable WebRtc_UWord32 last_report_jitter_transmission_time_offset_;
+ mutable uint32_t last_report_inorder_packets_;
+ mutable uint32_t last_report_old_packets_;
+ mutable uint16_t last_report_seq_max_;
+ mutable uint8_t last_report_fraction_lost_;
+ mutable uint32_t last_report_cumulative_lost_; // 24 bits valid.
+ mutable uint32_t last_report_extended_high_seq_num_;
+ mutable uint32_t last_report_jitter_;
+ mutable uint32_t last_report_jitter_transmission_time_offset_;
NACKMethod nack_method_;
int max_reordering_threshold_;
bool rtx_;
- WebRtc_UWord32 ssrc_rtx_;
+ uint32_t ssrc_rtx_;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc
index 55894eb..ea921cc 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc
@@ -20,7 +20,7 @@
#include "webrtc/system_wrappers/interface/trace_event.h"
namespace webrtc {
-RTPReceiverAudio::RTPReceiverAudio(const WebRtc_Word32 id,
+RTPReceiverAudio::RTPReceiverAudio(const int32_t id,
RtpData* data_callback,
RtpAudioFeedback* incoming_messages_callback)
: RTPReceiverStrategy(data_callback),
@@ -41,7 +41,7 @@
last_payload_.Audio.channels = 1;
}
-WebRtc_UWord32 RTPReceiverAudio::AudioFrequency() const {
+uint32_t RTPReceiverAudio::AudioFrequency() const {
CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
if (last_received_g722_) {
return 8000;
@@ -64,13 +64,13 @@
}
bool RTPReceiverAudio::TelephoneEventPayloadType(
- const WebRtc_Word8 payload_type) const {
+ const int8_t payload_type) const {
CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
return (telephone_event_payload_type_ == payload_type) ? true : false;
}
-bool RTPReceiverAudio::CNGPayloadType(const WebRtc_Word8 payload_type,
- WebRtc_UWord32* frequency,
+bool RTPReceiverAudio::CNGPayloadType(const int8_t payload_type,
+ uint32_t* frequency,
bool* cng_payload_type_has_changed) {
CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
*cng_payload_type_has_changed = false;
@@ -119,7 +119,7 @@
}
bool RTPReceiverAudio::ShouldReportCsrcChanges(
- WebRtc_UWord8 payload_type) const {
+ uint8_t payload_type) const {
// Don't do this for DTMF packets, otherwise it's fine.
return !TelephoneEventPayloadType(payload_type);
}
@@ -156,10 +156,10 @@
// - MPA frame N/A var. var.
// -
// - G7221 frame N/A
-WebRtc_Word32 RTPReceiverAudio::OnNewPayloadTypeCreated(
+int32_t RTPReceiverAudio::OnNewPayloadTypeCreated(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency) {
+ const int8_t payload_type,
+ const uint32_t frequency) {
CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
if (ModuleRTPUtility::StringCompare(payload_name, "telephone-event", 15)) {
@@ -183,21 +183,21 @@
return 0;
}
-WebRtc_Word32 RTPReceiverAudio::ParseRtpPacket(
+int32_t RTPReceiverAudio::ParseRtpPacket(
WebRtcRTPHeader* rtp_header,
const ModuleRTPUtility::PayloadUnion& specific_payload,
const bool is_red,
- const WebRtc_UWord8* packet,
- const WebRtc_UWord16 packet_length,
- const WebRtc_Word64 timestamp_ms,
+ const uint8_t* packet,
+ const uint16_t packet_length,
+ const int64_t timestamp_ms,
const bool is_first_packet) {
TRACE_EVENT_INSTANT2("webrtc_rtp", "RTPReceiverAudio::ParseRtpPacket",
"seqnum", rtp_header->header.sequenceNumber,
"timestamp", rtp_header->header.timestamp);
- const WebRtc_UWord8* payload_data =
+ const uint8_t* payload_data =
ModuleRTPUtility::GetPayloadData(rtp_header, packet);
- const WebRtc_UWord16 payload_data_length =
+ const uint16_t payload_data_length =
ModuleRTPUtility::GetPayloadDataLength(rtp_header, packet_length);
return ParseAudioCodecSpecific(rtp_header,
@@ -207,12 +207,12 @@
is_red);
}
-WebRtc_Word32 RTPReceiverAudio::GetFrequencyHz() const {
+int32_t RTPReceiverAudio::GetFrequencyHz() const {
return AudioFrequency();
}
RTPAliveType RTPReceiverAudio::ProcessDeadOrAlive(
- WebRtc_UWord16 last_payload_length) const {
+ uint16_t last_payload_length) const {
// Our CNG is 9 bytes; if it's a likely CNG the receiver needs to check
// kRtpNoRtp against NetEq speech_type kOutputPLCtoCNG.
@@ -224,7 +224,7 @@
}
void RTPReceiverAudio::CheckPayloadChanged(
- const WebRtc_Word8 payload_type,
+ const int8_t payload_type,
ModuleRTPUtility::PayloadUnion* specific_payload,
bool* should_reset_statistics,
bool* should_discard_changes) {
@@ -251,10 +251,10 @@
}
}
-WebRtc_Word32 RTPReceiverAudio::InvokeOnInitializeDecoder(
+int32_t RTPReceiverAudio::InvokeOnInitializeDecoder(
RtpFeedback* callback,
- const WebRtc_Word32 id,
- const WebRtc_Word8 payload_type,
+ const int32_t id,
+ const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const ModuleRTPUtility::PayloadUnion& specific_payload) const {
if (-1 == callback->OnInitializeDecoder(id,
@@ -274,10 +274,10 @@
}
// We are not allowed to have any critsects when calling data_callback.
-WebRtc_Word32 RTPReceiverAudio::ParseAudioCodecSpecific(
+int32_t RTPReceiverAudio::ParseAudioCodecSpecific(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_length,
+ const uint8_t* payload_data,
+ const uint16_t payload_length,
const ModuleRTPUtility::AudioPayload& audio_specific,
const bool is_red) {
@@ -300,7 +300,7 @@
if (payload_length % 4 != 0) {
return -1;
}
- WebRtc_UWord8 number_of_events = payload_length / 4;
+ uint8_t number_of_events = payload_length / 4;
// sanity
if (number_of_events >= MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS) {
@@ -309,7 +309,7 @@
for (int n = 0; n < number_of_events; ++n) {
bool end = (payload_data[(4 * n) + 1] & 0x80) ? true : false;
- std::set<WebRtc_UWord8>::iterator event =
+ std::set<uint8_t>::iterator event =
telephone_event_reported_.find(payload_data[4 * n]);
if (event != telephone_event_reported_.end()) {
@@ -340,7 +340,7 @@
}
// Check if this is a CNG packet, receiver might want to know
- WebRtc_UWord32 ignored;
+ uint32_t ignored;
bool also_ignored;
if (CNGPayloadType(rtp_header->header.payloadType,
&ignored,
@@ -358,7 +358,7 @@
// don't forward event to decoder
return 0;
}
- std::set<WebRtc_UWord8>::iterator first =
+ std::set<uint8_t>::iterator first =
telephone_event_reported_.begin();
if (first != telephone_event_reported_.end() && *first > 15) {
// don't forward non DTMF events
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
index 96df5f1..67b30c0 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
@@ -27,11 +27,11 @@
// Handles audio RTP packets. This class is thread-safe.
class RTPReceiverAudio : public RTPReceiverStrategy {
public:
- RTPReceiverAudio(const WebRtc_Word32 id,
+ RTPReceiverAudio(const int32_t id,
RtpData* data_callback,
RtpAudioFeedback* incoming_messages_callback);
- WebRtc_UWord32 AudioFrequency() const;
+ uint32_t AudioFrequency() const;
// Forward DTMFs to decoder for playout.
int SetTelephoneEventForwardToDecoder(bool forward_to_decoder);
@@ -40,38 +40,38 @@
bool TelephoneEventForwardToDecoder() const;
// Is TelephoneEvent configured with payload type payload_type
- bool TelephoneEventPayloadType(const WebRtc_Word8 payload_type) const;
+ bool TelephoneEventPayloadType(const int8_t payload_type) const;
// Returns true if CNG is configured with payload type payload_type. If so,
// the frequency and cng_payload_type_has_changed are filled in.
- bool CNGPayloadType(const WebRtc_Word8 payload_type,
- WebRtc_UWord32* frequency,
+ bool CNGPayloadType(const int8_t payload_type,
+ uint32_t* frequency,
bool* cng_payload_type_has_changed);
- WebRtc_Word32 ParseRtpPacket(
+ int32_t ParseRtpPacket(
WebRtcRTPHeader* rtp_header,
const ModuleRTPUtility::PayloadUnion& specific_payload,
const bool is_red,
- const WebRtc_UWord8* packet,
- const WebRtc_UWord16 packet_length,
- const WebRtc_Word64 timestamp_ms,
+ const uint8_t* packet,
+ const uint16_t packet_length,
+ const int64_t timestamp_ms,
const bool is_first_packet);
- WebRtc_Word32 GetFrequencyHz() const;
+ int32_t GetFrequencyHz() const;
- RTPAliveType ProcessDeadOrAlive(WebRtc_UWord16 last_payload_length) const;
+ RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const;
- bool ShouldReportCsrcChanges(WebRtc_UWord8 payload_type) const;
+ bool ShouldReportCsrcChanges(uint8_t payload_type) const;
- WebRtc_Word32 OnNewPayloadTypeCreated(
+ int32_t OnNewPayloadTypeCreated(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency);
+ const int8_t payload_type,
+ const uint32_t frequency);
- WebRtc_Word32 InvokeOnInitializeDecoder(
+ int32_t InvokeOnInitializeDecoder(
RtpFeedback* callback,
- const WebRtc_Word32 id,
- const WebRtc_Word8 payload_type,
+ const int32_t id,
+ const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const ModuleRTPUtility::PayloadUnion& specific_payload) const;
@@ -81,44 +81,44 @@
ModuleRTPUtility::PayloadTypeMap* payload_type_map,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const size_t payload_name_length,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) const;
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) const;
// We need to look out for special payload types here and sometimes reset
// statistics. In addition we sometimes need to tweak the frequency.
- void CheckPayloadChanged(const WebRtc_Word8 payload_type,
+ void CheckPayloadChanged(const int8_t payload_type,
ModuleRTPUtility::PayloadUnion* specific_payload,
bool* should_reset_statistics,
bool* should_discard_changes);
private:
- WebRtc_Word32 ParseAudioCodecSpecific(
+ int32_t ParseAudioCodecSpecific(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_length,
+ const uint8_t* payload_data,
+ const uint16_t payload_length,
const ModuleRTPUtility::AudioPayload& audio_specific,
const bool is_red);
- WebRtc_Word32 id_;
+ int32_t id_;
scoped_ptr<CriticalSectionWrapper> critical_section_rtp_receiver_audio_;
- WebRtc_UWord32 last_received_frequency_;
+ uint32_t last_received_frequency_;
bool telephone_event_forward_to_decoder_;
- WebRtc_Word8 telephone_event_payload_type_;
- std::set<WebRtc_UWord8> telephone_event_reported_;
+ int8_t telephone_event_payload_type_;
+ std::set<uint8_t> telephone_event_reported_;
- WebRtc_Word8 cng_nb_payload_type_;
- WebRtc_Word8 cng_wb_payload_type_;
- WebRtc_Word8 cng_swb_payload_type_;
- WebRtc_Word8 cng_fb_payload_type_;
- WebRtc_Word8 cng_payload_type_;
+ int8_t cng_nb_payload_type_;
+ int8_t cng_wb_payload_type_;
+ int8_t cng_swb_payload_type_;
+ int8_t cng_fb_payload_type_;
+ int8_t cng_payload_type_;
// G722 is special since it use the wrong number of RTP samples in timestamp
// VS. number of samples in the frame
- WebRtc_Word8 g722_payload_type_;
+ int8_t g722_payload_type_;
bool last_received_g722_;
RtpAudioFeedback* cb_audio_feedback_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h
index 19b6488..8e8fa1d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h
@@ -39,45 +39,45 @@
// make changes in the data as necessary. The specific_payload argument
// provides audio or video-specific data. The is_first_packet argument is true
// if this packet is either the first packet ever or the first in its frame.
- virtual WebRtc_Word32 ParseRtpPacket(
+ virtual int32_t ParseRtpPacket(
WebRtcRTPHeader* rtp_header,
const ModuleRTPUtility::PayloadUnion& specific_payload,
const bool is_red,
- const WebRtc_UWord8* packet,
- const WebRtc_UWord16 packet_length,
- const WebRtc_Word64 timestamp_ms,
+ const uint8_t* packet,
+ const uint16_t packet_length,
+ const int64_t timestamp_ms,
const bool is_first_packet) = 0;
// Retrieves the last known applicable frequency.
- virtual WebRtc_Word32 GetFrequencyHz() const = 0;
+ virtual int32_t GetFrequencyHz() const = 0;
// Computes the current dead-or-alive state.
virtual RTPAliveType ProcessDeadOrAlive(
- WebRtc_UWord16 last_payload_length) const = 0;
+ uint16_t last_payload_length) const = 0;
// Returns true if we should report CSRC changes for this payload type.
// TODO(phoglund): should move out of here along with other payload stuff.
- virtual bool ShouldReportCsrcChanges(WebRtc_UWord8 payload_type) const = 0;
+ virtual bool ShouldReportCsrcChanges(uint8_t payload_type) const = 0;
// Notifies the strategy that we have created a new non-RED payload type in
// the payload registry.
- virtual WebRtc_Word32 OnNewPayloadTypeCreated(
+ virtual int32_t OnNewPayloadTypeCreated(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 frequency) = 0;
+ const int8_t payloadType,
+ const uint32_t frequency) = 0;
// Invokes the OnInitializeDecoder callback in a media-specific way.
- virtual WebRtc_Word32 InvokeOnInitializeDecoder(
+ virtual int32_t InvokeOnInitializeDecoder(
RtpFeedback* callback,
- const WebRtc_Word32 id,
- const WebRtc_Word8 payload_type,
+ const int32_t id,
+ const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const ModuleRTPUtility::PayloadUnion& specific_payload) const = 0;
// Checks if the payload type has changed, and returns whether we should
// reset statistics and/or discard this packet.
virtual void CheckPayloadChanged(
- const WebRtc_Word8 payload_type,
+ const int8_t payload_type,
ModuleRTPUtility::PayloadUnion* specific_payload,
bool* should_reset_statistics,
bool* should_discard_changes) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc
index 09180d8..ca6e05b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc
@@ -25,12 +25,12 @@
#include "webrtc/system_wrappers/interface/trace_event.h"
namespace webrtc {
-WebRtc_UWord32 BitRateBPS(WebRtc_UWord16 x) {
- return (x & 0x3fff) * WebRtc_UWord32(pow(10.0f, (2 + (x >> 14))));
+uint32_t BitRateBPS(uint16_t x) {
+ return (x & 0x3fff) * uint32_t(pow(10.0f, (2 + (x >> 14))));
}
RTPReceiverVideo::RTPReceiverVideo(
- const WebRtc_Word32 id,
+ const int32_t id,
const RTPPayloadRegistry* rtp_rtp_payload_registry,
RtpData* data_callback)
: RTPReceiverStrategy(data_callback),
@@ -48,15 +48,15 @@
}
bool RTPReceiverVideo::ShouldReportCsrcChanges(
- WebRtc_UWord8 payload_type) const {
+ uint8_t payload_type) const {
// Always do this for video packets.
return true;
}
-WebRtc_Word32 RTPReceiverVideo::OnNewPayloadTypeCreated(
+int32_t RTPReceiverVideo::OnNewPayloadTypeCreated(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency) {
+ const int8_t payload_type,
+ const uint32_t frequency) {
if (ModuleRTPUtility::StringCompare(payload_name, "ULPFEC", 6)) {
// Enable FEC if not enabled.
if (receive_fec_ == NULL) {
@@ -67,20 +67,20 @@
return 0;
}
-WebRtc_Word32 RTPReceiverVideo::ParseRtpPacket(
+int32_t RTPReceiverVideo::ParseRtpPacket(
WebRtcRTPHeader* rtp_header,
const ModuleRTPUtility::PayloadUnion& specific_payload,
const bool is_red,
- const WebRtc_UWord8* packet,
- const WebRtc_UWord16 packet_length,
- const WebRtc_Word64 timestamp_ms,
+ const uint8_t* packet,
+ const uint16_t packet_length,
+ const int64_t timestamp_ms,
const bool is_first_packet) {
TRACE_EVENT_INSTANT2("webrtc_rtp", "RTPReceiverVideo::ParseRtpPacket",
"seqnum", rtp_header->header.sequenceNumber,
"timestamp", rtp_header->header.timestamp);
- const WebRtc_UWord8* payload_data =
+ const uint8_t* payload_data =
ModuleRTPUtility::GetPayloadData(rtp_header, packet);
- const WebRtc_UWord16 payload_data_length =
+ const uint16_t payload_data_length =
ModuleRTPUtility::GetPayloadDataLength(rtp_header, packet_length);
return ParseVideoCodecSpecific(rtp_header,
payload_data,
@@ -93,19 +93,19 @@
is_first_packet);
}
-WebRtc_Word32 RTPReceiverVideo::GetFrequencyHz() const {
+int32_t RTPReceiverVideo::GetFrequencyHz() const {
return kDefaultVideoFrequency;
}
RTPAliveType RTPReceiverVideo::ProcessDeadOrAlive(
- WebRtc_UWord16 last_payload_length) const {
+ uint16_t last_payload_length) const {
return kRtpDead;
}
-WebRtc_Word32 RTPReceiverVideo::InvokeOnInitializeDecoder(
+int32_t RTPReceiverVideo::InvokeOnInitializeDecoder(
RtpFeedback* callback,
- const WebRtc_Word32 id,
- const WebRtc_Word8 payload_type,
+ const int32_t id,
+ const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const ModuleRTPUtility::PayloadUnion& specific_payload) const {
// For video we just go with default values.
@@ -124,17 +124,17 @@
// we have no critext when calling this
// we are not allowed to have any critsects when calling
// CallbackOfReceivedPayloadData
-WebRtc_Word32 RTPReceiverVideo::ParseVideoCodecSpecific(
+int32_t RTPReceiverVideo::ParseVideoCodecSpecific(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length,
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length,
const RtpVideoCodecTypes video_type,
const bool is_red,
- const WebRtc_UWord8* incoming_rtp_packet,
- const WebRtc_UWord16 incoming_rtp_packet_size,
- const WebRtc_Word64 now_ms,
+ const uint8_t* incoming_rtp_packet,
+ const uint16_t incoming_rtp_packet_size,
+ const int64_t now_ms,
const bool is_first_packet) {
- WebRtc_Word32 ret_val = 0;
+ int32_t ret_val = 0;
critical_section_receiver_video_->Enter();
@@ -158,7 +158,7 @@
// empty payload and data length.
rtp_header->frameType = kFrameEmpty;
// We need this for the routing.
- WebRtc_Word32 ret_val = SetCodecType(video_type, rtp_header);
+ int32_t ret_val = SetCodecType(video_type, rtp_header);
if (ret_val != 0) {
return ret_val;
}
@@ -178,11 +178,11 @@
return ret_val;
}
-WebRtc_Word32 RTPReceiverVideo::BuildRTPheader(
+int32_t RTPReceiverVideo::BuildRTPheader(
const WebRtcRTPHeader* rtp_header,
- WebRtc_UWord8* data_buffer) const {
- data_buffer[0] = static_cast<WebRtc_UWord8>(0x80); // version 2
- data_buffer[1] = static_cast<WebRtc_UWord8>(rtp_header->header.payloadType);
+ uint8_t* data_buffer) const {
+ data_buffer[0] = static_cast<uint8_t>(0x80); // version 2
+ data_buffer[1] = static_cast<uint8_t>(rtp_header->header.payloadType);
if (rtp_header->header.markerBit) {
data_buffer[1] |= kRtpMarkerBitMask; // MarkerBit is 1
}
@@ -193,7 +193,7 @@
ModuleRTPUtility::AssignUWord32ToBuffer(data_buffer + 8,
rtp_header->header.ssrc);
- WebRtc_Word32 rtp_header_length = 12;
+ int32_t rtp_header_length = 12;
// Add the CSRCs if any
if (rtp_header->header.numCSRCs > 0) {
@@ -201,23 +201,23 @@
// error
assert(false);
}
- WebRtc_UWord8* ptr = &data_buffer[rtp_header_length];
- for (WebRtc_UWord32 i = 0; i < rtp_header->header.numCSRCs; ++i) {
+ 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]);
ptr += 4;
}
data_buffer[0] = (data_buffer[0] & 0xf0) | rtp_header->header.numCSRCs;
// Update length of header
- rtp_header_length += sizeof(WebRtc_UWord32) * rtp_header->header.numCSRCs;
+ rtp_header_length += sizeof(uint32_t) * rtp_header->header.numCSRCs;
}
return rtp_header_length;
}
-WebRtc_Word32 RTPReceiverVideo::ReceiveRecoveredPacketCallback(
+int32_t RTPReceiverVideo::ReceiveRecoveredPacketCallback(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length) {
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length) {
// TODO(pwestin) Re-factor this to avoid the messy critsect handling.
critical_section_receiver_video_->Enter();
@@ -231,11 +231,11 @@
}
// here we can re-create the original lost packet so that we can use it for
// the relay we need to re-create the RED header too
- WebRtc_UWord8 recovered_packet[IP_PACKET_SIZE];
- WebRtc_UWord16 rtp_header_length =
- (WebRtc_UWord16) BuildRTPheader(rtp_header, recovered_packet);
+ uint8_t recovered_packet[IP_PACKET_SIZE];
+ uint16_t rtp_header_length =
+ (uint16_t) BuildRTPheader(rtp_header, recovered_packet);
- const WebRtc_UWord8 kREDForFECHeaderLength = 1;
+ const uint8_t kREDForFECHeaderLength = 1;
// replace pltype
recovered_packet[1] &= 0x80; // Reset.
@@ -262,7 +262,7 @@
is_first_packet);
}
-WebRtc_Word32 RTPReceiverVideo::SetCodecType(
+int32_t RTPReceiverVideo::SetCodecType(
const RtpVideoCodecTypes video_type,
WebRtcRTPHeader* rtp_header) const {
switch (video_type) {
@@ -279,13 +279,13 @@
return 0;
}
-WebRtc_Word32 RTPReceiverVideo::ParseVideoCodecSpecificSwitch(
+int32_t RTPReceiverVideo::ParseVideoCodecSpecificSwitch(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length,
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length,
const RtpVideoCodecTypes video_type,
const bool is_first_packet) {
- WebRtc_Word32 ret_val = SetCodecType(video_type, rtp_header);
+ int32_t ret_val = SetCodecType(video_type, rtp_header);
if (ret_val != 0) {
critical_section_receiver_video_->Leave();
return ret_val;
@@ -312,10 +312,10 @@
return -1;
}
-WebRtc_Word32 RTPReceiverVideo::ReceiveVp8Codec(
+int32_t RTPReceiverVideo::ReceiveVp8Codec(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length) {
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length) {
bool success;
ModuleRTPUtility::RTPPayload parsed_packet;
if (payload_data_length == 0) {
@@ -378,10 +378,10 @@
return 0;
}
-WebRtc_Word32 RTPReceiverVideo::ReceiveGenericCodec(
+int32_t RTPReceiverVideo::ReceiveGenericCodec(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- WebRtc_UWord16 payload_data_length) {
+ const uint8_t* payload_data,
+ uint16_t payload_data_length) {
uint8_t generic_header = *payload_data++;
--payload_data_length;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
index d5bbb81..520e201 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
@@ -27,81 +27,81 @@
class RTPReceiverVideo : public RTPReceiverStrategy {
public:
- RTPReceiverVideo(const WebRtc_Word32 id,
+ RTPReceiverVideo(const int32_t id,
const RTPPayloadRegistry* rtp_payload_registry,
RtpData* data_callback);
virtual ~RTPReceiverVideo();
- WebRtc_Word32 ParseRtpPacket(
+ int32_t ParseRtpPacket(
WebRtcRTPHeader* rtp_header,
const ModuleRTPUtility::PayloadUnion& specific_payload,
const bool is_red,
- const WebRtc_UWord8* packet,
- const WebRtc_UWord16 packet_length,
- const WebRtc_Word64 timestamp,
+ const uint8_t* packet,
+ const uint16_t packet_length,
+ const int64_t timestamp,
const bool is_first_packet);
- WebRtc_Word32 GetFrequencyHz() const;
+ int32_t GetFrequencyHz() const;
- RTPAliveType ProcessDeadOrAlive(WebRtc_UWord16 last_payload_length) const;
+ RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const;
- bool ShouldReportCsrcChanges(WebRtc_UWord8 payload_type) const;
+ bool ShouldReportCsrcChanges(uint8_t payload_type) const;
- WebRtc_Word32 OnNewPayloadTypeCreated(
+ int32_t OnNewPayloadTypeCreated(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 frequency);
+ const int8_t payload_type,
+ const uint32_t frequency);
- WebRtc_Word32 InvokeOnInitializeDecoder(
+ int32_t InvokeOnInitializeDecoder(
RtpFeedback* callback,
- const WebRtc_Word32 id,
- const WebRtc_Word8 payload_type,
+ const int32_t id,
+ const int8_t payload_type,
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const ModuleRTPUtility::PayloadUnion& specific_payload) const;
- virtual WebRtc_Word32 ReceiveRecoveredPacketCallback(
+ virtual int32_t ReceiveRecoveredPacketCallback(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length);
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length);
- void SetPacketOverHead(WebRtc_UWord16 packet_over_head);
+ void SetPacketOverHead(uint16_t packet_over_head);
protected:
- WebRtc_Word32 SetCodecType(const RtpVideoCodecTypes video_type,
- WebRtcRTPHeader* rtp_header) const;
+ int32_t SetCodecType(const RtpVideoCodecTypes video_type,
+ WebRtcRTPHeader* rtp_header) const;
- WebRtc_Word32 ParseVideoCodecSpecificSwitch(
+ int32_t ParseVideoCodecSpecificSwitch(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length,
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length,
const RtpVideoCodecTypes video_type,
const bool is_first_packet);
- WebRtc_Word32 ReceiveGenericCodec(WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length);
+ int32_t ReceiveGenericCodec(WebRtcRTPHeader* rtp_header,
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length);
- WebRtc_Word32 ReceiveVp8Codec(WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length);
+ int32_t ReceiveVp8Codec(WebRtcRTPHeader* rtp_header,
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length);
- WebRtc_Word32 BuildRTPheader(const WebRtcRTPHeader* rtp_header,
- WebRtc_UWord8* data_buffer) const;
+ int32_t BuildRTPheader(const WebRtcRTPHeader* rtp_header,
+ uint8_t* data_buffer) const;
private:
- WebRtc_Word32 ParseVideoCodecSpecific(
+ int32_t ParseVideoCodecSpecific(
WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord16 payload_data_length,
+ const uint8_t* payload_data,
+ const uint16_t payload_data_length,
const RtpVideoCodecTypes video_type,
const bool is_red,
- const WebRtc_UWord8* incoming_rtp_packet,
- const WebRtc_UWord16 incoming_rtp_packet_size,
- const WebRtc_Word64 now_ms,
+ const uint8_t* incoming_rtp_packet,
+ const uint16_t incoming_rtp_packet_size,
+ const int64_t now_ms,
const bool is_first_packet);
- WebRtc_Word32 id_;
+ int32_t id_;
const RTPPayloadRegistry* rtp_rtp_payload_registry_;
CriticalSectionWrapper* critical_section_receiver_video_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 71d7940..1597ab2 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -159,7 +159,7 @@
rtcp_sender_.RegisterSendTransport(configuration.outgoing_transport);
// Make sure that RTCP objects are aware of our SSRC
- WebRtc_UWord32 SSRC = rtp_sender_.SSRC();
+ uint32_t SSRC = rtp_sender_.SSRC();
rtcp_sender_.SetSSRC(SSRC);
rtcp_receiver_.SetSSRC(SSRC);
@@ -228,14 +228,14 @@
// Returns the number of milliseconds until the module want a worker thread
// to call Process.
-WebRtc_Word32 ModuleRtpRtcpImpl::TimeUntilNextProcess() {
- const WebRtc_Word64 now = clock_->TimeInMilliseconds();
+int32_t ModuleRtpRtcpImpl::TimeUntilNextProcess() {
+ const int64_t now = clock_->TimeInMilliseconds();
return kRtpRtcpMaxIdleTimeProcess - (now - last_process_time_);
}
// Process any pending tasks such as timeouts (non time critical events).
-WebRtc_Word32 ModuleRtpRtcpImpl::Process() {
- const WebRtc_Word64 now = clock_->TimeInMilliseconds();
+int32_t ModuleRtpRtcpImpl::Process() {
+ const int64_t now = clock_->TimeInMilliseconds();
last_process_time_ = now;
if (now >=
@@ -309,9 +309,8 @@
}
void ModuleRtpRtcpImpl::ProcessDeadOrAliveTimer() {
-
bool RTCPalive = false;
- WebRtc_Word64 now = 0;
+ int64_t now = 0;
bool do_callback = false;
// Do operations on members under lock but avoid making the
@@ -336,9 +335,9 @@
rtp_receiver_->ProcessDeadOrAlive(RTCPalive, now);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetPeriodicDeadOrAliveStatus(
+int32_t ModuleRtpRtcpImpl::SetPeriodicDeadOrAliveStatus(
const bool enable,
- const WebRtc_UWord8 sample_time_seconds) {
+ const uint8_t sample_time_seconds) {
if (enable) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -364,9 +363,9 @@
return 0;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::PeriodicDeadOrAliveStatus(
+int32_t ModuleRtpRtcpImpl::PeriodicDeadOrAliveStatus(
bool& enable,
- WebRtc_UWord8& sample_time_seconds) {
+ uint8_t& sample_time_seconds) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -374,13 +373,13 @@
enable = dead_or_alive_active_;
sample_time_seconds =
- static_cast<WebRtc_UWord8>(dead_or_alive_timeout_ms_ / 1000);
+ static_cast<uint8_t>(dead_or_alive_timeout_ms_ / 1000);
return 0;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetPacketTimeout(
- const WebRtc_UWord32 rtp_timeout_ms,
- const WebRtc_UWord32 rtcp_timeout_ms) {
+int32_t ModuleRtpRtcpImpl::SetPacketTimeout(
+ const uint32_t rtp_timeout_ms,
+ const uint32_t rtcp_timeout_ms) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -394,7 +393,7 @@
return -1;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RegisterReceivePayload(
+int32_t ModuleRtpRtcpImpl::RegisterReceivePayload(
const CodecInst& voice_codec) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -409,7 +408,7 @@
(voice_codec.rate < 0) ? 0 : voice_codec.rate);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RegisterReceivePayload(
+int32_t ModuleRtpRtcpImpl::RegisterReceivePayload(
const VideoCodec& video_codec) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -423,9 +422,9 @@
video_codec.maxBitrate);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::ReceivePayloadType(
+int32_t ModuleRtpRtcpImpl::ReceivePayloadType(
const CodecInst& voice_codec,
- WebRtc_Word8* pl_type) {
+ int8_t* pl_type) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -439,9 +438,9 @@
pl_type);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::ReceivePayloadType(
+int32_t ModuleRtpRtcpImpl::ReceivePayloadType(
const VideoCodec& video_codec,
- WebRtc_Word8* pl_type) {
+ int8_t* pl_type) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -454,8 +453,8 @@
pl_type);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::DeRegisterReceivePayload(
- const WebRtc_Word8 payload_type) {
+int32_t ModuleRtpRtcpImpl::DeRegisterReceivePayload(
+ const int8_t payload_type) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -466,17 +465,17 @@
}
// Get the currently configured SSRC filter.
-WebRtc_Word32 ModuleRtpRtcpImpl::SSRCFilter(
- WebRtc_UWord32& allowed_ssrc) const {
+int32_t ModuleRtpRtcpImpl::SSRCFilter(
+ uint32_t& allowed_ssrc) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SSRCFilter()");
return rtp_receiver_->SSRCFilter(allowed_ssrc);
}
// Set a SSRC to be used as a filter for incoming RTP streams.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetSSRCFilter(
+int32_t ModuleRtpRtcpImpl::SetSSRCFilter(
const bool enable,
- const WebRtc_UWord32 allowed_ssrc) {
+ const uint32_t allowed_ssrc) {
if (enable) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -494,7 +493,7 @@
}
// Get last received remote timestamp.
-WebRtc_UWord32 ModuleRtpRtcpImpl::RemoteTimestamp() const {
+uint32_t ModuleRtpRtcpImpl::RemoteTimestamp() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteTimestamp()");
return rtp_receiver_->TimeStamp();
@@ -508,8 +507,8 @@
}
// Get the current estimated remote timestamp.
-WebRtc_Word32 ModuleRtpRtcpImpl::EstimatedRemoteTimeStamp(
- WebRtc_UWord32& timestamp) const {
+int32_t ModuleRtpRtcpImpl::EstimatedRemoteTimeStamp(
+ uint32_t& timestamp) const {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -519,51 +518,50 @@
}
// Get incoming SSRC.
-WebRtc_UWord32 ModuleRtpRtcpImpl::RemoteSSRC() const {
+uint32_t ModuleRtpRtcpImpl::RemoteSSRC() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteSSRC()");
return rtp_receiver_->SSRC();
}
// Get remote CSRC
-WebRtc_Word32 ModuleRtpRtcpImpl::RemoteCSRCs(
- WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const {
+int32_t ModuleRtpRtcpImpl::RemoteCSRCs(
+ uint32_t arr_of_csrc[kRtpCsrcSize]) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteCSRCs()");
return rtp_receiver_->CSRCs(arr_of_csrc);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetRTXSendStatus(
+int32_t ModuleRtpRtcpImpl::SetRTXSendStatus(
const RtxMode mode,
const bool set_ssrc,
- const WebRtc_UWord32 ssrc) {
+ const uint32_t ssrc) {
rtp_sender_.SetRTXStatus(mode, set_ssrc, ssrc);
return 0;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RTXSendStatus(RtxMode* mode,
- WebRtc_UWord32* ssrc) const {
+int32_t ModuleRtpRtcpImpl::RTXSendStatus(RtxMode* mode, uint32_t* ssrc) const {
rtp_sender_.RTXStatus(mode, ssrc);
return 0;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetRTXReceiveStatus(
+int32_t ModuleRtpRtcpImpl::SetRTXReceiveStatus(
const bool enable,
- const WebRtc_UWord32 ssrc) {
+ const uint32_t ssrc) {
rtp_receiver_->SetRTXStatus(enable, ssrc);
return 0;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RTXReceiveStatus(bool* enable,
- WebRtc_UWord32* ssrc) const {
+int32_t ModuleRtpRtcpImpl::RTXReceiveStatus(bool* enable,
+ uint32_t* ssrc) const {
rtp_receiver_->RTXStatus(enable, ssrc);
return 0;
}
// Called by the network module when we receive a packet.
-WebRtc_Word32 ModuleRtpRtcpImpl::IncomingPacket(
- const WebRtc_UWord8* incoming_packet,
- const WebRtc_UWord16 incoming_packet_length) {
+int32_t ModuleRtpRtcpImpl::IncomingPacket(
+ const uint8_t* incoming_packet,
+ const uint16_t incoming_packet_length) {
WEBRTC_TRACE(kTraceStream,
kTraceRtpRtcp,
id_,
@@ -579,7 +577,7 @@
return -1;
}
// Check RTP version.
- const WebRtc_UWord8 version = incoming_packet[0] >> 6;
+ const uint8_t version = incoming_packet[0] >> 6;
if (version != 2) {
WEBRTC_TRACE(kTraceDebug,
kTraceRtpRtcp,
@@ -606,7 +604,7 @@
return -1;
}
RTCPHelp::RTCPPacketInformation rtcp_packet_information;
- WebRtc_Word32 ret_val = rtcp_receiver_.IncomingRTCPPacket(
+ int32_t ret_val = rtcp_receiver_.IncomingRTCPPacket(
rtcp_packet_information, &rtcp_parser);
if (ret_val == 0) {
rtcp_receiver_.TriggerCallbacksFromRTCPPacket(rtcp_packet_information);
@@ -634,7 +632,7 @@
}
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RegisterSendPayload(
+int32_t ModuleRtpRtcpImpl::RegisterSendPayload(
const CodecInst& voice_codec) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -652,7 +650,7 @@
(voice_codec.rate < 0) ? 0 : voice_codec.rate);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RegisterSendPayload(
+int32_t ModuleRtpRtcpImpl::RegisterSendPayload(
const VideoCodec& video_codec) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -670,8 +668,8 @@
video_codec.maxBitrate);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::DeRegisterSendPayload(
- const WebRtc_Word8 payload_type) {
+int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(
+ const int8_t payload_type) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -680,19 +678,19 @@
return rtp_sender_.DeRegisterSendPayload(payload_type);
}
-WebRtc_Word8 ModuleRtpRtcpImpl::SendPayloadType() const {
+int8_t ModuleRtpRtcpImpl::SendPayloadType() const {
return rtp_sender_.SendPayloadType();
}
-WebRtc_UWord32 ModuleRtpRtcpImpl::StartTimestamp() const {
+uint32_t ModuleRtpRtcpImpl::StartTimestamp() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "StartTimestamp()");
return rtp_sender_.StartTimestamp();
}
// Configure start timestamp, default is a random number.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetStartTimestamp(
- const WebRtc_UWord32 timestamp) {
+int32_t ModuleRtpRtcpImpl::SetStartTimestamp(
+ const uint32_t timestamp) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -703,15 +701,15 @@
return 0; // TODO(pwestin): change to void.
}
-WebRtc_UWord16 ModuleRtpRtcpImpl::SequenceNumber() const {
+uint16_t ModuleRtpRtcpImpl::SequenceNumber() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SequenceNumber()");
return rtp_sender_.SequenceNumber();
}
// Set SequenceNumber, default is a random number.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetSequenceNumber(
- const WebRtc_UWord16 seq_num) {
+int32_t ModuleRtpRtcpImpl::SetSequenceNumber(
+ const uint16_t seq_num) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -722,14 +720,14 @@
return 0; // TODO(pwestin): change to void.
}
-WebRtc_UWord32 ModuleRtpRtcpImpl::SSRC() const {
+uint32_t ModuleRtpRtcpImpl::SSRC() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SSRC()");
return rtp_sender_.SSRC();
}
// Configure SSRC, default is a random number.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetSSRC(const WebRtc_UWord32 ssrc) {
+int32_t ModuleRtpRtcpImpl::SetSSRC(const uint32_t ssrc) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetSSRC(%d)", ssrc);
rtp_sender_.SetSSRC(ssrc);
@@ -738,22 +736,22 @@
return 0; // TODO(pwestin): change to void.
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetCSRCStatus(const bool include) {
+int32_t ModuleRtpRtcpImpl::SetCSRCStatus(const bool include) {
rtcp_sender_.SetCSRCStatus(include);
rtp_sender_.SetCSRCStatus(include);
return 0; // TODO(pwestin): change to void.
}
-WebRtc_Word32 ModuleRtpRtcpImpl::CSRCs(
- WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const {
+int32_t ModuleRtpRtcpImpl::CSRCs(
+ uint32_t arr_of_csrc[kRtpCsrcSize]) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "CSRCs()");
return rtp_sender_.CSRCs(arr_of_csrc);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetCSRCs(
- const WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize],
- const WebRtc_UWord8 arr_length) {
+int32_t ModuleRtpRtcpImpl::SetCSRCs(
+ const uint32_t arr_of_csrc[kRtpCsrcSize],
+ const uint8_t arr_length) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -785,13 +783,13 @@
return 0; // TODO(pwestin): change to void.
}
-WebRtc_UWord32 ModuleRtpRtcpImpl::PacketCountSent() const {
+uint32_t ModuleRtpRtcpImpl::PacketCountSent() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "PacketCountSent()");
return rtp_sender_.Packets();
}
-WebRtc_UWord32 ModuleRtpRtcpImpl::ByteCountSent() const {
+uint32_t ModuleRtpRtcpImpl::ByteCountSent() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "ByteCountSent()");
return rtp_sender_.Bytes();
@@ -804,7 +802,7 @@
return rtp_sender_.SendPayloadFrequency();
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetSendingStatus(const bool sending) {
+int32_t ModuleRtpRtcpImpl::SetSendingStatus(const bool sending) {
if (sending) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"SetSendingStatus(sending)");
@@ -831,7 +829,7 @@
// Make sure that RTCP objects are aware of our SSRC (it could have changed
// Due to collision)
- WebRtc_UWord32 SSRC = rtp_sender_.SSRC();
+ uint32_t SSRC = rtp_sender_.SSRC();
rtcp_receiver_.SetSSRC(SSRC);
rtcp_sender_.SetSSRC(SSRC);
return 0;
@@ -845,7 +843,7 @@
return rtcp_sender_.Sending();
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
+int32_t ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
if (sending) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"SetSendingMediaStatus(sending)");
@@ -877,13 +875,13 @@
return false;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SendOutgoingData(
+int32_t ModuleRtpRtcpImpl::SendOutgoingData(
FrameType frame_type,
- WebRtc_Word8 payload_type,
- WebRtc_UWord32 time_stamp,
+ int8_t payload_type,
+ uint32_t time_stamp,
int64_t capture_time_ms,
- const WebRtc_UWord8* payload_data,
- WebRtc_UWord32 payload_size,
+ const uint8_t* payload_data,
+ uint32_t payload_size,
const RTPFragmentationHeader* fragmentation,
const RTPVideoHeader* rtp_video_hdr) {
WEBRTC_TRACE(
@@ -911,7 +909,7 @@
NULL,
&(rtp_video_hdr->codecHeader));
}
- WebRtc_Word32 ret_val = -1;
+ int32_t ret_val = -1;
if (simulcast_) {
if (rtp_video_hdr == NULL) {
return -1;
@@ -1025,20 +1023,20 @@
}
}
-WebRtc_UWord16 ModuleRtpRtcpImpl::MaxPayloadLength() const {
+uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "MaxPayloadLength()");
return rtp_sender_.MaxPayloadLength();
}
-WebRtc_UWord16 ModuleRtpRtcpImpl::MaxDataPayloadLength() const {
+uint16_t ModuleRtpRtcpImpl::MaxDataPayloadLength() const {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
"MaxDataPayloadLength()");
// Assuming IP/UDP.
- WebRtc_UWord16 min_data_payload_length = IP_PACKET_SIZE - 28;
+ uint16_t min_data_payload_length = IP_PACKET_SIZE - 28;
const bool default_instance(child_modules_.empty() ? false : true);
if (default_instance) {
@@ -1049,7 +1047,7 @@
while (it != child_modules_.end()) {
RtpRtcp* module = *it;
if (module) {
- WebRtc_UWord16 data_payload_length =
+ uint16_t data_payload_length =
module->MaxDataPayloadLength();
if (data_payload_length < min_data_payload_length) {
min_data_payload_length = data_payload_length;
@@ -1059,17 +1057,17 @@
}
}
- WebRtc_UWord16 data_payload_length = rtp_sender_.MaxDataPayloadLength();
+ uint16_t data_payload_length = rtp_sender_.MaxDataPayloadLength();
if (data_payload_length < min_data_payload_length) {
min_data_payload_length = data_payload_length;
}
return min_data_payload_length;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetTransportOverhead(
+int32_t ModuleRtpRtcpImpl::SetTransportOverhead(
const bool tcp,
const bool ipv6,
- const WebRtc_UWord8 authentication_overhead) {
+ const uint8_t authentication_overhead) {
WEBRTC_TRACE(
kTraceModuleCall,
kTraceRtpRtcp,
@@ -1077,7 +1075,7 @@
"SetTransportOverhead(TCP:%d, IPV6:%d authentication_overhead:%u)",
tcp, ipv6, authentication_overhead);
- WebRtc_UWord16 packet_overhead = 0;
+ uint16_t packet_overhead = 0;
if (ipv6) {
packet_overhead = 40;
} else {
@@ -1097,17 +1095,17 @@
return 0;
}
// Calc diff.
- WebRtc_Word16 packet_over_head_diff = packet_overhead - packet_overhead_;
+ int16_t packet_over_head_diff = packet_overhead - packet_overhead_;
// Store new.
packet_overhead_ = packet_overhead;
- WebRtc_UWord16 length =
+ uint16_t length =
rtp_sender_.MaxPayloadLength() - packet_over_head_diff;
return rtp_sender_.SetMaxPayloadLength(length, packet_overhead_);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetMaxTransferUnit(const WebRtc_UWord16 mtu) {
+int32_t ModuleRtpRtcpImpl::SetMaxTransferUnit(const uint16_t mtu) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetMaxTransferUnit(%u)",
mtu);
@@ -1130,7 +1128,7 @@
}
// Configure RTCP status i.e on/off.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetRTCPStatus(const RTCPMethod method) {
+int32_t ModuleRtpRtcpImpl::SetRTCPStatus(const RTCPMethod method) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetRTCPStatus(%d)",
method);
@@ -1141,23 +1139,23 @@
}
// Only for internal test.
-WebRtc_UWord32 ModuleRtpRtcpImpl::LastSendReport(
- WebRtc_UWord32& last_rtcptime) {
+uint32_t ModuleRtpRtcpImpl::LastSendReport(
+ uint32_t& last_rtcptime) {
return rtcp_sender_.LastSendReport(last_rtcptime);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetCNAME(const char c_name[RTCP_CNAME_SIZE]) {
+int32_t ModuleRtpRtcpImpl::SetCNAME(const char c_name[RTCP_CNAME_SIZE]) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetCNAME(%s)", c_name);
return rtcp_sender_.SetCNAME(c_name);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::CNAME(char c_name[RTCP_CNAME_SIZE]) {
+int32_t ModuleRtpRtcpImpl::CNAME(char c_name[RTCP_CNAME_SIZE]) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "CNAME()");
return rtcp_sender_.CNAME(c_name);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::AddMixedCNAME(
- const WebRtc_UWord32 ssrc,
+int32_t ModuleRtpRtcpImpl::AddMixedCNAME(
+ const uint32_t ssrc,
const char c_name[RTCP_CNAME_SIZE]) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"AddMixedCNAME(SSRC:%u)", ssrc);
@@ -1165,14 +1163,14 @@
return rtcp_sender_.AddMixedCNAME(ssrc, c_name);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RemoveMixedCNAME(const WebRtc_UWord32 ssrc) {
+int32_t ModuleRtpRtcpImpl::RemoveMixedCNAME(const uint32_t ssrc) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"RemoveMixedCNAME(SSRC:%u)", ssrc);
return rtcp_sender_.RemoveMixedCNAME(ssrc);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RemoteCNAME(
- const WebRtc_UWord32 remote_ssrc,
+int32_t ModuleRtpRtcpImpl::RemoteCNAME(
+ const uint32_t remote_ssrc,
char c_name[RTCP_CNAME_SIZE]) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"RemoteCNAME(SSRC:%u)", remote_ssrc);
@@ -1180,18 +1178,18 @@
return rtcp_receiver_.CNAME(remote_ssrc, c_name);
}
-WebRtc_UWord16 ModuleRtpRtcpImpl::RemoteSequenceNumber() const {
+uint16_t ModuleRtpRtcpImpl::RemoteSequenceNumber() const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteSequenceNumber()");
return rtp_receiver_->SequenceNumber();
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RemoteNTP(
- WebRtc_UWord32* received_ntpsecs,
- WebRtc_UWord32* received_ntpfrac,
- WebRtc_UWord32* rtcp_arrival_time_secs,
- WebRtc_UWord32* rtcp_arrival_time_frac,
- WebRtc_UWord32* rtcp_timestamp) const {
+int32_t ModuleRtpRtcpImpl::RemoteNTP(
+ uint32_t* received_ntpsecs,
+ uint32_t* received_ntpfrac,
+ uint32_t* rtcp_arrival_time_secs,
+ uint32_t* rtcp_arrival_time_frac,
+ uint32_t* rtcp_timestamp) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteNTP()");
return rtcp_receiver_.NTP(received_ntpsecs,
@@ -1202,18 +1200,18 @@
}
// Get RoundTripTime.
-WebRtc_Word32 ModuleRtpRtcpImpl::RTT(const WebRtc_UWord32 remote_ssrc,
- WebRtc_UWord16* rtt,
- WebRtc_UWord16* avg_rtt,
- WebRtc_UWord16* min_rtt,
- WebRtc_UWord16* max_rtt) const {
+int32_t ModuleRtpRtcpImpl::RTT(const uint32_t remote_ssrc,
+ uint16_t* rtt,
+ uint16_t* avg_rtt,
+ uint16_t* min_rtt,
+ uint16_t* max_rtt) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RTT()");
return rtcp_receiver_.RTT(remote_ssrc, rtt, avg_rtt, min_rtt, max_rtt);
}
// Reset RoundTripTime statistics.
-WebRtc_Word32 ModuleRtpRtcpImpl::ResetRTT(const WebRtc_UWord32 remote_ssrc) {
+int32_t ModuleRtpRtcpImpl::ResetRTT(const uint32_t remote_ssrc) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "ResetRTT(SSRC:%u)",
remote_ssrc);
@@ -1222,18 +1220,18 @@
void ModuleRtpRtcpImpl:: SetRtt(uint32_t rtt) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetRtt(rtt: %u)", rtt);
- rtcp_receiver_.SetRTT(static_cast<WebRtc_UWord16>(rtt));
+ rtcp_receiver_.SetRTT(static_cast<uint16_t>(rtt));
}
// Reset RTP statistics.
-WebRtc_Word32 ModuleRtpRtcpImpl::ResetStatisticsRTP() {
+int32_t ModuleRtpRtcpImpl::ResetStatisticsRTP() {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "ResetStatisticsRTP()");
return rtp_receiver_->ResetStatistics();
}
// Reset RTP data counters for the receiving side.
-WebRtc_Word32 ModuleRtpRtcpImpl::ResetReceiveDataCountersRTP() {
+int32_t ModuleRtpRtcpImpl::ResetReceiveDataCountersRTP() {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"ResetReceiveDataCountersRTP()");
@@ -1241,7 +1239,7 @@
}
// Reset RTP data counters for the sending side.
-WebRtc_Word32 ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
+int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"ResetSendDataCountersRTP()");
@@ -1251,18 +1249,18 @@
// Force a send of an RTCP packet.
// Normal SR and RR are triggered via the process function.
-WebRtc_Word32 ModuleRtpRtcpImpl::SendRTCP(WebRtc_UWord32 rtcp_packet_type) {
+int32_t ModuleRtpRtcpImpl::SendRTCP(uint32_t rtcp_packet_type) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SendRTCP(0x%x)",
rtcp_packet_type);
return rtcp_sender_.SendRTCP(rtcp_packet_type);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
- const WebRtc_UWord8 sub_type,
- const WebRtc_UWord32 name,
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 length) {
+int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
+ const uint8_t sub_type,
+ const uint32_t name,
+ const uint8_t* data,
+ const uint16_t length) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"SetRTCPApplicationSpecificData(sub_type:%d name:0x%x)",
sub_type, name);
@@ -1271,7 +1269,7 @@
}
// (XR) VOIP metric.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetRTCPVoIPMetrics(
+int32_t ModuleRtpRtcpImpl::SetRTCPVoIPMetrics(
const RTCPVoIPMetric* voip_metric) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetRTCPVoIPMetrics()");
@@ -1279,17 +1277,17 @@
}
// Our locally created statistics of the received RTP stream.
-WebRtc_Word32 ModuleRtpRtcpImpl::StatisticsRTP(
- WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter,
- WebRtc_UWord32* max_jitter) const {
+int32_t ModuleRtpRtcpImpl::StatisticsRTP(
+ uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter,
+ uint32_t* max_jitter) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "StatisticsRTP()");
- WebRtc_UWord32 jitter_transmission_time_offset = 0;
+ uint32_t jitter_transmission_time_offset = 0;
- WebRtc_Word32 ret_val = rtp_receiver_->Statistics(
+ int32_t ret_val = rtp_receiver_->Statistics(
fraction_lost, cum_lost, ext_max, jitter, max_jitter,
&jitter_transmission_time_offset, (rtcp_sender_.Status() == kRtcpOff));
if (ret_val == -1) {
@@ -1299,11 +1297,11 @@
return ret_val;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::DataCountersRTP(
- WebRtc_UWord32* bytes_sent,
- WebRtc_UWord32* packets_sent,
- WebRtc_UWord32* bytes_received,
- WebRtc_UWord32* packets_received) const {
+int32_t ModuleRtpRtcpImpl::DataCountersRTP(
+ uint32_t* bytes_sent,
+ uint32_t* packets_sent,
+ uint32_t* bytes_received,
+ uint32_t* packets_received) const {
WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_, "DataCountersRTP()");
if (bytes_sent) {
@@ -1315,21 +1313,21 @@
return rtp_receiver_->DataCounters(bytes_received, packets_received);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::ReportBlockStatistics(
- WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter,
- WebRtc_UWord32* jitter_transmission_time_offset) {
+int32_t ModuleRtpRtcpImpl::ReportBlockStatistics(
+ uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter,
+ uint32_t* jitter_transmission_time_offset) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "ReportBlockStatistics()");
- WebRtc_Word32 missing = 0;
- WebRtc_Word32 ret = rtp_receiver_->Statistics(fraction_lost,
- cum_lost,
- ext_max,
- jitter,
- NULL,
- jitter_transmission_time_offset,
- &missing,
+ int32_t missing = 0;
+ int32_t ret = rtp_receiver_->Statistics(fraction_lost,
+ cum_lost,
+ ext_max,
+ jitter,
+ NULL,
+ jitter_transmission_time_offset,
+ &missing,
true);
#ifdef MATLAB
@@ -1344,30 +1342,30 @@
return ret;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RemoteRTCPStat(RTCPSenderInfo* sender_info) {
+int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(RTCPSenderInfo* sender_info) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteRTCPStat()");
return rtcp_receiver_.SenderInfoReceived(sender_info);
}
// Received RTCP report.
-WebRtc_Word32 ModuleRtpRtcpImpl::RemoteRTCPStat(
+int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(
std::vector<RTCPReportBlock>* receive_blocks) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteRTCPStat()");
return rtcp_receiver_.StatisticsReceived(receive_blocks);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::AddRTCPReportBlock(
- const WebRtc_UWord32 ssrc,
+int32_t ModuleRtpRtcpImpl::AddRTCPReportBlock(
+ const uint32_t ssrc,
const RTCPReportBlock* report_block) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "AddRTCPReportBlock()");
return rtcp_sender_.AddReportBlock(ssrc, report_block);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RemoveRTCPReportBlock(
- const WebRtc_UWord32 ssrc) {
+int32_t ModuleRtpRtcpImpl::RemoveRTCPReportBlock(
+ const uint32_t ssrc) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoveRTCPReportBlock()");
return rtcp_sender_.RemoveReportBlock(ssrc);
@@ -1380,7 +1378,7 @@
return rtcp_sender_.REMB();
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetREMBStatus(const bool enable) {
+int32_t ModuleRtpRtcpImpl::SetREMBStatus(const bool enable) {
if (enable) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1395,9 +1393,9 @@
return rtcp_sender_.SetREMBStatus(enable);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetREMBData(const WebRtc_UWord32 bitrate,
- const WebRtc_UWord8 number_of_ssrc,
- const WebRtc_UWord32* ssrc) {
+int32_t ModuleRtpRtcpImpl::SetREMBData(const uint32_t bitrate,
+ const uint8_t number_of_ssrc,
+ const uint32_t* ssrc) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"SetREMBData(bitrate:%d,?,?)", bitrate);
return rtcp_sender_.SetREMBData(bitrate, number_of_ssrc, ssrc);
@@ -1410,7 +1408,7 @@
return rtcp_sender_.IJ();
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetIJStatus(const bool enable) {
+int32_t ModuleRtpRtcpImpl::SetIJStatus(const bool enable) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -1419,24 +1417,24 @@
return rtcp_sender_.SetIJStatus(enable);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
+int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
const RTPExtensionType type,
- const WebRtc_UWord8 id) {
+ const uint8_t id) {
return rtp_sender_.RegisterRtpHeaderExtension(type, id);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
+int32_t ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
const RTPExtensionType type) {
return rtp_sender_.DeregisterRtpHeaderExtension(type);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RegisterReceiveRtpHeaderExtension(
+int32_t ModuleRtpRtcpImpl::RegisterReceiveRtpHeaderExtension(
const RTPExtensionType type,
- const WebRtc_UWord8 id) {
+ const uint8_t id) {
return rtp_receiver_->RegisterRtpHeaderExtension(type, id);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::DeregisterReceiveRtpHeaderExtension(
+int32_t ModuleRtpRtcpImpl::DeregisterReceiveRtpHeaderExtension(
const RTPExtensionType type) {
return rtp_receiver_->DeregisterRtpHeaderExtension(type);
}
@@ -1448,7 +1446,7 @@
return rtcp_sender_.TMMBR();
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetTMMBRStatus(const bool enable) {
+int32_t ModuleRtpRtcpImpl::SetTMMBRStatus(const bool enable) {
if (enable) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"SetTMMBRStatus(enable)");
@@ -1459,10 +1457,10 @@
return rtcp_sender_.SetTMMBRStatus(enable);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetTMMBN(const TMMBRSet* bounding_set) {
+int32_t ModuleRtpRtcpImpl::SetTMMBN(const TMMBRSet* bounding_set) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetTMMBN()");
- WebRtc_UWord32 max_bitrate_kbit =
+ uint32_t max_bitrate_kbit =
rtp_sender_.MaxConfiguredBitrateVideo() / 1000;
return rtcp_sender_.SetTMMBN(bounding_set, max_bitrate_kbit);
}
@@ -1501,7 +1499,7 @@
}
// Turn negative acknowledgment requests on/off.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetNACKStatus(
+int32_t ModuleRtpRtcpImpl::SetNACKStatus(
NACKMethod method, int max_reordering_threshold) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1534,24 +1532,24 @@
}
// Send a Negative acknowledgment packet.
-WebRtc_Word32 ModuleRtpRtcpImpl::SendNACK(const WebRtc_UWord16* nack_list,
- const WebRtc_UWord16 size) {
+int32_t ModuleRtpRtcpImpl::SendNACK(const uint16_t* nack_list,
+ const uint16_t size) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
"SendNACK(size:%u)", size);
- WebRtc_UWord16 avg_rtt = 0;
+ uint16_t avg_rtt = 0;
rtcp_receiver_.RTT(rtp_receiver_->SSRC(), NULL, &avg_rtt, NULL, NULL);
- WebRtc_Word64 wait_time = 5 + ((avg_rtt * 3) >> 1); // 5 + RTT * 1.5.
+ int64_t wait_time = 5 + ((avg_rtt * 3) >> 1); // 5 + RTT * 1.5.
if (wait_time == 5) {
wait_time = 100; // During startup we don't have an RTT.
}
- const WebRtc_Word64 now = clock_->TimeInMilliseconds();
- const WebRtc_Word64 time_limit = now - wait_time;
- WebRtc_UWord16 nackLength = size;
- WebRtc_UWord16 start_id = 0;
+ const int64_t now = clock_->TimeInMilliseconds();
+ const int64_t time_limit = now - wait_time;
+ uint16_t nackLength = size;
+ uint16_t start_id = 0;
if (nack_last_time_sent_full_ < time_limit) {
// Send list. Set the timer to make sure we only send a full NACK list once
@@ -1592,9 +1590,9 @@
// Store the sent packets, needed to answer to a Negative acknowledgment
// requests.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetStorePacketsStatus(
+int32_t ModuleRtpRtcpImpl::SetStorePacketsStatus(
const bool enable,
- const WebRtc_UWord16 number_to_store) {
+ const uint16_t number_to_store) {
if (enable) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"SetStorePacketsStatus(enable, number_to_store:%d)",
@@ -1631,10 +1629,10 @@
}
// Send a TelephoneEvent tone using RFC 2833 (4733).
-WebRtc_Word32 ModuleRtpRtcpImpl::SendTelephoneEventOutband(
- const WebRtc_UWord8 key,
- const WebRtc_UWord16 time_ms,
- const WebRtc_UWord8 level) {
+int32_t ModuleRtpRtcpImpl::SendTelephoneEventOutband(
+ const uint8_t key,
+ const uint16_t time_ms,
+ const uint8_t level) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
"SendTelephoneEventOutband(key:%u, time_ms:%u, level:%u)", key,
time_ms, level);
@@ -1643,7 +1641,7 @@
}
bool ModuleRtpRtcpImpl::SendTelephoneEventActive(
- WebRtc_Word8& telephone_event) const {
+ int8_t& telephone_event) const {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1655,8 +1653,8 @@
// Set audio packet size, used to determine when it's time to send a DTMF
// packet in silence (CNG).
-WebRtc_Word32 ModuleRtpRtcpImpl::SetAudioPacketSize(
- const WebRtc_UWord16 packet_size_samples) {
+int32_t ModuleRtpRtcpImpl::SetAudioPacketSize(
+ const uint16_t packet_size_samples) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1667,9 +1665,9 @@
return rtp_sender_.SetAudioPacketSize(packet_size_samples);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetRTPAudioLevelIndicationStatus(
+int32_t ModuleRtpRtcpImpl::SetRTPAudioLevelIndicationStatus(
const bool enable,
- const WebRtc_UWord8 id) {
+ const uint8_t id) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1686,9 +1684,9 @@
return rtp_sender_.SetAudioLevelIndicationStatus(enable, id);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::GetRTPAudioLevelIndicationStatus(
+int32_t ModuleRtpRtcpImpl::GetRTPAudioLevelIndicationStatus(
bool& enable,
- WebRtc_UWord8& id) const {
+ uint8_t& id) const {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1697,8 +1695,8 @@
return rtp_sender_.AudioLevelIndicationStatus(&enable, &id);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetAudioLevel(
- const WebRtc_UWord8 level_d_bov) {
+int32_t ModuleRtpRtcpImpl::SetAudioLevel(
+ const uint8_t level_d_bov) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -1708,8 +1706,8 @@
}
// Set payload type for Redundant Audio Data RFC 2198.
-WebRtc_Word32 ModuleRtpRtcpImpl::SetSendREDPayloadType(
- const WebRtc_Word8 payload_type) {
+int32_t ModuleRtpRtcpImpl::SetSendREDPayloadType(
+ const int8_t payload_type) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -1720,8 +1718,8 @@
}
// Get payload type for Redundant Audio Data RFC 2198.
-WebRtc_Word32 ModuleRtpRtcpImpl::SendREDPayloadType(
- WebRtc_Word8& payload_type) const {
+int32_t ModuleRtpRtcpImpl::SendREDPayloadType(
+ int8_t& payload_type) const {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SendREDPayloadType()");
return rtp_sender_.RED(&payload_type);
@@ -1774,7 +1772,7 @@
}
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetKeyFrameRequestMethod(
+int32_t ModuleRtpRtcpImpl::SetKeyFrameRequestMethod(
const KeyFrameRequestMethod method) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1786,7 +1784,7 @@
return 0;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::RequestKeyFrame() {
+int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -1803,8 +1801,8 @@
return -1;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SendRTCPSliceLossIndication(
- const WebRtc_UWord8 picture_id) {
+int32_t ModuleRtpRtcpImpl::SendRTCPSliceLossIndication(
+ const uint8_t picture_id) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -1813,7 +1811,7 @@
return rtcp_sender_.SendRTCP(kRtcpSli, 0, 0, false, picture_id);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetCameraDelay(const WebRtc_Word32 delay_ms) {
+int32_t ModuleRtpRtcpImpl::SetCameraDelay(const int32_t delay_ms) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
id_,
@@ -1837,10 +1835,10 @@
return rtcp_sender_.SetCameraDelay(delay_ms);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetGenericFECStatus(
+int32_t ModuleRtpRtcpImpl::SetGenericFECStatus(
const bool enable,
- const WebRtc_UWord8 payload_type_red,
- const WebRtc_UWord8 payload_type_fec) {
+ const uint8_t payload_type_red,
+ const uint8_t payload_type_fec) {
if (enable) {
WEBRTC_TRACE(kTraceModuleCall,
kTraceRtpRtcp,
@@ -1858,10 +1856,10 @@
payload_type_fec);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::GenericFECStatus(
+int32_t ModuleRtpRtcpImpl::GenericFECStatus(
bool& enable,
- WebRtc_UWord8& payload_type_red,
- WebRtc_UWord8& payload_type_fec) {
+ uint8_t& payload_type_red,
+ uint8_t& payload_type_fec) {
WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "GenericFECStatus()");
@@ -1875,8 +1873,8 @@
RtpRtcp* module = *it;
if (module) {
bool enabled = false;
- WebRtc_UWord8 dummy_ptype_red = 0;
- WebRtc_UWord8 dummy_ptype_fec = 0;
+ uint8_t dummy_ptype_red = 0;
+ uint8_t dummy_ptype_fec = 0;
if (module->GenericFECStatus(enabled,
dummy_ptype_red,
dummy_ptype_fec) == 0 && enabled) {
@@ -1887,9 +1885,9 @@
it++;
}
}
- WebRtc_Word32 ret_val = rtp_sender_.GenericFECStatus(&enable,
- &payload_type_red,
- &payload_type_fec);
+ int32_t ret_val = rtp_sender_.GenericFECStatus(&enable,
+ &payload_type_red,
+ &payload_type_fec);
if (child_enabled) {
// Returns true if enabled for any child module.
enable = child_enabled;
@@ -1897,7 +1895,7 @@
return ret_val;
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SetFecParameters(
+int32_t ModuleRtpRtcpImpl::SetFecParameters(
const FecProtectionParams* delta_params,
const FecProtectionParams* key_params) {
const bool default_instance(child_modules_.empty() ? false : true);
@@ -1918,7 +1916,7 @@
return rtp_sender_.SetFecParameters(delta_params, key_params);
}
-void ModuleRtpRtcpImpl::SetRemoteSSRC(const WebRtc_UWord32 ssrc) {
+void ModuleRtpRtcpImpl::SetRemoteSSRC(const uint32_t ssrc) {
// Inform about the incoming SSRC.
rtcp_sender_.SetRemoteSSRC(ssrc);
rtcp_receiver_.SetRemoteSSRC(ssrc);
@@ -1927,7 +1925,7 @@
if (rtp_sender_.SSRC() == ssrc && !collision_detected_) {
// If we detect a collision change the SSRC but only once.
collision_detected_ = true;
- WebRtc_UWord32 new_ssrc = rtp_sender_.GenerateNewSSRC();
+ uint32_t new_ssrc = rtp_sender_.GenerateNewSSRC();
if (new_ssrc == 0) {
// Configured via API ignore.
return;
@@ -1942,14 +1940,14 @@
}
}
-WebRtc_UWord32 ModuleRtpRtcpImpl::BitrateReceivedNow() const {
+uint32_t ModuleRtpRtcpImpl::BitrateReceivedNow() const {
return rtp_receiver_->BitrateNow();
}
-void ModuleRtpRtcpImpl::BitrateSent(WebRtc_UWord32* total_rate,
- WebRtc_UWord32* video_rate,
- WebRtc_UWord32* fec_rate,
- WebRtc_UWord32* nack_rate) const {
+void ModuleRtpRtcpImpl::BitrateSent(uint32_t* total_rate,
+ uint32_t* video_rate,
+ uint32_t* fec_rate,
+ uint32_t* nack_rate) const {
const bool default_instance(child_modules_.empty() ? false : true);
if (default_instance) {
@@ -1970,10 +1968,10 @@
while (it != child_modules_.end()) {
RtpRtcp* module = *it;
if (module) {
- WebRtc_UWord32 child_total_rate = 0;
- WebRtc_UWord32 child_video_rate = 0;
- WebRtc_UWord32 child_fec_rate = 0;
- WebRtc_UWord32 child_nack_rate = 0;
+ uint32_t child_total_rate = 0;
+ uint32_t child_video_rate = 0;
+ uint32_t child_fec_rate = 0;
+ uint32_t child_nack_rate = 0;
module->BitrateSent(&child_total_rate,
&child_video_rate,
&child_fec_rate,
@@ -2010,13 +2008,13 @@
rtcp_sender_.SendRTCP(kRtcpSr);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
- const WebRtc_UWord64 picture_id) {
+int32_t ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
+ const uint64_t picture_id) {
return rtcp_sender_.SendRTCP(kRtcpRpsi, 0, 0, false, picture_id);
}
-WebRtc_UWord32 ModuleRtpRtcpImpl::SendTimeOfSendReport(
- const WebRtc_UWord32 send_report) {
+uint32_t ModuleRtpRtcpImpl::SendTimeOfSendReport(
+ const uint32_t send_report) {
return rtcp_sender_.SendTimeOfSendReport(send_report);
}
@@ -2026,18 +2024,18 @@
nack_sequence_numbers.size() == 0) {
return;
}
- WebRtc_UWord16 avg_rtt = 0;
+ uint16_t avg_rtt = 0;
rtcp_receiver_.RTT(rtp_receiver_->SSRC(), NULL, &avg_rtt, NULL, NULL);
rtp_sender_.OnReceivedNACK(nack_sequence_numbers, avg_rtt);
}
-WebRtc_Word32 ModuleRtpRtcpImpl::LastReceivedNTP(
- WebRtc_UWord32& rtcp_arrival_time_secs, // When we got the last report.
- WebRtc_UWord32& rtcp_arrival_time_frac,
- WebRtc_UWord32& remote_sr) {
+int32_t ModuleRtpRtcpImpl::LastReceivedNTP(
+ uint32_t& rtcp_arrival_time_secs, // When we got the last report.
+ uint32_t& rtcp_arrival_time_frac,
+ uint32_t& remote_sr) {
// Remote SR: NTP inside the last received (mid 16 bits from sec and frac).
- WebRtc_UWord32 ntp_secs = 0;
- WebRtc_UWord32 ntp_frac = 0;
+ uint32_t ntp_secs = 0;
+ uint32_t ntp_frac = 0;
if (-1 == rtcp_receiver_.NTP(&ntp_secs,
&ntp_frac,
@@ -2057,8 +2055,8 @@
}
// Called from RTCPsender.
-WebRtc_Word32 ModuleRtpRtcpImpl::BoundingSet(bool& tmmbr_owner,
- TMMBRSet*& bounding_set) {
+int32_t ModuleRtpRtcpImpl::BoundingSet(bool& tmmbr_owner,
+ TMMBRSet*& bounding_set) {
return rtcp_receiver_.BoundingSet(tmmbr_owner, bounding_set);
}
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index b15b9aa..3d0be8b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -36,153 +36,152 @@
// Returns the number of milliseconds until the module want a worker thread to
// call Process.
- virtual WebRtc_Word32 TimeUntilNextProcess();
+ virtual int32_t TimeUntilNextProcess();
// Process any pending tasks such as timeouts.
- virtual WebRtc_Word32 Process();
+ virtual int32_t Process();
// Receiver part.
// Configure a timeout value.
- virtual WebRtc_Word32 SetPacketTimeout(const WebRtc_UWord32 rtp_timeout_ms,
- const WebRtc_UWord32 rtcp_timeout_ms);
+ virtual int32_t SetPacketTimeout(const uint32_t rtp_timeout_ms,
+ const uint32_t rtcp_timeout_ms);
// Set periodic dead or alive notification.
- virtual WebRtc_Word32 SetPeriodicDeadOrAliveStatus(
+ virtual int32_t SetPeriodicDeadOrAliveStatus(
const bool enable,
- const WebRtc_UWord8 sample_time_seconds);
+ const uint8_t sample_time_seconds);
// Get periodic dead or alive notification status.
- virtual WebRtc_Word32 PeriodicDeadOrAliveStatus(
+ virtual int32_t PeriodicDeadOrAliveStatus(
bool& enable,
- WebRtc_UWord8& sample_time_seconds);
+ uint8_t& sample_time_seconds);
- virtual WebRtc_Word32 RegisterReceivePayload(const CodecInst& voice_codec);
+ virtual int32_t RegisterReceivePayload(const CodecInst& voice_codec);
- virtual WebRtc_Word32 RegisterReceivePayload(const VideoCodec& video_codec);
+ virtual int32_t RegisterReceivePayload(const VideoCodec& video_codec);
- virtual WebRtc_Word32 ReceivePayloadType(const CodecInst& voice_codec,
- WebRtc_Word8* pl_type);
+ virtual int32_t ReceivePayloadType(const CodecInst& voice_codec,
+ int8_t* pl_type);
- virtual WebRtc_Word32 ReceivePayloadType(const VideoCodec& video_codec,
- WebRtc_Word8* pl_type);
+ virtual int32_t ReceivePayloadType(const VideoCodec& video_codec,
+ int8_t* pl_type);
- virtual WebRtc_Word32 DeRegisterReceivePayload(
- const WebRtc_Word8 payload_type);
+ virtual int32_t DeRegisterReceivePayload(
+ const int8_t payload_type);
// Register RTP header extension.
- virtual WebRtc_Word32 RegisterReceiveRtpHeaderExtension(
+ virtual int32_t RegisterReceiveRtpHeaderExtension(
const RTPExtensionType type,
- const WebRtc_UWord8 id);
+ const uint8_t id);
- virtual WebRtc_Word32 DeregisterReceiveRtpHeaderExtension(
+ virtual int32_t DeregisterReceiveRtpHeaderExtension(
const RTPExtensionType type);
// Get the currently configured SSRC filter.
- virtual WebRtc_Word32 SSRCFilter(WebRtc_UWord32& allowed_ssrc) const;
+ virtual int32_t SSRCFilter(uint32_t& allowed_ssrc) const;
// Set a SSRC to be used as a filter for incoming RTP streams.
- virtual WebRtc_Word32 SetSSRCFilter(const bool enable,
- const WebRtc_UWord32 allowed_ssrc);
+ virtual int32_t SetSSRCFilter(const bool enable,
+ const uint32_t allowed_ssrc);
// Get last received remote timestamp.
- virtual WebRtc_UWord32 RemoteTimestamp() const;
+ virtual uint32_t RemoteTimestamp() const;
// Get the local time of the last received remote timestamp.
virtual int64_t LocalTimeOfRemoteTimeStamp() const;
// Get the current estimated remote timestamp.
- virtual WebRtc_Word32 EstimatedRemoteTimeStamp(
- WebRtc_UWord32& timestamp) const;
+ virtual int32_t EstimatedRemoteTimeStamp(
+ uint32_t& timestamp) const;
- virtual WebRtc_UWord32 RemoteSSRC() const;
+ virtual uint32_t RemoteSSRC() const;
- virtual WebRtc_Word32 RemoteCSRCs(
- WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const;
+ virtual int32_t RemoteCSRCs(
+ uint32_t arr_of_csrc[kRtpCsrcSize]) const;
- virtual WebRtc_Word32 SetRTXReceiveStatus(const bool enable,
- const WebRtc_UWord32 ssrc);
+ virtual int32_t SetRTXReceiveStatus(const bool enable,
+ const uint32_t ssrc);
- virtual WebRtc_Word32 RTXReceiveStatus(bool* enable,
- WebRtc_UWord32* ssrc) const;
+ virtual int32_t RTXReceiveStatus(bool* enable,
+ uint32_t* ssrc) const;
// Called by the network module when we receive a packet.
- virtual WebRtc_Word32 IncomingPacket(const WebRtc_UWord8* incoming_packet,
- const WebRtc_UWord16 packet_length);
+ virtual int32_t IncomingPacket(const uint8_t* incoming_packet,
+ const uint16_t packet_length);
// Sender part.
- virtual WebRtc_Word32 RegisterSendPayload(const CodecInst& voice_codec);
+ virtual int32_t RegisterSendPayload(const CodecInst& voice_codec);
- virtual WebRtc_Word32 RegisterSendPayload(const VideoCodec& video_codec);
+ virtual int32_t RegisterSendPayload(const VideoCodec& video_codec);
- virtual WebRtc_Word32 DeRegisterSendPayload(const WebRtc_Word8 payload_type);
+ virtual int32_t DeRegisterSendPayload(const int8_t payload_type);
- virtual WebRtc_Word8 SendPayloadType() const;
+ virtual int8_t SendPayloadType() const;
// Register RTP header extension.
- virtual WebRtc_Word32 RegisterSendRtpHeaderExtension(
+ virtual int32_t RegisterSendRtpHeaderExtension(
const RTPExtensionType type,
- const WebRtc_UWord8 id);
+ const uint8_t id);
- virtual WebRtc_Word32 DeregisterSendRtpHeaderExtension(
+ virtual int32_t DeregisterSendRtpHeaderExtension(
const RTPExtensionType type);
// Get start timestamp.
- virtual WebRtc_UWord32 StartTimestamp() const;
+ virtual uint32_t StartTimestamp() const;
// Configure start timestamp, default is a random number.
- virtual WebRtc_Word32 SetStartTimestamp(const WebRtc_UWord32 timestamp);
+ virtual int32_t SetStartTimestamp(const uint32_t timestamp);
- virtual WebRtc_UWord16 SequenceNumber() const;
+ virtual uint16_t SequenceNumber() const;
// Set SequenceNumber, default is a random number.
- virtual WebRtc_Word32 SetSequenceNumber(const WebRtc_UWord16 seq);
+ virtual int32_t SetSequenceNumber(const uint16_t seq);
- virtual WebRtc_UWord32 SSRC() const;
+ virtual uint32_t SSRC() const;
// Configure SSRC, default is a random number.
- virtual WebRtc_Word32 SetSSRC(const WebRtc_UWord32 ssrc);
+ virtual int32_t SetSSRC(const uint32_t ssrc);
- virtual WebRtc_Word32 CSRCs(WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const;
+ virtual int32_t CSRCs(uint32_t arr_of_csrc[kRtpCsrcSize]) const;
- virtual WebRtc_Word32 SetCSRCs(const WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize],
- const WebRtc_UWord8 arr_length);
+ virtual int32_t SetCSRCs(const uint32_t arr_of_csrc[kRtpCsrcSize],
+ const uint8_t arr_length);
- virtual WebRtc_Word32 SetCSRCStatus(const bool include);
+ virtual int32_t SetCSRCStatus(const bool include);
- virtual WebRtc_UWord32 PacketCountSent() const;
+ virtual uint32_t PacketCountSent() const;
virtual int CurrentSendFrequencyHz() const;
- virtual WebRtc_UWord32 ByteCountSent() const;
+ virtual uint32_t ByteCountSent() const;
- virtual WebRtc_Word32 SetRTXSendStatus(const RtxMode mode,
- const bool set_ssrc,
- const WebRtc_UWord32 ssrc);
+ virtual int32_t SetRTXSendStatus(const RtxMode mode,
+ const bool set_ssrc,
+ const uint32_t ssrc);
- virtual WebRtc_Word32 RTXSendStatus(RtxMode* mode,
- WebRtc_UWord32* ssrc) const;
+ virtual int32_t RTXSendStatus(RtxMode* mode, uint32_t* ssrc) const;
// Sends kRtcpByeCode when going from true to false.
- virtual WebRtc_Word32 SetSendingStatus(const bool sending);
+ virtual int32_t SetSendingStatus(const bool sending);
virtual bool Sending() const;
// Drops or relays media packets.
- virtual WebRtc_Word32 SetSendingMediaStatus(const bool sending);
+ virtual int32_t SetSendingMediaStatus(const bool sending);
virtual bool SendingMedia() const;
// Used by the codec module to deliver a video or audio frame for
// packetization.
- virtual WebRtc_Word32 SendOutgoingData(
+ virtual int32_t SendOutgoingData(
const FrameType frame_type,
- const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 time_stamp,
+ const int8_t payload_type,
+ const uint32_t time_stamp,
int64_t capture_time_ms,
- const WebRtc_UWord8* payload_data,
- const WebRtc_UWord32 payload_size,
+ const uint8_t* payload_data,
+ const uint32_t payload_size,
const RTPFragmentationHeader* fragmentation = NULL,
const RTPVideoHeader* rtp_video_hdr = NULL);
@@ -194,117 +193,117 @@
virtual RTCPMethod RTCP() const;
// Configure RTCP status i.e on/off.
- virtual WebRtc_Word32 SetRTCPStatus(const RTCPMethod method);
+ virtual int32_t SetRTCPStatus(const RTCPMethod method);
// Set RTCP CName.
- virtual WebRtc_Word32 SetCNAME(const char c_name[RTCP_CNAME_SIZE]);
+ virtual int32_t SetCNAME(const char c_name[RTCP_CNAME_SIZE]);
// Get RTCP CName.
- virtual WebRtc_Word32 CNAME(char c_name[RTCP_CNAME_SIZE]);
+ virtual int32_t CNAME(char c_name[RTCP_CNAME_SIZE]);
// Get remote CName.
- virtual WebRtc_Word32 RemoteCNAME(const WebRtc_UWord32 remote_ssrc,
- char c_name[RTCP_CNAME_SIZE]) const;
+ virtual int32_t RemoteCNAME(const uint32_t remote_ssrc,
+ char c_name[RTCP_CNAME_SIZE]) const;
// Get remote NTP.
- virtual WebRtc_Word32 RemoteNTP(WebRtc_UWord32* received_ntp_secs,
- WebRtc_UWord32* received_ntp_frac,
- WebRtc_UWord32* rtcp_arrival_time_secs,
- WebRtc_UWord32* rtcp_arrival_time_frac,
- WebRtc_UWord32* rtcp_timestamp) const;
+ virtual int32_t RemoteNTP(uint32_t* received_ntp_secs,
+ uint32_t* received_ntp_frac,
+ uint32_t* rtcp_arrival_time_secs,
+ uint32_t* rtcp_arrival_time_frac,
+ uint32_t* rtcp_timestamp) const;
- virtual WebRtc_Word32 AddMixedCNAME(const WebRtc_UWord32 ssrc,
- const char c_name[RTCP_CNAME_SIZE]);
+ virtual int32_t AddMixedCNAME(const uint32_t ssrc,
+ const char c_name[RTCP_CNAME_SIZE]);
- virtual WebRtc_Word32 RemoveMixedCNAME(const WebRtc_UWord32 ssrc);
+ virtual int32_t RemoveMixedCNAME(const uint32_t ssrc);
// Get RoundTripTime.
- virtual WebRtc_Word32 RTT(const WebRtc_UWord32 remote_ssrc,
- WebRtc_UWord16* rtt,
- WebRtc_UWord16* avg_rtt,
- WebRtc_UWord16* min_rtt,
- WebRtc_UWord16* max_rtt) const;
+ virtual int32_t RTT(const uint32_t remote_ssrc,
+ uint16_t* rtt,
+ uint16_t* avg_rtt,
+ uint16_t* min_rtt,
+ uint16_t* max_rtt) const;
// Reset RoundTripTime statistics.
- virtual WebRtc_Word32 ResetRTT(const WebRtc_UWord32 remote_ssrc);
+ virtual int32_t ResetRTT(const uint32_t remote_ssrc);
virtual void SetRtt(uint32_t rtt);
// Force a send of an RTCP packet.
// Normal SR and RR are triggered via the process function.
- virtual WebRtc_Word32 SendRTCP(WebRtc_UWord32 rtcp_packet_type = kRtcpReport);
+ virtual int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport);
// Statistics of our locally created statistics of the received RTP stream.
- virtual WebRtc_Word32 StatisticsRTP(WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter,
- WebRtc_UWord32* max_jitter = NULL) const;
+ virtual int32_t StatisticsRTP(uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter,
+ uint32_t* max_jitter = NULL) const;
// Reset RTP statistics.
- virtual WebRtc_Word32 ResetStatisticsRTP();
+ virtual int32_t ResetStatisticsRTP();
- virtual WebRtc_Word32 ResetReceiveDataCountersRTP();
+ virtual int32_t ResetReceiveDataCountersRTP();
- virtual WebRtc_Word32 ResetSendDataCountersRTP();
+ virtual int32_t ResetSendDataCountersRTP();
// Statistics of the amount of data sent and received.
- virtual WebRtc_Word32 DataCountersRTP(WebRtc_UWord32* bytes_sent,
- WebRtc_UWord32* packets_sent,
- WebRtc_UWord32* bytes_received,
- WebRtc_UWord32* packets_received) const;
+ virtual int32_t DataCountersRTP(uint32_t* bytes_sent,
+ uint32_t* packets_sent,
+ uint32_t* bytes_received,
+ uint32_t* packets_received) const;
- virtual WebRtc_Word32 ReportBlockStatistics(
- WebRtc_UWord8* fraction_lost,
- WebRtc_UWord32* cum_lost,
- WebRtc_UWord32* ext_max,
- WebRtc_UWord32* jitter,
- WebRtc_UWord32* jitter_transmission_time_offset);
+ virtual int32_t ReportBlockStatistics(
+ uint8_t* fraction_lost,
+ uint32_t* cum_lost,
+ uint32_t* ext_max,
+ uint32_t* jitter,
+ uint32_t* jitter_transmission_time_offset);
// Get received RTCP report, sender info.
- virtual WebRtc_Word32 RemoteRTCPStat(RTCPSenderInfo* sender_info);
+ virtual int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info);
// Get received RTCP report, report block.
- virtual WebRtc_Word32 RemoteRTCPStat(
+ virtual int32_t RemoteRTCPStat(
std::vector<RTCPReportBlock>* receive_blocks) const;
// Set received RTCP report block.
- virtual WebRtc_Word32 AddRTCPReportBlock(
- const WebRtc_UWord32 ssrc, const RTCPReportBlock* receive_block);
+ virtual int32_t AddRTCPReportBlock(
+ const uint32_t ssrc, const RTCPReportBlock* receive_block);
- virtual WebRtc_Word32 RemoveRTCPReportBlock(const WebRtc_UWord32 ssrc);
+ virtual int32_t RemoveRTCPReportBlock(const uint32_t ssrc);
// (REMB) Receiver Estimated Max Bitrate.
virtual bool REMB() const;
- virtual WebRtc_Word32 SetREMBStatus(const bool enable);
+ virtual int32_t SetREMBStatus(const bool enable);
- virtual WebRtc_Word32 SetREMBData(const WebRtc_UWord32 bitrate,
- const WebRtc_UWord8 number_of_ssrc,
- const WebRtc_UWord32* ssrc);
+ virtual int32_t SetREMBData(const uint32_t bitrate,
+ const uint8_t number_of_ssrc,
+ const uint32_t* ssrc);
// (IJ) Extended jitter report.
virtual bool IJ() const;
- virtual WebRtc_Word32 SetIJStatus(const bool enable);
+ virtual int32_t SetIJStatus(const bool enable);
// (TMMBR) Temporary Max Media Bit Rate.
virtual bool TMMBR() const;
- virtual WebRtc_Word32 SetTMMBRStatus(const bool enable);
+ virtual int32_t SetTMMBRStatus(const bool enable);
- WebRtc_Word32 SetTMMBN(const TMMBRSet* bounding_set);
+ int32_t SetTMMBN(const TMMBRSet* bounding_set);
- virtual WebRtc_UWord16 MaxPayloadLength() const;
+ virtual uint16_t MaxPayloadLength() const;
- virtual WebRtc_UWord16 MaxDataPayloadLength() const;
+ virtual uint16_t MaxDataPayloadLength() const;
- virtual WebRtc_Word32 SetMaxTransferUnit(const WebRtc_UWord16 size);
+ virtual int32_t SetMaxTransferUnit(const uint16_t size);
- virtual WebRtc_Word32 SetTransportOverhead(
+ virtual int32_t SetTransportOverhead(
const bool tcp,
const bool ipv6,
- const WebRtc_UWord8 authentication_overhead = 0);
+ const uint8_t authentication_overhead = 0);
// (NACK) Negative acknowledgment part.
@@ -312,38 +311,37 @@
virtual NACKMethod NACK() const;
// Turn negative acknowledgment requests on/off.
- virtual WebRtc_Word32 SetNACKStatus(const NACKMethod method,
- int max_reordering_threshold);
+ virtual int32_t SetNACKStatus(const NACKMethod method,
+ int max_reordering_threshold);
virtual int SelectiveRetransmissions() const;
virtual int SetSelectiveRetransmissions(uint8_t settings);
// Send a Negative acknowledgment packet.
- virtual WebRtc_Word32 SendNACK(const WebRtc_UWord16* nack_list,
- const WebRtc_UWord16 size);
+ virtual int32_t SendNACK(const uint16_t* nack_list, const uint16_t size);
// Store the sent packets, needed to answer to a negative acknowledgment
// requests.
- virtual WebRtc_Word32 SetStorePacketsStatus(
- const bool enable, const WebRtc_UWord16 number_to_store);
+ virtual int32_t SetStorePacketsStatus(
+ const bool enable, const uint16_t number_to_store);
// (APP) Application specific data.
- virtual WebRtc_Word32 SetRTCPApplicationSpecificData(
- const WebRtc_UWord8 sub_type,
- const WebRtc_UWord32 name,
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 length);
+ virtual int32_t SetRTCPApplicationSpecificData(
+ const uint8_t sub_type,
+ const uint32_t name,
+ const uint8_t* data,
+ const uint16_t length);
// (XR) VOIP metric.
- virtual WebRtc_Word32 SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric);
+ virtual int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric);
// Audio part.
// Set audio packet size, used to determine when it's time to send a DTMF
// packet in silence (CNG).
- virtual WebRtc_Word32 SetAudioPacketSize(
- const WebRtc_UWord16 packet_size_samples);
+ virtual int32_t SetAudioPacketSize(
+ const uint16_t packet_size_samples);
// Forward DTMFs to decoder for playout.
virtual int SetTelephoneEventForwardToDecoder(bool forward_to_decoder);
@@ -351,30 +349,30 @@
// Is forwarding of outband telephone events turned on/off?
virtual bool TelephoneEventForwardToDecoder() const;
- virtual bool SendTelephoneEventActive(WebRtc_Word8& telephone_event) const;
+ virtual bool SendTelephoneEventActive(int8_t& telephone_event) const;
// Send a TelephoneEvent tone using RFC 2833 (4733).
- virtual WebRtc_Word32 SendTelephoneEventOutband(const WebRtc_UWord8 key,
- const WebRtc_UWord16 time_ms,
- const WebRtc_UWord8 level);
+ virtual int32_t SendTelephoneEventOutband(const uint8_t key,
+ const uint16_t time_ms,
+ const uint8_t level);
// Set payload type for Redundant Audio Data RFC 2198.
- virtual WebRtc_Word32 SetSendREDPayloadType(const WebRtc_Word8 payload_type);
+ virtual int32_t SetSendREDPayloadType(const int8_t payload_type);
// Get payload type for Redundant Audio Data RFC 2198.
- virtual WebRtc_Word32 SendREDPayloadType(WebRtc_Word8& payload_type) const;
+ virtual int32_t SendREDPayloadType(int8_t& payload_type) const;
// Set status and id for header-extension-for-audio-level-indication.
- virtual WebRtc_Word32 SetRTPAudioLevelIndicationStatus(
- const bool enable, const WebRtc_UWord8 id);
+ virtual int32_t SetRTPAudioLevelIndicationStatus(
+ const bool enable, const uint8_t id);
// Get status and id for header-extension-for-audio-level-indication.
- virtual WebRtc_Word32 GetRTPAudioLevelIndicationStatus(
- bool& enable, WebRtc_UWord8& id) const;
+ virtual int32_t GetRTPAudioLevelIndicationStatus(
+ bool& enable, uint8_t& id) const;
// Store the audio level in d_bov for header-extension-for-audio-level-
// indication.
- virtual WebRtc_Word32 SetAudioLevel(const WebRtc_UWord8 level_d_bov);
+ virtual int32_t SetAudioLevel(const uint8_t level_d_bov);
// Video part.
@@ -382,53 +380,52 @@
virtual RtpVideoCodecTypes SendVideoCodec() const;
- virtual WebRtc_Word32 SendRTCPSliceLossIndication(
- const WebRtc_UWord8 picture_id);
+ virtual int32_t SendRTCPSliceLossIndication(
+ const uint8_t picture_id);
// Set method for requestion a new key frame.
- virtual WebRtc_Word32 SetKeyFrameRequestMethod(
+ virtual int32_t SetKeyFrameRequestMethod(
const KeyFrameRequestMethod method);
// Send a request for a keyframe.
- virtual WebRtc_Word32 RequestKeyFrame();
+ virtual int32_t RequestKeyFrame();
- virtual WebRtc_Word32 SetCameraDelay(const WebRtc_Word32 delay_ms);
+ virtual int32_t SetCameraDelay(const int32_t delay_ms);
- virtual void SetTargetSendBitrate(const WebRtc_UWord32 bitrate);
+ virtual void SetTargetSendBitrate(const uint32_t bitrate);
- virtual WebRtc_Word32 SetGenericFECStatus(
+ virtual int32_t SetGenericFECStatus(
const bool enable,
- const WebRtc_UWord8 payload_type_red,
- const WebRtc_UWord8 payload_type_fec);
+ const uint8_t payload_type_red,
+ const uint8_t payload_type_fec);
- virtual WebRtc_Word32 GenericFECStatus(
+ virtual int32_t GenericFECStatus(
bool& enable,
- WebRtc_UWord8& payload_type_red,
- WebRtc_UWord8& payload_type_fec);
+ uint8_t& payload_type_red,
+ uint8_t& payload_type_fec);
- virtual WebRtc_Word32 SetFecParameters(
+ virtual int32_t SetFecParameters(
const FecProtectionParams* delta_params,
const FecProtectionParams* key_params);
- virtual WebRtc_Word32 LastReceivedNTP(WebRtc_UWord32& NTPsecs,
- WebRtc_UWord32& NTPfrac,
- WebRtc_UWord32& remote_sr);
+ virtual int32_t LastReceivedNTP(uint32_t& NTPsecs,
+ uint32_t& NTPfrac,
+ uint32_t& remote_sr);
- virtual WebRtc_Word32 BoundingSet(bool& tmmbr_owner,
- TMMBRSet*& bounding_set_rec);
+ virtual int32_t BoundingSet(bool& tmmbr_owner, TMMBRSet*& bounding_set_rec);
- virtual void BitrateSent(WebRtc_UWord32* total_rate,
- WebRtc_UWord32* video_rate,
- WebRtc_UWord32* fec_rate,
- WebRtc_UWord32* nackRate) const;
+ virtual void BitrateSent(uint32_t* total_rate,
+ uint32_t* video_rate,
+ uint32_t* fec_rate,
+ uint32_t* nackRate) const;
- virtual void SetRemoteSSRC(const WebRtc_UWord32 ssrc);
+ virtual void SetRemoteSSRC(const uint32_t ssrc);
- virtual WebRtc_UWord32 SendTimeOfSendReport(const WebRtc_UWord32 send_report);
+ virtual uint32_t SendTimeOfSendReport(const uint32_t send_report);
// Good state of RTP receiver inform sender.
- virtual WebRtc_Word32 SendRTCPReferencePictureSelection(
- const WebRtc_UWord64 picture_id);
+ virtual int32_t SendRTCPReferencePictureSelection(
+ const uint64_t picture_id);
void OnReceivedTMMBR();
@@ -436,11 +433,11 @@
void OnRequestIntraFrame();
// Received a request for a new SLI.
- void OnReceivedSliceLossIndication(const WebRtc_UWord8 picture_id);
+ void OnReceivedSliceLossIndication(const uint8_t picture_id);
// Received a new reference frame.
void OnReceivedReferencePictureSelectionIndication(
- const WebRtc_UWord64 picture_id);
+ const uint64_t picture_id);
void OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers);
@@ -455,13 +452,13 @@
void ProcessDeadOrAliveTimer();
- WebRtc_UWord32 BitrateReceivedNow() const;
+ uint32_t BitrateReceivedNow() const;
// Get remote SequenceNumber.
- WebRtc_UWord16 RemoteSequenceNumber() const;
+ uint16_t RemoteSequenceNumber() const;
// Only for internal testing.
- WebRtc_UWord32 LastSendReport(WebRtc_UWord32& last_rtcptime);
+ uint32_t LastSendReport(uint32_t& last_rtcptime);
RTPPayloadRegistry rtp_payload_registry_;
@@ -478,14 +475,14 @@
RTPReceiverAudio* rtp_telephone_event_handler_;
- WebRtc_Word32 id_;
+ int32_t id_;
const bool audio_;
bool collision_detected_;
- WebRtc_Word64 last_process_time_;
- WebRtc_Word64 last_bitrate_process_time_;
- WebRtc_Word64 last_packet_timeout_process_time_;
- WebRtc_Word64 last_rtt_process_time_;
- WebRtc_UWord16 packet_overhead_;
+ int64_t last_process_time_;
+ int64_t last_bitrate_process_time_;
+ int64_t last_packet_timeout_process_time_;
+ int64_t last_rtt_process_time_;
+ uint16_t packet_overhead_;
scoped_ptr<CriticalSectionWrapper> critical_section_module_ptrs_;
scoped_ptr<CriticalSectionWrapper> critical_section_module_ptrs_feedback_;
@@ -494,12 +491,12 @@
// Dead or alive.
bool dead_or_alive_active_;
- WebRtc_UWord32 dead_or_alive_timeout_ms_;
- WebRtc_Word64 dead_or_alive_last_timer_;
+ uint32_t dead_or_alive_timeout_ms_;
+ int64_t dead_or_alive_last_timer_;
// Send side
NACKMethod nack_method_;
- WebRtc_UWord32 nack_last_time_sent_full_;
- WebRtc_UWord16 nack_last_seq_number_sent_;
+ uint32_t nack_last_time_sent_full_;
+ uint16_t nack_last_seq_number_sent_;
bool simulcast_;
VideoCodec send_video_codec_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 2b43af1..9c5cfe0 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -21,7 +21,7 @@
namespace webrtc {
-RTPSender::RTPSender(const WebRtc_Word32 id, const bool audio, Clock *clock,
+RTPSender::RTPSender(const int32_t id, const bool audio, Clock *clock,
Transport *transport, RtpAudioFeedback *audio_feedback,
PacedSender *paced_sender)
: Bitrate(clock), id_(id), audio_configured_(audio), audio_(NULL),
@@ -45,7 +45,7 @@
memset(nack_byte_count_, 0, sizeof(nack_byte_count_));
memset(csrc_, 0, sizeof(csrc_));
// We need to seed the random generator.
- srand(static_cast<WebRtc_UWord32>(clock_->TimeInMilliseconds()));
+ srand(static_cast<uint32_t>(clock_->TimeInMilliseconds()));
ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0.
ssrc_rtx_ = ssrc_db_.CreateSSRC(); // Can't be 0.
// Random start, 16 bits. Can't be 0.
@@ -70,7 +70,7 @@
SSRCDatabase::ReturnSSRCDatabase();
delete send_critsect_;
while (!payload_type_map_.empty()) {
- std::map<WebRtc_Word8, ModuleRTPUtility::Payload *>::iterator it =
+ std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
payload_type_map_.begin();
delete it->second;
payload_type_map_.erase(it);
@@ -82,34 +82,34 @@
WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id_, "%s deleted", __FUNCTION__);
}
-void RTPSender::SetTargetSendBitrate(const WebRtc_UWord32 bits) {
+void RTPSender::SetTargetSendBitrate(const uint32_t bits) {
target_send_bitrate_ = static_cast<uint16_t>(bits / 1000);
}
-WebRtc_UWord16 RTPSender::ActualSendBitrateKbit() const {
- return (WebRtc_UWord16)(Bitrate::BitrateNow() / 1000);
+uint16_t RTPSender::ActualSendBitrateKbit() const {
+ return (uint16_t)(Bitrate::BitrateNow() / 1000);
}
-WebRtc_UWord32 RTPSender::VideoBitrateSent() const {
+uint32_t RTPSender::VideoBitrateSent() const {
if (video_) {
return video_->VideoBitrateSent();
}
return 0;
}
-WebRtc_UWord32 RTPSender::FecOverheadRate() const {
+uint32_t RTPSender::FecOverheadRate() const {
if (video_) {
return video_->FecOverheadRate();
}
return 0;
}
-WebRtc_UWord32 RTPSender::NackOverheadRate() const {
+uint32_t RTPSender::NackOverheadRate() const {
return nack_bitrate_.BitrateLast();
}
-WebRtc_Word32 RTPSender::SetTransmissionTimeOffset(
- const WebRtc_Word32 transmission_time_offset) {
+int32_t RTPSender::SetTransmissionTimeOffset(
+ const int32_t transmission_time_offset) {
if (transmission_time_offset > (0x800000 - 1) ||
transmission_time_offset < -(0x800000 - 1)) { // Word24.
return -1;
@@ -119,31 +119,31 @@
return 0;
}
-WebRtc_Word32 RTPSender::RegisterRtpHeaderExtension(const RTPExtensionType type,
- const WebRtc_UWord8 id) {
+int32_t RTPSender::RegisterRtpHeaderExtension(const RTPExtensionType type,
+ const uint8_t id) {
CriticalSectionScoped cs(send_critsect_);
return rtp_header_extension_map_.Register(type, id);
}
-WebRtc_Word32 RTPSender::DeregisterRtpHeaderExtension(
+int32_t RTPSender::DeregisterRtpHeaderExtension(
const RTPExtensionType type) {
CriticalSectionScoped cs(send_critsect_);
return rtp_header_extension_map_.Deregister(type);
}
-WebRtc_UWord16 RTPSender::RtpHeaderExtensionTotalLength() const {
+uint16_t RTPSender::RtpHeaderExtensionTotalLength() const {
CriticalSectionScoped cs(send_critsect_);
return rtp_header_extension_map_.GetTotalLengthInBytes();
}
-WebRtc_Word32 RTPSender::RegisterPayload(
+int32_t RTPSender::RegisterPayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_number, const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels, const WebRtc_UWord32 rate) {
+ const int8_t payload_number, const uint32_t frequency,
+ const uint8_t channels, const uint32_t rate) {
assert(payload_name);
CriticalSectionScoped cs(send_critsect_);
- std::map<WebRtc_Word8, ModuleRTPUtility::Payload *>::iterator it =
+ std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
payload_type_map_.find(payload_number);
if (payload_type_map_.end() != it) {
@@ -168,7 +168,7 @@
}
return -1;
}
- WebRtc_Word32 ret_val = -1;
+ int32_t ret_val = -1;
ModuleRTPUtility::Payload *payload = NULL;
if (audio_configured_) {
ret_val = audio_->RegisterAudioPayload(payload_name, payload_number,
@@ -183,11 +183,11 @@
return ret_val;
}
-WebRtc_Word32 RTPSender::DeRegisterSendPayload(
- const WebRtc_Word8 payload_type) {
+int32_t RTPSender::DeRegisterSendPayload(
+ const int8_t payload_type) {
CriticalSectionScoped lock(send_critsect_);
- std::map<WebRtc_Word8, ModuleRTPUtility::Payload *>::iterator it =
+ std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
payload_type_map_.find(payload_type);
if (payload_type_map_.end() == it) {
@@ -199,13 +199,13 @@
return 0;
}
-WebRtc_Word8 RTPSender::SendPayloadType() const { return payload_type_; }
+int8_t RTPSender::SendPayloadType() const { return payload_type_; }
int RTPSender::SendPayloadFrequency() const { return audio_->AudioFrequency(); }
-WebRtc_Word32 RTPSender::SetMaxPayloadLength(
- const WebRtc_UWord16 max_payload_length,
- const WebRtc_UWord16 packet_over_head) {
+int32_t RTPSender::SetMaxPayloadLength(
+ const uint16_t max_payload_length,
+ const uint16_t packet_over_head) {
// Sanity check.
if (max_payload_length < 100 || max_payload_length > IP_PACKET_SIZE) {
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_, "%s invalid argument",
@@ -221,7 +221,7 @@
return 0;
}
-WebRtc_UWord16 RTPSender::MaxDataPayloadLength() const {
+uint16_t RTPSender::MaxDataPayloadLength() const {
if (audio_configured_) {
return max_payload_length_ - RTPHeaderLength();
} else {
@@ -231,14 +231,14 @@
}
}
-WebRtc_UWord16 RTPSender::MaxPayloadLength() const {
+uint16_t RTPSender::MaxPayloadLength() const {
return max_payload_length_;
}
-WebRtc_UWord16 RTPSender::PacketOverHead() const { return packet_over_head_; }
+uint16_t RTPSender::PacketOverHead() const { return packet_over_head_; }
void RTPSender::SetRTXStatus(const RtxMode mode, const bool set_ssrc,
- const WebRtc_UWord32 ssrc) {
+ const uint32_t ssrc) {
CriticalSectionScoped cs(send_critsect_);
rtx_ = mode;
if (rtx_ != kRtxOff) {
@@ -250,14 +250,14 @@
}
}
-void RTPSender::RTXStatus(RtxMode* mode, WebRtc_UWord32 *SSRC) const {
+void RTPSender::RTXStatus(RtxMode* mode, uint32_t *SSRC) const {
CriticalSectionScoped cs(send_critsect_);
*mode = rtx_;
*SSRC = ssrc_rtx_;
}
-WebRtc_Word32 RTPSender::CheckPayloadType(const WebRtc_Word8 payload_type,
- RtpVideoCodecTypes *video_type) {
+int32_t RTPSender::CheckPayloadType(const int8_t payload_type,
+ RtpVideoCodecTypes *video_type) {
CriticalSectionScoped cs(send_critsect_);
if (payload_type < 0) {
@@ -266,7 +266,7 @@
return -1;
}
if (audio_configured_) {
- WebRtc_Word8 red_pl_type = -1;
+ int8_t red_pl_type = -1;
if (audio_->RED(red_pl_type) == 0) {
// We have configured RED.
if (red_pl_type == payload_type) {
@@ -281,7 +281,7 @@
}
return 0;
}
- std::map<WebRtc_Word8, ModuleRTPUtility::Payload *>::iterator it =
+ std::map<int8_t, ModuleRTPUtility::Payload *>::iterator it =
payload_type_map_.find(payload_type);
if (it == payload_type_map_.end()) {
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
@@ -299,10 +299,10 @@
return 0;
}
-WebRtc_Word32 RTPSender::SendOutgoingData(
- const FrameType frame_type, const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 capture_timestamp, int64_t capture_time_ms,
- const WebRtc_UWord8 *payload_data, const WebRtc_UWord32 payload_size,
+int32_t RTPSender::SendOutgoingData(
+ const FrameType frame_type, const int8_t payload_type,
+ const uint32_t capture_timestamp, int64_t capture_time_ms,
+ const uint8_t *payload_data, const uint32_t payload_size,
const RTPFragmentationHeader *fragmentation,
VideoCodecInformation *codec_info, const RTPVideoTypeHeader *rtp_type_hdr) {
{
@@ -340,8 +340,8 @@
}
}
-WebRtc_Word32 RTPSender::SendPaddingAccordingToBitrate(
- WebRtc_Word8 payload_type, WebRtc_UWord32 capture_timestamp,
+int32_t RTPSender::SendPaddingAccordingToBitrate(
+ int8_t payload_type, uint32_t capture_timestamp,
int64_t capture_time_ms) {
// Current bitrate since last estimate(1 second) averaged with the
// estimate since then, to get the most up to date bitrate.
@@ -365,16 +365,16 @@
return SendPadData(payload_type, capture_timestamp, capture_time_ms, bytes);
}
-WebRtc_Word32 RTPSender::SendPadData(
- WebRtc_Word8 payload_type, WebRtc_UWord32 capture_timestamp,
- int64_t capture_time_ms, WebRtc_Word32 bytes) {
+int32_t RTPSender::SendPadData(
+ int8_t payload_type, uint32_t capture_timestamp,
+ int64_t capture_time_ms, int32_t bytes) {
// Drop this packet if we're not sending media packets.
if (!sending_media_) {
return 0;
}
// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
int max_length = 224;
- WebRtc_UWord8 data_buffer[IP_PACKET_SIZE];
+ uint8_t data_buffer[IP_PACKET_SIZE];
for (; bytes > 0; bytes -= max_length) {
int padding_bytes_in_packet = max_length;
@@ -391,8 +391,8 @@
capture_timestamp, true, // Timestamp provided.
true); // Increment sequence number.
data_buffer[0] |= 0x20; // Set padding bit.
- WebRtc_Word32 *data =
- reinterpret_cast<WebRtc_Word32 *>(&(data_buffer[header_length]));
+ int32_t *data =
+ reinterpret_cast<int32_t *>(&(data_buffer[header_length]));
// Fill data buffer with random data.
for (int j = 0; j < (padding_bytes_in_packet >> 2); ++j) {
@@ -416,17 +416,16 @@
}
void RTPSender::SetStorePacketsStatus(const bool enable,
- const WebRtc_UWord16 number_to_store) {
+ const uint16_t number_to_store) {
packet_history_->SetStorePacketsStatus(enable, number_to_store);
}
bool RTPSender::StorePackets() const { return packet_history_->StorePackets(); }
-WebRtc_Word32 RTPSender::ReSendPacket(WebRtc_UWord16 packet_id,
- WebRtc_UWord32 min_resend_time) {
- WebRtc_UWord16 length = IP_PACKET_SIZE;
- WebRtc_UWord8 data_buffer[IP_PACKET_SIZE];
- WebRtc_UWord8 *buffer_to_send_ptr = data_buffer;
+int32_t RTPSender::ReSendPacket(uint16_t packet_id, uint32_t min_resend_time) {
+ uint16_t length = IP_PACKET_SIZE;
+ uint8_t data_buffer[IP_PACKET_SIZE];
+ uint8_t *buffer_to_send_ptr = data_buffer;
int64_t stored_time_in_ms;
StorageType type;
@@ -442,13 +441,13 @@
// packet should not be retransmitted.
return 0;
}
- WebRtc_UWord8 data_buffer_rtx[IP_PACKET_SIZE];
+ uint8_t data_buffer_rtx[IP_PACKET_SIZE];
if (rtx_ != kRtxOff) {
BuildRtxPacket(data_buffer, &length, data_buffer_rtx);
buffer_to_send_ptr = data_buffer_rtx;
}
- WebRtc_Word32 bytes_sent = ReSendToNetwork(buffer_to_send_ptr, length);
+ int32_t bytes_sent = ReSendToNetwork(buffer_to_send_ptr, length);
if (bytes_sent <= 0) {
WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
"Transport failed to resend packet_id %u", packet_id);
@@ -459,9 +458,8 @@
return bytes_sent;
}
-WebRtc_Word32 RTPSender::ReSendToNetwork(const WebRtc_UWord8 *packet,
- const WebRtc_UWord32 size) {
- WebRtc_Word32 bytes_sent = -1;
+int32_t RTPSender::ReSendToNetwork(const uint8_t *packet, const uint32_t size) {
+ int32_t bytes_sent = -1;
if (transport_) {
bytes_sent = transport_->SendPacket(id_, packet, size);
}
@@ -491,9 +489,9 @@
void RTPSender::OnReceivedNACK(
const std::list<uint16_t>& nack_sequence_numbers,
- const WebRtc_UWord16 avg_rtt) {
- const WebRtc_Word64 now = clock_->TimeInMilliseconds();
- WebRtc_UWord32 bytes_re_sent = 0;
+ const uint16_t avg_rtt) {
+ const int64_t now = clock_->TimeInMilliseconds();
+ uint32_t bytes_re_sent = 0;
// Enough bandwidth to send NACK?
if (!ProcessNACKBitRate(now)) {
@@ -505,7 +503,7 @@
for (std::list<uint16_t>::const_iterator it = nack_sequence_numbers.begin();
it != nack_sequence_numbers.end(); ++it) {
- const WebRtc_Word32 bytes_sent = ReSendPacket(*it, 5 + avg_rtt);
+ const int32_t bytes_sent = ReSendPacket(*it, 5 + avg_rtt);
if (bytes_sent > 0) {
bytes_re_sent += bytes_sent;
} else if (bytes_sent == 0) {
@@ -522,8 +520,8 @@
// Delay bandwidth estimate (RTT * BW).
if (target_send_bitrate_ != 0 && avg_rtt) {
// kbits/s * ms = bits => bits/8 = bytes
- WebRtc_UWord32 target_bytes =
- (static_cast<WebRtc_UWord32>(target_send_bitrate_) * avg_rtt) >> 3;
+ uint32_t target_bytes =
+ (static_cast<uint32_t>(target_send_bitrate_) * avg_rtt) >> 3;
if (bytes_re_sent > target_bytes) {
break; // Ignore the rest of the packets in the list.
}
@@ -536,10 +534,10 @@
}
}
-bool RTPSender::ProcessNACKBitRate(const WebRtc_UWord32 now) {
- WebRtc_UWord32 num = 0;
- WebRtc_Word32 byte_count = 0;
- const WebRtc_UWord32 avg_interval = 1000;
+bool RTPSender::ProcessNACKBitRate(const uint32_t now) {
+ uint32_t num = 0;
+ int32_t byte_count = 0;
+ const uint32_t avg_interval = 1000;
CriticalSectionScoped cs(send_critsect_);
@@ -554,7 +552,7 @@
byte_count += nack_byte_count_[num];
}
}
- WebRtc_Word32 time_interval = avg_interval;
+ int32_t time_interval = avg_interval;
if (num == NACK_BYTECOUNT_SIZE) {
// More than NACK_BYTECOUNT_SIZE nack messages has been received
// during the last msg_interval.
@@ -566,8 +564,8 @@
return (byte_count * 8) < (target_send_bitrate_ * time_interval);
}
-void RTPSender::UpdateNACKBitRate(const WebRtc_UWord32 bytes,
- const WebRtc_UWord32 now) {
+void RTPSender::UpdateNACKBitRate(const uint32_t bytes,
+ const uint32_t now) {
CriticalSectionScoped cs(send_critsect_);
// Save bitrate statistics.
@@ -635,7 +633,7 @@
}
// TODO(pwestin): send in the RTPHeaderParser to avoid parsing it again.
-WebRtc_Word32 RTPSender::SendToNetwork(
+int32_t RTPSender::SendToNetwork(
uint8_t *buffer, int payload_length, int rtp_header_length,
int64_t capture_time_ms, StorageType storage) {
ModuleRTPUtility::RTPHeaderParser rtp_parser(
@@ -658,11 +656,11 @@
return -1;
}
- WebRtc_Word32 bytes_sent = -1;
+ int32_t bytes_sent = -1;
// Create and send RTX Packet.
if (rtx_ == kRtxAll && storage == kAllowRetransmission) {
- WebRtc_UWord16 length_rtx = payload_length + rtp_header_length;
- WebRtc_UWord8 data_buffer_rtx[IP_PACKET_SIZE];
+ uint16_t length_rtx = payload_length + rtp_header_length;
+ uint8_t data_buffer_rtx[IP_PACKET_SIZE];
BuildRtxPacket(buffer, &length_rtx, data_buffer_rtx);
if (transport_) {
bytes_sent += transport_->SendPacket(id_, data_buffer_rtx, length_rtx);
@@ -711,16 +709,16 @@
video_->ProcessBitrate();
}
-WebRtc_UWord16 RTPSender::RTPHeaderLength() const {
- WebRtc_UWord16 rtp_header_length = 12;
+uint16_t RTPSender::RTPHeaderLength() const {
+ uint16_t rtp_header_length = 12;
if (include_csrcs_) {
- rtp_header_length += sizeof(WebRtc_UWord32) * csrcs_;
+ rtp_header_length += sizeof(uint32_t) * csrcs_;
}
rtp_header_length += RtpHeaderExtensionTotalLength();
return rtp_header_length;
}
-WebRtc_UWord16 RTPSender::IncrementSequenceNumber() {
+uint16_t RTPSender::IncrementSequenceNumber() {
CriticalSectionScoped cs(send_critsect_);
return sequence_number_++;
}
@@ -730,26 +728,26 @@
payload_bytes_sent_ = 0;
}
-WebRtc_UWord32 RTPSender::Packets() const {
+uint32_t RTPSender::Packets() const {
// Don't use critsect to avoid potential deadlock.
return packets_sent_;
}
// Number of sent RTP bytes.
// Don't use critsect to avoid potental deadlock.
-WebRtc_UWord32 RTPSender::Bytes() const {
+uint32_t RTPSender::Bytes() const {
return payload_bytes_sent_;
}
-WebRtc_Word32 RTPSender::BuildRTPheader(
- WebRtc_UWord8 *data_buffer, const WebRtc_Word8 payload_type,
- const bool marker_bit, const WebRtc_UWord32 capture_time_stamp,
+int32_t RTPSender::BuildRTPheader(
+ uint8_t *data_buffer, const int8_t payload_type,
+ const bool marker_bit, const uint32_t capture_time_stamp,
const bool time_stamp_provided, const bool inc_sequence_number) {
assert(payload_type >= 0);
CriticalSectionScoped cs(send_critsect_);
- data_buffer[0] = static_cast<WebRtc_UWord8>(0x80); // version 2.
- data_buffer[1] = static_cast<WebRtc_UWord8>(payload_type);
+ data_buffer[0] = static_cast<uint8_t>(0x80); // version 2.
+ data_buffer[1] = static_cast<uint8_t>(payload_type);
if (marker_bit) {
data_buffer[1] |= kRtpMarkerBitMask; // Marker bit is set.
}
@@ -764,7 +762,7 @@
ModuleRTPUtility::AssignUWord16ToBuffer(data_buffer + 2, sequence_number_);
ModuleRTPUtility::AssignUWord32ToBuffer(data_buffer + 4, time_stamp_);
ModuleRTPUtility::AssignUWord32ToBuffer(data_buffer + 8, ssrc_);
- WebRtc_Word32 rtp_header_length = 12;
+ int32_t rtp_header_length = 12;
// Add the CSRCs if any.
if (include_csrcs_ && csrcs_ > 0) {
@@ -773,19 +771,19 @@
assert(false);
return -1;
}
- WebRtc_UWord8 *ptr = &data_buffer[rtp_header_length];
- for (WebRtc_UWord32 i = 0; i < csrcs_; ++i) {
+ uint8_t *ptr = &data_buffer[rtp_header_length];
+ for (uint32_t i = 0; i < csrcs_; ++i) {
ModuleRTPUtility::AssignUWord32ToBuffer(ptr, csrc_[i]);
ptr += 4;
}
data_buffer[0] = (data_buffer[0] & 0xf0) | csrcs_;
// Update length of header.
- rtp_header_length += sizeof(WebRtc_UWord32) * csrcs_;
+ rtp_header_length += sizeof(uint32_t) * csrcs_;
}
sequence_number_++; // Prepare for next packet.
- WebRtc_UWord16 len = BuildRTPHeaderExtension(data_buffer + rtp_header_length);
+ uint16_t len = BuildRTPHeaderExtension(data_buffer + rtp_header_length);
if (len) {
data_buffer[0] |= 0x10; // Set extension bit.
rtp_header_length += len;
@@ -793,8 +791,8 @@
return rtp_header_length;
}
-WebRtc_UWord16 RTPSender::BuildRTPHeaderExtension(
- WebRtc_UWord8 *data_buffer) const {
+uint16_t RTPSender::BuildRTPHeaderExtension(
+ uint8_t *data_buffer) const {
if (rtp_header_extension_map_.Size() <= 0) {
return 0;
}
@@ -807,19 +805,19 @@
// | header extension |
// | .... |
//
- const WebRtc_UWord32 kPosLength = 2;
- const WebRtc_UWord32 kHeaderLength = RTP_ONE_BYTE_HEADER_LENGTH_IN_BYTES;
+ const uint32_t kPosLength = 2;
+ const uint32_t kHeaderLength = RTP_ONE_BYTE_HEADER_LENGTH_IN_BYTES;
// Add extension ID (0xBEDE).
ModuleRTPUtility::AssignUWord16ToBuffer(data_buffer,
RTP_ONE_BYTE_HEADER_EXTENSION);
// Add extensions.
- WebRtc_UWord16 total_block_length = 0;
+ uint16_t total_block_length = 0;
RTPExtensionType type = rtp_header_extension_map_.First();
while (type != kRtpExtensionNone) {
- WebRtc_UWord8 block_length = 0;
+ uint8_t block_length = 0;
if (type == kRtpExtensionTransmissionTimeOffset) {
block_length = BuildTransmissionTimeOffsetExtension(
data_buffer + kHeaderLength + total_block_length);
@@ -839,8 +837,8 @@
return kHeaderLength + total_block_length;
}
-WebRtc_UWord8 RTPSender::BuildTransmissionTimeOffsetExtension(
- WebRtc_UWord8* data_buffer) const {
+uint8_t RTPSender::BuildTransmissionTimeOffsetExtension(
+ uint8_t* data_buffer) const {
// From RFC 5450: Transmission Time Offsets in RTP Streams.
//
// The transmission time is signaled to the receiver in-band using the
@@ -859,14 +857,14 @@
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// Get id defined by user.
- WebRtc_UWord8 id;
+ uint8_t id;
if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset,
&id) != 0) {
// Not registered.
return 0;
}
int pos = 0;
- const WebRtc_UWord8 len = 2;
+ const uint8_t len = 2;
data_buffer[pos++] = (id << 4) + len;
ModuleRTPUtility::AssignUWord24ToBuffer(data_buffer + pos,
transmission_time_offset_);
@@ -876,8 +874,8 @@
}
bool RTPSender::UpdateTransmissionTimeOffset(
- WebRtc_UWord8 *rtp_packet, const WebRtc_UWord16 rtp_packet_length,
- const WebRtcRTPHeader &rtp_header, const WebRtc_Word64 time_diff_ms) const {
+ uint8_t *rtp_packet, const uint16_t rtp_packet_length,
+ const WebRtcRTPHeader &rtp_header, const int64_t time_diff_ms) const {
CriticalSectionScoped cs(send_critsect_);
// Get length until start of transmission block.
@@ -905,7 +903,7 @@
return false;
}
// Get id.
- WebRtc_UWord8 id = 0;
+ uint8_t id = 0;
if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset,
&id) != 0) {
WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_,
@@ -913,7 +911,7 @@
return false;
}
// Verify first byte in block.
- const WebRtc_UWord8 first_block_byte = (id << 4) + 2;
+ const uint8_t first_block_byte = (id << 4) + 2;
if (rtp_packet[block_pos] != first_block_byte) {
WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_,
"Failed to update transmission time offset.");
@@ -927,9 +925,9 @@
void RTPSender::SetSendingStatus(const bool enabled) {
if (enabled) {
- WebRtc_UWord32 frequency_hz;
+ uint32_t frequency_hz;
if (audio_configured_) {
- WebRtc_UWord32 frequency = audio_->AudioFrequency();
+ uint32_t frequency = audio_->AudioFrequency();
// sanity
switch (frequency) {
@@ -947,8 +945,7 @@
} else {
frequency_hz = kDefaultVideoFrequency;
}
- WebRtc_UWord32 RTPtime = ModuleRTPUtility::GetCurrentRTP(clock_,
- frequency_hz);
+ uint32_t RTPtime = ModuleRTPUtility::GetCurrentRTP(clock_, frequency_hz);
// Will be ignored if it's already configured via API.
SetStartTimestamp(RTPtime, false);
@@ -977,12 +974,12 @@
return sending_media_;
}
-WebRtc_UWord32 RTPSender::Timestamp() const {
+uint32_t RTPSender::Timestamp() const {
CriticalSectionScoped cs(send_critsect_);
return time_stamp_;
}
-void RTPSender::SetStartTimestamp(WebRtc_UWord32 timestamp, bool force) {
+void RTPSender::SetStartTimestamp(uint32_t timestamp, bool force) {
CriticalSectionScoped cs(send_critsect_);
if (force) {
start_time_stamp_forced_ = force;
@@ -994,12 +991,12 @@
}
}
-WebRtc_UWord32 RTPSender::StartTimestamp() const {
+uint32_t RTPSender::StartTimestamp() const {
CriticalSectionScoped cs(send_critsect_);
return start_time_stamp_;
}
-WebRtc_UWord32 RTPSender::GenerateNewSSRC() {
+uint32_t RTPSender::GenerateNewSSRC() {
// If configured via API, return 0.
CriticalSectionScoped cs(send_critsect_);
@@ -1010,7 +1007,7 @@
return ssrc_;
}
-void RTPSender::SetSSRC(WebRtc_UWord32 ssrc) {
+void RTPSender::SetSSRC(uint32_t ssrc) {
// This is configured via the API.
CriticalSectionScoped cs(send_critsect_);
@@ -1027,7 +1024,7 @@
}
}
-WebRtc_UWord32 RTPSender::SSRC() const {
+uint32_t RTPSender::SSRC() const {
CriticalSectionScoped cs(send_critsect_);
return ssrc_;
}
@@ -1036,8 +1033,8 @@
include_csrcs_ = include;
}
-void RTPSender::SetCSRCs(const WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize],
- const WebRtc_UWord8 arr_length) {
+void RTPSender::SetCSRCs(const uint32_t arr_of_csrc[kRtpCsrcSize],
+ const uint8_t arr_length) {
assert(arr_length <= kRtpCsrcSize);
CriticalSectionScoped cs(send_critsect_);
@@ -1047,7 +1044,7 @@
csrcs_ = arr_length;
}
-WebRtc_Word32 RTPSender::CSRCs(WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const {
+int32_t RTPSender::CSRCs(uint32_t arr_of_csrc[kRtpCsrcSize]) const {
assert(arr_of_csrc);
CriticalSectionScoped cs(send_critsect_);
for (int i = 0; i < csrcs_ && i < kRtpCsrcSize; i++) {
@@ -1056,67 +1053,67 @@
return csrcs_;
}
-void RTPSender::SetSequenceNumber(WebRtc_UWord16 seq) {
+void RTPSender::SetSequenceNumber(uint16_t seq) {
CriticalSectionScoped cs(send_critsect_);
sequence_number_forced_ = true;
sequence_number_ = seq;
}
-WebRtc_UWord16 RTPSender::SequenceNumber() const {
+uint16_t RTPSender::SequenceNumber() const {
CriticalSectionScoped cs(send_critsect_);
return sequence_number_;
}
// Audio.
-WebRtc_Word32 RTPSender::SendTelephoneEvent(const WebRtc_UWord8 key,
- const WebRtc_UWord16 time_ms,
- const WebRtc_UWord8 level) {
+int32_t RTPSender::SendTelephoneEvent(const uint8_t key,
+ const uint16_t time_ms,
+ const uint8_t level) {
if (!audio_configured_) {
return -1;
}
return audio_->SendTelephoneEvent(key, time_ms, level);
}
-bool RTPSender::SendTelephoneEventActive(WebRtc_Word8 *telephone_event) const {
+bool RTPSender::SendTelephoneEventActive(int8_t *telephone_event) const {
if (!audio_configured_) {
return false;
}
return audio_->SendTelephoneEventActive(*telephone_event);
}
-WebRtc_Word32 RTPSender::SetAudioPacketSize(
- const WebRtc_UWord16 packet_size_samples) {
+int32_t RTPSender::SetAudioPacketSize(
+ const uint16_t packet_size_samples) {
if (!audio_configured_) {
return -1;
}
return audio_->SetAudioPacketSize(packet_size_samples);
}
-WebRtc_Word32 RTPSender::SetAudioLevelIndicationStatus(const bool enable,
- const WebRtc_UWord8 ID) {
+int32_t RTPSender::SetAudioLevelIndicationStatus(const bool enable,
+ const uint8_t ID) {
if (!audio_configured_) {
return -1;
}
return audio_->SetAudioLevelIndicationStatus(enable, ID);
}
-WebRtc_Word32 RTPSender::AudioLevelIndicationStatus(bool *enable,
- WebRtc_UWord8* id) const {
+int32_t RTPSender::AudioLevelIndicationStatus(bool *enable,
+ uint8_t* id) const {
return audio_->AudioLevelIndicationStatus(*enable, *id);
}
-WebRtc_Word32 RTPSender::SetAudioLevel(const WebRtc_UWord8 level_d_bov) {
+int32_t RTPSender::SetAudioLevel(const uint8_t level_d_bov) {
return audio_->SetAudioLevel(level_d_bov);
}
-WebRtc_Word32 RTPSender::SetRED(const WebRtc_Word8 payload_type) {
+int32_t RTPSender::SetRED(const int8_t payload_type) {
if (!audio_configured_) {
return -1;
}
return audio_->SetRED(payload_type);
}
-WebRtc_Word32 RTPSender::RED(WebRtc_Word8 *payload_type) const {
+int32_t RTPSender::RED(int8_t *payload_type) const {
if (!audio_configured_) {
return -1;
}
@@ -1136,23 +1133,23 @@
return video_->VideoCodecType();
}
-WebRtc_UWord32 RTPSender::MaxConfiguredBitrateVideo() const {
+uint32_t RTPSender::MaxConfiguredBitrateVideo() const {
if (audio_configured_) {
return 0;
}
return video_->MaxConfiguredBitrateVideo();
}
-WebRtc_Word32 RTPSender::SendRTPIntraRequest() {
+int32_t RTPSender::SendRTPIntraRequest() {
if (audio_configured_) {
return -1;
}
return video_->SendRTPIntraRequest();
}
-WebRtc_Word32 RTPSender::SetGenericFECStatus(
- const bool enable, const WebRtc_UWord8 payload_type_red,
- const WebRtc_UWord8 payload_type_fec) {
+int32_t RTPSender::SetGenericFECStatus(
+ const bool enable, const uint8_t payload_type_red,
+ const uint8_t payload_type_fec) {
if (audio_configured_) {
return -1;
}
@@ -1160,9 +1157,9 @@
payload_type_fec);
}
-WebRtc_Word32 RTPSender::GenericFECStatus(
- bool *enable, WebRtc_UWord8 *payload_type_red,
- WebRtc_UWord8 *payload_type_fec) const {
+int32_t RTPSender::GenericFECStatus(
+ bool *enable, uint8_t *payload_type_red,
+ uint8_t *payload_type_fec) const {
if (audio_configured_) {
return -1;
}
@@ -1170,7 +1167,7 @@
*enable, *payload_type_red, *payload_type_fec);
}
-WebRtc_Word32 RTPSender::SetFecParameters(
+int32_t RTPSender::SetFecParameters(
const FecProtectionParams *delta_params,
const FecProtectionParams *key_params) {
if (audio_configured_) {
@@ -1179,13 +1176,13 @@
return video_->SetFecParameters(delta_params, key_params);
}
-void RTPSender::BuildRtxPacket(WebRtc_UWord8* buffer, WebRtc_UWord16* length,
- WebRtc_UWord8* buffer_rtx) {
+void RTPSender::BuildRtxPacket(uint8_t* buffer, uint16_t* length,
+ uint8_t* buffer_rtx) {
CriticalSectionScoped cs(send_critsect_);
- WebRtc_UWord8* data_buffer_rtx = buffer_rtx;
+ uint8_t* data_buffer_rtx = buffer_rtx;
// Add RTX header.
ModuleRTPUtility::RTPHeaderParser rtp_parser(
- reinterpret_cast<const WebRtc_UWord8 *>(buffer), *length);
+ reinterpret_cast<const uint8_t *>(buffer), *length);
WebRtcRTPHeader rtp_header;
rtp_parser.Parse(rtp_header);
@@ -1194,7 +1191,7 @@
memcpy(data_buffer_rtx, buffer, rtp_header.header.headerLength);
// Replace sequence number.
- WebRtc_UWord8 *ptr = data_buffer_rtx + 2;
+ uint8_t *ptr = data_buffer_rtx + 2;
ModuleRTPUtility::AssignUWord16ToBuffer(ptr, sequence_number_rtx_++);
// Replace SSRC.
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
index b101a3d..b57bcf4 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
@@ -38,55 +38,55 @@
RTPSenderInterface() {}
virtual ~RTPSenderInterface() {}
- virtual WebRtc_UWord32 SSRC() const = 0;
- virtual WebRtc_UWord32 Timestamp() const = 0;
+ virtual uint32_t SSRC() const = 0;
+ virtual uint32_t Timestamp() const = 0;
- virtual WebRtc_Word32 BuildRTPheader(
- WebRtc_UWord8 *data_buffer, const WebRtc_Word8 payload_type,
- const bool marker_bit, const WebRtc_UWord32 capture_time_stamp,
+ virtual int32_t BuildRTPheader(
+ uint8_t *data_buffer, const int8_t payload_type,
+ const bool marker_bit, const uint32_t capture_time_stamp,
const bool time_stamp_provided = true,
const bool inc_sequence_number = true) = 0;
- virtual WebRtc_UWord16 RTPHeaderLength() const = 0;
- virtual WebRtc_UWord16 IncrementSequenceNumber() = 0;
- virtual WebRtc_UWord16 SequenceNumber() const = 0;
- virtual WebRtc_UWord16 MaxPayloadLength() const = 0;
- virtual WebRtc_UWord16 MaxDataPayloadLength() const = 0;
- virtual WebRtc_UWord16 PacketOverHead() const = 0;
- virtual WebRtc_UWord16 ActualSendBitrateKbit() const = 0;
+ virtual uint16_t RTPHeaderLength() const = 0;
+ virtual uint16_t IncrementSequenceNumber() = 0;
+ virtual uint16_t SequenceNumber() const = 0;
+ virtual uint16_t MaxPayloadLength() const = 0;
+ virtual uint16_t MaxDataPayloadLength() const = 0;
+ virtual uint16_t PacketOverHead() const = 0;
+ virtual uint16_t ActualSendBitrateKbit() const = 0;
- virtual WebRtc_Word32 SendToNetwork(
+ virtual int32_t SendToNetwork(
uint8_t *data_buffer, int payload_length, int rtp_header_length,
int64_t capture_time_ms, StorageType storage) = 0;
};
class RTPSender : public Bitrate, public RTPSenderInterface {
public:
- RTPSender(const WebRtc_Word32 id, const bool audio, Clock *clock,
+ RTPSender(const int32_t id, const bool audio, Clock *clock,
Transport *transport, RtpAudioFeedback *audio_feedback,
PacedSender *paced_sender);
virtual ~RTPSender();
void ProcessBitrate();
- WebRtc_UWord16 ActualSendBitrateKbit() const;
+ uint16_t ActualSendBitrateKbit() const;
- WebRtc_UWord32 VideoBitrateSent() const;
- WebRtc_UWord32 FecOverheadRate() const;
- WebRtc_UWord32 NackOverheadRate() const;
+ uint32_t VideoBitrateSent() const;
+ uint32_t FecOverheadRate() const;
+ uint32_t NackOverheadRate() const;
- void SetTargetSendBitrate(const WebRtc_UWord32 bits);
+ void SetTargetSendBitrate(const uint32_t bits);
- WebRtc_UWord16 MaxDataPayloadLength() const; // with RTP and FEC headers.
+ uint16_t MaxDataPayloadLength() const; // with RTP and FEC headers.
- WebRtc_Word32 RegisterPayload(
+ int32_t RegisterPayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payload_type, const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels, const WebRtc_UWord32 rate);
+ const int8_t payload_type, const uint32_t frequency,
+ const uint8_t channels, const uint32_t rate);
- WebRtc_Word32 DeRegisterSendPayload(const WebRtc_Word8 payload_type);
+ int32_t DeRegisterSendPayload(const int8_t payload_type);
- WebRtc_Word8 SendPayloadType() const;
+ int8_t SendPayloadType() const;
int SendPayloadFrequency() const;
@@ -96,63 +96,63 @@
bool SendingMedia() const;
// Number of sent RTP packets.
- WebRtc_UWord32 Packets() const;
+ uint32_t Packets() const;
// Number of sent RTP bytes.
- WebRtc_UWord32 Bytes() const;
+ uint32_t Bytes() const;
void ResetDataCounters();
- WebRtc_UWord32 StartTimestamp() const;
- void SetStartTimestamp(WebRtc_UWord32 timestamp, bool force);
+ uint32_t StartTimestamp() const;
+ void SetStartTimestamp(uint32_t timestamp, bool force);
- WebRtc_UWord32 GenerateNewSSRC();
- void SetSSRC(const WebRtc_UWord32 ssrc);
+ uint32_t GenerateNewSSRC();
+ void SetSSRC(const uint32_t ssrc);
- WebRtc_UWord16 SequenceNumber() const;
- void SetSequenceNumber(WebRtc_UWord16 seq);
+ uint16_t SequenceNumber() const;
+ void SetSequenceNumber(uint16_t seq);
- WebRtc_Word32 CSRCs(WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const;
+ int32_t CSRCs(uint32_t arr_of_csrc[kRtpCsrcSize]) const;
void SetCSRCStatus(const bool include);
- void SetCSRCs(const WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize],
- const WebRtc_UWord8 arr_length);
+ void SetCSRCs(const uint32_t arr_of_csrc[kRtpCsrcSize],
+ const uint8_t arr_length);
- WebRtc_Word32 SetMaxPayloadLength(const WebRtc_UWord16 length,
- const WebRtc_UWord16 packet_over_head);
+ int32_t SetMaxPayloadLength(const uint16_t length,
+ const uint16_t packet_over_head);
- WebRtc_Word32 SendOutgoingData(
- const FrameType frame_type, const WebRtc_Word8 payload_type,
- const WebRtc_UWord32 time_stamp, int64_t capture_time_ms,
- const WebRtc_UWord8 *payload_data, const WebRtc_UWord32 payload_size,
+ int32_t SendOutgoingData(
+ const FrameType frame_type, const int8_t payload_type,
+ const uint32_t time_stamp, int64_t capture_time_ms,
+ const uint8_t *payload_data, const uint32_t payload_size,
const RTPFragmentationHeader *fragmentation,
VideoCodecInformation *codec_info = NULL,
const RTPVideoTypeHeader * rtp_type_hdr = NULL);
- WebRtc_Word32 SendPadData(WebRtc_Word8 payload_type,
- WebRtc_UWord32 capture_timestamp,
- int64_t capture_time_ms, WebRtc_Word32 bytes);
+ int32_t SendPadData(int8_t payload_type,
+ uint32_t capture_timestamp,
+ int64_t capture_time_ms, int32_t bytes);
// RTP header extension
- WebRtc_Word32 SetTransmissionTimeOffset(
- const WebRtc_Word32 transmission_time_offset);
+ int32_t SetTransmissionTimeOffset(
+ const int32_t transmission_time_offset);
- WebRtc_Word32 RegisterRtpHeaderExtension(const RTPExtensionType type,
- const WebRtc_UWord8 id);
+ int32_t RegisterRtpHeaderExtension(const RTPExtensionType type,
+ const uint8_t id);
- WebRtc_Word32 DeregisterRtpHeaderExtension(const RTPExtensionType type);
+ int32_t DeregisterRtpHeaderExtension(const RTPExtensionType type);
- WebRtc_UWord16 RtpHeaderExtensionTotalLength() const;
+ uint16_t RtpHeaderExtensionTotalLength() const;
- WebRtc_UWord16 BuildRTPHeaderExtension(WebRtc_UWord8 *data_buffer) const;
+ uint16_t BuildRTPHeaderExtension(uint8_t *data_buffer) const;
- WebRtc_UWord8 BuildTransmissionTimeOffsetExtension(
- WebRtc_UWord8 *data_buffer) const;
+ uint8_t BuildTransmissionTimeOffsetExtension(
+ uint8_t *data_buffer) const;
- bool UpdateTransmissionTimeOffset(WebRtc_UWord8 *rtp_packet,
- const WebRtc_UWord16 rtp_packet_length,
+ bool UpdateTransmissionTimeOffset(uint8_t *rtp_packet,
+ const uint16_t rtp_packet_length,
const WebRtcRTPHeader &rtp_header,
- const WebRtc_Word64 time_diff_ms) const;
+ const int64_t time_diff_ms) const;
void TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms);
@@ -160,113 +160,109 @@
int SelectiveRetransmissions() const;
int SetSelectiveRetransmissions(uint8_t settings);
void OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers,
- const WebRtc_UWord16 avg_rtt);
+ const uint16_t avg_rtt);
void SetStorePacketsStatus(const bool enable,
- const WebRtc_UWord16 number_to_store);
+ const uint16_t number_to_store);
bool StorePackets() const;
- WebRtc_Word32 ReSendPacket(WebRtc_UWord16 packet_id,
- WebRtc_UWord32 min_resend_time = 0);
+ int32_t ReSendPacket(uint16_t packet_id, uint32_t min_resend_time = 0);
- WebRtc_Word32 ReSendToNetwork(const WebRtc_UWord8 *packet,
- const WebRtc_UWord32 size);
+ int32_t ReSendToNetwork(const uint8_t *packet, const uint32_t size);
- bool ProcessNACKBitRate(const WebRtc_UWord32 now);
+ bool ProcessNACKBitRate(const uint32_t now);
// RTX.
void SetRTXStatus(const RtxMode mode, const bool set_ssrc,
- const WebRtc_UWord32 SSRC);
+ const uint32_t SSRC);
- void RTXStatus(RtxMode* mode, WebRtc_UWord32 *SSRC) const;
+ void RTXStatus(RtxMode* mode, uint32_t *SSRC) const;
// Functions wrapping RTPSenderInterface.
- virtual WebRtc_Word32 BuildRTPheader(
- WebRtc_UWord8 *data_buffer, const WebRtc_Word8 payload_type,
- const bool marker_bit, const WebRtc_UWord32 capture_time_stamp,
+ virtual int32_t BuildRTPheader(
+ uint8_t *data_buffer, const int8_t payload_type,
+ const bool marker_bit, const uint32_t capture_time_stamp,
const bool time_stamp_provided = true,
const bool inc_sequence_number = true);
- virtual WebRtc_UWord16 RTPHeaderLength() const;
- virtual WebRtc_UWord16 IncrementSequenceNumber();
- virtual WebRtc_UWord16 MaxPayloadLength() const;
- virtual WebRtc_UWord16 PacketOverHead() const;
+ virtual uint16_t RTPHeaderLength() const;
+ virtual uint16_t IncrementSequenceNumber();
+ virtual uint16_t MaxPayloadLength() const;
+ virtual uint16_t PacketOverHead() const;
// Current timestamp.
- virtual WebRtc_UWord32 Timestamp() const;
- virtual WebRtc_UWord32 SSRC() const;
+ virtual uint32_t Timestamp() const;
+ virtual uint32_t SSRC() const;
- virtual WebRtc_Word32 SendToNetwork(
+ virtual int32_t SendToNetwork(
uint8_t *data_buffer, int payload_length, int rtp_header_length,
int64_t capture_time_ms, StorageType storage);
// Audio.
// Send a DTMF tone using RFC 2833 (4733).
- WebRtc_Word32 SendTelephoneEvent(const WebRtc_UWord8 key,
- const WebRtc_UWord16 time_ms,
- const WebRtc_UWord8 level);
+ int32_t SendTelephoneEvent(const uint8_t key,
+ const uint16_t time_ms,
+ const uint8_t level);
- bool SendTelephoneEventActive(WebRtc_Word8 *telephone_event) const;
+ bool SendTelephoneEventActive(int8_t *telephone_event) const;
// Set audio packet size, used to determine when it's time to send a DTMF
// packet in silence (CNG).
- WebRtc_Word32 SetAudioPacketSize(const WebRtc_UWord16 packet_size_samples);
+ int32_t SetAudioPacketSize(const uint16_t packet_size_samples);
// Set status and ID for header-extension-for-audio-level-indication.
- WebRtc_Word32 SetAudioLevelIndicationStatus(const bool enable,
- const WebRtc_UWord8 ID);
+ int32_t SetAudioLevelIndicationStatus(const bool enable, const uint8_t ID);
// Get status and ID for header-extension-for-audio-level-indication.
- WebRtc_Word32 AudioLevelIndicationStatus(bool *enable,
- WebRtc_UWord8 *id) const;
+ int32_t AudioLevelIndicationStatus(bool *enable, uint8_t *id) const;
// Store the audio level in d_bov for
// header-extension-for-audio-level-indication.
- WebRtc_Word32 SetAudioLevel(const WebRtc_UWord8 level_d_bov);
+ int32_t SetAudioLevel(const uint8_t level_d_bov);
// Set payload type for Redundant Audio Data RFC 2198.
- WebRtc_Word32 SetRED(const WebRtc_Word8 payload_type);
+ int32_t SetRED(const int8_t payload_type);
// Get payload type for Redundant Audio Data RFC 2198.
- WebRtc_Word32 RED(WebRtc_Word8 *payload_type) const;
+ int32_t RED(int8_t *payload_type) const;
// Video.
VideoCodecInformation *CodecInformationVideo();
RtpVideoCodecTypes VideoCodecType() const;
- WebRtc_UWord32 MaxConfiguredBitrateVideo() const;
+ uint32_t MaxConfiguredBitrateVideo() const;
- WebRtc_Word32 SendRTPIntraRequest();
+ int32_t SendRTPIntraRequest();
// FEC.
- WebRtc_Word32 SetGenericFECStatus(const bool enable,
- const WebRtc_UWord8 payload_type_red,
- const WebRtc_UWord8 payload_type_fec);
+ int32_t SetGenericFECStatus(const bool enable,
+ const uint8_t payload_type_red,
+ const uint8_t payload_type_fec);
- WebRtc_Word32 GenericFECStatus(bool *enable, WebRtc_UWord8 *payload_type_red,
- WebRtc_UWord8 *payload_type_fec) const;
+ int32_t GenericFECStatus(bool *enable, uint8_t *payload_type_red,
+ uint8_t *payload_type_fec) const;
- WebRtc_Word32 SetFecParameters(const FecProtectionParams *delta_params,
- const FecProtectionParams *key_params);
+ int32_t SetFecParameters(const FecProtectionParams *delta_params,
+ const FecProtectionParams *key_params);
protected:
- WebRtc_Word32 CheckPayloadType(const WebRtc_Word8 payload_type,
- RtpVideoCodecTypes *video_type);
+ int32_t CheckPayloadType(const int8_t payload_type,
+ RtpVideoCodecTypes *video_type);
private:
- void UpdateNACKBitRate(const WebRtc_UWord32 bytes, const WebRtc_UWord32 now);
+ void UpdateNACKBitRate(const uint32_t bytes, const uint32_t now);
- WebRtc_Word32 SendPaddingAccordingToBitrate(WebRtc_Word8 payload_type,
- WebRtc_UWord32 capture_timestamp,
- int64_t capture_time_ms);
+ int32_t SendPaddingAccordingToBitrate(int8_t payload_type,
+ uint32_t capture_timestamp,
+ int64_t capture_time_ms);
- void BuildRtxPacket(WebRtc_UWord8* buffer, WebRtc_UWord16* length,
- WebRtc_UWord8* buffer_rtx);
+ void BuildRtxPacket(uint8_t* buffer, uint16_t* length,
+ uint8_t* buffer_rtx);
- WebRtc_Word32 id_;
+ int32_t id_;
const bool audio_configured_;
RTPSenderAudio *audio_;
RTPSenderVideo *video_;
@@ -277,43 +273,43 @@
Transport *transport_;
bool sending_media_;
- WebRtc_UWord16 max_payload_length_;
- WebRtc_UWord16 target_send_bitrate_;
- WebRtc_UWord16 packet_over_head_;
+ uint16_t max_payload_length_;
+ uint16_t target_send_bitrate_;
+ uint16_t packet_over_head_;
- WebRtc_Word8 payload_type_;
- std::map<WebRtc_Word8, ModuleRTPUtility::Payload *> payload_type_map_;
+ int8_t payload_type_;
+ std::map<int8_t, ModuleRTPUtility::Payload *> payload_type_map_;
RtpHeaderExtensionMap rtp_header_extension_map_;
- WebRtc_Word32 transmission_time_offset_;
+ int32_t transmission_time_offset_;
// NACK
- WebRtc_UWord32 nack_byte_count_times_[NACK_BYTECOUNT_SIZE];
- WebRtc_Word32 nack_byte_count_[NACK_BYTECOUNT_SIZE];
+ uint32_t nack_byte_count_times_[NACK_BYTECOUNT_SIZE];
+ int32_t nack_byte_count_[NACK_BYTECOUNT_SIZE];
Bitrate nack_bitrate_;
RTPPacketHistory *packet_history_;
// Statistics
- WebRtc_UWord32 packets_sent_;
- WebRtc_UWord32 payload_bytes_sent_;
+ uint32_t packets_sent_;
+ uint32_t payload_bytes_sent_;
// RTP variables
bool start_time_stamp_forced_;
- WebRtc_UWord32 start_time_stamp_;
+ uint32_t start_time_stamp_;
SSRCDatabase &ssrc_db_;
- WebRtc_UWord32 remote_ssrc_;
+ uint32_t remote_ssrc_;
bool sequence_number_forced_;
- WebRtc_UWord16 sequence_number_;
- WebRtc_UWord16 sequence_number_rtx_;
+ uint16_t sequence_number_;
+ uint16_t sequence_number_rtx_;
bool ssrc_forced_;
- WebRtc_UWord32 ssrc_;
- WebRtc_UWord32 time_stamp_;
- WebRtc_UWord8 csrcs_;
- WebRtc_UWord32 csrc_[kRtpCsrcSize];
+ uint32_t ssrc_;
+ uint32_t time_stamp_;
+ uint8_t csrcs_;
+ uint32_t csrc_[kRtpCsrcSize];
bool include_csrcs_;
RtxMode rtx_;
- WebRtc_UWord32 ssrc_rtx_;
+ uint32_t ssrc_rtx_;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
index 34f650f..8589874 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
@@ -14,7 +14,7 @@
#include <cassert> //assert
namespace webrtc {
-RTPSenderAudio::RTPSenderAudio(const WebRtc_Word32 id, Clock* clock,
+RTPSenderAudio::RTPSenderAudio(const int32_t id, Clock* clock,
RTPSenderInterface* rtpSender) :
_id(id),
_clock(clock),
@@ -51,7 +51,7 @@
delete _audioFeedbackCritsect;
}
-WebRtc_Word32
+int32_t
RTPSenderAudio::RegisterAudioCallback(RtpAudioFeedback* messagesCallback)
{
CriticalSectionScoped cs(_audioFeedbackCritsect);
@@ -60,7 +60,7 @@
}
void
-RTPSenderAudio::SetAudioFrequency(const WebRtc_UWord32 f)
+RTPSenderAudio::SetAudioFrequency(const uint32_t f)
{
CriticalSectionScoped cs(_sendAudioCritsect);
_frequency = f;
@@ -74,8 +74,8 @@
}
// set audio packet size, used to determine when it's time to send a DTMF packet in silence (CNG)
-WebRtc_Word32
-RTPSenderAudio::SetAudioPacketSize(const WebRtc_UWord16 packetSizeSamples)
+int32_t
+RTPSenderAudio::SetAudioPacketSize(const uint16_t packetSizeSamples)
{
CriticalSectionScoped cs(_sendAudioCritsect);
@@ -83,12 +83,12 @@
return 0;
}
-WebRtc_Word32 RTPSenderAudio::RegisterAudioPayload(
+int32_t RTPSenderAudio::RegisterAudioPayload(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
+ const int8_t payloadType,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
ModuleRTPUtility::Payload*& payload) {
CriticalSectionScoped cs(_sendAudioCritsect);
@@ -129,7 +129,7 @@
bool
RTPSenderAudio::MarkerBit(const FrameType frameType,
- const WebRtc_Word8 payloadType)
+ const int8_t payloadType)
{
CriticalSectionScoped cs(_sendAudioCritsect);
@@ -210,14 +210,14 @@
}
bool
-RTPSenderAudio::SendTelephoneEventActive(WebRtc_Word8& telephoneEvent) const
+RTPSenderAudio::SendTelephoneEventActive(int8_t& telephoneEvent) const
{
if(_dtmfEventIsOn)
{
telephoneEvent = _dtmfKey;
return true;
}
- WebRtc_Word64 delaySinceLastDTMF = _clock->TimeInMilliseconds() -
+ int64_t delaySinceLastDTMF = _clock->TimeInMilliseconds() -
_dtmfTimeLastSent;
if(delaySinceLastDTMF < 100)
{
@@ -228,25 +228,25 @@
return false;
}
-WebRtc_Word32 RTPSenderAudio::SendAudio(
+int32_t RTPSenderAudio::SendAudio(
const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 dataSize,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ const uint8_t* payloadData,
+ const uint32_t dataSize,
const RTPFragmentationHeader* fragmentation) {
// TODO(pwestin) Breakup function in smaller functions.
- WebRtc_UWord16 payloadSize = static_cast<WebRtc_UWord16>(dataSize);
- WebRtc_UWord16 maxPayloadLength = _rtpSender->MaxPayloadLength();
+ uint16_t payloadSize = static_cast<uint16_t>(dataSize);
+ uint16_t maxPayloadLength = _rtpSender->MaxPayloadLength();
bool dtmfToneStarted = false;
- WebRtc_UWord16 dtmfLengthMS = 0;
- WebRtc_UWord8 key = 0;
+ uint16_t dtmfLengthMS = 0;
+ uint8_t key = 0;
// Check if we have pending DTMFs to send
if (!_dtmfEventIsOn && PendingDTMF()) {
CriticalSectionScoped cs(_sendAudioCritsect);
- WebRtc_Word64 delaySinceLastDTMF = _clock->TimeInMilliseconds() -
+ int64_t delaySinceLastDTMF = _clock->TimeInMilliseconds() -
_dtmfTimeLastSent;
if (delaySinceLastDTMF > 100) {
@@ -285,7 +285,7 @@
}
}
_dtmfTimestampLastSent = captureTimeStamp;
- WebRtc_UWord32 dtmfDurationSamples = captureTimeStamp - _dtmfTimestamp;
+ uint32_t dtmfDurationSamples = captureTimeStamp - _dtmfTimestamp;
bool ended = false;
bool send = true;
@@ -305,7 +305,7 @@
if (dtmfDurationSamples > 0xffff) {
// RFC 4733 2.5.2.3 Long-Duration Events
SendTelephoneEventPacket(ended, _dtmfTimestamp,
- static_cast<WebRtc_UWord16>(0xffff), false);
+ static_cast<uint16_t>(0xffff), false);
// set new timestap for this segment
_dtmfTimestamp = captureTimeStamp;
@@ -315,7 +315,7 @@
return SendTelephoneEventPacket(
ended,
_dtmfTimestamp,
- static_cast<WebRtc_UWord16>(dtmfDurationSamples),
+ static_cast<uint16_t>(dtmfDurationSamples),
false);
} else {
// set markerBit on the first packet in the burst
@@ -323,7 +323,7 @@
return SendTelephoneEventPacket(
ended,
_dtmfTimestamp,
- static_cast<WebRtc_UWord16>(dtmfDurationSamples),
+ static_cast<uint16_t>(dtmfDurationSamples),
!_dtmfEventFirstPacketSent);
}
}
@@ -339,21 +339,21 @@
}
return -1;
}
- WebRtc_UWord8 dataBuffer[IP_PACKET_SIZE];
+ uint8_t dataBuffer[IP_PACKET_SIZE];
bool markerBit = MarkerBit(frameType, payloadType);
- WebRtc_Word32 rtpHeaderLength = 0;
- WebRtc_UWord16 timestampOffset = 0;
+ int32_t rtpHeaderLength = 0;
+ uint16_t timestampOffset = 0;
if (_REDPayloadType >= 0 && fragmentation && !markerBit &&
fragmentation->fragmentationVectorSize > 1) {
// have we configured RED? use its payload type
// we need to get the current timestamp to calc the diff
- WebRtc_UWord32 oldTimeStamp = _rtpSender->Timestamp();
+ uint32_t oldTimeStamp = _rtpSender->Timestamp();
rtpHeaderLength = _rtpSender->BuildRTPheader(dataBuffer, _REDPayloadType,
markerBit, captureTimeStamp);
- timestampOffset = WebRtc_UWord16(_rtpSender->Timestamp() - oldTimeStamp);
+ timestampOffset = uint16_t(_rtpSender->Timestamp() - oldTimeStamp);
} else {
rtpHeaderLength = _rtpSender->BuildRTPheader(dataBuffer, payloadType,
markerBit, captureTimeStamp);
@@ -382,19 +382,19 @@
rtpHeaderLength += 2;
// add the length (length=1) in number of word32
- const WebRtc_UWord8 length = 1;
+ const uint8_t length = 1;
ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer+rtpHeaderLength,
length);
rtpHeaderLength += 2;
// add ID (defined by the user) and len(=0) byte
- const WebRtc_UWord8 id = _audioLevelIndicationID;
- const WebRtc_UWord8 len = 0;
+ const uint8_t id = _audioLevelIndicationID;
+ const uint8_t len = 0;
dataBuffer[rtpHeaderLength++] = (id << 4) + len;
// add voice-activity flag (V) bit and the audio level (in dBov)
- const WebRtc_UWord8 V = (frameType == kAudioFrameSpeech);
- WebRtc_UWord8 level = _audioLevel_dBov;
+ const uint8_t V = (frameType == kAudioFrameSpeech);
+ uint8_t level = _audioLevel_dBov;
dataBuffer[rtpHeaderLength++] = (V << 7) + level;
// add two bytes zero padding
@@ -419,13 +419,13 @@
// only 0x80 if we have multiple blocks
dataBuffer[rtpHeaderLength++] = 0x80 +
fragmentation->fragmentationPlType[1];
- WebRtc_UWord32 blockLength = fragmentation->fragmentationLength[1];
+ uint32_t blockLength = fragmentation->fragmentationLength[1];
// sanity blockLength
if(blockLength > 0x3ff) { // block length 10 bits 1023 bytes
return -1;
}
- WebRtc_UWord32 REDheader = (timestampOffset << 10) + blockLength;
+ uint32_t REDheader = (timestampOffset << 10) + blockLength;
ModuleRTPUtility::AssignUWord24ToBuffer(dataBuffer + rtpHeaderLength,
REDheader);
rtpHeaderLength += 3;
@@ -442,7 +442,7 @@
payloadData + fragmentation->fragmentationOffset[0],
fragmentation->fragmentationLength[0]);
- payloadSize = static_cast<WebRtc_UWord16>(
+ payloadSize = static_cast<uint16_t>(
fragmentation->fragmentationLength[0] +
fragmentation->fragmentationLength[1]);
} else {
@@ -452,7 +452,7 @@
payloadData + fragmentation->fragmentationOffset[0],
fragmentation->fragmentationLength[0]);
- payloadSize = static_cast<WebRtc_UWord16>(
+ payloadSize = static_cast<uint16_t>(
fragmentation->fragmentationLength[0]);
}
} else {
@@ -463,7 +463,7 @@
payloadData + fragmentation->fragmentationOffset[0],
fragmentation->fragmentationLength[0]);
- payloadSize = static_cast<WebRtc_UWord16>(
+ payloadSize = static_cast<uint16_t>(
fragmentation->fragmentationLength[0]);
} else {
memcpy(dataBuffer+rtpHeaderLength, payloadData, payloadSize);
@@ -473,14 +473,14 @@
} // end critical section
return _rtpSender->SendToNetwork(dataBuffer,
payloadSize,
- static_cast<WebRtc_UWord16>(rtpHeaderLength),
+ static_cast<uint16_t>(rtpHeaderLength),
-1,
kAllowRetransmission);
}
-WebRtc_Word32
+int32_t
RTPSenderAudio::SetAudioLevelIndicationStatus(const bool enable,
- const WebRtc_UWord8 ID)
+ const uint8_t ID)
{
if(ID < 1 || ID > 14)
{
@@ -494,9 +494,9 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderAudio::AudioLevelIndicationStatus(bool& enable,
- WebRtc_UWord8& ID) const
+ uint8_t& ID) const
{
CriticalSectionScoped cs(_sendAudioCritsect);
enable = _includeAudioLevelIndication;
@@ -505,8 +505,8 @@
}
// Audio level magnitude and voice activity flag are set for each RTP packet
-WebRtc_Word32
-RTPSenderAudio::SetAudioLevel(const WebRtc_UWord8 level_dBov)
+int32_t
+RTPSenderAudio::SetAudioLevel(const uint8_t level_dBov)
{
if (level_dBov > 127)
{
@@ -518,8 +518,8 @@
}
// Set payload type for Redundant Audio Data RFC 2198
-WebRtc_Word32
-RTPSenderAudio::SetRED(const WebRtc_Word8 payloadType)
+int32_t
+RTPSenderAudio::SetRED(const int8_t payloadType)
{
if(payloadType < -1 )
{
@@ -530,8 +530,8 @@
}
// Get payload type for Redundant Audio Data RFC 2198
-WebRtc_Word32
-RTPSenderAudio::RED(WebRtc_Word8& payloadType) const
+int32_t
+RTPSenderAudio::RED(int8_t& payloadType) const
{
if(_REDPayloadType == -1)
{
@@ -543,10 +543,10 @@
}
// Send a TelephoneEvent tone using RFC 2833 (4733)
-WebRtc_Word32
-RTPSenderAudio::SendTelephoneEvent(const WebRtc_UWord8 key,
- const WebRtc_UWord16 time_ms,
- const WebRtc_UWord8 level)
+int32_t
+RTPSenderAudio::SendTelephoneEvent(const uint8_t key,
+ const uint16_t time_ms,
+ const uint8_t level)
{
// DTMF is protected by its own critsect
if(_dtmfPayloadType < 0)
@@ -557,15 +557,15 @@
return AddDTMF(key, time_ms, level);
}
-WebRtc_Word32
+int32_t
RTPSenderAudio::SendTelephoneEventPacket(const bool ended,
- const WebRtc_UWord32 dtmfTimeStamp,
- const WebRtc_UWord16 duration,
+ const uint32_t dtmfTimeStamp,
+ const uint16_t duration,
const bool markerBit)
{
- WebRtc_UWord8 dtmfbuffer[IP_PACKET_SIZE];
- WebRtc_UWord8 sendCount = 1;
- WebRtc_Word32 retVal = 0;
+ uint8_t dtmfbuffer[IP_PACKET_SIZE];
+ uint8_t sendCount = 1;
+ int32_t retVal = 0;
if(ended)
{
@@ -592,11 +592,11 @@
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
// R bit always cleared
- WebRtc_UWord8 R = 0x00;
- WebRtc_UWord8 volume = _dtmfLevel;
+ uint8_t R = 0x00;
+ uint8_t volume = _dtmfLevel;
// First packet un-ended
- WebRtc_UWord8 E = 0x00;
+ uint8_t E = 0x00;
if(ended)
{
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h
index 535c0d0..c7b3672 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h
@@ -24,71 +24,69 @@
class RTPSenderAudio: public DTMFqueue
{
public:
- RTPSenderAudio(const WebRtc_Word32 id, Clock* clock,
+ RTPSenderAudio(const int32_t id, Clock* clock,
RTPSenderInterface* rtpSender);
virtual ~RTPSenderAudio();
- WebRtc_Word32 RegisterAudioPayload(
+ int32_t RegisterAudioPayload(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate,
+ const int8_t payloadType,
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate,
ModuleRTPUtility::Payload*& payload);
- WebRtc_Word32 SendAudio(const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 captureTimeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
- const RTPFragmentationHeader* fragmentation);
+ int32_t SendAudio(const FrameType frameType,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
+ const RTPFragmentationHeader* fragmentation);
// set audio packet size, used to determine when it's time to send a DTMF packet in silence (CNG)
- WebRtc_Word32 SetAudioPacketSize(const WebRtc_UWord16 packetSizeSamples);
+ int32_t SetAudioPacketSize(const uint16_t packetSizeSamples);
// Set status and ID for header-extension-for-audio-level-indication.
// Valid ID range is [1,14].
- WebRtc_Word32 SetAudioLevelIndicationStatus(const bool enable,
- const WebRtc_UWord8 ID);
+ int32_t SetAudioLevelIndicationStatus(const bool enable, const uint8_t ID);
// Get status and ID for header-extension-for-audio-level-indication.
- WebRtc_Word32 AudioLevelIndicationStatus(bool& enable,
- WebRtc_UWord8& ID) const;
+ int32_t AudioLevelIndicationStatus(bool& enable, uint8_t& ID) const;
// Store the audio level in dBov for header-extension-for-audio-level-indication.
// Valid range is [0,100]. Actual value is negative.
- WebRtc_Word32 SetAudioLevel(const WebRtc_UWord8 level_dBov);
+ int32_t SetAudioLevel(const uint8_t level_dBov);
// Send a DTMF tone using RFC 2833 (4733)
- WebRtc_Word32 SendTelephoneEvent(const WebRtc_UWord8 key,
- const WebRtc_UWord16 time_ms,
- const WebRtc_UWord8 level);
+ int32_t SendTelephoneEvent(const uint8_t key,
+ const uint16_t time_ms,
+ const uint8_t level);
- bool SendTelephoneEventActive(WebRtc_Word8& telephoneEvent) const;
+ bool SendTelephoneEventActive(int8_t& telephoneEvent) const;
- void SetAudioFrequency(const WebRtc_UWord32 f);
+ void SetAudioFrequency(const uint32_t f);
int AudioFrequency() const;
// Set payload type for Redundant Audio Data RFC 2198
- WebRtc_Word32 SetRED(const WebRtc_Word8 payloadType);
+ int32_t SetRED(const int8_t payloadType);
// Get payload type for Redundant Audio Data RFC 2198
- WebRtc_Word32 RED(WebRtc_Word8& payloadType) const;
+ int32_t RED(int8_t& payloadType) const;
- WebRtc_Word32 RegisterAudioCallback(RtpAudioFeedback* messagesCallback);
+ int32_t RegisterAudioCallback(RtpAudioFeedback* messagesCallback);
protected:
- WebRtc_Word32 SendTelephoneEventPacket(const bool ended,
- const WebRtc_UWord32 dtmfTimeStamp,
- const WebRtc_UWord16 duration,
- const bool markerBit); // set on first packet in talk burst
+ int32_t SendTelephoneEventPacket(const bool ended,
+ const uint32_t dtmfTimeStamp,
+ const uint16_t duration,
+ const bool markerBit); // set on first packet in talk burst
bool MarkerBit(const FrameType frameType,
- const WebRtc_Word8 payloadType);
+ const int8_t payloadType);
private:
- WebRtc_Word32 _id;
+ int32_t _id;
Clock* _clock;
RTPSenderInterface* _rtpSender;
CriticalSectionWrapper* _audioFeedbackCritsect;
@@ -96,34 +94,34 @@
CriticalSectionWrapper* _sendAudioCritsect;
- WebRtc_UWord32 _frequency;
- WebRtc_UWord16 _packetSizeSamples;
+ uint32_t _frequency;
+ uint16_t _packetSizeSamples;
// DTMF
bool _dtmfEventIsOn;
bool _dtmfEventFirstPacketSent;
- WebRtc_Word8 _dtmfPayloadType;
- WebRtc_UWord32 _dtmfTimestamp;
- WebRtc_UWord8 _dtmfKey;
- WebRtc_UWord32 _dtmfLengthSamples;
- WebRtc_UWord8 _dtmfLevel;
- WebRtc_Word64 _dtmfTimeLastSent;
- WebRtc_UWord32 _dtmfTimestampLastSent;
+ int8_t _dtmfPayloadType;
+ uint32_t _dtmfTimestamp;
+ uint8_t _dtmfKey;
+ uint32_t _dtmfLengthSamples;
+ uint8_t _dtmfLevel;
+ int64_t _dtmfTimeLastSent;
+ uint32_t _dtmfTimestampLastSent;
- WebRtc_Word8 _REDPayloadType;
+ int8_t _REDPayloadType;
// VAD detection, used for markerbit
bool _inbandVADactive;
- WebRtc_Word8 _cngNBPayloadType;
- WebRtc_Word8 _cngWBPayloadType;
- WebRtc_Word8 _cngSWBPayloadType;
- WebRtc_Word8 _cngFBPayloadType;
- WebRtc_Word8 _lastPayloadType;
+ int8_t _cngNBPayloadType;
+ int8_t _cngWBPayloadType;
+ int8_t _cngSWBPayloadType;
+ int8_t _cngFBPayloadType;
+ int8_t _lastPayloadType;
// Audio level indication (https://datatracker.ietf.org/doc/draft-lennox-avt-rtp-audio-level-exthdr/)
bool _includeAudioLevelIndication;
- WebRtc_UWord8 _audioLevelIndicationID;
- WebRtc_UWord8 _audioLevel_dBov;
+ uint8_t _audioLevelIndicationID;
+ uint8_t _audioLevel_dBov;
};
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 4d38bec..2c22201 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -92,10 +92,10 @@
}
TEST_F(RtpSenderTest, BuildRTPPacket) {
- WebRtc_Word32 length = rtp_sender_->BuildRTPheader(packet_,
- kPayload,
- kMarkerBit,
- kTimestamp);
+ int32_t length = rtp_sender_->BuildRTPheader(packet_,
+ kPayload,
+ kMarkerBit,
+ kTimestamp);
EXPECT_EQ(12, length);
// Verify
@@ -117,10 +117,10 @@
EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kType, kId));
- WebRtc_Word32 length = rtp_sender_->BuildRTPheader(packet_,
- kPayload,
- kMarkerBit,
- kTimestamp);
+ int32_t length = rtp_sender_->BuildRTPheader(packet_,
+ kPayload,
+ kMarkerBit,
+ kTimestamp);
EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
// Verify
@@ -152,10 +152,10 @@
EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset));
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kType, kId));
- WebRtc_Word32 length = rtp_sender_->BuildRTPheader(packet_,
- kPayload,
- kMarkerBit,
- kTimestamp);
+ int32_t length = rtp_sender_->BuildRTPheader(packet_,
+ kPayload,
+ kMarkerBit,
+ kTimestamp);
EXPECT_EQ(12 + rtp_sender_->RtpHeaderExtensionTotalLength(), length);
// Verify
@@ -174,10 +174,10 @@
}
TEST_F(RtpSenderTest, NoTrafficSmoothing) {
- WebRtc_Word32 rtp_length = rtp_sender_->BuildRTPheader(packet_,
- kPayload,
- kMarkerBit,
- kTimestamp);
+ int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
+ kPayload,
+ kMarkerBit,
+ kTimestamp);
// Packet should be sent immediately.
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
@@ -194,10 +194,10 @@
rtp_sender_->SetStorePacketsStatus(true, 10);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kType, kId));
rtp_sender_->SetTargetSendBitrate(300000);
- WebRtc_Word32 rtp_length = rtp_sender_->BuildRTPheader(packet_,
- kPayload,
- kMarkerBit,
- kTimestamp);
+ int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
+ kPayload,
+ kMarkerBit,
+ kTimestamp);
// Packet should be stored in a send bucket.
EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
0,
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
index 59d4403..034b3df 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -27,11 +27,11 @@
enum { REDForFECHeaderLength = 1 };
struct RtpPacket {
- WebRtc_UWord16 rtpHeaderLength;
+ uint16_t rtpHeaderLength;
ForwardErrorCorrection::Packet* pkt;
};
-RTPSenderVideo::RTPSenderVideo(const WebRtc_Word32 id,
+RTPSenderVideo::RTPSenderVideo(const int32_t id,
Clock* clock,
RTPSenderInterface* rtpSender) :
_id(id),
@@ -83,10 +83,10 @@
return _videoType;
}
-WebRtc_Word32 RTPSenderVideo::RegisterVideoPayload(
+int32_t RTPSenderVideo::RegisterVideoPayload(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 maxBitRate,
+ const int8_t payloadType,
+ const uint32_t maxBitRate,
ModuleRTPUtility::Payload*& payload) {
CriticalSectionScoped cs(_sendVideoCritsect);
@@ -107,10 +107,10 @@
return 0;
}
-WebRtc_Word32
-RTPSenderVideo::SendVideoPacket(WebRtc_UWord8* data_buffer,
- const WebRtc_UWord16 payload_length,
- const WebRtc_UWord16 rtp_header_length,
+int32_t
+RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
+ const uint16_t payload_length,
+ const uint16_t rtp_header_length,
int64_t capture_time_ms,
StorageType storage,
bool protect) {
@@ -188,14 +188,14 @@
return ret;
}
-WebRtc_Word32
+int32_t
RTPSenderVideo::SendRTPIntraRequest()
{
// RFC 2032
// 5.2.1. Full intra-frame Request (FIR) packet
- WebRtc_UWord16 length = 8;
- WebRtc_UWord8 data[8];
+ uint16_t length = 8;
+ uint8_t data[8];
data[0] = 0x80;
data[1] = 192;
data[2] = 0;
@@ -206,10 +206,10 @@
return _rtpSender.SendToNetwork(data, 0, length, -1, kDontStore);
}
-WebRtc_Word32
+int32_t
RTPSenderVideo::SetGenericFECStatus(const bool enable,
- const WebRtc_UWord8 payloadTypeRED,
- const WebRtc_UWord8 payloadTypeFEC)
+ const uint8_t payloadTypeRED,
+ const uint8_t payloadTypeFEC)
{
_fecEnabled = enable;
_payloadTypeRED = payloadTypeRED;
@@ -222,10 +222,10 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderVideo::GenericFECStatus(bool& enable,
- WebRtc_UWord8& payloadTypeRED,
- WebRtc_UWord8& payloadTypeFEC) const
+ uint8_t& payloadTypeRED,
+ uint8_t& payloadTypeFEC) const
{
enable = _fecEnabled;
payloadTypeRED = _payloadTypeRED;
@@ -233,7 +233,7 @@
return 0;
}
-WebRtc_UWord16
+uint16_t
RTPSenderVideo::FECPacketOverhead() const
{
if (_fecEnabled)
@@ -244,7 +244,7 @@
return 0;
}
-WebRtc_Word32 RTPSenderVideo::SetFecParameters(
+int32_t RTPSenderVideo::SetFecParameters(
const FecProtectionParams* delta_params,
const FecProtectionParams* key_params) {
assert(delta_params);
@@ -254,14 +254,14 @@
return 0;
}
-WebRtc_Word32
+int32_t
RTPSenderVideo::SendVideo(const RtpVideoCodecTypes videoType,
const FrameType frameType,
- const WebRtc_Word8 payloadType,
+ const int8_t payloadType,
const uint32_t captureTimeStamp,
int64_t capture_time_ms,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
const RTPFragmentationHeader* fragmentation,
VideoCodecInformation* codecInfo,
const RTPVideoTypeHeader* rtpTypeHdr)
@@ -283,7 +283,7 @@
// Will be extracted in SendVP8 for VP8 codec; other codecs use 0
_numberFirstPartition = 0;
- WebRtc_Word32 retVal = -1;
+ int32_t retVal = -1;
switch(videoType)
{
case kRtpGenericVideo:
@@ -375,33 +375,33 @@
}
void
-RTPSenderVideo::SetMaxConfiguredBitrateVideo(const WebRtc_UWord32 maxBitrate)
+RTPSenderVideo::SetMaxConfiguredBitrateVideo(const uint32_t maxBitrate)
{
_maxBitrate = maxBitrate;
}
-WebRtc_UWord32
+uint32_t
RTPSenderVideo::MaxConfiguredBitrateVideo() const
{
return _maxBitrate;
}
-WebRtc_Word32
+int32_t
RTPSenderVideo::SendVP8(const FrameType frameType,
- const WebRtc_Word8 payloadType,
+ const int8_t payloadType,
const uint32_t captureTimeStamp,
int64_t capture_time_ms,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
const RTPFragmentationHeader* fragmentation,
const RTPVideoTypeHeader* rtpTypeHdr)
{
- const WebRtc_UWord16 rtpHeaderLength = _rtpSender.RTPHeaderLength();
+ const uint16_t rtpHeaderLength = _rtpSender.RTPHeaderLength();
- WebRtc_Word32 payloadBytesToSend = payloadSize;
- const WebRtc_UWord8* data = payloadData;
+ int32_t payloadBytesToSend = payloadSize;
+ const uint8_t* data = payloadData;
- WebRtc_UWord16 maxPayloadLengthVP8 = _rtpSender.MaxDataPayloadLength();
+ uint16_t maxPayloadLengthVP8 = _rtpSender.MaxDataPayloadLength();
assert(rtpTypeHdr);
// Initialize disregarding partition boundaries: this will use kEqualSize
@@ -427,7 +427,7 @@
while (!last)
{
// Write VP8 Payload Descriptor and VP8 payload.
- WebRtc_UWord8 dataBuffer[IP_PACKET_SIZE] = {0};
+ uint8_t dataBuffer[IP_PACKET_SIZE] = {0};
int payloadBytesInPacket = 0;
int packetStartPartition =
packetizer.NextPacket(&dataBuffer[rtpHeaderLength],
@@ -465,11 +465,11 @@
_fecOverheadRate.Process();
}
-WebRtc_UWord32 RTPSenderVideo::VideoBitrateSent() const {
+uint32_t RTPSenderVideo::VideoBitrateSent() const {
return _videoBitrate.BitrateLast();
}
-WebRtc_UWord32 RTPSenderVideo::FecOverheadRate() const {
+uint32_t RTPSenderVideo::FecOverheadRate() const {
return _fecOverheadRate.BitrateLast();
}
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
index 9ddd860b..e1dc942 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
@@ -33,100 +33,100 @@
class RTPSenderVideo
{
public:
- RTPSenderVideo(const WebRtc_Word32 id, Clock* clock,
+ RTPSenderVideo(const int32_t id, Clock* clock,
RTPSenderInterface* rtpSender);
virtual ~RTPSenderVideo();
virtual RtpVideoCodecTypes VideoCodecType() const;
- WebRtc_UWord16 FECPacketOverhead() const;
+ uint16_t FECPacketOverhead() const;
- WebRtc_Word32 RegisterVideoPayload(
+ int32_t RegisterVideoPayload(
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_Word8 payloadType,
- const WebRtc_UWord32 maxBitRate,
+ const int8_t payloadType,
+ const uint32_t maxBitRate,
ModuleRTPUtility::Payload*& payload);
- WebRtc_Word32 SendVideo(const RtpVideoCodecTypes videoType,
- const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const uint32_t captureTimeStamp,
- int64_t capture_time_ms,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
- const RTPFragmentationHeader* fragmentation,
- VideoCodecInformation* codecInfo,
- const RTPVideoTypeHeader* rtpTypeHdr);
+ int32_t SendVideo(const RtpVideoCodecTypes videoType,
+ const FrameType frameType,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ int64_t capture_time_ms,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
+ const RTPFragmentationHeader* fragmentation,
+ VideoCodecInformation* codecInfo,
+ const RTPVideoTypeHeader* rtpTypeHdr);
- WebRtc_Word32 SendRTPIntraRequest();
+ int32_t SendRTPIntraRequest();
void SetVideoCodecType(RtpVideoCodecTypes type);
VideoCodecInformation* CodecInformationVideo();
- void SetMaxConfiguredBitrateVideo(const WebRtc_UWord32 maxBitrate);
+ void SetMaxConfiguredBitrateVideo(const uint32_t maxBitrate);
- WebRtc_UWord32 MaxConfiguredBitrateVideo() const;
+ uint32_t MaxConfiguredBitrateVideo() const;
// FEC
- WebRtc_Word32 SetGenericFECStatus(const bool enable,
- const WebRtc_UWord8 payloadTypeRED,
- const WebRtc_UWord8 payloadTypeFEC);
+ int32_t SetGenericFECStatus(const bool enable,
+ const uint8_t payloadTypeRED,
+ const uint8_t payloadTypeFEC);
- WebRtc_Word32 GenericFECStatus(bool& enable,
- WebRtc_UWord8& payloadTypeRED,
- WebRtc_UWord8& payloadTypeFEC) const;
+ int32_t GenericFECStatus(bool& enable,
+ uint8_t& payloadTypeRED,
+ uint8_t& payloadTypeFEC) const;
- WebRtc_Word32 SetFecParameters(const FecProtectionParams* delta_params,
- const FecProtectionParams* key_params);
+ int32_t SetFecParameters(const FecProtectionParams* delta_params,
+ const FecProtectionParams* key_params);
void ProcessBitrate();
- WebRtc_UWord32 VideoBitrateSent() const;
- WebRtc_UWord32 FecOverheadRate() const;
+ uint32_t VideoBitrateSent() const;
+ uint32_t FecOverheadRate() const;
int SelectiveRetransmissions() const;
int SetSelectiveRetransmissions(uint8_t settings);
protected:
- virtual WebRtc_Word32 SendVideoPacket(WebRtc_UWord8* dataBuffer,
- const WebRtc_UWord16 payloadLength,
- const WebRtc_UWord16 rtpHeaderLength,
- int64_t capture_time_ms,
- StorageType storage,
- bool protect);
+ virtual int32_t SendVideoPacket(uint8_t* dataBuffer,
+ const uint16_t payloadLength,
+ const uint16_t rtpHeaderLength,
+ int64_t capture_time_ms,
+ StorageType storage,
+ bool protect);
private:
- WebRtc_Word32 SendGeneric(const FrameType frame_type,
- const int8_t payload_type,
- const uint32_t capture_timestamp,
- int64_t capture_time_ms,
- const uint8_t* payload, const uint32_t size);
-
- WebRtc_Word32 SendVP8(const FrameType frameType,
- const WebRtc_Word8 payloadType,
- const uint32_t captureTimeStamp,
+ int32_t SendGeneric(const FrameType frame_type,
+ const int8_t payload_type,
+ const uint32_t capture_timestamp,
int64_t capture_time_ms,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
- const RTPFragmentationHeader* fragmentation,
- const RTPVideoTypeHeader* rtpTypeHdr);
+ const uint8_t* payload, const uint32_t size);
+
+ int32_t SendVP8(const FrameType frameType,
+ const int8_t payloadType,
+ const uint32_t captureTimeStamp,
+ int64_t capture_time_ms,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
+ const RTPFragmentationHeader* fragmentation,
+ const RTPVideoTypeHeader* rtpTypeHdr);
private:
- WebRtc_Word32 _id;
+ int32_t _id;
RTPSenderInterface& _rtpSender;
CriticalSectionWrapper* _sendVideoCritsect;
RtpVideoCodecTypes _videoType;
VideoCodecInformation* _videoCodecInformation;
- WebRtc_UWord32 _maxBitrate;
- WebRtc_Word32 _retransmissionSettings;
+ uint32_t _maxBitrate;
+ int32_t _retransmissionSettings;
// FEC
ForwardErrorCorrection _fec;
bool _fecEnabled;
- WebRtc_Word8 _payloadTypeRED;
- WebRtc_Word8 _payloadTypeFEC;
+ int8_t _payloadTypeRED;
+ int8_t _payloadTypeFEC;
unsigned int _numberFirstPartition;
FecProtectionParams delta_fec_params_;
FecProtectionParams key_fec_params_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_utility.cc b/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
index 08743b3..c9af76c 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
@@ -54,13 +54,13 @@
* Time routines.
*/
-WebRtc_UWord32 GetCurrentRTP(Clock* clock, WebRtc_UWord32 freq) {
+uint32_t GetCurrentRTP(Clock* clock, uint32_t freq) {
const bool use_global_clock = (clock == NULL);
Clock* local_clock = clock;
if (use_global_clock) {
local_clock = Clock::GetRealTimeClock();
}
- WebRtc_UWord32 secs = 0, frac = 0;
+ uint32_t secs = 0, frac = 0;
local_clock->CurrentNtp(secs, frac);
if (use_global_clock) {
delete local_clock;
@@ -68,20 +68,17 @@
return ConvertNTPTimeToRTP(secs, frac, freq);
}
-WebRtc_UWord32 ConvertNTPTimeToRTP(WebRtc_UWord32 NTPsec,
- WebRtc_UWord32 NTPfrac,
- WebRtc_UWord32 freq) {
+uint32_t ConvertNTPTimeToRTP(uint32_t NTPsec, uint32_t NTPfrac, uint32_t freq) {
float ftemp = (float)NTPfrac / (float)NTP_FRAC;
- WebRtc_UWord32 tmp = (WebRtc_UWord32)(ftemp * freq);
+ uint32_t tmp = (uint32_t)(ftemp * freq);
return NTPsec * freq + tmp;
}
-WebRtc_UWord32 ConvertNTPTimeToMS(WebRtc_UWord32 NTPsec,
- WebRtc_UWord32 NTPfrac) {
+uint32_t ConvertNTPTimeToMS(uint32_t NTPsec, uint32_t NTPfrac) {
int freq = 1000;
float ftemp = (float)NTPfrac / (float)NTP_FRAC;
- WebRtc_UWord32 tmp = (WebRtc_UWord32)(ftemp * freq);
- WebRtc_UWord32 MStime = NTPsec * freq + tmp;
+ uint32_t tmp = (uint32_t)(ftemp * freq);
+ uint32_t MStime = NTPsec * freq + tmp;
return MStime;
}
@@ -107,26 +104,26 @@
* Misc utility routines
*/
-const WebRtc_UWord8* GetPayloadData(const WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* packet) {
+const uint8_t* GetPayloadData(const WebRtcRTPHeader* rtp_header,
+ const uint8_t* packet) {
return packet + rtp_header->header.headerLength;
}
-WebRtc_UWord16 GetPayloadDataLength(const WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord16 packet_length) {
- WebRtc_UWord16 length = packet_length - rtp_header->header.paddingLength -
+uint16_t GetPayloadDataLength(const WebRtcRTPHeader* rtp_header,
+ const uint16_t packet_length) {
+ uint16_t length = packet_length - rtp_header->header.paddingLength -
rtp_header->header.headerLength;
- return static_cast<WebRtc_UWord16>(length);
+ return static_cast<uint16_t>(length);
}
#if defined(_WIN32)
bool StringCompare(const char* str1, const char* str2,
- const WebRtc_UWord32 length) {
+ const uint32_t length) {
return (_strnicmp(str1, str2, length) == 0) ? true : false;
}
#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
bool StringCompare(const char* str1, const char* str2,
- const WebRtc_UWord32 length) {
+ const uint32_t length) {
return (strncasecmp(str1, str2, length) == 0) ? true : false;
}
#endif
@@ -139,62 +136,62 @@
All integer fields are carried in network byte order, that is, most
significant byte (octet) first. AKA big-endian.
*/
-void AssignUWord32ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord32 value) {
+void AssignUWord32ToBuffer(uint8_t* dataBuffer, uint32_t value) {
#if defined(WEBRTC_LITTLE_ENDIAN)
- dataBuffer[0] = static_cast<WebRtc_UWord8>(value >> 24);
- dataBuffer[1] = static_cast<WebRtc_UWord8>(value >> 16);
- dataBuffer[2] = static_cast<WebRtc_UWord8>(value >> 8);
- dataBuffer[3] = static_cast<WebRtc_UWord8>(value);
+ dataBuffer[0] = static_cast<uint8_t>(value >> 24);
+ dataBuffer[1] = static_cast<uint8_t>(value >> 16);
+ dataBuffer[2] = static_cast<uint8_t>(value >> 8);
+ dataBuffer[3] = static_cast<uint8_t>(value);
#else
- WebRtc_UWord32* ptr = reinterpret_cast<WebRtc_UWord32*>(dataBuffer);
+ uint32_t* ptr = reinterpret_cast<uint32_t*>(dataBuffer);
ptr[0] = value;
#endif
}
-void AssignUWord24ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord32 value) {
+void AssignUWord24ToBuffer(uint8_t* dataBuffer, uint32_t value) {
#if defined(WEBRTC_LITTLE_ENDIAN)
- dataBuffer[0] = static_cast<WebRtc_UWord8>(value >> 16);
- dataBuffer[1] = static_cast<WebRtc_UWord8>(value >> 8);
- dataBuffer[2] = static_cast<WebRtc_UWord8>(value);
+ dataBuffer[0] = static_cast<uint8_t>(value >> 16);
+ dataBuffer[1] = static_cast<uint8_t>(value >> 8);
+ dataBuffer[2] = static_cast<uint8_t>(value);
#else
- dataBuffer[0] = static_cast<WebRtc_UWord8>(value);
- dataBuffer[1] = static_cast<WebRtc_UWord8>(value >> 8);
- dataBuffer[2] = static_cast<WebRtc_UWord8>(value >> 16);
+ dataBuffer[0] = static_cast<uint8_t>(value);
+ dataBuffer[1] = static_cast<uint8_t>(value >> 8);
+ dataBuffer[2] = static_cast<uint8_t>(value >> 16);
#endif
}
-void AssignUWord16ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord16 value) {
+void AssignUWord16ToBuffer(uint8_t* dataBuffer, uint16_t value) {
#if defined(WEBRTC_LITTLE_ENDIAN)
- dataBuffer[0] = static_cast<WebRtc_UWord8>(value >> 8);
- dataBuffer[1] = static_cast<WebRtc_UWord8>(value);
+ dataBuffer[0] = static_cast<uint8_t>(value >> 8);
+ dataBuffer[1] = static_cast<uint8_t>(value);
#else
- WebRtc_UWord16* ptr = reinterpret_cast<WebRtc_UWord16*>(dataBuffer);
+ uint16_t* ptr = reinterpret_cast<uint16_t*>(dataBuffer);
ptr[0] = value;
#endif
}
-WebRtc_UWord16 BufferToUWord16(const WebRtc_UWord8* dataBuffer) {
+uint16_t BufferToUWord16(const uint8_t* dataBuffer) {
#if defined(WEBRTC_LITTLE_ENDIAN)
return (dataBuffer[0] << 8) + dataBuffer[1];
#else
- return *reinterpret_cast<const WebRtc_UWord16*>(dataBuffer);
+ return *reinterpret_cast<const uint16_t*>(dataBuffer);
#endif
}
-WebRtc_UWord32 BufferToUWord24(const WebRtc_UWord8* dataBuffer) {
+uint32_t BufferToUWord24(const uint8_t* dataBuffer) {
return (dataBuffer[0] << 16) + (dataBuffer[1] << 8) + dataBuffer[2];
}
-WebRtc_UWord32 BufferToUWord32(const WebRtc_UWord8* dataBuffer) {
+uint32_t BufferToUWord32(const uint8_t* dataBuffer) {
#if defined(WEBRTC_LITTLE_ENDIAN)
return (dataBuffer[0] << 24) + (dataBuffer[1] << 16) + (dataBuffer[2] << 8) +
dataBuffer[3];
#else
- return *reinterpret_cast<const WebRtc_UWord32*>(dataBuffer);
+ return *reinterpret_cast<const uint32_t*>(dataBuffer);
#endif
}
-WebRtc_UWord32 pow2(WebRtc_UWord8 exp) {
+uint32_t pow2(uint8_t exp) {
return 1 << exp;
}
@@ -225,8 +222,8 @@
}
}
-RTPHeaderParser::RTPHeaderParser(const WebRtc_UWord8* rtpData,
- const WebRtc_UWord32 rtpDataLength)
+RTPHeaderParser::RTPHeaderParser(const uint8_t* rtpData,
+ const uint32_t rtpDataLength)
: _ptrRTPDataBegin(rtpData),
_ptrRTPDataEnd(rtpData ? (rtpData + rtpDataLength) : NULL) {
}
@@ -279,12 +276,12 @@
return false;
}
- const WebRtc_UWord8 V = _ptrRTPDataBegin[0] >> 6;
+ const uint8_t V = _ptrRTPDataBegin[0] >> 6;
if (V != kRtcpExpectedVersion) {
return false;
}
- const WebRtc_UWord8 payloadType = _ptrRTPDataBegin[1];
+ const uint8_t payloadType = _ptrRTPDataBegin[1];
bool RTCP = false;
switch (payloadType) {
case 192:
@@ -318,27 +315,27 @@
}
// Version
- const WebRtc_UWord8 V = _ptrRTPDataBegin[0] >> 6;
+ const uint8_t V = _ptrRTPDataBegin[0] >> 6;
// Padding
const bool P = ((_ptrRTPDataBegin[0] & 0x20) == 0) ? false : true;
// eXtension
const bool X = ((_ptrRTPDataBegin[0] & 0x10) == 0) ? false : true;
- const WebRtc_UWord8 CC = _ptrRTPDataBegin[0] & 0x0f;
+ const uint8_t CC = _ptrRTPDataBegin[0] & 0x0f;
const bool M = ((_ptrRTPDataBegin[1] & 0x80) == 0) ? false : true;
- const WebRtc_UWord8 PT = _ptrRTPDataBegin[1] & 0x7f;
+ const uint8_t PT = _ptrRTPDataBegin[1] & 0x7f;
- const WebRtc_UWord16 sequenceNumber = (_ptrRTPDataBegin[2] << 8) +
+ const uint16_t sequenceNumber = (_ptrRTPDataBegin[2] << 8) +
_ptrRTPDataBegin[3];
- const WebRtc_UWord8* ptr = &_ptrRTPDataBegin[4];
+ const uint8_t* ptr = &_ptrRTPDataBegin[4];
- WebRtc_UWord32 RTPTimestamp = *ptr++ << 24;
+ uint32_t RTPTimestamp = *ptr++ << 24;
RTPTimestamp += *ptr++ << 16;
RTPTimestamp += *ptr++ << 8;
RTPTimestamp += *ptr++;
- WebRtc_UWord32 SSRC = *ptr++ << 24;
+ uint32_t SSRC = *ptr++ << 24;
SSRC += *ptr++ << 16;
SSRC += *ptr++ << 8;
SSRC += *ptr++;
@@ -347,7 +344,7 @@
return false;
}
- const WebRtc_UWord8 CSRCocts = CC * 4;
+ const uint8_t CSRCocts = CC * 4;
if ((ptr + CSRCocts) > _ptrRTPDataEnd) {
return false;
@@ -362,7 +359,7 @@
parsedPacket.header.paddingLength = P ? *(_ptrRTPDataEnd - 1) : 0;
for (unsigned int i = 0; i < CC; ++i) {
- WebRtc_UWord32 CSRC = *ptr++ << 24;
+ uint32_t CSRC = *ptr++ << 24;
CSRC += *ptr++ << 16;
CSRC += *ptr++ << 8;
CSRC += *ptr++;
@@ -393,10 +390,10 @@
parsedPacket.header.headerLength += 4;
- WebRtc_UWord16 definedByProfile = *ptr++ << 8;
+ uint16_t definedByProfile = *ptr++ << 8;
definedByProfile += *ptr++;
- WebRtc_UWord16 XLen = *ptr++ << 8;
+ uint16_t XLen = *ptr++ << 8;
XLen += *ptr++; // in 32 bit words
XLen *= 4; // in octs
@@ -404,7 +401,7 @@
return false;
}
if (definedByProfile == RTP_ONE_BYTE_HEADER_EXTENSION) {
- const WebRtc_UWord8* ptrRTPDataExtensionEnd = ptr + XLen;
+ const uint8_t* ptrRTPDataExtensionEnd = ptr + XLen;
ParseOneByteExtensionHeader(parsedPacket,
ptrExtensionMap,
ptrRTPDataExtensionEnd,
@@ -418,8 +415,8 @@
void RTPHeaderParser::ParseOneByteExtensionHeader(
WebRtcRTPHeader& parsedPacket,
const RtpHeaderExtensionMap* ptrExtensionMap,
- const WebRtc_UWord8* ptrRTPDataExtensionEnd,
- const WebRtc_UWord8* ptr) const {
+ const uint8_t* ptrRTPDataExtensionEnd,
+ const uint8_t* ptr) const {
if (!ptrExtensionMap) {
return;
}
@@ -431,8 +428,8 @@
// | ID | len |
// +-+-+-+-+-+-+-+-+
- const WebRtc_UWord8 id = (*ptr & 0xf0) >> 4;
- const WebRtc_UWord8 len = (*ptr & 0x0f);
+ const uint8_t id = (*ptr & 0xf0) >> 4;
+ const uint8_t len = (*ptr & 0x0f);
ptr++;
if (id == 15) {
@@ -461,7 +458,7 @@
// | ID | len=2 | transmission offset |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
- WebRtc_Word32 transmissionTimeOffset = *ptr++ << 16;
+ int32_t transmissionTimeOffset = *ptr++ << 16;
transmissionTimeOffset += *ptr++ << 8;
transmissionTimeOffset += *ptr++;
parsedPacket.extension.transmissionTimeOffset = transmissionTimeOffset;
@@ -481,8 +478,8 @@
//
// Parse out the fields but only use it for debugging for now.
- // const WebRtc_UWord8 V = (*ptr & 0x80) >> 7;
- // const WebRtc_UWord8 level = (*ptr & 0x7f);
+ // const uint8_t V = (*ptr & 0x80) >> 7;
+ // const uint8_t level = (*ptr & 0x7f);
// DEBUG_PRINT("RTP_AUDIO_LEVEL_UNIQUE_ID: ID=%u, len=%u, V=%u,
// level=%u", ID, len, V, level);
break;
@@ -493,16 +490,16 @@
return;
}
}
- WebRtc_UWord8 num_bytes = ParsePaddingBytes(ptrRTPDataExtensionEnd, ptr);
+ uint8_t num_bytes = ParsePaddingBytes(ptrRTPDataExtensionEnd, ptr);
ptr += num_bytes;
}
}
-WebRtc_UWord8 RTPHeaderParser::ParsePaddingBytes(
- const WebRtc_UWord8* ptrRTPDataExtensionEnd,
- const WebRtc_UWord8* ptr) const {
+uint8_t RTPHeaderParser::ParsePaddingBytes(
+ const uint8_t* ptrRTPDataExtensionEnd,
+ const uint8_t* ptr) const {
- WebRtc_UWord8 num_zero_bytes = 0;
+ uint8_t num_zero_bytes = 0;
while (ptrRTPDataExtensionEnd - ptr > 0) {
if (*ptr != 0) {
return num_zero_bytes;
@@ -515,9 +512,9 @@
// RTP payload parser
RTPPayloadParser::RTPPayloadParser(const RtpVideoCodecTypes videoType,
- const WebRtc_UWord8* payloadData,
- WebRtc_UWord16 payloadDataLength,
- WebRtc_Word32 id)
+ const uint8_t* payloadData,
+ uint16_t payloadDataLength,
+ int32_t id)
:
_id(id),
_dataPtr(payloadData),
@@ -572,7 +569,7 @@
bool RTPPayloadParser::ParseVP8(RTPPayload& parsedPacket) const {
RTPPayloadVP8* vp8 = &parsedPacket.info.VP8;
- const WebRtc_UWord8* dataPtr = _dataPtr;
+ const uint8_t* dataPtr = _dataPtr;
int dataLength = _dataLength;
// Parse mandatory first byte of payload descriptor
@@ -618,7 +615,7 @@
}
int RTPPayloadParser::ParseVP8FrameSize(RTPPayload& parsedPacket,
- const WebRtc_UWord8* dataPtr,
+ const uint8_t* dataPtr,
int dataLength) const {
if (parsedPacket.frameType != kIFrame) {
// Included in payload header for I-frames.
@@ -636,7 +633,7 @@
}
int RTPPayloadParser::ParseVP8Extension(RTPPayloadVP8* vp8,
- const WebRtc_UWord8* dataPtr,
+ const uint8_t* dataPtr,
int dataLength) const {
int parsedBytes = 0;
if (dataLength <= 0) return -1;
@@ -672,7 +669,7 @@
}
int RTPPayloadParser::ParseVP8PictureID(RTPPayloadVP8* vp8,
- const WebRtc_UWord8** dataPtr,
+ const uint8_t** dataPtr,
int* dataLength,
int* parsedBytes) const {
if (*dataLength <= 0) return -1;
@@ -691,7 +688,7 @@
}
int RTPPayloadParser::ParseVP8Tl0PicIdx(RTPPayloadVP8* vp8,
- const WebRtc_UWord8** dataPtr,
+ const uint8_t** dataPtr,
int* dataLength,
int* parsedBytes) const {
if (*dataLength <= 0) return -1;
@@ -703,7 +700,7 @@
}
int RTPPayloadParser::ParseVP8TIDAndKeyIdx(RTPPayloadVP8* vp8,
- const WebRtc_UWord8** dataPtr,
+ const uint8_t** dataPtr,
int* dataLength,
int* parsedBytes) const {
if (*dataLength <= 0) return -1;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_utility.h b/webrtc/modules/rtp_rtcp/source/rtp_utility.h
index 255c080..7614ca6 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_utility.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_utility.h
@@ -26,7 +26,7 @@
kRtpVp8Video = 11
};
-const WebRtc_UWord8 kRtpMarkerBitMask = 0x80;
+const uint8_t kRtpMarkerBitMask = 0x80;
namespace ModuleRTPUtility
{
@@ -38,14 +38,14 @@
struct AudioPayload
{
- WebRtc_UWord32 frequency;
- WebRtc_UWord8 channels;
- WebRtc_UWord32 rate;
+ uint32_t frequency;
+ uint8_t channels;
+ uint32_t rate;
};
struct VideoPayload
{
RtpVideoCodecTypes videoCodecType;
- WebRtc_UWord32 maxRate;
+ uint32_t maxRate;
};
union PayloadUnion
{
@@ -59,31 +59,31 @@
PayloadUnion typeSpecific;
};
- typedef std::map<WebRtc_Word8, Payload*> PayloadTypeMap;
+ typedef std::map<int8_t, Payload*> PayloadTypeMap;
// Return the current RTP timestamp from the NTP timestamp
// returned by the specified clock.
- WebRtc_UWord32 GetCurrentRTP(Clock* clock, WebRtc_UWord32 freq);
+ uint32_t GetCurrentRTP(Clock* clock, uint32_t freq);
// Return the current RTP absolute timestamp.
- WebRtc_UWord32 ConvertNTPTimeToRTP(WebRtc_UWord32 NTPsec,
- WebRtc_UWord32 NTPfrac,
- WebRtc_UWord32 freq);
+ uint32_t ConvertNTPTimeToRTP(uint32_t NTPsec,
+ uint32_t NTPfrac,
+ uint32_t freq);
// Return the time in milliseconds corresponding to the specified
// NTP timestamp.
- WebRtc_UWord32 ConvertNTPTimeToMS(WebRtc_UWord32 NTPsec,
- WebRtc_UWord32 NTPfrac);
+ uint32_t ConvertNTPTimeToMS(uint32_t NTPsec,
+ uint32_t NTPfrac);
- WebRtc_UWord32 pow2(WebRtc_UWord8 exp);
+ uint32_t pow2(uint8_t exp);
// Returns a pointer to the payload data given a packet.
- const WebRtc_UWord8* GetPayloadData(const WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord8* packet);
+ const uint8_t* GetPayloadData(const WebRtcRTPHeader* rtp_header,
+ const uint8_t* packet);
// Returns payload length given a packet.
- WebRtc_UWord16 GetPayloadDataLength(const WebRtcRTPHeader* rtp_header,
- const WebRtc_UWord16 packet_length);
+ uint16_t GetPayloadDataLength(const WebRtcRTPHeader* rtp_header,
+ const uint16_t packet_length);
// Returns true if |newTimestamp| is older than |existingTimestamp|.
// |wrapped| will be set to true if there has been a wraparound between the
@@ -94,38 +94,38 @@
bool StringCompare(const char* str1,
const char* str2,
- const WebRtc_UWord32 length);
+ const uint32_t length);
- void AssignUWord32ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord32 value);
- void AssignUWord24ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord32 value);
- void AssignUWord16ToBuffer(WebRtc_UWord8* dataBuffer, WebRtc_UWord16 value);
+ void AssignUWord32ToBuffer(uint8_t* dataBuffer, uint32_t value);
+ void AssignUWord24ToBuffer(uint8_t* dataBuffer, uint32_t value);
+ void AssignUWord16ToBuffer(uint8_t* dataBuffer, uint16_t value);
/**
* Converts a network-ordered two-byte input buffer to a host-ordered value.
* \param[in] dataBuffer Network-ordered two-byte buffer to convert.
* \return Host-ordered value.
*/
- WebRtc_UWord16 BufferToUWord16(const WebRtc_UWord8* dataBuffer);
+ uint16_t BufferToUWord16(const uint8_t* dataBuffer);
/**
* Converts a network-ordered three-byte input buffer to a host-ordered value.
* \param[in] dataBuffer Network-ordered three-byte buffer to convert.
* \return Host-ordered value.
*/
- WebRtc_UWord32 BufferToUWord24(const WebRtc_UWord8* dataBuffer);
+ uint32_t BufferToUWord24(const uint8_t* dataBuffer);
/**
* Converts a network-ordered four-byte input buffer to a host-ordered value.
* \param[in] dataBuffer Network-ordered four-byte buffer to convert.
* \return Host-ordered value.
*/
- WebRtc_UWord32 BufferToUWord32(const WebRtc_UWord8* dataBuffer);
+ uint32_t BufferToUWord32(const uint8_t* dataBuffer);
class RTPHeaderParser
{
public:
- RTPHeaderParser(const WebRtc_UWord8* rtpData,
- const WebRtc_UWord32 rtpDataLength);
+ RTPHeaderParser(const uint8_t* rtpData,
+ const uint32_t rtpDataLength);
~RTPHeaderParser();
bool RTCP() const;
@@ -136,15 +136,15 @@
void ParseOneByteExtensionHeader(
WebRtcRTPHeader& parsedPacket,
const RtpHeaderExtensionMap* ptrExtensionMap,
- const WebRtc_UWord8* ptrRTPDataExtensionEnd,
- const WebRtc_UWord8* ptr) const;
+ const uint8_t* ptrRTPDataExtensionEnd,
+ const uint8_t* ptr) const;
- WebRtc_UWord8 ParsePaddingBytes(
- const WebRtc_UWord8* ptrRTPDataExtensionEnd,
- const WebRtc_UWord8* ptr) const;
+ uint8_t ParsePaddingBytes(
+ const uint8_t* ptrRTPDataExtensionEnd,
+ const uint8_t* ptr) const;
- const WebRtc_UWord8* const _ptrRTPDataBegin;
- const WebRtc_UWord8* const _ptrRTPDataEnd;
+ const uint8_t* const _ptrRTPDataBegin;
+ const uint8_t* const _ptrRTPDataEnd;
};
enum FrameTypes
@@ -170,8 +170,8 @@
int frameWidth;
int frameHeight;
- const WebRtc_UWord8* data;
- WebRtc_UWord16 dataLength;
+ const uint8_t* data;
+ uint16_t dataLength;
};
union RTPPayloadUnion
@@ -193,9 +193,9 @@
{
public:
RTPPayloadParser(const RtpVideoCodecTypes payloadType,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadDataLength, // Length w/o padding.
- const WebRtc_Word32 id);
+ const uint8_t* payloadData,
+ const uint16_t payloadDataLength, // Length w/o padding.
+ const int32_t id);
~RTPPayloadParser();
@@ -207,32 +207,32 @@
bool ParseVP8(RTPPayload& parsedPacket) const;
int ParseVP8Extension(RTPPayloadVP8 *vp8,
- const WebRtc_UWord8 *dataPtr,
+ const uint8_t *dataPtr,
int dataLength) const;
int ParseVP8PictureID(RTPPayloadVP8 *vp8,
- const WebRtc_UWord8 **dataPtr,
+ const uint8_t **dataPtr,
int *dataLength,
int *parsedBytes) const;
int ParseVP8Tl0PicIdx(RTPPayloadVP8 *vp8,
- const WebRtc_UWord8 **dataPtr,
+ const uint8_t **dataPtr,
int *dataLength,
int *parsedBytes) const;
int ParseVP8TIDAndKeyIdx(RTPPayloadVP8 *vp8,
- const WebRtc_UWord8 **dataPtr,
+ const uint8_t **dataPtr,
int *dataLength,
int *parsedBytes) const;
int ParseVP8FrameSize(RTPPayload& parsedPacket,
- const WebRtc_UWord8 *dataPtr,
+ const uint8_t *dataPtr,
int dataLength) const;
private:
- WebRtc_Word32 _id;
- const WebRtc_UWord8* _dataPtr;
- const WebRtc_UWord16 _dataLength;
+ int32_t _id;
+ const uint8_t* _dataPtr;
+ const uint16_t _dataLength;
const RtpVideoCodecTypes _videoType;
};
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_utility_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_utility_unittest.cc
index eabc812..b20eb6a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_utility_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_utility_unittest.cc
@@ -72,7 +72,7 @@
}
TEST(ParseVP8Test, BasicHeader) {
- WebRtc_UWord8 payload[4] = {0};
+ uint8_t payload[4] = {0};
payload[0] = 0x14; // Binary 0001 0100; S = 1, PartID = 4.
payload[1] = 0x01; // P frame.
@@ -92,7 +92,7 @@
}
TEST(ParseVP8Test, PictureID) {
- WebRtc_UWord8 payload[10] = {0};
+ uint8_t payload[10] = {0};
payload[0] = 0xA0;
payload[1] = 0x80;
payload[2] = 17;
@@ -131,7 +131,7 @@
}
TEST(ParseVP8Test, Tl0PicIdx) {
- WebRtc_UWord8 payload[13] = {0};
+ uint8_t payload[13] = {0};
payload[0] = 0x90;
payload[1] = 0x40;
payload[2] = 17;
@@ -154,7 +154,7 @@
}
TEST(ParseVP8Test, TIDAndLayerSync) {
- WebRtc_UWord8 payload[10] = {0};
+ uint8_t payload[10] = {0};
payload[0] = 0x88;
payload[1] = 0x20;
payload[2] = 0x80; // TID(2) + LayerSync(false)
@@ -178,7 +178,7 @@
}
TEST(ParseVP8Test, KeyIdx) {
- WebRtc_UWord8 payload[10] = {0};
+ uint8_t payload[10] = {0};
payload[0] = 0x88;
payload[1] = 0x10; // K = 1.
payload[2] = 0x11; // KEYIDX = 17 decimal.
@@ -201,7 +201,7 @@
}
TEST(ParseVP8Test, MultipleExtensions) {
- WebRtc_UWord8 payload[10] = {0};
+ uint8_t payload[10] = {0};
payload[0] = 0x88;
payload[1] = 0x80 | 0x40 | 0x20 | 0x10;
payload[2] = 0x80 | 17; // PictureID, high 7 bits.
@@ -230,7 +230,7 @@
}
TEST(ParseVP8Test, TooShortHeader) {
- WebRtc_UWord8 payload[4] = {0};
+ uint8_t payload[4] = {0};
payload[0] = 0x88;
payload[1] = 0x80 | 0x40 | 0x20 | 0x10; // All extensions are enabled...
payload[2] = 0x80 | 17; // ... but only 2 bytes PictureID is provided.
@@ -243,8 +243,8 @@
}
TEST(ParseVP8Test, TestWithPacketizer) {
- WebRtc_UWord8 payload[10] = {0};
- WebRtc_UWord8 packet[20] = {0};
+ uint8_t payload[10] = {0};
+ uint8_t packet[20] = {0};
RTPVideoHeaderVP8 inputHeader;
inputHeader.nonReference = true;
inputHeader.pictureId = 300;
diff --git a/webrtc/modules/rtp_rtcp/source/ssrc_database.cc b/webrtc/modules/rtp_rtcp/source/ssrc_database.cc
index b3e9ab0..b51efb5 100644
--- a/webrtc/modules/rtp_rtcp/source/ssrc_database.cc
+++ b/webrtc/modules/rtp_rtcp/source/ssrc_database.cc
@@ -51,12 +51,12 @@
StaticInstance(kRelease);
}
-WebRtc_UWord32
+uint32_t
SSRCDatabase::CreateSSRC()
{
CriticalSectionScoped lock(_critSect);
- WebRtc_UWord32 ssrc = GenerateRandom();
+ uint32_t ssrc = GenerateRandom();
#ifndef WEBRTC_NO_STL
@@ -71,8 +71,8 @@
{
// allocate more space
const int newSize = _sizeOfSSRC + 10;
- WebRtc_UWord32* tempSSRCVector = new WebRtc_UWord32[newSize];
- memcpy(tempSSRCVector, _ssrcVector, _sizeOfSSRC*sizeof(WebRtc_UWord32));
+ uint32_t* tempSSRCVector = new uint32_t[newSize];
+ memcpy(tempSSRCVector, _ssrcVector, _sizeOfSSRC*sizeof(uint32_t));
delete [] _ssrcVector;
_ssrcVector = tempSSRCVector;
@@ -100,8 +100,8 @@
return ssrc;
}
-WebRtc_Word32
-SSRCDatabase::RegisterSSRC(const WebRtc_UWord32 ssrc)
+int32_t
+SSRCDatabase::RegisterSSRC(const uint32_t ssrc)
{
CriticalSectionScoped lock(_critSect);
@@ -114,8 +114,8 @@
{
// allocate more space
const int newSize = _sizeOfSSRC + 10;
- WebRtc_UWord32* tempSSRCVector = new WebRtc_UWord32[newSize];
- memcpy(tempSSRCVector, _ssrcVector, _sizeOfSSRC*sizeof(WebRtc_UWord32));
+ uint32_t* tempSSRCVector = new uint32_t[newSize];
+ memcpy(tempSSRCVector, _ssrcVector, _sizeOfSSRC*sizeof(uint32_t));
delete [] _ssrcVector;
_ssrcVector = tempSSRCVector;
@@ -140,8 +140,8 @@
return 0;
}
-WebRtc_Word32
-SSRCDatabase::ReturnSSRC(const WebRtc_UWord32 ssrc)
+int32_t
+SSRCDatabase::ReturnSSRC(const uint32_t ssrc)
{
CriticalSectionScoped lock(_critSect);
@@ -182,7 +182,7 @@
#ifdef WEBRTC_NO_STL
_sizeOfSSRC = 10;
_numberOfSSRC = 0;
- _ssrcVector = new WebRtc_UWord32[10];
+ _ssrcVector = new uint32_t[10];
#endif
_critSect = CriticalSectionWrapper::CreateCriticalSection();
@@ -201,9 +201,9 @@
WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, -1, "%s deleted", __FUNCTION__);
}
-WebRtc_UWord32 SSRCDatabase::GenerateRandom()
+uint32_t SSRCDatabase::GenerateRandom()
{
- WebRtc_UWord32 ssrc = 0;
+ uint32_t ssrc = 0;
do
{
ssrc = rand();
diff --git a/webrtc/modules/rtp_rtcp/source/ssrc_database.h b/webrtc/modules/rtp_rtcp/source/ssrc_database.h
index 370e549..555fe09 100644
--- a/webrtc/modules/rtp_rtcp/source/ssrc_database.h
+++ b/webrtc/modules/rtp_rtcp/source/ssrc_database.h
@@ -27,9 +27,9 @@
static SSRCDatabase* GetSSRCDatabase();
static void ReturnSSRCDatabase();
- WebRtc_UWord32 CreateSSRC();
- WebRtc_Word32 RegisterSSRC(const WebRtc_UWord32 ssrc);
- WebRtc_Word32 ReturnSSRC(const WebRtc_UWord32 ssrc);
+ uint32_t CreateSSRC();
+ int32_t RegisterSSRC(const uint32_t ssrc);
+ int32_t ReturnSSRC(const uint32_t ssrc);
protected:
SSRCDatabase();
@@ -44,15 +44,15 @@
CountOperation count_operation);
static SSRCDatabase* StaticInstance(CountOperation count_operation);
- WebRtc_UWord32 GenerateRandom();
+ uint32_t GenerateRandom();
#ifdef WEBRTC_NO_STL
int _numberOfSSRC;
int _sizeOfSSRC;
- WebRtc_UWord32* _ssrcVector;
+ uint32_t* _ssrcVector;
#else
- std::map<WebRtc_UWord32, WebRtc_UWord32> _ssrcMap;
+ std::map<uint32_t, uint32_t> _ssrcMap;
#endif
CriticalSectionWrapper* _critSect;
diff --git a/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc b/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc
index ab85cdc..5bd6221 100644
--- a/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc
+++ b/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc
@@ -29,7 +29,7 @@
}
void
-TMMBRSet::VerifyAndAllocateSet(WebRtc_UWord32 minimumSize)
+TMMBRSet::VerifyAndAllocateSet(uint32_t minimumSize)
{
if(minimumSize > _sizeOfSet)
{
@@ -38,7 +38,7 @@
_sizeOfSet = minimumSize;
}
// reset memory
- for(WebRtc_UWord32 i = 0; i < _sizeOfSet; i++)
+ for(uint32_t i = 0; i < _sizeOfSet; i++)
{
_data.at(i).tmmbr = 0;
_data.at(i).packet_oh = 0;
@@ -48,7 +48,7 @@
}
void
-TMMBRSet::VerifyAndAllocateSetKeepingData(WebRtc_UWord32 minimumSize)
+TMMBRSet::VerifyAndAllocateSetKeepingData(uint32_t minimumSize)
{
if(minimumSize > _sizeOfSet)
{
@@ -60,9 +60,9 @@
}
void TMMBRSet::SetEntry(unsigned int i,
- WebRtc_UWord32 tmmbrSet,
- WebRtc_UWord32 packetOHSet,
- WebRtc_UWord32 ssrcSet) {
+ uint32_t tmmbrSet,
+ uint32_t packetOHSet,
+ uint32_t ssrcSet) {
assert(i < _sizeOfSet);
_data.at(i).tmmbr = tmmbrSet;
_data.at(i).packet_oh = packetOHSet;
@@ -72,28 +72,28 @@
}
}
-void TMMBRSet::AddEntry(WebRtc_UWord32 tmmbrSet,
- WebRtc_UWord32 packetOHSet,
- WebRtc_UWord32 ssrcSet) {
+void TMMBRSet::AddEntry(uint32_t tmmbrSet,
+ uint32_t packetOHSet,
+ uint32_t ssrcSet) {
assert(_lengthOfSet < _sizeOfSet);
SetEntry(_lengthOfSet, tmmbrSet, packetOHSet, ssrcSet);
}
-void TMMBRSet::RemoveEntry(WebRtc_UWord32 sourceIdx) {
+void TMMBRSet::RemoveEntry(uint32_t sourceIdx) {
assert(sourceIdx < _lengthOfSet);
_data.erase(_data.begin() + sourceIdx);
_lengthOfSet--;
_data.resize(_sizeOfSet); // Ensure that size remains the same.
}
-void TMMBRSet::SwapEntries(WebRtc_UWord32 i, WebRtc_UWord32 j) {
+void TMMBRSet::SwapEntries(uint32_t i, uint32_t j) {
SetElement temp;
temp = _data[i];
_data[i] = _data[j];
_data[j] = temp;
}
-void TMMBRSet::ClearEntry(WebRtc_UWord32 idx) {
+void TMMBRSet::ClearEntry(uint32_t idx) {
SetEntry(idx, 0, 0, 0);
}
@@ -115,7 +115,7 @@
}
TMMBRSet*
-TMMBRHelp::VerifyAndAllocateBoundingSet(WebRtc_UWord32 minimumSize)
+TMMBRHelp::VerifyAndAllocateBoundingSet(uint32_t minimumSize)
{
CriticalSectionScoped lock(_criticalSection);
@@ -138,9 +138,9 @@
return &_boundingSet;
}
-WebRtc_Word32
+int32_t
TMMBRHelp::SetTMMBRBoundingSetToSend(const TMMBRSet* boundingSetToSend,
- const WebRtc_UWord32 maxBitrateKbit)
+ const uint32_t maxBitrateKbit)
{
CriticalSectionScoped lock(_criticalSection);
@@ -152,10 +152,10 @@
VerifyAndAllocateBoundingSetToSend(boundingSetToSend->lengthOfSet());
_boundingSetToSend.clearSet();
- for (WebRtc_UWord32 i = 0; i < boundingSetToSend->lengthOfSet(); i++)
+ for (uint32_t i = 0; i < boundingSetToSend->lengthOfSet(); i++)
{
// cap at our configured max bitrate
- WebRtc_UWord32 bitrate = boundingSetToSend->Tmmbr(i);
+ uint32_t bitrate = boundingSetToSend->Tmmbr(i);
if(maxBitrateKbit)
{
// do we have a configured max bitrate?
@@ -171,8 +171,8 @@
return 0;
}
-WebRtc_Word32
-TMMBRHelp::VerifyAndAllocateBoundingSetToSend(WebRtc_UWord32 minimumSize)
+int32_t
+TMMBRHelp::VerifyAndAllocateBoundingSetToSend(uint32_t minimumSize)
{
CriticalSectionScoped lock(_criticalSection);
@@ -181,7 +181,7 @@
}
TMMBRSet*
-TMMBRHelp::VerifyAndAllocateCandidateSet(WebRtc_UWord32 minimumSize)
+TMMBRHelp::VerifyAndAllocateCandidateSet(uint32_t minimumSize)
{
CriticalSectionScoped lock(_criticalSection);
@@ -201,7 +201,7 @@
return &_boundingSetToSend;
}
-WebRtc_Word32
+int32_t
TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet)
{
CriticalSectionScoped lock(_criticalSection);
@@ -211,7 +211,7 @@
candidateSet.VerifyAndAllocateSet(_candidateSet.sizeOfSet());
// TODO(hta) Figure out if this should be lengthOfSet instead.
- for (WebRtc_UWord32 i = 0; i < _candidateSet.sizeOfSet(); i++)
+ for (uint32_t i = 0; i < _candidateSet.sizeOfSet(); i++)
{
if(_candidateSet.Tmmbr(i))
{
@@ -229,9 +229,9 @@
}
// Number of set candidates
- WebRtc_Word32 numSetCandidates = candidateSet.lengthOfSet();
+ int32_t numSetCandidates = candidateSet.lengthOfSet();
// Find bounding set
- WebRtc_UWord32 numBoundingSet = 0;
+ uint32_t numBoundingSet = 0;
if (numSetCandidates > 0)
{
numBoundingSet = FindTMMBRBoundingSet(numSetCandidates, candidateSet);
@@ -245,18 +245,18 @@
}
-WebRtc_Word32
-TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidateSet)
+int32_t
+TMMBRHelp::FindTMMBRBoundingSet(int32_t numCandidates, TMMBRSet& candidateSet)
{
CriticalSectionScoped lock(_criticalSection);
- WebRtc_UWord32 numBoundingSet = 0;
+ uint32_t numBoundingSet = 0;
VerifyAndAllocateBoundingSet(candidateSet.sizeOfSet());
if (numCandidates == 1)
{
// TODO(hta): lengthOfSet instead of sizeOfSet?
- for (WebRtc_UWord32 i = 0; i < candidateSet.sizeOfSet(); i++)
+ for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
{
if (candidateSet.Tmmbr(i) > 0)
{
@@ -284,15 +284,15 @@
}
}
// 2. For tuples with same OH, keep the one w/ the lowest bitrate
- for (WebRtc_UWord32 i = 0; i < candidateSet.sizeOfSet(); i++)
+ for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
{
if (candidateSet.Tmmbr(i) > 0)
{
// get min bitrate for packets w/ same OH
- WebRtc_UWord32 currentPacketOH = candidateSet.PacketOH(i);
- WebRtc_UWord32 currentMinTMMBR = candidateSet.Tmmbr(i);
- WebRtc_UWord32 currentMinIndexTMMBR = i;
- for (WebRtc_UWord32 j = i+1; j < candidateSet.sizeOfSet(); j++)
+ uint32_t currentPacketOH = candidateSet.PacketOH(i);
+ uint32_t currentMinTMMBR = candidateSet.Tmmbr(i);
+ uint32_t currentMinIndexTMMBR = i;
+ for (uint32_t j = i+1; j < candidateSet.sizeOfSet(); j++)
{
if(candidateSet.PacketOH(j) == currentPacketOH)
{
@@ -304,7 +304,7 @@
}
}
// keep lowest bitrate
- for (WebRtc_UWord32 j = 0; j < candidateSet.sizeOfSet(); j++)
+ for (uint32_t j = 0; j < candidateSet.sizeOfSet(); j++)
{
if(candidateSet.PacketOH(j) == currentPacketOH
&& j != currentMinIndexTMMBR)
@@ -316,9 +316,9 @@
}
// 3. Select and remove tuple w/ lowest tmmbr.
// (If more than 1, choose the one w/ highest OH).
- WebRtc_UWord32 minTMMBR = 0;
- WebRtc_UWord32 minIndexTMMBR = 0;
- for (WebRtc_UWord32 i = 0; i < candidateSet.sizeOfSet(); i++)
+ uint32_t minTMMBR = 0;
+ uint32_t minIndexTMMBR = 0;
+ for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
{
if (candidateSet.Tmmbr(i) > 0)
{
@@ -328,7 +328,7 @@
}
}
- for (WebRtc_UWord32 i = 0; i < candidateSet.sizeOfSet(); i++)
+ for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
{
if (candidateSet.Tmmbr(i) > 0 && candidateSet.Tmmbr(i) <= minTMMBR)
{
@@ -356,7 +356,7 @@
// 4. Discard from candidate list all tuple w/ lower OH
// (next tuple must be steeper)
- for (WebRtc_UWord32 i = 0; i < candidateSet.sizeOfSet(); i++)
+ for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
{
if(candidateSet.Tmmbr(i) > 0
&& candidateSet.PacketOH(i) < _boundingSet.PacketOH(0))
@@ -383,7 +383,7 @@
if (getNewCandidate)
{
// 5. Remove first remaining tuple from candidate list
- for (WebRtc_UWord32 i = 0; i < candidateSet.sizeOfSet(); i++)
+ for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
{
if (candidateSet.Tmmbr(i) > 0)
{
@@ -443,15 +443,15 @@
return numBoundingSet;
}
-bool TMMBRHelp::IsOwner(const WebRtc_UWord32 ssrc,
- const WebRtc_UWord32 length) const {
+bool TMMBRHelp::IsOwner(const uint32_t ssrc,
+ const uint32_t length) const {
CriticalSectionScoped lock(_criticalSection);
if (length == 0) {
// Empty bounding set.
return false;
}
- for(WebRtc_UWord32 i = 0;
+ for(uint32_t i = 0;
(i < length) && (i < _boundingSet.sizeOfSet()); ++i) {
if(_boundingSet.Ssrc(i) == ssrc) {
return true;
@@ -460,7 +460,7 @@
return false;
}
-bool TMMBRHelp::CalcMinBitRate( WebRtc_UWord32* minBitrateKbit) const {
+bool TMMBRHelp::CalcMinBitRate( uint32_t* minBitrateKbit) const {
CriticalSectionScoped lock(_criticalSection);
if (_candidateSet.sizeOfSet() == 0) {
@@ -469,8 +469,8 @@
}
*minBitrateKbit = std::numeric_limits<uint32_t>::max();
- for (WebRtc_UWord32 i = 0; i < _candidateSet.lengthOfSet(); ++i) {
- WebRtc_UWord32 curNetBitRateKbit = _candidateSet.Tmmbr(i);
+ for (uint32_t i = 0; i < _candidateSet.lengthOfSet(); ++i) {
+ uint32_t curNetBitRateKbit = _candidateSet.Tmmbr(i);
if (curNetBitRateKbit < MIN_VIDEO_BW_MANAGEMENT_BITRATE) {
curNetBitRateKbit = MIN_VIDEO_BW_MANAGEMENT_BITRATE;
}
diff --git a/webrtc/modules/rtp_rtcp/source/tmmbr_help.h b/webrtc/modules/rtp_rtcp/source/tmmbr_help.h
index 45ce1c4..055c9ed 100644
--- a/webrtc/modules/rtp_rtcp/source/tmmbr_help.h
+++ b/webrtc/modules/rtp_rtcp/source/tmmbr_help.h
@@ -27,56 +27,56 @@
TMMBRSet();
~TMMBRSet();
- void VerifyAndAllocateSet(WebRtc_UWord32 minimumSize);
- void VerifyAndAllocateSetKeepingData(WebRtc_UWord32 minimumSize);
+ void VerifyAndAllocateSet(uint32_t minimumSize);
+ void VerifyAndAllocateSetKeepingData(uint32_t minimumSize);
// Number of valid data items in set.
- WebRtc_UWord32 lengthOfSet() const { return _lengthOfSet; }
+ uint32_t lengthOfSet() const { return _lengthOfSet; }
// Presently allocated max size of set.
- WebRtc_UWord32 sizeOfSet() const { return _sizeOfSet; }
+ uint32_t sizeOfSet() const { return _sizeOfSet; }
void clearSet() {
_lengthOfSet = 0;
}
- WebRtc_UWord32 Tmmbr(int i) const {
+ uint32_t Tmmbr(int i) const {
return _data.at(i).tmmbr;
}
- WebRtc_UWord32 PacketOH(int i) const {
+ uint32_t PacketOH(int i) const {
return _data.at(i).packet_oh;
}
- WebRtc_UWord32 Ssrc(int i) const {
+ uint32_t Ssrc(int i) const {
return _data.at(i).ssrc;
}
void SetEntry(unsigned int i,
- WebRtc_UWord32 tmmbrSet,
- WebRtc_UWord32 packetOHSet,
- WebRtc_UWord32 ssrcSet);
+ uint32_t tmmbrSet,
+ uint32_t packetOHSet,
+ uint32_t ssrcSet);
- void AddEntry(WebRtc_UWord32 tmmbrSet,
- WebRtc_UWord32 packetOHSet,
- WebRtc_UWord32 ssrcSet);
+ void AddEntry(uint32_t tmmbrSet,
+ uint32_t packetOHSet,
+ uint32_t ssrcSet);
// Remove one entry from table, and move all others down.
- void RemoveEntry(WebRtc_UWord32 sourceIdx);
+ void RemoveEntry(uint32_t sourceIdx);
- void SwapEntries(WebRtc_UWord32 firstIdx,
- WebRtc_UWord32 secondIdx);
+ void SwapEntries(uint32_t firstIdx,
+ uint32_t secondIdx);
// Set entry data to zero, but keep it in table.
- void ClearEntry(WebRtc_UWord32 idx);
+ void ClearEntry(uint32_t idx);
private:
class SetElement {
public:
SetElement() : tmmbr(0), packet_oh(0), ssrc(0) {}
- WebRtc_UWord32 tmmbr;
- WebRtc_UWord32 packet_oh;
- WebRtc_UWord32 ssrc;
+ uint32_t tmmbr;
+ uint32_t packet_oh;
+ uint32_t ssrc;
};
std::vector<SetElement> _data;
// Number of places allocated.
- WebRtc_UWord32 _sizeOfSet;
+ uint32_t _sizeOfSet;
// NUmber of places currently in use.
- WebRtc_UWord32 _lengthOfSet;
+ uint32_t _lengthOfSet;
};
class TMMBRHelp
@@ -89,21 +89,21 @@
TMMBRSet* CandidateSet();
TMMBRSet* BoundingSetToSend();
- TMMBRSet* VerifyAndAllocateCandidateSet(const WebRtc_UWord32 minimumSize);
- WebRtc_Word32 FindTMMBRBoundingSet(TMMBRSet*& boundingSet);
- WebRtc_Word32 SetTMMBRBoundingSetToSend(
+ TMMBRSet* VerifyAndAllocateCandidateSet(const uint32_t minimumSize);
+ int32_t FindTMMBRBoundingSet(TMMBRSet*& boundingSet);
+ int32_t SetTMMBRBoundingSetToSend(
const TMMBRSet* boundingSetToSend,
- const WebRtc_UWord32 maxBitrateKbit);
+ const uint32_t maxBitrateKbit);
- bool IsOwner(const WebRtc_UWord32 ssrc, const WebRtc_UWord32 length) const;
+ bool IsOwner(const uint32_t ssrc, const uint32_t length) const;
- bool CalcMinBitRate(WebRtc_UWord32* minBitrateKbit) const;
+ bool CalcMinBitRate(uint32_t* minBitrateKbit) const;
protected:
- TMMBRSet* VerifyAndAllocateBoundingSet(WebRtc_UWord32 minimumSize);
- WebRtc_Word32 VerifyAndAllocateBoundingSetToSend(WebRtc_UWord32 minimumSize);
+ TMMBRSet* VerifyAndAllocateBoundingSet(uint32_t minimumSize);
+ int32_t VerifyAndAllocateBoundingSetToSend(uint32_t minimumSize);
- WebRtc_Word32 FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidateSet);
+ int32_t FindTMMBRBoundingSet(int32_t numCandidates, TMMBRSet& candidateSet);
private:
CriticalSectionWrapper* _criticalSection;
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.cc
index 1a55e4e..e917e93 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.cc
@@ -38,7 +38,7 @@
}
-int BWEConvergenceTestUp::Init(std::string ip, WebRtc_UWord16 port)
+int BWEConvergenceTestUp::Init(std::string ip, uint16_t port)
{
// create the load generator object
const int rtpSampleRate = 90000;
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.h
index b830d14..0226787 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.h
@@ -25,7 +25,7 @@
BWEConvergenceTestUp(std::string testName, int startRateKbps, int availBWkbps);
virtual ~BWEConvergenceTestUp();
- virtual int Init(std::string ip, WebRtc_UWord16 port);
+ virtual int Init(std::string ip, uint16_t port);
protected:
virtual bool StoppingCriterionMaster();
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.cc
index 1fd19fe..886ad85 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.cc
@@ -35,7 +35,7 @@
}
-int BWEStabilityTest::Init(std::string ip, WebRtc_UWord16 port)
+int BWEStabilityTest::Init(std::string ip, uint16_t port)
{
// create the load generator object
const int rtpSampleRate = 90000;
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.h
index 8f213b1..dc23557 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.h
@@ -25,7 +25,7 @@
BWEStabilityTest(std::string testName, int rateKbps, int testDurationSeconds);
virtual ~BWEStabilityTest();
- virtual int Init(std::string ip, WebRtc_UWord16 port);
+ virtual int Init(std::string ip, uint16_t port);
virtual void Report(std::fstream &log);
protected:
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
index 471ea5f..1f01c70 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
@@ -32,36 +32,36 @@
myTransportCB (RtpRtcp *rtpMod) : _rtpMod(rtpMod) {};
protected:
// Inherited from UdpTransportData
- virtual void IncomingRTPPacket(const WebRtc_Word8* incomingRtpPacket,
- const WebRtc_Word32 rtpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort);
+ virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket,
+ const int32_t rtpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort);
- virtual void IncomingRTCPPacket(const WebRtc_Word8* incomingRtcpPacket,
- const WebRtc_Word32 rtcpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort);
+ virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
+ const int32_t rtcpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort);
private:
RtpRtcp *_rtpMod;
};
-void myTransportCB::IncomingRTPPacket(const WebRtc_Word8* incomingRtpPacket,
- const WebRtc_Word32 rtpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort)
+void myTransportCB::IncomingRTPPacket(const int8_t* incomingRtpPacket,
+ const int32_t rtpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort)
{
printf("Receiving RTP from IP %s, port %u\n", fromIP, fromPort);
- _rtpMod->IncomingPacket((WebRtc_UWord8 *) incomingRtpPacket, static_cast<WebRtc_UWord16>(rtpPacketLength));
+ _rtpMod->IncomingPacket((uint8_t *) incomingRtpPacket, static_cast<uint16_t>(rtpPacketLength));
}
-void myTransportCB::IncomingRTCPPacket(const WebRtc_Word8* incomingRtcpPacket,
- const WebRtc_Word32 rtcpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort)
+void myTransportCB::IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
+ const int32_t rtcpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort)
{
printf("Receiving RTCP from IP %s, port %u\n", fromIP, fromPort);
- _rtpMod->IncomingPacket((WebRtc_UWord8 *) incomingRtcpPacket, static_cast<WebRtc_UWord16>(rtcpPacketLength));
+ _rtpMod->IncomingPacket((uint8_t *) incomingRtcpPacket, static_cast<uint16_t>(rtcpPacketLength));
}
@@ -69,7 +69,7 @@
{
bool isSender = false;
bool isReceiver = false;
- WebRtc_UWord16 port;
+ uint16_t port;
std::string ip;
TestSenderReceiver *sendrec = new TestSenderReceiver();
TestLoadGenerator *gen;
@@ -105,12 +105,12 @@
if (isSender)
{
- const WebRtc_UWord32 startRateKbps = 1000;
+ const uint32_t startRateKbps = 1000;
//gen = new CBRGenerator(sendrec, 1000, 500);
gen = new CBRFixFRGenerator(sendrec, startRateKbps, 90000, 30, 0.2);
//gen = new PeriodicKeyFixFRGenerator(sendrec, startRateKbps, 90000, 30, 0.2, 7, 300);
- //const WebRtc_UWord16 numFrameRates = 5;
- //const WebRtc_UWord8 frameRates[numFrameRates] = {30, 15, 20, 23, 25};
+ //const uint16_t numFrameRates = 5;
+ //const uint8_t frameRates[numFrameRates] = {30, 15, 20, 23, 25};
//gen = new CBRVarFRGenerator(sendrec, 1000, frameRates, numFrameRates, 90000, 4.0, 0.1, 0.2);
//gen = new CBRFrameDropGenerator(sendrec, startRateKbps, 90000, 0.2);
sendrec->SetLoadGenerator(gen);
@@ -130,7 +130,7 @@
delete sendrec;
- //WebRtc_UWord8 numberOfSocketThreads = 1;
+ //uint8_t numberOfSocketThreads = 1;
//UdpTransport* transport = UdpTransport::Create(0, numberOfSocketThreads);
//RtpRtcp* rtp = RtpRtcp::CreateRtpRtcp(1, false);
@@ -153,7 +153,7 @@
// transport->InitializeReceiveSockets(tp, 10000, "0.0.0.0");
// transport->StartReceiving(500);
- // WebRtc_Word8 data[100];
+ // int8_t data[100];
// for (int i = 0; i < 100; data[i] = i++);
// for (int i = 0; i < 100; i++)
@@ -163,11 +163,11 @@
- // WebRtc_Word32 totTime = 0;
+ // int32_t totTime = 0;
// while (totTime < 10000)
// {
// transport->Process();
- // WebRtc_Word32 wTime = transport->TimeUntilNextProcess();
+ // int32_t wTime = transport->TimeUntilNextProcess();
// totTime += wTime;
// Sleep(wTime);
// }
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.cc
index 2940abd..8b289a5 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.cc
@@ -235,7 +235,7 @@
}
-int BWETest::Init(std::string ip, WebRtc_UWord16 port)
+int BWETest::Init(std::string ip, uint16_t port)
{
if (_initialized)
{
@@ -403,17 +403,17 @@
// SenderReceiver callback
-void BWETest::OnOnNetworkChanged(const WebRtc_UWord32 bitrateTargetBps,
- const WebRtc_UWord8 fractionLost,
- const WebRtc_UWord16 roundTripTimeMs,
- const WebRtc_UWord32 jitterMS,
- const WebRtc_UWord16 bwEstimateKbitMin,
- const WebRtc_UWord16 bwEstimateKbitMax)
+void BWETest::OnOnNetworkChanged(const uint32_t bitrateTargetBps,
+ const uint8_t fractionLost,
+ const uint16_t roundTripTimeMs,
+ const uint32_t jitterMS,
+ const uint16_t bwEstimateKbitMin,
+ const uint16_t bwEstimateKbitMax)
{
CriticalSectionScoped cs(_statCritSect);
// bitrate statistics
- WebRtc_Word32 newBitrateKbps = bitrateTargetBps/1000;
+ int32_t newBitrateKbps = bitrateTargetBps/1000;
_rateVecKbps.push_back(newBitrateKbps);
_rttVecMs.push_back(roundTripTimeMs);
@@ -421,7 +421,7 @@
}
-int BWEOneWayTest::Init(std::string ip, WebRtc_UWord16 port)
+int BWEOneWayTest::Init(std::string ip, uint16_t port)
{
if (!_master)
@@ -442,10 +442,10 @@
if (!_master)
{
// send one dummy RTP packet to enable RTT measurements
- const WebRtc_UWord8 dummy = 0;
+ const uint8_t dummy = 0;
//_gen->sendPayload(TickTime::MillisecondTimestamp(), &dummy, 0);
_sendrec->SendOutgoingData(
- static_cast<WebRtc_UWord32>(TickTime::MillisecondTimestamp()*90),
+ static_cast<uint32_t>(TickTime::MillisecondTimestamp()*90),
&dummy, 1, webrtc::kVideoFrameDelta);
}
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.h
index bab1b94..06dd803 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.h
@@ -41,7 +41,7 @@
bool SetMaster(bool isMaster = true);
void UseRecvTimeout() { _sendrec->SetPacketTimeout(1000); };
- virtual int Init(std::string ip, WebRtc_UWord16 port);
+ virtual int Init(std::string ip, uint16_t port);
virtual bool Start();
virtual bool Stop();
bool ProcLoop(void);
@@ -49,12 +49,12 @@
std::string TestName() { return (_testName); };
// SenderReceiver callback
- virtual void OnOnNetworkChanged(const WebRtc_UWord32 bitrateTargetBps,
- const WebRtc_UWord8 fractionLost,
- const WebRtc_UWord16 roundTripTimeMs,
- const WebRtc_UWord32 jitterMS,
- const WebRtc_UWord16 bwEstimateKbitMin,
- const WebRtc_UWord16 bwEstimateKbitMax);
+ virtual void OnOnNetworkChanged(const uint32_t bitrateTargetBps,
+ const uint8_t fractionLost,
+ const uint16_t roundTripTimeMs,
+ const uint32_t jitterMS,
+ const uint16_t bwEstimateKbitMin,
+ const uint16_t bwEstimateKbitMax);
protected:
@@ -72,8 +72,8 @@
bool _running;
EventWrapper *_eventPtr;
ThreadWrapper* _procThread;
- WebRtc_Word64 _startTimeMs;
- WebRtc_Word64 _stopTimeMs;
+ int64_t _startTimeMs;
+ int64_t _stopTimeMs;
// Statistics, protected by separate CritSect
CriticalSectionWrapper* _statCritSect;
@@ -89,7 +89,7 @@
BWEOneWayTest(std::string testName, int startRateKbps) :
BWETest(testName, startRateKbps) {};
- virtual int Init(std::string ip, WebRtc_UWord16 port);
+ virtual int Init(std::string ip, uint16_t port);
virtual bool Start();
protected:
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETester.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETester.cc
index f1d79fe..7f19410 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETester.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETester.cc
@@ -148,7 +148,7 @@
{
bool isMaster = false;
- WebRtc_UWord16 port;
+ uint16_t port;
std::string ip;
std::fstream log;
log.open("TestLog.txt", std::fstream::out | std::fstream::app);
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.cc
index 043c7b0..1c0acc2 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.cc
@@ -38,7 +38,7 @@
}
-int BWETwoWayLimitFinding::Init(std::string ip, WebRtc_UWord16 port)
+int BWETwoWayLimitFinding::Init(std::string ip, uint16_t port)
{
// create the load generator object
const int rtpSampleRate = 90000;
@@ -64,7 +64,7 @@
_forwLimitReached = true;
}
- WebRtc_Word32 revRateKbps = _sendrec->ReceiveBitrateKbps();
+ int32_t revRateKbps = _sendrec->ReceiveBitrateKbps();
if (revRateKbps > (0.95 * _incomingAvailBWkbps))
{
_revLimitReached = true;
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.h
index fc790e5..4fef0e6 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.h
@@ -23,7 +23,7 @@
virtual ~BWETwoWayLimitFinding();
- virtual int Init(std::string ip, WebRtc_UWord16 port);
+ virtual int Init(std::string ip, uint16_t port);
protected:
virtual bool StoppingCriterionMaster();
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.cc
index 9c81fd0..939cd8a 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.cc
@@ -66,7 +66,7 @@
void MatlabLine::Append(double x, double y)
{
- if (_maxLen > 0 && _xData.size() > static_cast<WebRtc_UWord32>(_maxLen))
+ if (_maxLen > 0 && _xData.size() > static_cast<uint32_t>(_maxLen))
{
_xData.resize(_maxLen);
_yData.resize(_maxLen);
@@ -312,7 +312,7 @@
MatlabTimeLine::MatlabTimeLine(int horizonSeconds /*= -1*/, const char *plotAttrib /*= NULL*/,
const char *name /*= NULL*/,
- WebRtc_Word64 refTimeMs /* = -1*/)
+ int64_t refTimeMs /* = -1*/)
:
_timeHorizon(horizonSeconds),
MatlabLine(-1, plotAttrib, name) // infinite number of elements
@@ -340,7 +340,7 @@
- _timeHorizon; // remove data points older than this
std::list<double>::reverse_iterator ritx = _xData.rbegin();
- WebRtc_UWord32 removeCount = 0;
+ uint32_t removeCount = 0;
while (ritx != _xData.rend())
{
if (*ritx >= historyLimit)
@@ -366,7 +366,7 @@
}
-WebRtc_Word64 MatlabTimeLine::GetRefTime()
+int64_t MatlabTimeLine::GetRefTime()
{
return(_refTimeMs);
}
@@ -433,7 +433,7 @@
int MatlabPlot::AddTimeLine(int maxLen /*= -1*/, const char *plotAttrib /*= NULL*/, const char *name /*= NULL*/,
- WebRtc_Word64 refTimeMs /*= -1*/)
+ int64_t refTimeMs /*= -1*/)
{
CriticalSectionScoped cs(_critSect);
@@ -1031,7 +1031,7 @@
// things to plot, we have already accessed what we need in the plot
plot->DonePlotting();
- WebRtc_Word64 start = TickTime::MillisecondTimestamp();
+ int64_t start = TickTime::MillisecondTimestamp();
// plot it
int ret = engEvalString(ep, cmd.str().c_str());
printf("time=%I64i\n", TickTime::MillisecondTimestamp() - start);
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.h
index 08c7006..fdf382d 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.h
@@ -74,14 +74,14 @@
{
public:
MatlabTimeLine(int horizonSeconds = -1, const char *plotAttrib = NULL, const char *name = NULL,
- WebRtc_Word64 refTimeMs = -1);
+ int64_t refTimeMs = -1);
~MatlabTimeLine() {};
void Append(double y);
void PurgeOldData();
- WebRtc_Word64 GetRefTime();
+ int64_t GetRefTime();
private:
- WebRtc_Word64 _refTimeMs;
+ int64_t _refTimeMs;
int _timeHorizon;
};
@@ -96,7 +96,7 @@
int AddLine(int maxLen = -1, const char *plotAttrib = NULL, const char *name = NULL);
int AddTimeLine(int maxLen = -1, const char *plotAttrib = NULL, const char *name = NULL,
- WebRtc_Word64 refTimeMs = -1);
+ int64_t refTimeMs = -1);
int GetLineIx(const char *name);
void Append(int lineIndex, double x, double y);
void Append(int lineIndex, double y);
@@ -118,8 +118,8 @@
int MakeTrend(const char *sourceName, const char *trendName, double slope, double offset, const char *plotAttrib = NULL);
#ifdef PLOT_TESTING
- WebRtc_Word64 _plotStartTime;
- WebRtc_Word64 _plotDelay;
+ int64_t _plotStartTime;
+ int64_t _plotDelay;
#endif
private:
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
index d322242..cc49402 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
@@ -31,7 +31,7 @@
}
-TestLoadGenerator::TestLoadGenerator(TestSenderReceiver *sender, WebRtc_Word32 rtpSampleRate)
+TestLoadGenerator::TestLoadGenerator(TestSenderReceiver *sender, int32_t rtpSampleRate)
:
_critSect(CriticalSectionWrapper::CreateCriticalSection()),
_eventPtr(NULL),
@@ -53,7 +53,7 @@
delete _critSect;
}
-WebRtc_Word32 TestLoadGenerator::SetBitrate (WebRtc_Word32 newBitrateKbps)
+int32_t TestLoadGenerator::SetBitrate (int32_t newBitrateKbps)
{
CriticalSectionScoped cs(_critSect);
@@ -70,7 +70,7 @@
}
-WebRtc_Word32 TestLoadGenerator::Start (const char *threadName)
+int32_t TestLoadGenerator::Start (const char *threadName)
{
CriticalSectionScoped cs(_critSect);
@@ -92,7 +92,7 @@
}
-WebRtc_Word32 TestLoadGenerator::Stop ()
+int32_t TestLoadGenerator::Stop ()
{
_critSect.Enter();
@@ -123,13 +123,13 @@
int TestLoadGenerator::generatePayload ()
{
- return(generatePayload( static_cast<WebRtc_UWord32>( TickTime::MillisecondTimestamp() * _rtpSampleRate / 1000 )));
+ return(generatePayload( static_cast<uint32_t>( TickTime::MillisecondTimestamp() * _rtpSampleRate / 1000 )));
}
-int TestLoadGenerator::sendPayload (const WebRtc_UWord32 timeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+int TestLoadGenerator::sendPayload (const uint32_t timeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
const webrtc::FrameType frameType /*= webrtc::kVideoFrameDelta*/)
{
@@ -137,11 +137,11 @@
}
-CBRGenerator::CBRGenerator (TestSenderReceiver *sender, WebRtc_Word32 payloadSizeBytes, WebRtc_Word32 bitrateKbps, WebRtc_Word32 rtpSampleRate)
+CBRGenerator::CBRGenerator (TestSenderReceiver *sender, int32_t payloadSizeBytes, int32_t bitrateKbps, int32_t rtpSampleRate)
:
//_eventPtr(NULL),
_payloadSizeBytes(payloadSizeBytes),
-_payload(new WebRtc_UWord8[payloadSizeBytes]),
+_payload(new uint8_t[payloadSizeBytes]),
TestLoadGenerator(sender, rtpSampleRate)
{
SetBitrate (bitrateKbps);
@@ -164,37 +164,37 @@
bool CBRGenerator::GeneratorLoop ()
{
double periodMs;
- WebRtc_Word64 nextSendTime = TickTime::MillisecondTimestamp();
+ int64_t nextSendTime = TickTime::MillisecondTimestamp();
// no critSect
while (_running)
{
// send data (critSect inside)
- generatePayload( static_cast<WebRtc_UWord32>(nextSendTime * _rtpSampleRate / 1000) );
+ generatePayload( static_cast<uint32_t>(nextSendTime * _rtpSampleRate / 1000) );
// calculate wait time
periodMs = 8.0 * _payloadSizeBytes / ( _bitrateKbps );
- nextSendTime = static_cast<WebRtc_Word64>(nextSendTime + periodMs);
+ nextSendTime = static_cast<int64_t>(nextSendTime + periodMs);
- WebRtc_Word32 waitTime = static_cast<WebRtc_Word32>(nextSendTime - TickTime::MillisecondTimestamp());
+ int32_t waitTime = static_cast<int32_t>(nextSendTime - TickTime::MillisecondTimestamp());
if (waitTime < 0)
{
waitTime = 0;
}
// wait
- _eventPtr->Wait(static_cast<WebRtc_Word32>(waitTime));
+ _eventPtr->Wait(static_cast<int32_t>(waitTime));
}
return true;
}
-int CBRGenerator::generatePayload ( WebRtc_UWord32 timestamp )
+int CBRGenerator::generatePayload ( uint32_t timestamp )
{
CriticalSectionScoped cs(_critSect);
- //WebRtc_UWord8 *payload = new WebRtc_UWord8[_payloadSizeBytes];
+ //uint8_t *payload = new uint8_t[_payloadSizeBytes];
int ret = sendPayload(timestamp, _payload, _payloadSizeBytes);
@@ -207,8 +207,8 @@
/////////////////////
-CBRFixFRGenerator::CBRFixFRGenerator (TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps,
- WebRtc_Word32 rtpSampleRate, WebRtc_Word32 frameRateFps /*= 30*/,
+CBRFixFRGenerator::CBRFixFRGenerator (TestSenderReceiver *sender, int32_t bitrateKbps,
+ int32_t rtpSampleRate, int32_t frameRateFps /*= 30*/,
double spread /*= 0.0*/)
:
//_eventPtr(NULL),
@@ -240,7 +240,7 @@
bool CBRFixFRGenerator::GeneratorLoop ()
{
double periodMs;
- WebRtc_Word64 nextSendTime = TickTime::MillisecondTimestamp();
+ int64_t nextSendTime = TickTime::MillisecondTimestamp();
_critSect.Enter();
@@ -271,22 +271,22 @@
_payload = NULL;
}
- _payloadAllocLen = static_cast<WebRtc_Word32>((_payloadSizeBytes * (1 + _spreadFactor) * 3) / 2 + .5); // 50% extra to avoid frequent re-alloc
- _payload = new WebRtc_UWord8[_payloadAllocLen];
+ _payloadAllocLen = static_cast<int32_t>((_payloadSizeBytes * (1 + _spreadFactor) * 3) / 2 + .5); // 50% extra to avoid frequent re-alloc
+ _payload = new uint8_t[_payloadAllocLen];
}
// send data (critSect inside)
- generatePayload( static_cast<WebRtc_UWord32>(nextSendTime * _rtpSampleRate / 1000) );
+ generatePayload( static_cast<uint32_t>(nextSendTime * _rtpSampleRate / 1000) );
}
_critSect.Leave();
// calculate wait time
periodMs = 1000.0 / _frameRateFps;
- nextSendTime = static_cast<WebRtc_Word64>(nextSendTime + periodMs + 0.5);
+ nextSendTime = static_cast<int64_t>(nextSendTime + periodMs + 0.5);
- WebRtc_Word32 waitTime = static_cast<WebRtc_Word32>(nextSendTime - TickTime::MillisecondTimestamp());
+ int32_t waitTime = static_cast<int32_t>(nextSendTime - TickTime::MillisecondTimestamp());
if (waitTime < 0)
{
waitTime = 0;
@@ -298,20 +298,20 @@
return true;
}
-WebRtc_Word32 CBRFixFRGenerator::nextPayloadSize()
+int32_t CBRFixFRGenerator::nextPayloadSize()
{
const double periodMs = 1000.0 / _frameRateFps;
- return static_cast<WebRtc_Word32>(_bitrateKbps * periodMs / 8 + 0.5);
+ return static_cast<int32_t>(_bitrateKbps * periodMs / 8 + 0.5);
}
-int CBRFixFRGenerator::generatePayload ( WebRtc_UWord32 timestamp )
+int CBRFixFRGenerator::generatePayload ( uint32_t timestamp )
{
CriticalSectionScoped cs(_critSect);
double factor = ((double) rand() - RAND_MAX/2) / RAND_MAX; // [-0.5; 0.5]
factor = 1 + 2 * _spreadFactor * factor; // [1 - _spreadFactor ; 1 + _spreadFactor]
- WebRtc_Word32 thisPayloadBytes = static_cast<WebRtc_Word32>(_payloadSizeBytes * factor);
+ int32_t thisPayloadBytes = static_cast<int32_t>(_payloadSizeBytes * factor);
// sanity
if (thisPayloadBytes > _payloadAllocLen)
{
@@ -325,9 +325,9 @@
/////////////////////
-PeriodicKeyFixFRGenerator::PeriodicKeyFixFRGenerator (TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps,
- WebRtc_Word32 rtpSampleRate, WebRtc_Word32 frameRateFps /*= 30*/,
- double spread /*= 0.0*/, double keyFactor /*= 4.0*/, WebRtc_UWord32 keyPeriod /*= 300*/)
+PeriodicKeyFixFRGenerator::PeriodicKeyFixFRGenerator (TestSenderReceiver *sender, int32_t bitrateKbps,
+ int32_t rtpSampleRate, int32_t frameRateFps /*= 30*/,
+ double spread /*= 0.0*/, double keyFactor /*= 4.0*/, uint32_t keyPeriod /*= 300*/)
:
_keyFactor(keyFactor),
_keyPeriod(keyPeriod),
@@ -336,15 +336,15 @@
{
}
-WebRtc_Word32 PeriodicKeyFixFRGenerator::nextPayloadSize()
+int32_t PeriodicKeyFixFRGenerator::nextPayloadSize()
{
// calculate payload size for a delta frame
- WebRtc_Word32 payloadSizeBytes = static_cast<WebRtc_Word32>(1000 * _bitrateKbps / (8.0 * _frameRateFps * (1.0 + (_keyFactor - 1.0) / _keyPeriod)) + 0.5);
+ int32_t payloadSizeBytes = static_cast<int32_t>(1000 * _bitrateKbps / (8.0 * _frameRateFps * (1.0 + (_keyFactor - 1.0) / _keyPeriod)) + 0.5);
if (_frameCount % _keyPeriod == 0)
{
// this is a key frame, scale the payload size
- payloadSizeBytes = static_cast<WebRtc_Word32>(_keyFactor * _payloadSizeBytes + 0.5);
+ payloadSizeBytes = static_cast<int32_t>(_keyFactor * _payloadSizeBytes + 0.5);
}
_frameCount++;
@@ -353,8 +353,8 @@
////////////////////
-CBRVarFRGenerator::CBRVarFRGenerator(TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps, const WebRtc_UWord8* frameRates,
- WebRtc_UWord16 numFrameRates, WebRtc_Word32 rtpSampleRate, double avgFrPeriodMs,
+CBRVarFRGenerator::CBRVarFRGenerator(TestSenderReceiver *sender, int32_t bitrateKbps, const uint8_t* frameRates,
+ uint16_t numFrameRates, int32_t rtpSampleRate, double avgFrPeriodMs,
double frSpreadFactor, double spreadFactor)
:
_avgFrPeriodMs(avgFrPeriodMs),
@@ -364,7 +364,7 @@
_frChangeTimeMs(TickTime::MillisecondTimestamp() + _avgFrPeriodMs),
CBRFixFRGenerator(sender, bitrateKbps, rtpSampleRate, frameRates[0], spreadFactor)
{
- _frameRates = new WebRtc_UWord8[_numFrameRates];
+ _frameRates = new uint8_t[_numFrameRates];
memcpy(_frameRates, frameRates, _numFrameRates);
}
@@ -375,26 +375,26 @@
void CBRVarFRGenerator::ChangeFrameRate()
{
- const WebRtc_Word64 nowMs = TickTime::MillisecondTimestamp();
+ const int64_t nowMs = TickTime::MillisecondTimestamp();
if (nowMs < _frChangeTimeMs)
{
return;
}
// Time to change frame rate
- WebRtc_UWord16 frIndex = static_cast<WebRtc_UWord16>(static_cast<double>(rand()) / RAND_MAX
+ uint16_t frIndex = static_cast<uint16_t>(static_cast<double>(rand()) / RAND_MAX
* (_numFrameRates - 1) + 0.5) ;
assert(frIndex < _numFrameRates);
_frameRateFps = _frameRates[frIndex];
// Update the next frame rate change time
double factor = ((double) rand() - RAND_MAX/2) / RAND_MAX; // [-0.5; 0.5]
factor = 1 + 2 * _frSpreadFactor * factor; // [1 - _frSpreadFactor ; 1 + _frSpreadFactor]
- _frChangeTimeMs = nowMs + static_cast<WebRtc_Word64>(1000.0 * factor *
- _avgFrPeriodMs + 0.5);
+ _frChangeTimeMs = nowMs + static_cast<int64_t>(1000.0 * factor *
+ _avgFrPeriodMs + 0.5);
printf("New frame rate: %d\n", _frameRateFps);
}
-WebRtc_Word32 CBRVarFRGenerator::nextPayloadSize()
+int32_t CBRVarFRGenerator::nextPayloadSize()
{
ChangeFrameRate();
return CBRFixFRGenerator::nextPayloadSize();
@@ -402,8 +402,8 @@
////////////////////
-CBRFrameDropGenerator::CBRFrameDropGenerator(TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps,
- WebRtc_Word32 rtpSampleRate, double spreadFactor)
+CBRFrameDropGenerator::CBRFrameDropGenerator(TestSenderReceiver *sender, int32_t bitrateKbps,
+ int32_t rtpSampleRate, double spreadFactor)
:
_accBits(0),
CBRFixFRGenerator(sender, bitrateKbps, rtpSampleRate, 30, spreadFactor)
@@ -414,7 +414,7 @@
{
}
-WebRtc_Word32 CBRFrameDropGenerator::nextPayloadSize()
+int32_t CBRFrameDropGenerator::nextPayloadSize()
{
_accBits -= 1000 * _bitrateKbps / _frameRateFps;
if (_accBits < 0)
@@ -430,8 +430,8 @@
{
//printf("keep\n");
const double periodMs = 1000.0 / _frameRateFps;
- WebRtc_Word32 frameSize = static_cast<WebRtc_Word32>(_bitrateKbps * periodMs / 8 + 0.5);
- frameSize = std::max(frameSize, static_cast<WebRtc_Word32>(300 * periodMs / 8 + 0.5));
+ int32_t frameSize = static_cast<int32_t>(_bitrateKbps * periodMs / 8 + 0.5);
+ frameSize = std::max(frameSize, static_cast<int32_t>(300 * periodMs / 8 + 0.5));
_accBits += frameSize * 8;
return frameSize;
}
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h
index c22591c..232796a 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h
@@ -26,85 +26,85 @@
class TestLoadGenerator
{
public:
- TestLoadGenerator (TestSenderReceiver *sender, WebRtc_Word32 rtpSampleRate = 90000);
+ TestLoadGenerator (TestSenderReceiver *sender, int32_t rtpSampleRate = 90000);
virtual ~TestLoadGenerator ();
- WebRtc_Word32 SetBitrate (WebRtc_Word32 newBitrateKbps);
- virtual WebRtc_Word32 Start (const char *threadName = NULL);
- virtual WebRtc_Word32 Stop ();
+ int32_t SetBitrate (int32_t newBitrateKbps);
+ virtual int32_t Start (const char *threadName = NULL);
+ virtual int32_t Stop ();
virtual bool GeneratorLoop () = 0;
protected:
- virtual int generatePayload ( WebRtc_UWord32 timestamp ) = 0;
+ virtual int generatePayload ( uint32_t timestamp ) = 0;
int generatePayload ();
- int sendPayload (const WebRtc_UWord32 timeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+ int sendPayload (const uint32_t timeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
const webrtc::FrameType frameType = webrtc::kVideoFrameDelta);
webrtc::CriticalSectionWrapper* _critSect;
webrtc::EventWrapper *_eventPtr;
webrtc::ThreadWrapper* _genThread;
- WebRtc_Word32 _bitrateKbps;
+ int32_t _bitrateKbps;
TestSenderReceiver *_sender;
bool _running;
- WebRtc_Word32 _rtpSampleRate;
+ int32_t _rtpSampleRate;
};
class CBRGenerator : public TestLoadGenerator
{
public:
- CBRGenerator (TestSenderReceiver *sender, WebRtc_Word32 payloadSizeBytes, WebRtc_Word32 bitrateKbps, WebRtc_Word32 rtpSampleRate = 90000);
+ CBRGenerator (TestSenderReceiver *sender, int32_t payloadSizeBytes, int32_t bitrateKbps, int32_t rtpSampleRate = 90000);
virtual ~CBRGenerator ();
- virtual WebRtc_Word32 Start () {return (TestLoadGenerator::Start("CBRGenerator"));};
+ virtual int32_t Start () {return (TestLoadGenerator::Start("CBRGenerator"));};
virtual bool GeneratorLoop ();
protected:
- virtual int generatePayload ( WebRtc_UWord32 timestamp );
+ virtual int generatePayload ( uint32_t timestamp );
- WebRtc_Word32 _payloadSizeBytes;
- WebRtc_UWord8 *_payload;
+ int32_t _payloadSizeBytes;
+ uint8_t *_payload;
};
class CBRFixFRGenerator : public TestLoadGenerator // constant bitrate and fixed frame rate
{
public:
- CBRFixFRGenerator (TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps, WebRtc_Word32 rtpSampleRate = 90000,
- WebRtc_Word32 frameRateFps = 30, double spread = 0.0);
+ CBRFixFRGenerator (TestSenderReceiver *sender, int32_t bitrateKbps, int32_t rtpSampleRate = 90000,
+ int32_t frameRateFps = 30, double spread = 0.0);
virtual ~CBRFixFRGenerator ();
- virtual WebRtc_Word32 Start () {return (TestLoadGenerator::Start("CBRFixFRGenerator"));};
+ virtual int32_t Start () {return (TestLoadGenerator::Start("CBRFixFRGenerator"));};
virtual bool GeneratorLoop ();
protected:
- virtual WebRtc_Word32 nextPayloadSize ();
- virtual int generatePayload ( WebRtc_UWord32 timestamp );
+ virtual int32_t nextPayloadSize ();
+ virtual int generatePayload ( uint32_t timestamp );
- WebRtc_Word32 _payloadSizeBytes;
- WebRtc_UWord8 *_payload;
- WebRtc_Word32 _payloadAllocLen;
- WebRtc_Word32 _frameRateFps;
+ int32_t _payloadSizeBytes;
+ uint8_t *_payload;
+ int32_t _payloadAllocLen;
+ int32_t _frameRateFps;
double _spreadFactor;
};
class PeriodicKeyFixFRGenerator : public CBRFixFRGenerator // constant bitrate and fixed frame rate with periodically large frames
{
public:
- PeriodicKeyFixFRGenerator (TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps, WebRtc_Word32 rtpSampleRate = 90000,
- WebRtc_Word32 frameRateFps = 30, double spread = 0.0, double keyFactor = 4.0, WebRtc_UWord32 keyPeriod = 300);
+ PeriodicKeyFixFRGenerator (TestSenderReceiver *sender, int32_t bitrateKbps, int32_t rtpSampleRate = 90000,
+ int32_t frameRateFps = 30, double spread = 0.0, double keyFactor = 4.0, uint32_t keyPeriod = 300);
virtual ~PeriodicKeyFixFRGenerator () {}
protected:
- virtual WebRtc_Word32 nextPayloadSize ();
+ virtual int32_t nextPayloadSize ();
double _keyFactor;
- WebRtc_UWord32 _keyPeriod;
- WebRtc_UWord32 _frameCount;
+ uint32_t _keyPeriod;
+ uint32_t _frameCount;
};
// Probably better to inherit CBRFixFRGenerator from CBRVarFRGenerator, but since
@@ -112,33 +112,33 @@
class CBRVarFRGenerator : public CBRFixFRGenerator // constant bitrate and variable frame rate
{
public:
- CBRVarFRGenerator(TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps, const WebRtc_UWord8* frameRates,
- WebRtc_UWord16 numFrameRates, WebRtc_Word32 rtpSampleRate = 90000, double avgFrPeriodMs = 5.0,
+ CBRVarFRGenerator(TestSenderReceiver *sender, int32_t bitrateKbps, const uint8_t* frameRates,
+ uint16_t numFrameRates, int32_t rtpSampleRate = 90000, double avgFrPeriodMs = 5.0,
double frSpreadFactor = 0.05, double spreadFactor = 0.0);
~CBRVarFRGenerator();
protected:
virtual void ChangeFrameRate();
- virtual WebRtc_Word32 nextPayloadSize ();
+ virtual int32_t nextPayloadSize ();
double _avgFrPeriodMs;
double _frSpreadFactor;
- WebRtc_UWord8* _frameRates;
- WebRtc_UWord16 _numFrameRates;
- WebRtc_Word64 _frChangeTimeMs;
+ uint8_t* _frameRates;
+ uint16_t _numFrameRates;
+ int64_t _frChangeTimeMs;
};
class CBRFrameDropGenerator : public CBRFixFRGenerator // constant bitrate and variable frame rate
{
public:
- CBRFrameDropGenerator(TestSenderReceiver *sender, WebRtc_Word32 bitrateKbps,
- WebRtc_Word32 rtpSampleRate = 90000, double spreadFactor = 0.0);
+ CBRFrameDropGenerator(TestSenderReceiver *sender, int32_t bitrateKbps,
+ int32_t rtpSampleRate = 90000, double spreadFactor = 0.0);
~CBRFrameDropGenerator();
protected:
- virtual WebRtc_Word32 nextPayloadSize();
+ virtual int32_t nextPayloadSize();
double _accBits;
};
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
index 1fc0fd3..85666c5 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
@@ -71,7 +71,7 @@
}
// SocketTransport module
- WebRtc_UWord8 numberOfThreads = 1;
+ uint8_t numberOfThreads = 1;
_transport = UdpTransport::Create(0, numberOfThreads);
if (!_transport)
{
@@ -104,9 +104,9 @@
}
-WebRtc_Word32 TestSenderReceiver::InitReceiver (const WebRtc_UWord16 rtpPort,
- const WebRtc_UWord16 rtcpPort,
- const WebRtc_Word8 payloadType /*= 127*/)
+int32_t TestSenderReceiver::InitReceiver (const uint16_t rtpPort,
+ const uint16_t rtcpPort,
+ const int8_t payloadType /*= 127*/)
{
CriticalSectionScoped cs(_critSect);
@@ -153,7 +153,7 @@
}
-WebRtc_Word32 TestSenderReceiver::Start()
+int32_t TestSenderReceiver::Start()
{
CriticalSectionScoped cs(_critSect);
@@ -191,7 +191,7 @@
}
-WebRtc_Word32 TestSenderReceiver::Stop ()
+int32_t TestSenderReceiver::Stop ()
{
CriticalSectionScoped cs(_critSect);
@@ -232,12 +232,12 @@
while (_running)
{
// ask RTP/RTCP module for wait time
- WebRtc_Word32 rtpWait = _rtp->TimeUntilNextProcess();
+ int32_t rtpWait = _rtp->TimeUntilNextProcess();
// ask SocketTransport module for wait time
- WebRtc_Word32 tpWait = _transport->TimeUntilNextProcess();
+ int32_t tpWait = _transport->TimeUntilNextProcess();
- WebRtc_Word32 minWait = (rtpWait < tpWait) ? rtpWait: tpWait;
+ int32_t minWait = (rtpWait < tpWait) ? rtpWait: tpWait;
minWait = (minWait > 0) ? minWait : 0;
// wait
_eventPtr->Wait(minWait);
@@ -254,23 +254,23 @@
}
-WebRtc_Word32 TestSenderReceiver::ReceiveBitrateKbps ()
+int32_t TestSenderReceiver::ReceiveBitrateKbps ()
{
- WebRtc_UWord32 bytesSent;
- WebRtc_UWord32 packetsSent;
- WebRtc_UWord32 bytesReceived;
- WebRtc_UWord32 packetsReceived;
+ uint32_t bytesSent;
+ uint32_t packetsSent;
+ uint32_t bytesReceived;
+ uint32_t packetsReceived;
if (_rtp->DataCountersRTP(&bytesSent, &packetsSent, &bytesReceived, &packetsReceived) == 0)
{
- WebRtc_Word64 now = TickTime::MillisecondTimestamp();
- WebRtc_Word32 kbps = 0;
+ int64_t now = TickTime::MillisecondTimestamp();
+ int32_t kbps = 0;
if (now > _lastTime)
{
if (_lastTime > 0)
{
// 8 * bytes / ms = kbps
- kbps = static_cast<WebRtc_Word32>(
+ kbps = static_cast<int32_t>(
(8 * (bytesReceived - _lastBytesReceived)) / (now - _lastTime));
}
_lastTime = now;
@@ -283,13 +283,13 @@
}
-WebRtc_Word32 TestSenderReceiver::SetPacketTimeout(const WebRtc_UWord32 timeoutMS)
+int32_t TestSenderReceiver::SetPacketTimeout(const uint32_t timeoutMS)
{
return (_rtp->SetPacketTimeout(timeoutMS, 0 /* RTCP timeout */));
}
-void TestSenderReceiver::OnPacketTimeout(const WebRtc_Word32 id)
+void TestSenderReceiver::OnPacketTimeout(const int32_t id)
{
CriticalSectionScoped lock(_critSect);
@@ -297,7 +297,7 @@
}
-void TestSenderReceiver::OnReceivedPacket(const WebRtc_Word32 id,
+void TestSenderReceiver::OnReceivedPacket(const int32_t id,
const RtpRtcpPacketType packetType)
{
// do nothing
@@ -305,31 +305,31 @@
}
-WebRtc_Word32 TestSenderReceiver::OnReceivedPayloadData(const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
- const webrtc::WebRtcRTPHeader* rtpHeader)
+int32_t TestSenderReceiver::OnReceivedPayloadData(const uint8_t* payloadData,
+ const uint16_t payloadSize,
+ const webrtc::WebRtcRTPHeader* rtpHeader)
{
//printf("OnReceivedPayloadData\n");
return (0);
}
-void TestSenderReceiver::IncomingRTPPacket(const WebRtc_Word8* incomingRtpPacket,
- const WebRtc_Word32 rtpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort)
+void TestSenderReceiver::IncomingRTPPacket(const int8_t* incomingRtpPacket,
+ const int32_t rtpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort)
{
- _rtp->IncomingPacket((WebRtc_UWord8 *) incomingRtpPacket, static_cast<WebRtc_UWord16>(rtpPacketLength));
+ _rtp->IncomingPacket((uint8_t *) incomingRtpPacket, static_cast<uint16_t>(rtpPacketLength));
}
-void TestSenderReceiver::IncomingRTCPPacket(const WebRtc_Word8* incomingRtcpPacket,
- const WebRtc_Word32 rtcpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort)
+void TestSenderReceiver::IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
+ const int32_t rtcpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort)
{
- _rtp->IncomingPacket((WebRtc_UWord8 *) incomingRtcpPacket, static_cast<WebRtc_UWord16>(rtcpPacketLength));
+ _rtp->IncomingPacket((uint8_t *) incomingRtcpPacket, static_cast<uint16_t>(rtcpPacketLength));
}
@@ -339,11 +339,11 @@
///////////////////
-WebRtc_Word32 TestSenderReceiver::InitSender (const WebRtc_UWord32 startBitrateKbps,
- const WebRtc_Word8* ipAddr,
- const WebRtc_UWord16 rtpPort,
- const WebRtc_UWord16 rtcpPort /*= 0*/,
- const WebRtc_Word8 payloadType /*= 127*/)
+int32_t TestSenderReceiver::InitSender (const uint32_t startBitrateKbps,
+ const int8_t* ipAddr,
+ const uint16_t rtpPort,
+ const uint16_t rtcpPort /*= 0*/,
+ const int8_t payloadType /*= 127*/)
{
CriticalSectionScoped cs(_critSect);
@@ -399,17 +399,17 @@
-WebRtc_Word32
-TestSenderReceiver::SendOutgoingData(const WebRtc_UWord32 timeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+int32_t
+TestSenderReceiver::SendOutgoingData(const uint32_t timeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
const webrtc::FrameType frameType /*= webrtc::kVideoFrameDelta*/)
{
return (_rtp->SendOutgoingData(frameType, _payloadType, timeStamp, payloadData, payloadSize));
}
-WebRtc_Word32 TestSenderReceiver::SetLoadGenerator(TestLoadGenerator *generator)
+int32_t TestSenderReceiver::SetLoadGenerator(TestLoadGenerator *generator)
{
CriticalSectionScoped cs(_critSect);
@@ -418,13 +418,13 @@
}
-void TestSenderReceiver::OnNetworkChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 minBitrateBps,
- const WebRtc_UWord32 maxBitrateBps,
- const WebRtc_UWord8 fractionLost,
- const WebRtc_UWord16 roundTripTimeMs,
- const WebRtc_UWord16 bwEstimateKbitMin,
- const WebRtc_UWord16 bwEstimateKbitMax)
+void TestSenderReceiver::OnNetworkChanged(const int32_t id,
+ const uint32_t minBitrateBps,
+ const uint32_t maxBitrateBps,
+ const uint8_t fractionLost,
+ const uint16_t roundTripTimeMs,
+ const uint16_t bwEstimateKbitMin,
+ const uint16_t bwEstimateKbitMax)
{
if (_loadGenerator)
{
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
index 7f7f2f0..e9c65ae 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
@@ -31,11 +31,11 @@
class SendRecCB
{
public:
- virtual void OnOnNetworkChanged(const WebRtc_UWord32 bitrateTarget,
- const WebRtc_UWord8 fractionLost,
- const WebRtc_UWord16 roundTripTimeMs,
- const WebRtc_UWord16 bwEstimateKbitMin,
- const WebRtc_UWord16 bwEstimateKbitMax) = 0;
+ virtual void OnOnNetworkChanged(const uint32_t bitrateTarget,
+ const uint8_t fractionLost,
+ const uint16_t roundTripTimeMs,
+ const uint16_t bwEstimateKbitMin,
+ const uint16_t bwEstimateKbitMax) = 0;
virtual ~SendRecCB() {};
};
@@ -51,99 +51,99 @@
void SetCallback (SendRecCB *cb) { _sendRecCB = cb; };
- WebRtc_Word32 Start();
+ int32_t Start();
- WebRtc_Word32 Stop();
+ int32_t Stop();
bool ProcLoop();
/////////////////////////////////////////////
// Receiver methods
- WebRtc_Word32 InitReceiver (const WebRtc_UWord16 rtpPort,
- const WebRtc_UWord16 rtcpPort = 0,
- const WebRtc_Word8 payloadType = 127);
+ int32_t InitReceiver (const uint16_t rtpPort,
+ const uint16_t rtcpPort = 0,
+ const int8_t payloadType = 127);
- WebRtc_Word32 ReceiveBitrateKbps ();
+ int32_t ReceiveBitrateKbps ();
- WebRtc_Word32 SetPacketTimeout(const WebRtc_UWord32 timeoutMS);
+ int32_t SetPacketTimeout(const uint32_t timeoutMS);
bool timeOutTriggered () { return (_timeOut); };
// Inherited from RtpFeedback
- virtual WebRtc_Word32 OnInitializeDecoder(const WebRtc_Word32 id,
- const WebRtc_Word8 payloadType,
- const WebRtc_Word8 payloadName[RTP_PAYLOAD_NAME_SIZE],
- const WebRtc_UWord32 frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) { return(0);};
+ virtual int32_t OnInitializeDecoder(const int32_t id,
+ const int8_t payloadType,
+ const int8_t payloadName[RTP_PAYLOAD_NAME_SIZE],
+ const uint32_t frequency,
+ const uint8_t channels,
+ const uint32_t rate) { return(0);};
- virtual void OnPacketTimeout(const WebRtc_Word32 id);
+ virtual void OnPacketTimeout(const int32_t id);
- virtual void OnReceivedPacket(const WebRtc_Word32 id,
+ virtual void OnReceivedPacket(const int32_t id,
const RtpRtcpPacketType packetType);
- virtual void OnPeriodicDeadOrAlive(const WebRtc_Word32 id,
+ virtual void OnPeriodicDeadOrAlive(const int32_t id,
const RTPAliveType alive) {};
- virtual void OnIncomingSSRCChanged( const WebRtc_Word32 id,
- const WebRtc_UWord32 SSRC) {};
+ virtual void OnIncomingSSRCChanged( const int32_t id,
+ const uint32_t SSRC) {};
- virtual void OnIncomingCSRCChanged( const WebRtc_Word32 id,
- const WebRtc_UWord32 CSRC,
+ virtual void OnIncomingCSRCChanged( const int32_t id,
+ const uint32_t CSRC,
const bool added) {};
// Inherited from RtpData
- virtual WebRtc_Word32 OnReceivedPayloadData(const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
- const webrtc::WebRtcRTPHeader* rtpHeader);
+ virtual int32_t OnReceivedPayloadData(const uint8_t* payloadData,
+ const uint16_t payloadSize,
+ const webrtc::WebRtcRTPHeader* rtpHeader);
// Inherited from UdpTransportData
- virtual void IncomingRTPPacket(const WebRtc_Word8* incomingRtpPacket,
- const WebRtc_Word32 rtpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort);
+ virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket,
+ const int32_t rtpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort);
- virtual void IncomingRTCPPacket(const WebRtc_Word8* incomingRtcpPacket,
- const WebRtc_Word32 rtcpPacketLength,
- const WebRtc_Word8* fromIP,
- const WebRtc_UWord16 fromPort);
+ virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
+ const int32_t rtcpPacketLength,
+ const int8_t* fromIP,
+ const uint16_t fromPort);
/////////////////////////////////
// Sender methods
- WebRtc_Word32 InitSender (const WebRtc_UWord32 startBitrateKbps,
- const WebRtc_Word8* ipAddr,
- const WebRtc_UWord16 rtpPort,
- const WebRtc_UWord16 rtcpPort = 0,
- const WebRtc_Word8 payloadType = 127);
+ int32_t InitSender (const uint32_t startBitrateKbps,
+ const int8_t* ipAddr,
+ const uint16_t rtpPort,
+ const uint16_t rtcpPort = 0,
+ const int8_t payloadType = 127);
- WebRtc_Word32 SendOutgoingData(const WebRtc_UWord32 timeStamp,
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord32 payloadSize,
+ int32_t SendOutgoingData(const uint32_t timeStamp,
+ const uint8_t* payloadData,
+ const uint32_t payloadSize,
const webrtc::FrameType frameType = webrtc::kVideoFrameDelta);
- WebRtc_Word32 SetLoadGenerator(TestLoadGenerator *generator);
+ int32_t SetLoadGenerator(TestLoadGenerator *generator);
- WebRtc_UWord32 BitrateSent() { return (_rtp->BitrateSent()); };
+ uint32_t BitrateSent() { return (_rtp->BitrateSent()); };
// Inherited from RtpVideoFeedback
- virtual void OnReceivedIntraFrameRequest(const WebRtc_Word32 id,
- const WebRtc_UWord8 message = 0) {};
+ virtual void OnReceivedIntraFrameRequest(const int32_t id,
+ const uint8_t message = 0) {};
- virtual void OnNetworkChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 minBitrateBps,
- const WebRtc_UWord32 maxBitrateBps,
- const WebRtc_UWord8 fractionLost,
- const WebRtc_UWord16 roundTripTimeMs,
- const WebRtc_UWord16 bwEstimateKbitMin,
- const WebRtc_UWord16 bwEstimateKbitMax);
+ virtual void OnNetworkChanged(const int32_t id,
+ const uint32_t minBitrateBps,
+ const uint32_t maxBitrateBps,
+ const uint8_t fractionLost,
+ const uint16_t roundTripTimeMs,
+ const uint16_t bwEstimateKbitMin,
+ const uint16_t bwEstimateKbitMax);
private:
RtpRtcp* _rtp;
@@ -152,14 +152,14 @@
webrtc::EventWrapper *_eventPtr;
webrtc::ThreadWrapper* _procThread;
bool _running;
- WebRtc_Word8 _payloadType;
+ int8_t _payloadType;
TestLoadGenerator* _loadGenerator;
bool _isSender;
bool _isReceiver;
bool _timeOut;
SendRecCB * _sendRecCB;
- WebRtc_UWord32 _lastBytesReceived;
- WebRtc_Word64 _lastTime;
+ uint32_t _lastBytesReceived;
+ int64_t _lastTime;
};
diff --git a/webrtc/modules/rtp_rtcp/test/bitstreamTest/bitstreamTest.cc b/webrtc/modules/rtp_rtcp/test/bitstreamTest/bitstreamTest.cc
index 38b6e15..e947142 100644
--- a/webrtc/modules/rtp_rtcp/test/bitstreamTest/bitstreamTest.cc
+++ b/webrtc/modules/rtp_rtcp/test/bitstreamTest/bitstreamTest.cc
@@ -17,12 +17,12 @@
#include <tchar.h>
#include <windows.h>
-WebRtc_UWord32 BitRateBPS(WebRtc_UWord16 x )
+uint32_t BitRateBPS(uint16_t x )
{
- return (x & 0x3fff) * WebRtc_UWord32(pow(10.0f,(2 + (x >> 14))));
+ return (x & 0x3fff) * uint32_t(pow(10.0f,(2 + (x >> 14))));
}
-WebRtc_UWord16 BitRateBPSInv(WebRtc_UWord32 x )
+uint16_t BitRateBPSInv(uint32_t x )
{
// 16383 0x3fff
// 1 638 300 exp 0
@@ -32,16 +32,16 @@
const float exp = log10(float(x>>14)) - 2;
if(exp < 0.0)
{
- return WebRtc_UWord16(x /100);
+ return uint16_t(x /100);
}else if(exp < 1.0)
{
- return 0x4000 + WebRtc_UWord16(x /1000);
+ return 0x4000 + uint16_t(x /1000);
}else if(exp < 2.0)
{
- return 0x8000 + WebRtc_UWord16(x /10000);
+ return 0x8000 + uint16_t(x /10000);
}else if(exp < 3.0)
{
- return 0xC000 + WebRtc_UWord16(x /100000);
+ return 0xC000 + uint16_t(x /100000);
} else
{
assert(false);
@@ -52,7 +52,7 @@
int _tmain(int argc, _TCHAR* argv[])
{
- WebRtc_UWord8 dataBuffer[128];
+ uint8_t dataBuffer[128];
BitstreamBuilder builder(dataBuffer, sizeof(dataBuffer));
// test 1 to 4 bits
@@ -278,27 +278,27 @@
BitstreamBuilder builderScalabilityInfo(dataBuffer, sizeof(dataBuffer));
BitstreamParser parserScalabilityInfo(dataBuffer, sizeof(dataBuffer));
- const WebRtc_UWord8 numberOfLayers = 4;
- const WebRtc_UWord8 layerId[numberOfLayers] = {0,1,2,3};
- const WebRtc_UWord8 priorityId[numberOfLayers] = {0,1,2,3};
- const WebRtc_UWord8 discardableId[numberOfLayers] = {0,1,1,1};
+ const uint8_t numberOfLayers = 4;
+ const uint8_t layerId[numberOfLayers] = {0,1,2,3};
+ const uint8_t priorityId[numberOfLayers] = {0,1,2,3};
+ const uint8_t discardableId[numberOfLayers] = {0,1,1,1};
- const WebRtc_UWord8 dependencyId[numberOfLayers]= {0,1,1,1};
- const WebRtc_UWord8 qualityId[numberOfLayers]= {0,0,0,1};
- const WebRtc_UWord8 temporalId[numberOfLayers]= {0,0,1,1};
+ const uint8_t dependencyId[numberOfLayers]= {0,1,1,1};
+ const uint8_t qualityId[numberOfLayers]= {0,0,0,1};
+ const uint8_t temporalId[numberOfLayers]= {0,0,1,1};
- const WebRtc_UWord16 avgBitrate[numberOfLayers]= {BitRateBPSInv(100000),
+ const uint16_t avgBitrate[numberOfLayers]= {BitRateBPSInv(100000),
BitRateBPSInv(200000),
BitRateBPSInv(400000),
BitRateBPSInv(800000)};
// todo which one is the sum?
- const WebRtc_UWord16 maxBitrateLayer[numberOfLayers]= {BitRateBPSInv(150000),
+ const uint16_t maxBitrateLayer[numberOfLayers]= {BitRateBPSInv(150000),
BitRateBPSInv(300000),
BitRateBPSInv(500000),
BitRateBPSInv(900000)};
- const WebRtc_UWord16 maxBitrateLayerRepresentation[numberOfLayers] = {BitRateBPSInv(150000),
+ const uint16_t maxBitrateLayerRepresentation[numberOfLayers] = {BitRateBPSInv(150000),
BitRateBPSInv(450000),
BitRateBPSInv(950000),
BitRateBPSInv(1850000)};
@@ -314,7 +314,7 @@
assert( 18500000 == BitRateBPS(BitRateBPSInv(18500000)));
assert( 185000000 == BitRateBPS(BitRateBPSInv(185000000)));
- const WebRtc_UWord16 maxBitrareCalcWindow[numberOfLayers] = {200, 200,200,200};// in 1/100 of second
+ const uint16_t maxBitrareCalcWindow[numberOfLayers] = {200, 200,200,200};// in 1/100 of second
builderScalabilityInfo.Add1Bit(0); // temporal_id_nesting_flag
builderScalabilityInfo.Add1Bit(0); // priority_layer_info_present_flag
@@ -360,11 +360,11 @@
// Scalability Info parser
parserScalabilityInfo.Get1Bit(); // not used in futher parsing
- const WebRtc_UWord8 priority_layer_info_present = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 priority_id_setting_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t priority_layer_info_present = parserScalabilityInfo.Get1Bit();
+ const uint8_t priority_id_setting_flag = parserScalabilityInfo.Get1Bit();
- WebRtc_UWord32 numberOfLayersMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 j = 0; j<= numberOfLayersMinusOne; j++)
+ uint32_t numberOfLayersMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t j = 0; j<= numberOfLayersMinusOne; j++)
{
parserScalabilityInfo.GetUE();
parserScalabilityInfo.Get6Bits();
@@ -373,24 +373,24 @@
parserScalabilityInfo.Get4Bits();
parserScalabilityInfo.Get3Bits();
- const WebRtc_UWord8 sub_pic_layer_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 sub_region_layer_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 iroi_division_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 profile_level_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 bitrate_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 frm_rate_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 frm_size_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 layer_dependency_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 parameter_sets_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 bitstream_restriction_info_present_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 exact_inter_layer_pred_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
+ const uint8_t sub_pic_layer_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t sub_region_layer_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t iroi_division_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t profile_level_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t bitrate_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t frm_rate_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t frm_size_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t layer_dependency_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t parameter_sets_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t bitstream_restriction_info_present_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t exact_inter_layer_pred_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
if(sub_pic_layer_flag || iroi_division_info_present_flag)
{
parserScalabilityInfo.Get1Bit();
}
- const WebRtc_UWord8 layer_conversion_flag = parserScalabilityInfo.Get1Bit();
- const WebRtc_UWord8 layer_output_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
+ const uint8_t layer_conversion_flag = parserScalabilityInfo.Get1Bit();
+ const uint8_t layer_output_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
if(profile_level_info_present_flag)
{
@@ -440,8 +440,8 @@
parserScalabilityInfo.GetUE();
}else
{
- const WebRtc_UWord32 numRoisMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <= numRoisMinusOne; k++)
+ const uint32_t numRoisMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k <= numRoisMinusOne; k++)
{
parserScalabilityInfo.GetUE();
parserScalabilityInfo.GetUE();
@@ -451,8 +451,8 @@
}
if(layer_dependency_info_present_flag)
{
- const WebRtc_UWord32 numDirectlyDependentLayers = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k < numDirectlyDependentLayers; k++)
+ const uint32_t numDirectlyDependentLayers = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k < numDirectlyDependentLayers; k++)
{
parserScalabilityInfo.GetUE();
}
@@ -462,18 +462,18 @@
}
if(parameter_sets_info_present_flag)
{
- const WebRtc_UWord32 numSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <= numSeqParameterSetMinusOne; k++)
+ const uint32_t numSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k <= numSeqParameterSetMinusOne; k++)
{
parserScalabilityInfo.GetUE();
}
- const WebRtc_UWord32 numSubsetSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 l = 0; l <= numSubsetSeqParameterSetMinusOne; l++)
+ const uint32_t numSubsetSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t l = 0; l <= numSubsetSeqParameterSetMinusOne; l++)
{
parserScalabilityInfo.GetUE();
}
- const WebRtc_UWord32 numPicParameterSetMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 m = 0; m <= numPicParameterSetMinusOne; m++)
+ const uint32_t numPicParameterSetMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t m = 0; m <= numPicParameterSetMinusOne; m++)
{
parserScalabilityInfo.GetUE();
}
@@ -494,7 +494,7 @@
if(layer_conversion_flag)
{
parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <2;k++)
+ for(uint32_t k = 0; k <2;k++)
{
if(parserScalabilityInfo.Get1Bit())
{
@@ -507,12 +507,12 @@
}
if(priority_layer_info_present)
{
- const WebRtc_UWord32 prNumDidMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 k = 0; k <= prNumDidMinusOne;k++)
+ const uint32_t prNumDidMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t k = 0; k <= prNumDidMinusOne;k++)
{
parserScalabilityInfo.Get3Bits();
- const WebRtc_UWord32 prNumMinusOne = parserScalabilityInfo.GetUE();
- for(WebRtc_UWord32 l = 0; l <= prNumMinusOne; l++)
+ const uint32_t prNumMinusOne = parserScalabilityInfo.GetUE();
+ for(uint32_t l = 0; l <= prNumMinusOne; l++)
{
parserScalabilityInfo.GetUE();
parserScalabilityInfo.Get24Bits();
@@ -523,8 +523,8 @@
}
if(priority_id_setting_flag)
{
- WebRtc_UWord8 priorityIdSettingUri;
- WebRtc_UWord32 priorityIdSettingUriIdx = 0;
+ uint8_t priorityIdSettingUri;
+ uint32_t priorityIdSettingUriIdx = 0;
do
{
priorityIdSettingUri = parserScalabilityInfo.Get8Bits();
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc
index fb1b337..4a00935 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc
@@ -41,10 +41,10 @@
int test_id;
RtpRtcp* module;
- WebRtc_UWord32 test_ssrc;
- WebRtc_UWord32 test_timestamp;
- WebRtc_UWord16 test_sequence_number;
- WebRtc_UWord32 test_CSRC[webrtc::kRtpCsrcSize];
+ uint32_t test_ssrc;
+ uint32_t test_timestamp;
+ uint16_t test_sequence_number;
+ uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
};
@@ -80,7 +80,7 @@
TEST_F(RtpRtcpAPITest, CSRC) {
EXPECT_EQ(0, module->SetCSRCs(test_CSRC, 2));
- WebRtc_UWord32 testOfCSRC[webrtc::kRtpCsrcSize];
+ uint32_t testOfCSRC[webrtc::kRtpCsrcSize];
EXPECT_EQ(2, module->CSRCs(testOfCSRC));
EXPECT_EQ(test_CSRC[0], testOfCSRC[0]);
EXPECT_EQ(test_CSRC[1], testOfCSRC[1]);
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
index d3698d4..040ed06 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
@@ -37,13 +37,13 @@
return len;
}
}
- if (_rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (_rtpRtcpModule->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
}
virtual int SendRTCPPacket(int channel, const void *data, int len) {
- if (_rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (_rtpRtcpModule->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
@@ -58,9 +58,9 @@
public:
enum { kMaxPayloadSize = 1500 };
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* payloadData,
+ const uint16_t payloadSize,
const webrtc::WebRtcRTPHeader* rtpHeader) {
EXPECT_LE(payloadSize, kMaxPayloadSize);
memcpy(_payloadData, payloadData, payloadSize);
@@ -69,11 +69,11 @@
return 0;
}
- const WebRtc_UWord8* payload_data() const {
+ const uint8_t* payload_data() const {
return _payloadData;
}
- WebRtc_UWord16 payload_size() const {
+ uint16_t payload_size() const {
return _payloadSize;
}
@@ -82,8 +82,8 @@
}
private:
- WebRtc_UWord8 _payloadData[kMaxPayloadSize];
- WebRtc_UWord16 _payloadSize;
+ uint8_t _payloadData[kMaxPayloadSize];
+ uint16_t _payloadSize;
webrtc::WebRtcRTPHeader _rtpHeader;
};
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
index f59b192..0d1ed9d 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
@@ -24,9 +24,9 @@
class VerifyingAudioReceiver : public RtpData {
public:
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* payloadData,
+ const uint16_t payloadSize,
const webrtc::WebRtcRTPHeader* rtpHeader) {
if (rtpHeader->header.payloadType == 98 ||
rtpHeader->header.payloadType == 99) {
@@ -60,44 +60,44 @@
class RTPCallback : public RtpFeedback {
public:
- virtual WebRtc_Word32 OnInitializeDecoder(
- const WebRtc_Word32 id,
- const WebRtc_Word8 payloadType,
+ virtual int32_t OnInitializeDecoder(
+ const int32_t id,
+ const int8_t payloadType,
const char payloadName[RTP_PAYLOAD_NAME_SIZE],
const int frequency,
- const WebRtc_UWord8 channels,
- const WebRtc_UWord32 rate) {
+ const uint8_t channels,
+ const uint32_t rate) {
if (payloadType == 96) {
EXPECT_EQ(test_rate, rate) <<
"The rate should be 64K for this payloadType";
}
return 0;
}
- virtual void OnPacketTimeout(const WebRtc_Word32 id) {
+ virtual void OnPacketTimeout(const int32_t id) {
}
- virtual void OnReceivedPacket(const WebRtc_Word32 id,
+ virtual void OnReceivedPacket(const int32_t id,
const RtpRtcpPacketType packetType) {
}
- virtual void OnPeriodicDeadOrAlive(const WebRtc_Word32 id,
+ virtual void OnPeriodicDeadOrAlive(const int32_t id,
const RTPAliveType alive) {
}
- virtual void OnIncomingSSRCChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 SSRC) {
+ virtual void OnIncomingSSRCChanged(const int32_t id,
+ const uint32_t SSRC) {
}
- virtual void OnIncomingCSRCChanged(const WebRtc_Word32 id,
- const WebRtc_UWord32 CSRC,
+ virtual void OnIncomingCSRCChanged(const int32_t id,
+ const uint32_t CSRC,
const bool added) {
}
};
class AudioFeedback : public RtpAudioFeedback {
- virtual void OnReceivedTelephoneEvent(const WebRtc_Word32 id,
- const WebRtc_UWord8 event,
+ virtual void OnReceivedTelephoneEvent(const int32_t id,
+ const uint8_t event,
const bool end) {
- static WebRtc_UWord8 expectedEvent = 0;
+ static uint8_t expectedEvent = 0;
if (end) {
- WebRtc_UWord8 oldEvent = expectedEvent-1;
+ uint8_t oldEvent = expectedEvent-1;
if (expectedEvent == 32) {
oldEvent = 15;
}
@@ -110,10 +110,10 @@
expectedEvent = 32;
}
}
- virtual void OnPlayTelephoneEvent(const WebRtc_Word32 id,
- const WebRtc_UWord8 event,
- const WebRtc_UWord16 lengthMs,
- const WebRtc_UWord8 volume) {
+ virtual void OnPlayTelephoneEvent(const int32_t id,
+ const uint8_t event,
+ const uint16_t lengthMs,
+ const uint8_t volume) {
};
};
@@ -179,10 +179,10 @@
LoopBackTransport* transport2;
AudioFeedback* audioFeedback;
RTPCallback* rtp_callback;
- WebRtc_UWord32 test_ssrc;
- WebRtc_UWord32 test_timestamp;
- WebRtc_UWord16 test_sequence_number;
- WebRtc_UWord32 test_CSRC[webrtc::kRtpCsrcSize];
+ uint32_t test_ssrc;
+ uint32_t test_timestamp;
+ uint16_t test_sequence_number;
+ uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
};
@@ -214,7 +214,7 @@
EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
printf("4\n");
- const WebRtc_UWord8 test[5] = "test";
+ const uint8_t test[5] = "test";
EXPECT_EQ(0, module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96,
0, -1, test, 4));
@@ -243,7 +243,7 @@
memcpy(voiceCodec.plname, "RED", 4);
EXPECT_EQ(0, module1->SetSendREDPayloadType(voiceCodec.pltype));
- WebRtc_Word8 red = 0;
+ int8_t red = 0;
EXPECT_EQ(0, module1->SendREDPayloadType(red));
EXPECT_EQ(voiceCodec.pltype, red);
EXPECT_EQ(0, module1->RegisterReceivePayload(voiceCodec));
@@ -251,20 +251,20 @@
RTPFragmentationHeader fragmentation;
fragmentation.fragmentationVectorSize = 2;
- fragmentation.fragmentationLength = new WebRtc_UWord32[2];
+ fragmentation.fragmentationLength = new uint32_t[2];
fragmentation.fragmentationLength[0] = 4;
fragmentation.fragmentationLength[1] = 4;
- fragmentation.fragmentationOffset = new WebRtc_UWord32[2];
+ fragmentation.fragmentationOffset = new uint32_t[2];
fragmentation.fragmentationOffset[0] = 0;
fragmentation.fragmentationOffset[1] = 4;
- fragmentation.fragmentationTimeDiff = new WebRtc_UWord16[2];
+ fragmentation.fragmentationTimeDiff = new uint16_t[2];
fragmentation.fragmentationTimeDiff[0] = 0;
fragmentation.fragmentationTimeDiff[1] = 0;
- fragmentation.fragmentationPlType = new WebRtc_UWord8[2];
+ fragmentation.fragmentationPlType = new uint8_t[2];
fragmentation.fragmentationPlType[0] = 96;
fragmentation.fragmentationPlType[1] = 96;
- const WebRtc_UWord8 test[5] = "test";
+ const uint8_t test[5] = "test";
// Send a RTP packet.
EXPECT_EQ(0, module1->SendOutgoingData(webrtc::kAudioFrameSpeech,
96, 160, -1, test, 4,
@@ -299,7 +299,7 @@
EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
// Start DTMF test.
- WebRtc_UWord32 timeStamp = 160;
+ uint32_t timeStamp = 160;
// Send a DTMF tone using RFC 2833 (4733).
for (int i = 0; i < 16; i++) {
@@ -307,7 +307,7 @@
}
timeStamp += 160; // Prepare for next packet.
- const WebRtc_UWord8 test[9] = "test";
+ const uint8_t test[9] = "test";
// Send RTP packets for 16 tones a 160 ms 100ms
// pause between = 2560ms + 1600ms = 4160ms
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_nack.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_nack.cc
index 1a859c2..92663fa 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_nack.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_nack.cc
@@ -24,9 +24,9 @@
const int kVideoNackListSize = 10;
const int kTestId = 123;
-const WebRtc_UWord32 kTestSsrc = 3456;
-const WebRtc_UWord16 kTestSequenceNumber = 2345;
-const WebRtc_UWord32 kTestNumberOfPackets = 450;
+const uint32_t kTestSsrc = 3456;
+const uint16_t kTestSequenceNumber = 2345;
+const uint32_t kTestNumberOfPackets = 450;
const int kTestNumberOfRtxPackets = 49;
class VerifyingNackReceiver : public RtpData
@@ -34,9 +34,9 @@
public:
VerifyingNackReceiver() {}
- virtual WebRtc_Word32 OnReceivedPayloadData(
- const WebRtc_UWord8* data,
- const WebRtc_UWord16 size,
+ virtual int32_t OnReceivedPayloadData(
+ const uint8_t* data,
+ const uint16_t size,
const webrtc::WebRtcRTPHeader* rtp_header) {
EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc);
@@ -91,13 +91,13 @@
count_ < consecutive_drop_end_) {
return len;
}
- if (module_->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (module_->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
}
virtual int SendRTCPPacket(int channel, const void *data, int len) {
- if (module_->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) {
+ if (module_->IncomingPacket((const uint8_t*)data, len) == 0) {
return len;
}
return -1;
@@ -171,12 +171,12 @@
nack_receiver_->sequence_numbers_.begin();
while (it != nack_receiver_->sequence_numbers_.end()) {
- WebRtc_UWord16 sequence_number_1 = *it;
+ uint16_t sequence_number_1 = *it;
++it;
if (it != nack_receiver_->sequence_numbers_.end()) {
- WebRtc_UWord16 sequence_number_2 = *it;
+ uint16_t sequence_number_2 = *it;
// Add all missing sequence numbers to list
- for (WebRtc_UWord16 i = sequence_number_1 + 1; i < sequence_number_2;
+ for (uint16_t i = sequence_number_1 + 1; i < sequence_number_2;
++i) {
missing_sequence_numbers.push_back(i);
}
@@ -203,13 +203,13 @@
RtpRtcp* video_module_;
NackLoopBackTransport* transport_;
VerifyingNackReceiver* nack_receiver_;
- WebRtc_UWord8 payload_data[65000];
+ uint8_t payload_data[65000];
int payload_data_length;
SimulatedClock fake_clock;
};
TEST_F(RtpRtcpNackTest, RTCP) {
- WebRtc_UWord32 timestamp = 3000;
+ uint32_t timestamp = 3000;
uint16_t nack_list[kVideoNackListSize];
transport_->DropEveryNthPacket(10);
@@ -240,7 +240,7 @@
const int kNumPacketsToDrop = 900;
const int kNumFrames = 30;
const int kNumRequiredRtcp = 4;
- WebRtc_UWord32 timestamp = 3000;
+ uint32_t timestamp = 3000;
uint16_t nack_list[kNumPacketsToDrop];
// Disable StorePackets to be able to set a larger packet history.
EXPECT_EQ(0, video_module_->SetStorePacketsStatus(false, 0));
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
index d15dcc8..681f74e 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
@@ -27,20 +27,20 @@
void SetModule(RtpRtcp* module) {
_rtpRtcpModule = module;
};
- virtual void OnRTCPPacketTimeout(const WebRtc_Word32 id) {
+ virtual void OnRTCPPacketTimeout(const int32_t id) {
}
- virtual void OnLipSyncUpdate(const WebRtc_Word32 id,
- const WebRtc_Word32 audioVideoOffset) {
+ virtual void OnLipSyncUpdate(const int32_t id,
+ const int32_t audioVideoOffset) {
};
virtual void OnXRVoIPMetricReceived(
- const WebRtc_Word32 id,
+ const int32_t id,
const RTCPVoIPMetric* metric) {
};
- virtual void OnApplicationDataReceived(const WebRtc_Word32 id,
- const WebRtc_UWord8 subType,
- const WebRtc_UWord32 name,
- const WebRtc_UWord16 length,
- const WebRtc_UWord8* data) {
+ virtual void OnApplicationDataReceived(const int32_t id,
+ const uint8_t subType,
+ const uint32_t name,
+ const uint16_t length,
+ const uint8_t* data) {
char print_name[5];
print_name[0] = static_cast<char>(name >> 24);
print_name[1] = static_cast<char>(name >> 16);
@@ -50,16 +50,16 @@
EXPECT_STRCASEEQ("test", print_name);
};
- virtual void OnSendReportReceived(const WebRtc_Word32 id,
- const WebRtc_UWord32 senderSSRC,
+ virtual void OnSendReportReceived(const int32_t id,
+ const uint32_t senderSSRC,
uint32_t ntp_secs,
uint32_t ntp_frac,
uint32_t timestamp) {
RTCPSenderInfo senderInfo;
EXPECT_EQ(0, _rtpRtcpModule->RemoteRTCPStat(&senderInfo));
};
- virtual void OnReceiveReportReceived(const WebRtc_Word32 id,
- const WebRtc_UWord32 senderSSRC) {
+ virtual void OnReceiveReportReceived(const int32_t id,
+ const uint32_t senderSSRC) {
};
virtual void OnReceivedIntraFrameRequest(uint32_t ssrc) {
};
@@ -143,7 +143,7 @@
// We need to send one RTP packet to get the RTCP packet to be accepted by
// the receiving module.
// send RTP packet with the data "testtest"
- const WebRtc_UWord8 test[9] = "testtest";
+ const uint8_t test[9] = "testtest";
EXPECT_EQ(0, module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96,
0, -1, test, 8));
}
@@ -167,10 +167,10 @@
RtcpCallback* myRTCPFeedback1;
RtcpCallback* myRTCPFeedback2;
- WebRtc_UWord32 test_ssrc;
- WebRtc_UWord32 test_timestamp;
- WebRtc_UWord16 test_sequence_number;
- WebRtc_UWord32 test_CSRC[webrtc::kRtpCsrcSize];
+ uint32_t test_ssrc;
+ uint32_t test_timestamp;
+ uint16_t test_sequence_number;
+ uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
};
@@ -180,7 +180,7 @@
}
TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
- WebRtc_UWord32 testOfCSRC[webrtc::kRtpCsrcSize];
+ uint32_t testOfCSRC[webrtc::kRtpCsrcSize];
EXPECT_EQ(2, module2->RemoteCSRCs(testOfCSRC));
EXPECT_EQ(test_CSRC[0], testOfCSRC[0]);
EXPECT_EQ(test_CSRC[1], testOfCSRC[1]);
@@ -236,14 +236,14 @@
reportBlock.lastSR= 7;
EXPECT_EQ(0, module1->AddRTCPReportBlock(test_CSRC[1], &reportBlock));
- WebRtc_UWord32 name = 't' << 24;
+ uint32_t name = 't' << 24;
name += 'e' << 16;
name += 's' << 8;
name += 't';
EXPECT_EQ(0, module1->SetRTCPApplicationSpecificData(
3,
name,
- (const WebRtc_UWord8 *)"test test test test test test test test test"\
+ (const uint8_t *)"test test test test test test test test test"\
" test test test test test test test test test test test test test"\
" test test test test test test test test test test test test test"\
" test test test test test test test test test test test test test"\
@@ -256,10 +256,10 @@
fake_clock.AdvanceTimeMilliseconds(100);
module2->Process();
- WebRtc_UWord32 receivedNTPsecs = 0;
- WebRtc_UWord32 receivedNTPfrac = 0;
- WebRtc_UWord32 RTCPArrivalTimeSecs = 0;
- WebRtc_UWord32 RTCPArrivalTimeFrac = 0;
+ uint32_t receivedNTPsecs = 0;
+ uint32_t receivedNTPfrac = 0;
+ uint32_t RTCPArrivalTimeSecs = 0;
+ uint32_t RTCPArrivalTimeFrac = 0;
EXPECT_EQ(0, module2->RemoteNTP(&receivedNTPsecs,
&receivedNTPfrac,
&RTCPArrivalTimeSecs,
@@ -281,28 +281,28 @@
EXPECT_EQ(test_sequence_number, reportBlockReceived.extendedHighSeqNum);
EXPECT_EQ(0, reportBlockReceived.fractionLost);
- EXPECT_EQ(static_cast<WebRtc_UWord32>(0),
+ EXPECT_EQ(static_cast<uint32_t>(0),
reportBlockReceived.cumulativeLost);
- WebRtc_UWord8 fraction_lost = 0; // scale 0 to 255
- WebRtc_UWord32 cum_lost = 0; // number of lost packets
- WebRtc_UWord32 ext_max = 0; // highest sequence number received
- WebRtc_UWord32 jitter = 0;
- WebRtc_UWord32 max_jitter = 0;
+ uint8_t fraction_lost = 0; // scale 0 to 255
+ uint32_t cum_lost = 0; // number of lost packets
+ uint32_t ext_max = 0; // highest sequence number received
+ uint32_t jitter = 0;
+ uint32_t max_jitter = 0;
EXPECT_EQ(0, module2->StatisticsRTP(&fraction_lost,
&cum_lost,
&ext_max,
&jitter,
&max_jitter));
EXPECT_EQ(0, fraction_lost);
- EXPECT_EQ((WebRtc_UWord32)0, cum_lost);
+ EXPECT_EQ((uint32_t)0, cum_lost);
EXPECT_EQ(test_sequence_number, ext_max);
EXPECT_EQ(reportBlockReceived.jitter, jitter);
- WebRtc_UWord16 RTT;
- WebRtc_UWord16 avgRTT;
- WebRtc_UWord16 minRTT;
- WebRtc_UWord16 maxRTT;
+ uint16_t RTT;
+ uint16_t avgRTT;
+ uint16_t minRTT;
+ uint16_t maxRTT;
// Get RoundTripTime.
EXPECT_EQ(0, module1->RTT(test_ssrc + 1, &RTT, &avgRTT, &minRTT, &maxRTT));
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc
index cf181a6..ea22738 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc
@@ -68,24 +68,24 @@
}
}
- WebRtc_Word32 BuildRTPheader(WebRtc_UWord8* dataBuffer,
- WebRtc_UWord32 timestamp,
- WebRtc_UWord32 sequence_number) {
- dataBuffer[0] = static_cast<WebRtc_UWord8>(0x80); // version 2
- dataBuffer[1] = static_cast<WebRtc_UWord8>(kPayloadType);
+ int32_t BuildRTPheader(uint8_t* dataBuffer,
+ uint32_t timestamp,
+ 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.
- WebRtc_Word32 rtpHeaderLength = 12;
+ int32_t rtpHeaderLength = 12;
return rtpHeaderLength;
}
int PaddingPacket(uint8_t* buffer,
- WebRtc_UWord32 timestamp,
- WebRtc_UWord32 sequence_number,
- WebRtc_Word32 bytes) {
+ uint32_t timestamp,
+ uint32_t sequence_number,
+ int32_t bytes) {
// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
int max_length = 224;
@@ -97,8 +97,8 @@
int header_length = BuildRTPheader(buffer, timestamp,
sequence_number);
buffer[0] |= 0x20; // Set padding bit.
- WebRtc_Word32* data =
- reinterpret_cast<WebRtc_Word32*>(&(buffer[header_length]));
+ int32_t* data =
+ reinterpret_cast<int32_t*>(&(buffer[header_length]));
// Fill data buffer with random data.
for (int j = 0; j < (padding_bytes_in_packet >> 2); j++) {
@@ -120,17 +120,17 @@
RtpRtcp* video_module_;
LoopBackTransport* transport_;
RtpReceiver* receiver_;
- WebRtc_UWord32 test_ssrc_;
- WebRtc_UWord32 test_timestamp_;
- WebRtc_UWord16 test_sequence_number_;
- WebRtc_UWord8 video_frame_[65000];
+ uint32_t test_ssrc_;
+ uint32_t test_timestamp_;
+ uint16_t test_sequence_number_;
+ uint8_t video_frame_[65000];
int payload_data_length_;
SimulatedClock fake_clock;
enum { kPayloadType = 100 };
};
TEST_F(RtpRtcpVideoTest, BasicVideo) {
- WebRtc_UWord32 timestamp = 3000;
+ uint32_t timestamp = 3000;
EXPECT_EQ(0, video_module_->SendOutgoingData(kVideoFrameDelta, 123,
timestamp,
timestamp / 90,
diff --git a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
index 1918ff8..3110a0d 100644
--- a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
+++ b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
@@ -34,15 +34,15 @@
void ReceivePackets(
ForwardErrorCorrection::ReceivedPacketList* toDecodeList,
ForwardErrorCorrection::ReceivedPacketList* receivedPacketList,
- WebRtc_UWord32 numPacketsToDecode, float reorderRate, float duplicateRate);
+ uint32_t numPacketsToDecode, float reorderRate, float duplicateRate);
int main() {
// TODO(marpan): Split this function into subroutines/helper functions.
enum { kMaxNumberMediaPackets = 48 };
enum { kMaxNumberFecPackets = 48 };
- const WebRtc_UWord32 kNumMaskBytesL0 = 2;
- const WebRtc_UWord32 kNumMaskBytesL1 = 6;
+ const uint32_t kNumMaskBytesL0 = 2;
+ const uint32_t kNumMaskBytesL1 = 6;
// FOR UEP
const bool kUseUnequalProtection = true;
@@ -58,7 +58,7 @@
return -1;
}
- WebRtc_UWord32 id = 0;
+ uint32_t id = 0;
ForwardErrorCorrection fec(id);
ForwardErrorCorrection::PacketList mediaPacketList;
@@ -66,18 +66,18 @@
ForwardErrorCorrection::ReceivedPacketList toDecodeList;
ForwardErrorCorrection::ReceivedPacketList receivedPacketList;
ForwardErrorCorrection::RecoveredPacketList recoveredPacketList;
- std::list<WebRtc_UWord8*> fecMaskList;
+ std::list<uint8_t*> fecMaskList;
ForwardErrorCorrection::Packet* mediaPacket = NULL;
// Running over only one loss rate to limit execution time.
const float lossRate[] = {0.5f};
- const WebRtc_UWord32 lossRateSize = sizeof(lossRate)/sizeof(*lossRate);
+ const uint32_t lossRateSize = sizeof(lossRate)/sizeof(*lossRate);
const float reorderRate = 0.1f;
const float duplicateRate = 0.1f;
- WebRtc_UWord8 mediaLossMask[kMaxNumberMediaPackets];
- WebRtc_UWord8 fecLossMask[kMaxNumberFecPackets];
- WebRtc_UWord8 fecPacketMasks[kMaxNumberFecPackets][kMaxNumberMediaPackets];
+ uint8_t mediaLossMask[kMaxNumberMediaPackets];
+ uint8_t fecLossMask[kMaxNumberFecPackets];
+ uint8_t fecPacketMasks[kMaxNumberFecPackets][kMaxNumberMediaPackets];
// Seed the random number generator, storing the seed to file in order to
// reproduce past results.
@@ -89,48 +89,48 @@
fclose(randomSeedFile);
randomSeedFile = NULL;
- WebRtc_UWord16 seqNum = static_cast<WebRtc_UWord16>(rand());
- WebRtc_UWord32 timeStamp = static_cast<WebRtc_UWord32>(rand());
- const WebRtc_UWord32 ssrc = static_cast<WebRtc_UWord32>(rand());
+ uint16_t seqNum = static_cast<uint16_t>(rand());
+ uint32_t timeStamp = static_cast<uint32_t>(rand());
+ const uint32_t ssrc = static_cast<uint32_t>(rand());
// Loop over the mask types: random and bursty.
for (int mask_type_idx = 0; mask_type_idx < kNumFecMaskTypes;
++mask_type_idx) {
- for (WebRtc_UWord32 lossRateIdx = 0; lossRateIdx < lossRateSize;
+ for (uint32_t lossRateIdx = 0; lossRateIdx < lossRateSize;
++lossRateIdx) {
printf("Loss rate: %.2f, Mask type %d \n", lossRate[lossRateIdx],
mask_type_idx);
- const WebRtc_UWord32 packetMaskMax = kMaxMediaPackets[mask_type_idx];
- WebRtc_UWord8* packetMask =
- new WebRtc_UWord8[packetMaskMax * kNumMaskBytesL1];
+ const uint32_t packetMaskMax = kMaxMediaPackets[mask_type_idx];
+ uint8_t* packetMask =
+ new uint8_t[packetMaskMax * kNumMaskBytesL1];
FecMaskType fec_mask_type = kMaskTypes[mask_type_idx];
- for (WebRtc_UWord32 numMediaPackets = 1;
+ for (uint32_t numMediaPackets = 1;
numMediaPackets <= packetMaskMax;
numMediaPackets++) {
internal::PacketMaskTable mask_table(fec_mask_type, numMediaPackets);
- for (WebRtc_UWord32 numFecPackets = 1;
+ for (uint32_t numFecPackets = 1;
numFecPackets <= numMediaPackets &&
numFecPackets <= packetMaskMax;
numFecPackets++) {
// Loop over numImpPackets: usually <= (0.3*numMediaPackets).
// For this test we check up to ~ (0.5*numMediaPackets).
- WebRtc_UWord32 maxNumImpPackets = numMediaPackets / 2 + 1;
- for (WebRtc_UWord32 numImpPackets = 0;
+ uint32_t maxNumImpPackets = numMediaPackets / 2 + 1;
+ for (uint32_t numImpPackets = 0;
numImpPackets <= maxNumImpPackets &&
numImpPackets <= packetMaskMax;
numImpPackets++) {
- WebRtc_UWord8 protectionFactor = static_cast<WebRtc_UWord8>
+ uint8_t protectionFactor = static_cast<uint8_t>
(numFecPackets * 255 / numMediaPackets);
- const WebRtc_UWord32 maskBytesPerFecPacket =
+ const uint32_t maskBytesPerFecPacket =
(numMediaPackets > 16) ? kNumMaskBytesL1 : kNumMaskBytesL0;
memset(packetMask, 0, numMediaPackets * maskBytesPerFecPacket);
@@ -151,11 +151,11 @@
printf("Packet mask matrix \n");
#endif
- for (WebRtc_UWord32 i = 0; i < numFecPackets; i++) {
- for (WebRtc_UWord32 j = 0; j < numMediaPackets; j++) {
- const WebRtc_UWord8 byteMask =
+ for (uint32_t i = 0; i < numFecPackets; i++) {
+ for (uint32_t j = 0; j < numMediaPackets; j++) {
+ const uint8_t byteMask =
packetMask[i * maskBytesPerFecPacket + j / 8];
- const WebRtc_UWord32 bitPosition = (7 - j % 8);
+ const uint32_t bitPosition = (7 - j % 8);
fecPacketMasks[i][j] =
(byteMask & (1 << bitPosition)) >> bitPosition;
#ifdef VERBOSE_OUTPUT
@@ -170,10 +170,10 @@
printf("\n");
#endif
// Check for all zero rows or columns: indicates incorrect mask.
- WebRtc_UWord32 rowLimit = numMediaPackets;
- for (WebRtc_UWord32 i = 0; i < numFecPackets; ++i) {
- WebRtc_UWord32 rowSum = 0;
- for (WebRtc_UWord32 j = 0; j < rowLimit; ++j) {
+ uint32_t rowLimit = numMediaPackets;
+ for (uint32_t i = 0; i < numFecPackets; ++i) {
+ uint32_t rowSum = 0;
+ for (uint32_t j = 0; j < rowLimit; ++j) {
rowSum += fecPacketMasks[i][j];
}
if (rowSum == 0) {
@@ -181,9 +181,9 @@
return -1;
}
}
- for (WebRtc_UWord32 j = 0; j < rowLimit; ++j) {
- WebRtc_UWord32 columnSum = 0;
- for (WebRtc_UWord32 i = 0; i < numFecPackets; ++i) {
+ for (uint32_t j = 0; j < rowLimit; ++j) {
+ uint32_t columnSum = 0;
+ for (uint32_t i = 0; i < numFecPackets; ++i) {
columnSum += fecPacketMasks[i][j];
}
if (columnSum == 0) {
@@ -193,19 +193,19 @@
}
// Construct media packets.
- for (WebRtc_UWord32 i = 0; i < numMediaPackets; ++i) {
+ for (uint32_t i = 0; i < numMediaPackets; ++i) {
mediaPacket = new ForwardErrorCorrection::Packet;
mediaPacketList.push_back(mediaPacket);
mediaPacket->length =
- static_cast<WebRtc_UWord16>((static_cast<float>(rand()) /
+ static_cast<uint16_t>((static_cast<float>(rand()) /
RAND_MAX) * (IP_PACKET_SIZE - 12 -
28 - ForwardErrorCorrection::PacketOverhead()));
if (mediaPacket->length < 12) {
mediaPacket->length = 12;
}
// Generate random values for the first 2 bytes.
- mediaPacket->data[0] = static_cast<WebRtc_UWord8>(rand() % 256);
- mediaPacket->data[1] = static_cast<WebRtc_UWord8>(rand() % 256);
+ mediaPacket->data[0] = static_cast<uint8_t>(rand() % 256);
+ mediaPacket->data[1] = static_cast<uint8_t>(rand() % 256);
// The first two bits are assumed to be 10 by the
// FEC encoder. In fact the FEC decoder will set the
@@ -230,9 +230,9 @@
ModuleRTPUtility::AssignUWord32ToBuffer(&mediaPacket->data[8],
ssrc);
// Generate random values for payload
- for (WebRtc_Word32 j = 12; j < mediaPacket->length; ++j) {
+ for (int32_t j = 12; j < mediaPacket->length; ++j) {
mediaPacket->data[j] =
- static_cast<WebRtc_UWord8> (rand() % 256);
+ static_cast<uint8_t> (rand() % 256);
}
seqNum++;
}
@@ -249,14 +249,14 @@
printf("Error: we requested %u FEC packets, "
"but GenerateFEC() produced %u\n",
numFecPackets,
- static_cast<WebRtc_UWord32>(fecPacketList.size()));
+ static_cast<uint32_t>(fecPacketList.size()));
return -1;
}
memset(mediaLossMask, 0, sizeof(mediaLossMask));
ForwardErrorCorrection::PacketList::iterator
mediaPacketListItem = mediaPacketList.begin();
ForwardErrorCorrection::ReceivedPacket* receivedPacket;
- WebRtc_UWord32 mediaPacketIdx = 0;
+ uint32_t mediaPacketIdx = 0;
while (mediaPacketListItem != mediaPacketList.end()) {
mediaPacket = *mediaPacketListItem;
@@ -285,7 +285,7 @@
ForwardErrorCorrection::PacketList::iterator
fecPacketListItem = fecPacketList.begin();
ForwardErrorCorrection::Packet* fecPacket;
- WebRtc_UWord32 fecPacketIdx = 0;
+ uint32_t fecPacketIdx = 0;
while (fecPacketListItem != fecPacketList.end()) {
fecPacket = *fecPacketListItem;
const float lossRandomVariable =
@@ -315,31 +315,31 @@
#ifdef VERBOSE_OUTPUT
printf("Media loss mask:\n");
- for (WebRtc_UWord32 i = 0; i < numMediaPackets; i++) {
+ for (uint32_t i = 0; i < numMediaPackets; i++) {
printf("%u ", mediaLossMask[i]);
}
printf("\n\n");
printf("FEC loss mask:\n");
- for (WebRtc_UWord32 i = 0; i < numFecPackets; i++) {
+ for (uint32_t i = 0; i < numFecPackets; i++) {
printf("%u ", fecLossMask[i]);
}
printf("\n\n");
#endif
- std::list<WebRtc_UWord8*>::iterator fecMaskIt = fecMaskList.begin();
- WebRtc_UWord8* fecMask;
+ std::list<uint8_t*>::iterator fecMaskIt = fecMaskList.begin();
+ uint8_t* fecMask;
while (fecMaskIt != fecMaskList.end()) {
fecMask = *fecMaskIt;
- WebRtc_UWord32 hammingDist = 0;
- WebRtc_UWord32 recoveryPosition = 0;
- for (WebRtc_UWord32 i = 0; i < numMediaPackets; i++) {
+ uint32_t hammingDist = 0;
+ uint32_t recoveryPosition = 0;
+ for (uint32_t i = 0; i < numMediaPackets; i++) {
if (mediaLossMask[i] == 0 && fecMask[i] == 1) {
recoveryPosition = i;
++hammingDist;
}
}
- std::list<WebRtc_UWord8*>::iterator itemToDelete = fecMaskIt;
+ std::list<uint8_t*>::iterator itemToDelete = fecMaskIt;
++fecMaskIt;
if (hammingDist == 1) {
@@ -353,7 +353,7 @@
}
#ifdef VERBOSE_OUTPUT
printf("Recovery mask:\n");
- for (WebRtc_UWord32 i = 0; i < numMediaPackets; ++i) {
+ for (uint32_t i = 0; i < numMediaPackets; ++i) {
printf("%u ", mediaLossMask[i]);
}
printf("\n\n");
@@ -361,7 +361,7 @@
// For error-checking frame completion.
bool fecPacketReceived = false;
while (!receivedPacketList.empty()) {
- WebRtc_UWord32 numPacketsToDecode = static_cast<WebRtc_UWord32>
+ uint32_t numPacketsToDecode = static_cast<uint32_t>
((static_cast<float>(rand()) / RAND_MAX) *
receivedPacketList.size() + 0.5);
if (numPacketsToDecode < 1) {
@@ -428,7 +428,7 @@
if (!recoveredPacketList.empty()) {
printf("Error: excessive number of recovered packets.\n");
printf("\t size is:%u\n",
- static_cast<WebRtc_UWord32>(recoveredPacketList.size()));
+ static_cast<uint32_t>(recoveredPacketList.size()));
return -1;
}
// -- Teardown --
@@ -482,12 +482,12 @@
void ReceivePackets(
ForwardErrorCorrection::ReceivedPacketList* toDecodeList,
ForwardErrorCorrection::ReceivedPacketList* receivedPacketList,
- WebRtc_UWord32 numPacketsToDecode, float reorderRate, float duplicateRate) {
+ uint32_t numPacketsToDecode, float reorderRate, float duplicateRate) {
assert(toDecodeList->empty());
assert(numPacketsToDecode <= receivedPacketList->size());
ForwardErrorCorrection::ReceivedPacketList::iterator it;
- for (WebRtc_UWord32 i = 0; i < numPacketsToDecode; i++) {
+ for (uint32_t i = 0; i < numPacketsToDecode; i++) {
it = receivedPacketList->begin();
// Reorder packets.
float randomVariable = static_cast<float>(rand()) / RAND_MAX;
diff --git a/webrtc/modules/rtp_rtcp/test/testRateControl/testRateControl.cc b/webrtc/modules/rtp_rtcp/test/testRateControl/testRateControl.cc
index c282557..2fdaedf 100644
--- a/webrtc/modules/rtp_rtcp/test/testRateControl/testRateControl.cc
+++ b/webrtc/modules/rtp_rtcp/test/testRateControl/testRateControl.cc
@@ -25,14 +25,14 @@
const int maxFileLen = 200;
-WebRtc_UWord8* dataFile[maxFileLen];
+uint8_t* dataFile[maxFileLen];
struct InputSet
{
- WebRtc_UWord32 TMMBR;
- WebRtc_UWord32 packetOH;
- WebRtc_UWord32 SSRC;
+ uint32_t TMMBR;
+ uint32_t packetOH;
+ uint32_t SSRC;
};
const InputSet set0 = {220, 80, 11111}; // bitRate, packetOH, ssrc
@@ -48,7 +48,7 @@
-WebRtc_Word32 GetFile(char* fileName)
+int32_t GetFile(char* fileName)
{
if (!fileName[0])
{
@@ -58,7 +58,7 @@
FILE* openFile = fopen(fileName, "rb");
assert(openFile != NULL);
fseek(openFile, 0, SEEK_END);
- int len = (WebRtc_Word16)(ftell(openFile));
+ int len = (int16_t)(ftell(openFile));
rewind(openFile);
assert(len > 0 && len < maxFileLen);
fread(dataFile, 1, len, openFile);
@@ -77,7 +77,7 @@
}
virtual int SendPacket(int channel, const void *data, int len)
{
- return _rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len);
+ return _rtpRtcpModule->IncomingPacket((const uint8_t*)data, len);
}
virtual int SendRTCPPacket(int channel, const void *data, int len)
{
@@ -92,10 +92,10 @@
}
// Send in bitrate request
- return _rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)dataFile, len);
+ return _rtpRtcpModule->IncomingPacket((const uint8_t*)dataFile, len);
}
RtpRtcp* _rtpRtcpModule;
- WebRtc_UWord32 _cnt;
+ uint32_t _cnt;
};
@@ -109,7 +109,7 @@
}
virtual int SendPacket(int channel, const void *data, int len)
{
- return _rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len);
+ return _rtpRtcpModule->IncomingPacket((const uint8_t*)data, len);
}
virtual int SendRTCPPacket(int channel, const void *data, int len)
{
@@ -127,11 +127,11 @@
}
// Send in bitrate request*/
- return _rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)dataFile, len);
+ return _rtpRtcpModule->IncomingPacket((const uint8_t*)dataFile, len);
}
RtpRtcp* _rtpRtcpModule;
- WebRtc_UWord32 _cnt;
+ uint32_t _cnt;
};
class TestRateControl : private RateControlDetector
@@ -148,16 +148,16 @@
//Test perfect conditions
// But only one packet per frame
SetLastUsedBitRate(500);
- WebRtc_UWord32 rtpTs=1234*90;
- WebRtc_UWord32 framePeriod=33; // In Ms
- WebRtc_UWord32 rtpDelta=framePeriod*90;
- WebRtc_UWord32 netWorkDelay=10;
- WebRtc_UWord32 arrivalTime=rtpTs/90+netWorkDelay;
- WebRtc_UWord32 newBitRate=0;
- for(WebRtc_UWord32 k=0;k<10;k++)
+ uint32_t rtpTs=1234*90;
+ uint32_t framePeriod=33; // In Ms
+ uint32_t rtpDelta=framePeriod*90;
+ uint32_t netWorkDelay=10;
+ uint32_t arrivalTime=rtpTs/90+netWorkDelay;
+ uint32_t newBitRate=0;
+ for(uint32_t k=0;k<10;k++)
{
// Receive 10 packets
- for(WebRtc_UWord32 i=0;i<10;i++)
+ for(uint32_t i=0;i<10;i++)
{
NotifyNewArrivedPacket(rtpTs,arrivalTime);
rtpTs+=rtpDelta;
@@ -175,16 +175,16 @@
std::cout << "Test increasing RTT - No Receive timing changes" << std::endl;
SetLastUsedBitRate(500);
- for(WebRtc_UWord32 k=0;k<10;k++)
+ for(uint32_t k=0;k<10;k++)
{
// Receive 10 packets
- for(WebRtc_UWord32 i=0;i<10;i++)
+ for(uint32_t i=0;i<10;i++)
{
NotifyNewArrivedPacket(rtpTs,arrivalTime);
rtpTs+=rtpDelta;
arrivalTime=rtpTs/90+netWorkDelay;
}
- WebRtc_UWord32 rtt=2*netWorkDelay+k*20;
+ uint32_t rtt=2*netWorkDelay+k*20;
newBitRate=RateControl(rtt);
Sleep(10*framePeriod);
SetLastUsedBitRate(newBitRate);
@@ -199,16 +199,16 @@
std::cout << "Test increasing RTT - Changed receive timing" << std::endl;
SetLastUsedBitRate(500);
- for(WebRtc_UWord32 k=0;k<10;k++)
+ for(uint32_t k=0;k<10;k++)
{
// Receive 10 packets
- for(WebRtc_UWord32 i=0;i<10;i++)
+ for(uint32_t i=0;i<10;i++)
{
NotifyNewArrivedPacket(rtpTs,arrivalTime);
rtpTs+=rtpDelta;
arrivalTime=rtpTs/90+netWorkDelay+i+(k*20);
}
- WebRtc_UWord32 rtt=2*netWorkDelay+k*20;
+ uint32_t rtt=2*netWorkDelay+k*20;
newBitRate=RateControl(rtt);
Sleep(10*framePeriod);
SetLastUsedBitRate(newBitRate);
@@ -223,9 +223,9 @@
class NULLDataZink: public RtpData
{
- virtual WebRtc_Word32 OnReceivedPayloadData(const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
- const webrtc::WebRtcRTPHeader* rtpHeader)
+ virtual int32_t OnReceivedPayloadData(const uint8_t* payloadData,
+ const uint16_t payloadSize,
+ const webrtc::WebRtcRTPHeader* rtpHeader)
{
return 0;
};
diff --git a/webrtc/modules/rtp_rtcp/test/testTMMBR/testTMMBR.cc b/webrtc/modules/rtp_rtcp/test/testTMMBR/testTMMBR.cc
index d1e1572..c77015a 100644
--- a/webrtc/modules/rtp_rtcp/test/testTMMBR/testTMMBR.cc
+++ b/webrtc/modules/rtp_rtcp/test/testTMMBR/testTMMBR.cc
@@ -24,14 +24,14 @@
const int maxFileLen = 200;
-WebRtc_UWord8* dataFile[maxFileLen];
+uint8_t* dataFile[maxFileLen];
struct InputSet
{
- WebRtc_UWord32 TMMBR;
- WebRtc_UWord32 packetOH;
- WebRtc_UWord32 SSRC;
+ uint32_t TMMBR;
+ uint32_t packetOH;
+ uint32_t SSRC;
};
const InputSet set0 = {220, 80, 11111}; // bitRate, packetOH, ssrc
@@ -56,7 +56,7 @@
int ParseRTCPPacket(const void *data, int len, TMMBRSet*& boundingSet)
{
int numItems = -1;
- RTCPUtility::RTCPParserV2 rtcpParser((const WebRtc_UWord8*)data, len, true);
+ RTCPUtility::RTCPParserV2 rtcpParser((const uint8_t*)data, len, true);
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Begin();
while (pktType != RTCPUtility::kRtcpNotValidCode)
{
@@ -79,7 +79,7 @@
return numItems;
};
-WebRtc_Word32 GetFile(char* fileName)
+int32_t GetFile(char* fileName)
{
if (!fileName[0])
{
@@ -89,7 +89,7 @@
FILE* openFile = fopen(fileName, "rb");
assert(openFile != NULL);
fseek(openFile, 0, SEEK_END);
- int len = (WebRtc_Word16)(ftell(openFile));
+ int len = (int16_t)(ftell(openFile));
rewind(openFile);
assert(len > 0 && len < maxFileLen);
fread(dataFile, 1, len, openFile);
@@ -109,7 +109,7 @@
}
virtual int SendPacket(int channel, const void *data, int len)
{
- if( 0 == _rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len))
+ if( 0 == _rtpRtcpModule->IncomingPacket((const uint8_t*)data, len))
{
return len;
}
@@ -144,14 +144,14 @@
}
// Send in bitrate request
- if(_rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)dataFile, len) == 0)
+ if(_rtpRtcpModule->IncomingPacket((const uint8_t*)dataFile, len) == 0)
{
return len;
}
return -1;
}
RtpRtcp* _rtpRtcpModule;
- WebRtc_UWord32 _cnt;
+ uint32_t _cnt;
};
@@ -166,7 +166,7 @@
}
virtual int SendPacket(int channel, const void *data, int len)
{
- if(_rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)data, len)== 0)
+ if(_rtpRtcpModule->IncomingPacket((const uint8_t*)data, len)== 0)
{
return len;
}
@@ -330,7 +330,7 @@
}
// Send in bitrate request
- if( 0 == _rtpRtcpModule->IncomingPacket((const WebRtc_UWord8*)dataFile, len))
+ if( 0 == _rtpRtcpModule->IncomingPacket((const uint8_t*)dataFile, len))
{
return len;
}
@@ -338,7 +338,7 @@
}
RtpRtcp* _rtpRtcpModule;
- WebRtc_UWord32 _cnt;
+ uint32_t _cnt;
};
class TestTMMBR : private TMMBRHelp
@@ -363,14 +363,14 @@
TMMBRSet* boundingSetToSend = BoundingSetToSend();
assert(0 == boundingSetToSend->sizeOfSet);
- WebRtc_Word32 numBoundingSet = FindTMMBRBoundingSet(boundingSet);
+ int32_t numBoundingSet = FindTMMBRBoundingSet(boundingSet);
assert(0 == numBoundingSet); // should be empty
assert( 0 == SetTMMBRBoundingSetToSend(NULL,0)); // ok to send empty set
assert( 0 == SetTMMBRBoundingSetToSend(boundingSet,0)); // ok to send empty set
- WebRtc_UWord32 minBitrateKbit = 0;
- WebRtc_UWord32 maxBitrateKbit = 0;
+ uint32_t minBitrateKbit = 0;
+ uint32_t maxBitrateKbit = 0;
assert(-1 == CalcMinMaxBitRate(0, 0, 1, false, minBitrateKbit, maxBitrateKbit)); // no bounding set
// ---------------------------------
@@ -918,11 +918,11 @@
class NULLDataZink: public RtpData
{
- virtual WebRtc_Word32 OnReceivedPayloadData(const WebRtc_UWord8* payloadData,
- const WebRtc_UWord16 payloadSize,
- const webrtc::WebRtcRTPHeader* rtpHeader,
- const WebRtc_UWord8* incomingRtpPacket,
- const WebRtc_UWord16 incomingRtpPacketLengt)
+ virtual int32_t OnReceivedPayloadData(const uint8_t* payloadData,
+ const uint16_t payloadSize,
+ const webrtc::WebRtcRTPHeader* rtpHeader,
+ const uint8_t* incomingRtpPacket,
+ const uint16_t incomingRtpPacketLengt)
{
return 0;
};
@@ -963,7 +963,7 @@
// send a RTP packet with SSRC 11111 to get 11111 as the received SSRC
assert(0 == rtpRtcpModuleVideo->SetSSRC(11111));
- const WebRtc_UWord8 testStream[9] = "testtest";
+ const uint8_t testStream[9] = "testtest";
assert(0 == rtpRtcpModuleVideo->RegisterIncomingDataCallback(new NULLDataZink())); // needed to avoid error from parsing the incoming stream
assert(0 == rtpRtcpModuleVideo->SendOutgoingData(webrtc::kVideoFrameKey,96, 0, testStream, 8));
