From 2f44673d665899ca788ae44247a9a7f4764f5e2b Mon Sep 17 00:00:00 2001 From: "pbos@webrtc.org" Date: Mon, 8 Apr 2013 11:08:41 +0000 Subject: [PATCH] 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 --- webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h | 328 +++++----- .../rtp_rtcp/interface/rtp_rtcp_defines.h | 126 ++-- webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h | 244 +++---- .../rtp_rtcp/source/H264/bitstream_builder.cc | 108 +-- .../rtp_rtcp/source/H264/bitstream_builder.h | 42 +- .../rtp_rtcp/source/H264/bitstream_parser.cc | 60 +- .../rtp_rtcp/source/H264/bitstream_parser.h | 34 +- .../rtp_rtcp/source/H264/h264_information.cc | 158 ++--- .../rtp_rtcp/source/H264/h264_information.h | 96 +-- .../rtp_rtcp/source/H264/rtp_sender_h264.cc | 340 +++++----- .../rtp_rtcp/source/H264/rtp_sender_h264.h | 194 +++--- webrtc/modules/rtp_rtcp/source/bitrate.cc | 32 +- webrtc/modules/rtp_rtcp/source/bitrate.h | 26 +- webrtc/modules/rtp_rtcp/source/dtmf_queue.cc | 16 +- webrtc/modules/rtp_rtcp/source/dtmf_queue.h | 12 +- .../source/mock/mock_rtp_payload_strategy.h | 16 +- .../source/mock/mock_rtp_receiver_video.h | 28 +- .../rtp_rtcp/source/nack_rtx_unittest.cc | 52 +- .../modules/rtp_rtcp/source/producer_fec.cc | 2 +- .../modules/rtp_rtcp/source/receiver_fec.cc | 20 +- webrtc/modules/rtp_rtcp/source/receiver_fec.h | 16 +- .../source/rtcp_format_remb_unittest.cc | 12 +- .../modules/rtp_rtcp/source/rtcp_receiver.cc | 189 +++--- .../modules/rtp_rtcp/source/rtcp_receiver.h | 109 ++-- .../rtp_rtcp/source/rtcp_receiver_help.cc | 40 +- .../rtp_rtcp/source/rtcp_receiver_help.h | 78 +-- .../rtp_rtcp/source/rtcp_receiver_unittest.cc | 60 +- webrtc/modules/rtp_rtcp/source/rtcp_sender.cc | 614 +++++++++--------- webrtc/modules/rtp_rtcp/source/rtcp_sender.h | 221 ++++--- .../rtp_rtcp/source/rtcp_sender_unittest.cc | 28 +- .../modules/rtp_rtcp/source/rtcp_utility.cc | 62 +- webrtc/modules/rtp_rtcp/source/rtcp_utility.h | 200 +++--- .../modules/rtp_rtcp/source/rtp_format_vp8.cc | 36 +- .../modules/rtp_rtcp/source/rtp_format_vp8.h | 24 +- .../source/rtp_format_vp8_test_helper.cc | 4 +- .../rtp_rtcp/source/rtp_payload_registry.cc | 70 +- .../rtp_rtcp/source/rtp_payload_registry.h | 68 +- .../modules/rtp_rtcp/source/rtp_receiver.cc | 234 +++---- webrtc/modules/rtp_rtcp/source/rtp_receiver.h | 202 +++--- .../rtp_rtcp/source/rtp_receiver_audio.cc | 56 +- .../rtp_rtcp/source/rtp_receiver_audio.h | 70 +- .../rtp_rtcp/source/rtp_receiver_strategy.h | 28 +- .../rtp_rtcp/source/rtp_receiver_video.cc | 104 +-- .../rtp_rtcp/source/rtp_receiver_video.h | 76 +-- .../modules/rtp_rtcp/source/rtp_rtcp_impl.cc | 472 +++++++------- .../modules/rtp_rtcp/source/rtp_rtcp_impl.h | 369 ++++++----- webrtc/modules/rtp_rtcp/source/rtp_sender.cc | 293 +++++---- webrtc/modules/rtp_rtcp/source/rtp_sender.h | 246 ++++--- .../rtp_rtcp/source/rtp_sender_audio.cc | 132 ++-- .../rtp_rtcp/source/rtp_sender_audio.h | 96 ++- .../rtp_rtcp/source/rtp_sender_unittest.cc | 40 +- .../rtp_rtcp/source/rtp_sender_video.cc | 76 +-- .../rtp_rtcp/source/rtp_sender_video.h | 104 +-- webrtc/modules/rtp_rtcp/source/rtp_utility.cc | 153 +++-- webrtc/modules/rtp_rtcp/source/rtp_utility.h | 92 +-- .../rtp_rtcp/source/rtp_utility_unittest.cc | 18 +- .../modules/rtp_rtcp/source/ssrc_database.cc | 26 +- .../modules/rtp_rtcp/source/ssrc_database.h | 12 +- webrtc/modules/rtp_rtcp/source/tmmbr_help.cc | 92 +-- webrtc/modules/rtp_rtcp/source/tmmbr_help.h | 62 +- .../test/BWEStandAlone/BWEConvergenceTest.cc | 2 +- .../test/BWEStandAlone/BWEConvergenceTest.h | 2 +- .../test/BWEStandAlone/BWEStabilityTest.cc | 2 +- .../test/BWEStandAlone/BWEStabilityTest.h | 2 +- .../test/BWEStandAlone/BWEStandAlone.cc | 52 +- .../test/BWEStandAlone/BWETestBase.cc | 22 +- .../rtp_rtcp/test/BWEStandAlone/BWETestBase.h | 20 +- .../rtp_rtcp/test/BWEStandAlone/BWETester.cc | 2 +- .../BWEStandAlone/BWETwoWayLimitFinding.cc | 4 +- .../BWEStandAlone/BWETwoWayLimitFinding.h | 2 +- .../rtp_rtcp/test/BWEStandAlone/MatlabPlot.cc | 12 +- .../rtp_rtcp/test/BWEStandAlone/MatlabPlot.h | 12 +- .../test/BWEStandAlone/TestLoadGenerator.cc | 96 +-- .../test/BWEStandAlone/TestLoadGenerator.h | 76 +-- .../test/BWEStandAlone/TestSenderReceiver.cc | 100 +-- .../test/BWEStandAlone/TestSenderReceiver.h | 116 ++-- .../test/bitstreamTest/bitstreamTest.cc | 106 +-- .../modules/rtp_rtcp/test/testAPI/test_api.cc | 10 +- .../modules/rtp_rtcp/test/testAPI/test_api.h | 18 +- .../rtp_rtcp/test/testAPI/test_api_audio.cc | 72 +- .../rtp_rtcp/test/testAPI/test_api_nack.cc | 28 +- .../rtp_rtcp/test/testAPI/test_api_rtcp.cc | 72 +- .../rtp_rtcp/test/testAPI/test_api_video.cc | 32 +- .../modules/rtp_rtcp/test/testFec/test_fec.cc | 110 ++-- .../test/testRateControl/testRateControl.cc | 58 +- .../rtp_rtcp/test/testTMMBR/testTMMBR.cc | 44 +- 86 files changed, 3934 insertions(+), 3956 deletions(-) diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h index 648b1b0f55..385520487c 100644 --- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h +++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h @@ -89,9 +89,9 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * return -1 on failure else 0 */ - virtual WebRtc_Word32 RegisterReceivePayload( + virtual int32_t RegisterReceivePayload( const VideoCodec& videoCodec) = 0; /* @@ -140,18 +140,18 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * 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 @@ class RtpRtcp : public Module { * 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 @@ class RtpRtcp : public Module { * * return -1 on failure else 0 */ - virtual WebRtc_Word32 RegisterSendPayload( + virtual int32_t RegisterSendPayload( const VideoCodec& videoCodec) = 0; /* @@ -326,25 +326,25 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { /* * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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* 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { */ 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * 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 @@ class RtpRtcp : public Module { * * return -1 on failure else 0 */ - virtual WebRtc_Word32 SetKeyFrameRequestMethod( + virtual int32_t SetKeyFrameRequestMethod( const KeyFrameRequestMethod method) = 0; /* @@ -928,7 +928,7 @@ class RtpRtcp : public Module { * * 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 f0ef84f14d..616e5345d8 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 @@ enum RtxMode { 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 @@ protected: 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 @@ public: /* * 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 @@ protected: 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 @@ class NullRtpFeedback : public RtpFeedback { 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 NullRtpFeedback : public RtpFeedback { 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 @@ class NullRtpAudioFeedback : public RtpAudioFeedback { 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 53670f9f08..76cc31680c 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 @@ namespace webrtc { 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 @@ class MockRtpRtcp : public RtpRtcp { 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* receiveBlocks)); + int32_t(std::vector* 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 05b7e2f0a2..7909f88712 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 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 @@ BitstreamBuilder::BitstreamBuilder(WebRtc_UWord8* data, const WebRtc_UWord32 dat 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 @@ BitstreamBuilder::Add1Bit(const WebRtc_UWord8 bit) } void -BitstreamBuilder::Add1BitWithoutSanity(const WebRtc_UWord8 bit) +BitstreamBuilder::Add1BitWithoutSanity(const uint8_t bit) { if(bit & 0x1) { @@ -63,8 +63,8 @@ BitstreamBuilder::Add1BitWithoutSanity(const WebRtc_UWord8 bit) } } -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 @@ BitstreamBuilder::Add2Bits(const WebRtc_UWord8 bits) 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 @@ BitstreamBuilder::Add3Bits(const WebRtc_UWord8 bits) 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 @@ BitstreamBuilder::Add4Bits(const WebRtc_UWord8 bits) 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 @@ BitstreamBuilder::Add5Bits(const WebRtc_UWord8 bits) 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 @@ BitstreamBuilder::Add6Bits(const WebRtc_UWord8 bits) 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 @@ BitstreamBuilder::Add7Bits(const WebRtc_UWord8 bits) 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 @@ BitstreamBuilder::Add8Bits(const WebRtc_UWord8 bits) 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 @@ BitstreamBuilder::Add16Bits(const WebRtc_UWord16 bits) } 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 @@ BitstreamBuilder::Add24Bits(const WebRtc_UWord32 bits) } 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 @@ BitstreamBuilder::Add32Bits(const WebRtc_UWord32 bits) } 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 @@ BitstreamBuilder::Add32Bits(const WebRtc_UWord32 bits) 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 @@ BitstreamBuilder::AddUE(const WebRtc_UWord32 value) 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 @@ BitstreamBuilder::AddPrefix(const WebRtc_UWord8 numZeros) } 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 c88ef8f5c5..edfe67790f 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 @@ namespace webrtc { 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 79ec9671a5..43b1398646 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 @@ BitstreamParser::BitstreamParser(const WebRtc_UWord8* data, const WebRtc_UWord32 } // 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 @@ BitstreamParser::Get1Bit() 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 @@ BitstreamParser::Get5Bits() 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 @@ BitstreamParser::Get6Bits() 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 @@ BitstreamParser::Get7Bits() return retVal; } -WebRtc_UWord8 +uint8_t BitstreamParser::Get8Bits() { - WebRtc_UWord16 retVal; + uint16_t retVal; if(_bitOffset != 0) { @@ -112,13 +112,13 @@ BitstreamParser::Get8Bits() 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 @@ BitstreamParser::Get16Bits() 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 @@ BitstreamParser::Get24Bits() 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 @@ BitstreamParser::Get32Bits() tempVal += _data[_byteOffset+4]; tempVal >>= (8-_bitOffset); - retVal = WebRtc_UWord32(tempVal); + retVal = uint32_t(tempVal); }else { // read 32 bits @@ -194,11 +194,11 @@ BitstreamParser::Get32Bits() 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 3d8f9ef9f9..31c66c644f 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 @@ namespace webrtc { 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 cf6b549eaa..e75ddf5afe 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 #include - 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 @@ H264Information::Reset() 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 @@ H264Information::Reset() } /******************************************************************************* - * 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 @@ H264Information::Reset() * - 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 @@ H264Information::Type() /******************************************************************************* - * 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 @@ H264Information::Type() */ bool -H264Information::HasInfo(const WebRtc_UWord32 length) +H264Information::HasInfo(const uint32_t length) { if (!_info.numNALUs) { @@ -162,8 +162,8 @@ H264Information::HasInfo(const WebRtc_UWord32 length) } /******************************************************************************* - * 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 @@ H264Information::HasInfo(const WebRtc_UWord32 length) * - 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 @@ H264Information::FindInfo(const WebRtc_UWord8* ptrEncodedBuffer, const WebRtc_UW } // Get NAL unit payload size - WebRtc_Word32 foundLast = FindNALU(); + int32_t foundLast = FindNALU(); if (foundLast == -1) { Reset(); @@ -251,7 +251,7 @@ H264Information::FindInfo(const WebRtc_UWord8* ptrEncodedBuffer, const WebRtc_UW } /******************************************************************************* - * WebRtc_Word32 FindNALUStartCodeSize(); + * int32_t FindNALUStartCodeSize(); * * Finds the start code length of the current NAL unit. * @@ -262,15 +262,15 @@ H264Information::FindInfo(const WebRtc_UWord8* ptrEncodedBuffer, const WebRtc_UW * - 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 @@ H264Information::FindNALUStartCodeSize() } /******************************************************************************* - * WebRtc_Word32 FindNALU(); + * int32_t FindNALU(); * * Finds the length of the current NAL unit. * @@ -292,14 +292,14 @@ H264Information::FindNALUStartCodeSize() * - 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 @@ H264Information::GetNRI() // 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 @@ H264Information::GetNRI() /******************************************************************************* - * WebRtc_Word32 FindNALUType(); + * int32_t FindNALUType(); * * Finds the type of the current NAL unit. * @@ -381,7 +381,7 @@ H264Information::GetNRI() * - 0 : ok * - (-1) : Error */ -WebRtc_Word32 +int32_t H264Information::FindNALUType() { // NAL unit header (1 byte) @@ -406,7 +406,7 @@ H264Information::FindNALUType() } /******************************************************************************* - * 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 @@ H264Information::FindNALUType() * - 0 : ok * - (-1) : Error */ -WebRtc_Word32 +int32_t H264Information::ParseSVCNALUHeader() { if (_info.type[_info.numNALUs] == 5) @@ -426,16 +426,16 @@ H264Information::ParseSVCNALUHeader() } 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 @@ H264Information::ParseSVCNALUHeader() { _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 @@ H264Information::ParseSVCNALUHeader() 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 @@ H264Information::ParseSVCNALUHeader() 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 @@ H264Information::ParseSVCNALUHeader() } 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 @@ H264Information::ParseSVCNALUHeader() } 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 @@ H264Information::ParseSVCNALUHeader() 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 @@ H264Information::ParseSVCNALUHeader() } 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 @@ H264Information::ParseSVCNALUHeader() } 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 @@ H264Information::ParseSVCNALUHeader() 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 @@ H264Information::ParseSVCNALUHeader() * */ void -H264Information::SetLayerSEBit(WebRtc_Word32 foundLast) +H264Information::SetLayerSEBit(int32_t foundLast) { if (_info.numNALUs == 0) { @@ -766,7 +766,7 @@ H264Information::SetLayerSEBit(WebRtc_Word32 foundLast) } /******************************************************************************* - * WebRtc_Word32 SetLayerLengths(); + * int32_t SetLayerLengths(); * * Sets the accumulated layer length. * @@ -778,17 +778,17 @@ H264Information::SetLayerSEBit(WebRtc_Word32 foundLast) * - (-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 @@ H264Information::SetLayerLengths() 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 c7f5214bd9..e51b9e1aed 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 @@ struct H264_SVC_NALUHeader 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 @@ public: } } - 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 @@ struct H264Info 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 @@ public: 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 1f35526de0..f121a41126 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 @@ RTPSenderH264::~RTPSenderH264() { } -WebRtc_Word32 +int32_t RTPSenderH264::Init() { _h264SendPPS_SPS = true; @@ -71,8 +71,8 @@ RTPSenderH264::Init() 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 @@ RTPSenderH264::AddH264SVCNALUHeader(const H264_SVC_NALUHeader& svc, 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 @@ RTPSenderH264::AddH264PACSINALU(const bool firstPacketInNALU, 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 @@ RTPSenderH264::AddH264PACSINALU(const bool firstPacketInNALU, 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 @@ RTPSenderH264::AddH264PACSINALU(const bool firstPacketInNALU, 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 @@ RTPSenderH264::SetH264RelayCompleteLayer(const bool complete) 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 @@ RTPSenderH264::SendH264FillerData(const WebRtcRTPHeader* rtpHeader, } // 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(0x80); // version 2 + dataBuffer[0] = static_cast(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 @@ RTPSenderH264::SendH264FillerData(const WebRtcRTPHeader* rtpHeader, 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(fillerLengthheader.sequenceNumber != (WebRtc_UWord16)(_h264SVCRelaySequenceNumber + 1)) + if (rtpHeader->header.sequenceNumber != (uint16_t)(_h264SVCRelaySequenceNumber + 1)) { // not continous, signal loss _rtpSender.IncrementSequenceNumber(); @@ -346,7 +346,7 @@ RTPSenderH264::SendH264SVCRelayPacket(const WebRtcRTPHeader* rtpHeader, // 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 @@ RTPSenderH264::SendH264SVCRelayPacket(const WebRtcRTPHeader* rtpHeader, 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 @@ RTPSenderH264::SendH264_STAP_A(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_STAP_A(const FrameType frameType, // 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 @@ RTPSenderH264::SendH264_STAP_A(const FrameType frameType, } // 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 @@ RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType, { // 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 @@ RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_STAP_A_PACSI(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_FU_A(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_FU_A(const FrameType frameType, // 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 @@ RTPSenderH264::SendH264_FU_A(const FrameType frameType, // 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 @@ RTPSenderH264::SendH264_FU_A(const FrameType frameType, // 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 @@ RTPSenderH264::SendH264_FU_A(const FrameType frameType, } } // 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 @@ RTPSenderH264::SendH264_FU_A(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_SingleMode(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_SingleMode(const FrameType frameType, // 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 @@ RTPSenderH264::SendH264_SingleMode(const FrameType frameType, 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 @@ RTPSenderH264::SendH264_SinglePACSI(const FrameType frameType, } 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 @@ RTPSenderH264::SendH264_SinglePACSI(const FrameType frameType, -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 @@ RTPSenderH264::SendH264SVC(const FrameType frameType, { // 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 @@ RTPSenderH264::SendH264SVC(const FrameType frameType, } } - WebRtc_UWord16 idxNALU = 0; + uint16_t idxNALU = 0; while (payloadBytesToSend > 0) { bool switchToFUA = false; @@ -1010,14 +1010,14 @@ RTPSenderH264::SendH264SVC(const FrameType frameType, 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 @@ RTPSenderH264::SetH264SendModeNALU_PPS_SPS(const bool dontSend) 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 @@ RTPSenderH264::SendH264SVCLayer(const FrameType frameType, 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 @@ RTPSenderH264::SetHighestSendLayer(const WebRtc_UWord8 dependencyQualityLayer, 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 @@ RTPSenderH264::HighestSendLayer(WebRtc_UWord8& dependencyQualityLayer, /* * 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 564b8700de..60e71b2943 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 @@ namespace webrtc { 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 69601d2a88..e3995ad7d2 100644 --- a/webrtc/modules/rtp_rtcp/source/bitrate.cc +++ b/webrtc/modules/rtp_rtcp/source/bitrate.cc @@ -27,40 +27,40 @@ Bitrate::Bitrate(Clock* clock) 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(bitrate_) * 1000 + + int64_t bitrate = (static_cast(bitrate_) * 1000 + bits_since_last_rate_update) / (1000 + diff_ms); - return static_cast(bitrate); + return static_cast(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 @@ void Bitrate::Process() { 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 @@ void Bitrate::Process() { time_last_rate_update_ = now; bytes_count_ = 0; packet_count_ = 0; - packet_rate_ = static_cast(sum_packetrateMS / sum_diffMS); - bitrate_ = static_cast(sum_bitrateMS / sum_diffMS); + packet_rate_ = static_cast(sum_packetrateMS / sum_diffMS); + bitrate_ = static_cast(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 9a0217f954..708fd9858c 100644 --- a/webrtc/modules/rtp_rtcp/source/bitrate.h +++ b/webrtc/modules/rtp_rtcp/source/bitrate.h @@ -30,30 +30,30 @@ class Bitrate { 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 749309b6b1..6fa6d65f99 100644 --- a/webrtc/modules/rtp_rtcp/source/dtmf_queue.cc +++ b/webrtc/modules/rtp_rtcp/source/dtmf_queue.cc @@ -27,8 +27,8 @@ DTMFqueue::~DTMFqueue() 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 @@ DTMFqueue::AddDTMF(WebRtc_UWord8 key, WebRtc_UWord16 len, WebRtc_UWord8 level) { return -1; } - WebRtc_Word32 index = _nextEmptyIndex; + int32_t index = _nextEmptyIndex; _DTMFKey[index] = key; _DTMFLen[index] = len; _DTMFLevel[index] = level; @@ -44,8 +44,8 @@ DTMFqueue::AddDTMF(WebRtc_UWord8 key, WebRtc_UWord16 len, WebRtc_UWord8 level) 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 @@ DTMFqueue::NextDTMF(WebRtc_UWord8* DTMFKey, WebRtc_UWord16* len, WebRtc_UWord8* *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 8451a211b5..190f2ac8e3 100644 --- a/webrtc/modules/rtp_rtcp/source/dtmf_queue.h +++ b/webrtc/modules/rtp_rtcp/source/dtmf_queue.h @@ -23,17 +23,17 @@ public: 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 9acec286fb..855b91147b 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 @@ class MockRTPPayloadStrategy : public RTPPayloadStrategy { 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 498c864901..b9ad4465d9 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 @@ class MockRTPReceiverVideo : public RTPReceiverVideo { 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 59d8f1c7f1..925db94e79 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 @@ class VerifyingRtxReceiver : public RtpData { sequence_numbers_.push_back(rtp_header->header.sequenceNumber); return 0; } - std::vector sequence_numbers_; + std::vector sequence_numbers_; }; class RtxLoopBackTransport : public webrtc::Transport { @@ -66,13 +66,13 @@ class RtxLoopBackTransport : public webrtc::Transport { 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 @@ class RtpRtcpRtxNackTest : public ::testing::Test { 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 @@ TEST_F(RtpRtcpRtxNackTest, RTCP) { std::sort(receiver_.sequence_numbers_.begin(), receiver_.sequence_numbers_.end()); - std::vector missing_sequence_numbers; - std::vector::iterator it = + std::vector missing_sequence_numbers; + std::vector::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 @@ TEST_F(RtpRtcpRtxNackTest, RTXNack) { 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 @@ TEST_F(RtpRtcpRtxNackTest, RTXNack) { std::sort(receiver_.sequence_numbers_.begin(), receiver_.sequence_numbers_.end()); - std::vector missing_sequence_numbers; + std::vector missing_sequence_numbers; - std::vector::iterator it = + std::vector::iterator it = receiver_.sequence_numbers_.begin(); while (it != receiver_.sequence_numbers_.end()) { int sequence_number_1 = *it; @@ -255,7 +255,7 @@ TEST_F(RtpRtcpRtxNackTest, RTXAllNoLoss) { 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 @@ TEST_F(RtpRtcpRtxNackTest, RTXAllWithLoss) { 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 @@ TEST_F(RtpRtcpRtxNackTest, RTXAllWithLoss) { payload_data_length)); std::sort(receiver_.sequence_numbers_.begin(), receiver_.sequence_numbers_.end()); - std::vector missing_sequence_numbers; + std::vector missing_sequence_numbers; - std::vector::iterator it = + std::vector::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 52d5086a8e..9d9a4b345b 100644 --- a/webrtc/modules/rtp_rtcp/source/producer_fec.cc +++ b/webrtc/modules/rtp_rtcp/source/producer_fec.cc @@ -32,7 +32,7 @@ enum { kHighProtectionThreshold = 80 }; // Corresponds to ~30 overhead, range // 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 e86f5786b7..bf640d6793 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 @@ ReceiverFEC::~ReceiverFEC() { } } -void ReceiverFEC::SetPayloadTypeFEC(const WebRtc_Word8 payloadType) { +void ReceiverFEC::SetPayloadTypeFEC(const int8_t payloadType) { _payloadTypeFEC = payloadType; } @@ -76,16 +76,16 @@ RFC 2198 RTP Payload for Redundant Audio Data September 1997 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 @@ WebRtc_Word32 ReceiverFEC::AddReceivedFECPacket( 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 @@ WebRtc_Word32 ReceiverFEC::AddReceivedFECPacket( } 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 @@ WebRtc_Word32 ReceiverFEC::AddReceivedFECPacket( 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 63aaa728bc..4ce2e9775a 100644 --- a/webrtc/modules/rtp_rtcp/source/receiver_fec.h +++ b/webrtc/modules/rtp_rtcp/source/receiver_fec.h @@ -23,17 +23,17 @@ class RTPReceiverVideo; 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 @@ private: // 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 cdf334d709..3d0c3faf96 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 @@ class TestTransport : public Transport { 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 @@ class TestTransport : public Transport { 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, TestBasicAPI) { } 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 fba1818dd8..d6bf0927f7 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc @@ -30,7 +30,7 @@ using namespace RTCPHelp; // 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 @@ RTCPReceiver::~RTCPReceiver() { delete _criticalSectionFeedbacks; while (!_receivedReportBlockMap.empty()) { - std::map::iterator first = + std::map::iterator first = _receivedReportBlockMap.begin(); delete first->second; _receivedReportBlockMap.erase(first); } while (!_receivedInfoMap.empty()) { - std::map::iterator first = + std::map::iterator first = _receivedInfoMap.begin(); delete first->second; _receivedInfoMap.erase(first); } while (!_receivedCnameMap.empty()) { - std::map::iterator first = + std::map::iterator first = _receivedCnameMap.begin(); delete first->second; _receivedCnameMap.erase(first); @@ -86,7 +86,7 @@ RTCPReceiver::~RTCPReceiver() { } void -RTCPReceiver::ChangeUniqueId(const WebRtc_Word32 id) +RTCPReceiver::ChangeUniqueId(const int32_t id) { _id = id; } @@ -98,7 +98,7 @@ RTCPReceiver::Status() const return _method; } -WebRtc_Word32 +int32_t RTCPReceiver::SetRTCPStatus(const RTCPMethod method) { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); @@ -106,17 +106,17 @@ RTCPReceiver::SetRTCPStatus(const RTCPMethod method) 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 @@ RTCPReceiver::LastReceivedReceiverReport() const { 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::RegisterRtcpObservers( } -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 @@ void RTCPReceiver::SetSSRC(const WebRtc_UWord32 ssrc) { } } -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 @@ WebRtc_Word32 RTCPReceiver::ResetRTT(const WebRtc_UWord32 remoteSSRC) { 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 @@ WebRtc_Word32 RTCPReceiver::RTT(const WebRtc_UWord32 remoteSSRC, return 0; } -WebRtc_UWord16 RTCPReceiver::RTT() const { +uint16_t RTCPReceiver::RTT() const { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); if (!_receivedReportBlockMap.empty()) { return 0; @@ -218,7 +218,7 @@ WebRtc_UWord16 RTCPReceiver::RTT() const { 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 @@ int RTCPReceiver::SetRTT(WebRtc_UWord16 rtt) { 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 @@ RTCPReceiver::NTP(WebRtc_UWord32 *ReceivedNTPsecs, return 0; } -WebRtc_Word32 +int32_t RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const { if(senderInfo == NULL) @@ -277,12 +277,12 @@ RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const // 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* receiveBlocks) const { assert(receiveBlocks); CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::const_iterator it = + std::map::const_iterator it = _receivedReportBlockMap.begin(); while (it != _receivedReportBlockMap.end()) { @@ -292,7 +292,7 @@ WebRtc_Word32 RTCPReceiver::StatisticsReceived( return 0; } -WebRtc_Word32 +int32_t RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation, RTCPUtility::RTCPParserV2* rtcpParser) { @@ -383,8 +383,8 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser, // 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 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser, 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 @@ RTCPReceiver::HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket, // 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 @@ RTCPReceiver::HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket, 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 @@ RTCPReceiver::HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket, } 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 @@ RTCPReceiver::HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket, reportBlock->avgRTT = static_cast (newAverage + 0.5f); } else { // first RTT - reportBlock->avgRTT = (WebRtc_UWord16) RTT; + reportBlock->avgRTT = (uint16_t) RTT; } reportBlock->numAverageCalcs++; } @@ -560,16 +560,16 @@ RTCPReceiver::HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket, // 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::iterator it = + std::map::iterator it = _receivedReportBlockMap.find(remoteSSRC); RTCPReportBlockInformation* ptrReportBlockInfo = NULL; @@ -583,10 +583,10 @@ RTCPReceiver::CreateReportBlockInformation(WebRtc_UWord32 remoteSSRC) { } RTCPReportBlockInformation* -RTCPReceiver::GetReportBlockInformation(WebRtc_UWord32 remoteSSRC) const { +RTCPReceiver::GetReportBlockInformation(uint32_t remoteSSRC) const { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::const_iterator it = + std::map::const_iterator it = _receivedReportBlockMap.find(remoteSSRC); if (it == _receivedReportBlockMap.end()) { @@ -596,10 +596,10 @@ RTCPReceiver::GetReportBlockInformation(WebRtc_UWord32 remoteSSRC) const { } RTCPCnameInformation* -RTCPReceiver::CreateCnameInformation(WebRtc_UWord32 remoteSSRC) { +RTCPReceiver::CreateCnameInformation(uint32_t remoteSSRC) { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::iterator it = + std::map::iterator it = _receivedCnameMap.find(remoteSSRC); if (it != _receivedCnameMap.end()) { @@ -612,10 +612,10 @@ RTCPReceiver::CreateCnameInformation(WebRtc_UWord32 remoteSSRC) { } RTCPCnameInformation* -RTCPReceiver::GetCnameInformation(WebRtc_UWord32 remoteSSRC) const { +RTCPReceiver::GetCnameInformation(uint32_t remoteSSRC) const { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::const_iterator it = + std::map::const_iterator it = _receivedCnameMap.find(remoteSSRC); if (it == _receivedCnameMap.end()) { @@ -625,10 +625,10 @@ RTCPReceiver::GetCnameInformation(WebRtc_UWord32 remoteSSRC) const { } RTCPReceiveInformation* -RTCPReceiver::CreateReceiveInformation(WebRtc_UWord32 remoteSSRC) { +RTCPReceiver::CreateReceiveInformation(uint32_t remoteSSRC) { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::iterator it = + std::map::iterator it = _receivedInfoMap.find(remoteSSRC); if (it != _receivedInfoMap.end()) { @@ -640,10 +640,10 @@ RTCPReceiver::CreateReceiveInformation(WebRtc_UWord32 remoteSSRC) { } RTCPReceiveInformation* -RTCPReceiver::GetReceiveInformation(WebRtc_UWord32 remoteSSRC) { +RTCPReceiver::GetReceiveInformation(uint32_t remoteSSRC) { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::iterator it = + std::map::iterator it = _receivedInfoMap.find(remoteSSRC); if (it == _receivedInfoMap.end()) { return NULL; @@ -690,9 +690,9 @@ bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); bool updateBoundingSet = false; - WebRtc_Word64 timeNow = _clock->TimeInMilliseconds(); + int64_t timeNow = _clock->TimeInMilliseconds(); - std::map::iterator receiveInfoIt = + std::map::iterator receiveInfoIt = _receivedInfoMap.begin(); while (receiveInfoIt != _receivedInfoMap.end()) { @@ -718,7 +718,7 @@ bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() { receiveInfoIt++; } else if (receiveInfo->readyForDelete) { // store our current receiveInfoItem - std::map::iterator + std::map::iterator receiveInfoItemToBeErased = receiveInfoIt; receiveInfoIt++; delete receiveInfoItemToBeErased->second; @@ -730,11 +730,10 @@ bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() { return updateBoundingSet; } -WebRtc_Word32 RTCPReceiver::BoundingSet(bool &tmmbrOwner, - TMMBRSet* boundingSetRec) { +int32_t RTCPReceiver::BoundingSet(bool &tmmbrOwner, TMMBRSet* boundingSetRec) { CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::iterator receiveInfoIt = + std::map::iterator receiveInfoIt = _receivedInfoMap.find(_remoteSSRC); if (receiveInfoIt == _receivedInfoMap.end()) { @@ -750,7 +749,7 @@ WebRtc_Word32 RTCPReceiver::BoundingSet(bool &tmmbrOwner, 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 @@ RTCPReceiver::HandleNACKItem(const RTCPUtility::RTCPPacket& rtcpPacket, { 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 @@ void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) { // clear our lists CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - std::map::iterator + std::map::iterator reportBlockInfoIt = _receivedReportBlockMap.find( rtcpPacket.BYE.SenderSSRC); @@ -848,14 +847,14 @@ void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) { _receivedReportBlockMap.erase(reportBlockInfoIt); } // we can't delete it due to TMMBR - std::map::iterator receiveInfoIt = + std::map::iterator receiveInfoIt = _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC); if (receiveInfoIt != _receivedInfoMap.end()) { receiveInfoIt->second->readyForDelete = true; } - std::map::iterator cnameInfoIt = + std::map::iterator cnameInfoIt = _receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC); if (cnameInfoIt != _receivedCnameMap.end()) { @@ -927,7 +926,7 @@ RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser, { 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 @@ RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser, 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 @@ void 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 @@ RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser, return; } - ptrReceiveInfo->VerifyAndAllocateBoundingSet((WebRtc_UWord32)maxNumOfTMMBNBlocks); + ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks); RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); while (pktType == RTCPUtility::kRtcpRtpfbTmmbnItemCode) @@ -1078,8 +1077,8 @@ RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser, 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 @@ void RTCPReceiver::HandleFIRItem(RTCPReceiveInformation* receiveInfo, // 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 @@ RTCPReceiver::HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser, 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 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket( 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 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket( } } -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 @@ WebRtc_Word32 RTCPReceiver::CNAME(const WebRtc_UWord32 remoteSSRC, } // 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::const_iterator + std::map::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 @@ WebRtc_Word32 RTCPReceiver::TMMBRReceived(const WebRtc_UWord32 size, 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 @@ void RTCPReceiver::PacketTimeout() 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 befe2dfd8b..0833b4a573 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h @@ -27,61 +27,62 @@ class ModuleRtpRtcpImpl; 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* receiveBlocks) const; // Returns true if we haven't received an RTCP RR for several RTCP @@ -95,28 +96,28 @@ public: 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 @@ protected: 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 @@ protected: 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 @@ protected: RTCPHelp::RTCPPacketInformation& rtcpPacketInformation); private: - typedef std::map + typedef std::map 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 @@ protected: 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 + std::map _receivedReportBlockMap; ReceivedInfoMap _receivedInfoMap; - std::map + std::map _receivedCnameMap; - WebRtc_UWord32 _packetTimeOutMS; + uint32_t _packetTimeOutMS; // The last time we received an RTCP RR. int64_t _lastReceivedRrMs; @@ -239,7 +240,7 @@ protected: // 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 4115f5d027..31b41abe1e 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 @@ RTCPPacketInformation::AddVoIPMetric(const RTCPVoIPMetric* metric) 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 @@ RTCPPacketInformation::ResetNACKPacketIdArray() } void -RTCPPacketInformation::AddNACKPacket(const WebRtc_UWord16 packetID) +RTCPPacketInformation::AddNACKPacket(const uint16_t packetID) { if (nackSequenceNumbers.size() >= kSendSideNackListSizeSanity) { return; @@ -95,10 +95,10 @@ RTCPPacketInformation::AddNACKPacket(const WebRtc_UWord16 packetID) } 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 @@ RTCPReceiveInformation::~RTCPReceiveInformation() { // 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::VerifyAndAllocateTMMBRSet( } 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 @@ void RTCPReceiveInformation::InsertTMMBRItem( _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 @@ WebRtc_Word32 RTCPReceiveInformation::GetTMMBRSet( } 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 1d538f0b48..2c2c375ecd 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 @@ public: 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 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 @@ public: // 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 @@ public: 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 @@ public: bool readyForDelete; private: - std::vector _tmmbrSetTimeouts; + std::vector _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 6de259014b..b0f5c20659 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 @@ class PacketBuilder { } - 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 @@ class PacketBuilder { 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 @@ class PacketBuilder { 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 @@ class PacketBuilder { Add32(0); // Delay since last SR. } - const WebRtc_UWord8* packet() { + const uint8_t* packet() { PatchLengthField(); return buffer_; } @@ -131,7 +131,7 @@ class PacketBuilder { // 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 @@ class TestTransport : public Transport, 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 @@ class RtcpReceiverTest : public ::testing::Test { // 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 @@ class RtcpReceiverTest : public ::testing::Test { 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, TmmbrReceivedWithNoIncomingPacket) { } 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, TmmbrPacketAccepted) { } 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, TmmbrPacketNotForUsIgnored) { } 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, TmmbrPacketZeroRateIgnored) { } 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 92b0be6dfa..ef97f85ac4 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc @@ -30,7 +30,7 @@ NACKStringBuilder::NACKStringBuilder() : // Empty. } -void NACKStringBuilder::PushNACK(WebRtc_UWord16 nack) +void NACKStringBuilder::PushNACK(uint16_t nack) { if (_count == 0) { @@ -61,7 +61,7 @@ std::string NACKStringBuilder::GetResult() 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 @@ RTCPSender::~RTCPSender() { delete [] _appData; while (!_reportBlocks.empty()) { - std::map::iterator it = + std::map::iterator it = _reportBlocks.begin(); delete it->second; _reportBlocks.erase(it); } while (!_csrcCNAMEs.empty()) { - std::map::iterator it = + std::map::iterator it = _csrcCNAMEs.begin(); delete it->second; _csrcCNAMEs.erase(it); @@ -151,7 +151,7 @@ RTCPSender::~RTCPSender() { WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, "%s deleted", __FUNCTION__); } -WebRtc_Word32 +int32_t RTCPSender::Init() { CriticalSectionScoped lock(_criticalSectionRTCPSender); @@ -201,12 +201,12 @@ RTCPSender::Init() } 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 @@ RTCPSender::Status() const return _method; } -WebRtc_Word32 +int32_t RTCPSender::SetRTCPStatus(const RTCPMethod method) { CriticalSectionScoped lock(_criticalSectionRTCPSender); @@ -248,7 +248,7 @@ RTCPSender::Sending() const return _sending; } -WebRtc_Word32 +int32_t RTCPSender::SetSendingStatus(const bool sending) { bool sendRTCPBye = false; @@ -279,7 +279,7 @@ RTCPSender::REMB() const return _REMB; } -WebRtc_Word32 +int32_t RTCPSender::SetREMBStatus(const bool enable) { CriticalSectionScoped lock(_criticalSectionRTCPSender); @@ -287,10 +287,10 @@ RTCPSender::SetREMBStatus(const bool enable) 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 @@ RTCPSender::SetREMBData(const WebRtc_UWord32 bitrate, if(_sizeRembSSRC < numberOfSSRC) { delete [] _rembSSRC; - _rembSSRC = new WebRtc_UWord32[numberOfSSRC]; + _rembSSRC = new uint32_t[numberOfSSRC]; _sizeRembSSRC = numberOfSSRC; } @@ -318,7 +318,7 @@ RTCPSender::TMMBR() const return _TMMBR; } -WebRtc_Word32 +int32_t RTCPSender::SetTMMBRStatus(const bool enable) { CriticalSectionScoped lock(_criticalSectionRTCPSender); @@ -333,7 +333,7 @@ RTCPSender::IJ() const return _IJ; } -WebRtc_Word32 +int32_t RTCPSender::SetIJStatus(const bool enable) { CriticalSectionScoped lock(_criticalSectionRTCPSender); @@ -358,7 +358,7 @@ void RTCPSender::SetLastRtpTime(uint32_t rtp_timestamp, } void -RTCPSender::SetSSRC( const WebRtc_UWord32 ssrc) +RTCPSender::SetSSRC( const uint32_t ssrc) { CriticalSectionScoped lock(_criticalSectionRTCPSender); @@ -372,16 +372,16 @@ RTCPSender::SetSSRC( const WebRtc_UWord32 ssrc) _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 @@ RTCPSender::SetCameraDelay(const WebRtc_Word32 delayMS) 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 @@ WebRtc_Word32 RTCPSender::CNAME(char cName[RTCP_CNAME_SIZE]) { 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 @@ WebRtc_Word32 RTCPSender::SetCNAME(const char cName[RTCP_CNAME_SIZE]) { 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 @@ WebRtc_Word32 RTCPSender::AddMixedCNAME(const WebRtc_UWord32 SSRC, return 0; } -WebRtc_Word32 RTCPSender::RemoveMixedCNAME(const WebRtc_UWord32 SSRC) { +int32_t RTCPSender::RemoveMixedCNAME(const uint32_t SSRC) { CriticalSectionScoped lock(_criticalSectionRTCPSender); - std::map::iterator it = + std::map::iterator it = _csrcCNAMEs.find(SSRC); if (it == _csrcCNAMEs.end()) { @@ -498,7 +498,7 @@ From RFC 3550 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 @@ From RFC 3550 return false; } -WebRtc_UWord32 -RTCPSender::LastSendReport( WebRtc_UWord32& lastRTCPTime) +uint32_t +RTCPSender::LastSendReport( uint32_t& lastRTCPTime) { CriticalSectionScoped lock(_criticalSectionRTCPSender); @@ -535,8 +535,8 @@ RTCPSender::LastSendReport( WebRtc_UWord32& lastRTCPTime) 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 @@ RTCPSender::SendTimeOfSendReport(const WebRtc_UWord32 sendReport) 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 @@ WebRtc_Word32 RTCPSender::AddReportBlock(const WebRtc_UWord32 SSRC, "%s invalid argument", __FUNCTION__); return -1; } - std::map::iterator it = + std::map::iterator it = _reportBlocks.find(SSRC); if (it != _reportBlocks.end()) { delete it->second; @@ -583,10 +583,10 @@ WebRtc_Word32 RTCPSender::AddReportBlock(const WebRtc_UWord32 SSRC, return 0; } -WebRtc_Word32 RTCPSender::RemoveReportBlock(const WebRtc_UWord32 SSRC) { +int32_t RTCPSender::RemoveReportBlock(const uint32_t SSRC) { CriticalSectionScoped lock(_criticalSectionRTCPSender); - std::map::iterator it = + std::map::iterator it = _reportBlocks.find(SSRC); if (it == _reportBlocks.end()) { @@ -597,11 +597,11 @@ WebRtc_Word32 RTCPSender::RemoveReportBlock(const WebRtc_UWord32 SSRC) { 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 @@ RTCPSender::BuildSR(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildSR(WebRtc_UWord8* rtcpbuffer, _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 @@ RTCPSender::BuildSR(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildSR(WebRtc_UWord8* rtcpbuffer, } 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 @@ WebRtc_Word32 RTCPSender::BuildSDEC(WebRtc_UWord8* rtcpbuffer, // SDEC Source Description // We always need to add SDES CNAME - rtcpbuffer[pos++] = static_cast(0x80 + 1 + _csrcCNAMEs.size()); - rtcpbuffer[pos++] = static_cast(202); + rtcpbuffer[pos++] = static_cast(0x80 + 1 + _csrcCNAMEs.size()); + rtcpbuffer[pos++] = static_cast(202); // handle SDES length later on - WebRtc_UWord32 SDESLengthPos = pos; + uint32_t SDESLengthPos = pos; pos++; pos++; @@ -711,18 +711,18 @@ WebRtc_Word32 RTCPSender::BuildSDEC(WebRtc_UWord8* rtcpbuffer, pos += 4; // CNAME = 1 - rtcpbuffer[pos++] = static_cast(1); + rtcpbuffer[pos++] = static_cast(1); // - rtcpbuffer[pos++] = static_cast(lengthCname); + rtcpbuffer[pos++] = static_cast(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 @@ WebRtc_Word32 RTCPSender::BuildSDEC(WebRtc_UWord8* rtcpbuffer, } SDESLength += padding; - std::map::iterator it = + std::map::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(1); + rtcpbuffer[pos++] = static_cast(1); size_t length = strlen(cname->name); assert(length < RTCP_CNAME_SIZE); - rtcpbuffer[pos++]= static_cast(length); + rtcpbuffer[pos++]= static_cast(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 @@ WebRtc_Word32 RTCPSender::BuildSDEC(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildRR(WebRtc_UWord8* rtcpbuffer, { 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 @@ RTCPSender::BuildRR(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildRR(WebRtc_UWord8* rtcpbuffer, // (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 @@ RTCPSender::BuildExtendedJitterReport( 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 @@ RTCPSender::BuildExtendedJitterReport( 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 @@ RTCPSender::BuildPLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildPLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ WebRtc_Word32 RTCPSender::BuildFIR(WebRtc_UWord8* rtcpbuffer, } // 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 @@ WebRtc_Word32 RTCPSender::BuildFIR(WebRtc_UWord8* rtcpbuffer, // 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 @@ WebRtc_Word32 RTCPSender::BuildFIR(WebRtc_UWord8* rtcpbuffer, | 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 @@ RTCPSender::BuildSLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos, const WebRt 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 @@ RTCPSender::BuildSLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos, const WebRt // 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 @@ RTCPSender::BuildSLI(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos, const WebRt /* * 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 @@ RTCPSender::BuildRPSI(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildRPSI(WebRtc_UWord8* rtcpbuffer, { size = 4; } - rtcpbuffer[pos++]=(WebRtc_UWord8)0; + rtcpbuffer[pos++]=(uint8_t)0; rtcpbuffer[pos++]=size; // Add our own SSRC @@ -1034,7 +1034,7 @@ RTCPSender::BuildRPSI(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildRPSI(WebRtc_UWord8* rtcpbuffer, // 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 @@ RTCPSender::BuildRPSI(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildREMB(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildREMB(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::SetTargetBitrate(unsigned int target_bitrate) _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 @@ RTCPSender::BuildTMMBR(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) // 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 @@ RTCPSender::BuildTMMBR(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildTMMBR(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) // 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 @@ RTCPSender::BuildTMMBN(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildTMMBN(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) // 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 @@ RTCPSender::BuildAPP(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildAPP(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer, 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 @@ RTCPSender::BuildNACK(WebRtc_UWord8* rtcpbuffer, } 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 @@ RTCPSender::BuildBYE(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildBYE(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) } 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 @@ RTCPSender::BuildBYE(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildVoIPMetric(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) } // 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 @@ RTCPSender::BuildVoIPMetric(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::BuildVoIPMetric(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) 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 @@ RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags, { 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 @@ RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags, _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 @@ RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags, { // 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 @@ RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags, } // 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 @@ RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags, } 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 @@ RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags, } 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 @@ RTCPSender::SendRTCP(const WebRtc_UWord32 packetTypeFlags, { 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 @@ RTCPSender::SendToNetwork(const WebRtc_UWord8* dataBuffer, 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 @@ RTCPSender::SetCSRCs(const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize], 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 @@ RTCPSender::SetApplicationSpecificData(const WebRtc_UWord8 subType, _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 @@ RTCPSender::SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) } // 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 @@ WebRtc_Word32 RTCPSender::AddReportBlocks(WebRtc_UWord8* rtcpbuffer, "%s invalid argument", __FUNCTION__); return -1; } - std::map::iterator it = + std::map::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 @@ WebRtc_Word32 RTCPSender::AddReportBlocks(WebRtc_UWord8* rtcpbuffer, } // 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 5ca6a01829..014b975d4f 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h @@ -32,176 +32,173 @@ class NACKStringBuilder { 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 @@ private: 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 _reportBlocks; - std::map _csrcCNAMEs; + std::map _reportBlocks; + std::map _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 23951303eb..74dd91deb4 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 @@ TEST(NACKStringBuilderTest, TestCase13) { 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 @@ class TestTransport : public Transport, } 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 @@ class TestTransport : public Transport, 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, IJStatus) { 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 @@ TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndValid) { 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 8673e872cf..b330e18e58 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 @@ RTCPUtility::RTCPParserV2::EndCurrentBlock() } 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 @@ RTCPUtility::RTCPParserV2::ParseSDESChunk() return false; } - WebRtc_UWord32 SSRC = *_ptrRTCPData++ << 24; + uint32_t SSRC = *_ptrRTCPData++ << 24; SSRC += *_ptrRTCPData++ << 16; SSRC += *_ptrRTCPData++ << 8; SSRC += *_ptrRTCPData++; @@ -717,7 +717,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem() 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 @@ RTCPUtility::RTCPParserV2::ParseSDESItem() if (_ptrRTCPData < _ptrRTCPBlockEnd) { - const WebRtc_UWord8 len = *_ptrRTCPData++; + const uint8_t len = *_ptrRTCPData++; ++itemOctetsRead; if (tag == 1) @@ -747,10 +747,10 @@ RTCPUtility::RTCPParserV2::ParseSDESItem() 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 @@ RTCPUtility::RTCPParserV2::ParseXRItem() 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 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header) _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 @@ RTCPUtility::RTCPParserV2::ParseRPSIItem() _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 @@ RTCPUtility::RTCPParserV2::ParsePsfbREMBItem() } _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 @@ RTCPUtility::RTCPParserV2::ParseTMMBRItem() _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 @@ RTCPUtility::RTCPParserV2::ParseTMMBNItem() _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 @@ RTCPUtility::RTCPParserV2::ParseSLIItem() } _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 @@ RTCPUtility::RTCPParserV2::ParseAPP( const RTCPCommonHeader& header) _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 @@ RTCPUtility::RTCPParserV2::ParseAPPItem() }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 cce1f0b3ac..86b2efd75c 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_utility.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_utility.h @@ -26,177 +26,177 @@ namespace RTCPUtility { }; 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 @@ namespace RTCPUtility { 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 @@ namespace RTCPUtility { 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 @@ namespace RTCPUtility { 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 @@ namespace RTCPUtility { class RTCPPacketIterator { public: - RTCPPacketIterator(WebRtc_UWord8* rtcpData, + RTCPPacketIterator(uint8_t* rtcpData, size_t rtcpDataLength); ~RTCPPacketIterator(); @@ -434,10 +434,10 @@ namespace RTCPUtility { 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 1b3c598d52..5f1a17c56e 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::balance_modes_[kNumModes] = 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 @@ RtpFormatVp8::RtpFormatVp8(const WebRtc_UWord8* payload_data, 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 @@ RtpFormatVp8::RtpFormatVp8(const WebRtc_UWord8* payload_data, 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 @@ void RtpFormatVp8::QueuePacket(int start_pos, } 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 @@ int RtpFormatVp8::WriteHeaderAndPayload(const InfoStruct& packet_info, + 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 @@ int RtpFormatVp8::WriteExtensionFields(WebRtc_UWord8* buffer, 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 @@ int RtpFormatVp8::WritePictureIDFields(WebRtc_UWord8* x_field, 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 (hdr_info_.pictureId); + const uint16_t pic_id = + static_cast (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 @@ int RtpFormatVp8::WritePictureID(WebRtc_UWord8* buffer, 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 @@ int RtpFormatVp8::WriteTl0PicIdxFields(WebRtc_UWord8* x_field, 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 f568f4d2b8..2a62b40785 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 @@ class RtpFormatVp8 { 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 @@ class RtpFormatVp8 { // 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 @@ class RtpFormatVp8 { // 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 @@ class RtpFormatVp8 { // 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 @@ class RtpFormatVp8 { 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 6c668dd464..5bd4647cdd 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 @@ bool RtpFormatVp8TestHelper::Init(const int* partition_sizes, 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 13b9b77bf7..cb689ee424 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 @@ RTPPayloadRegistry::~RTPPayloadRegistry() { } } -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 @@ WebRtc_Word32 RTPPayloadRegistry::RegisterReceivePayload( 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 @@ WebRtc_Word32 RTPPayloadRegistry::DeRegisterReceivePayload( 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 @@ void RTPPayloadRegistry::DeregisterAudioCodecOrRedTypeRegardlessOfPayloadType( } } -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 @@ WebRtc_Word32 RTPPayloadRegistry::ReceivePayloadType( 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 @@ WebRtc_Word32 RTPPayloadRegistry::PayloadTypeToPayload( } 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 @@ class RTPPayloadAudioStrategy : public RTPPayloadStrategy { 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 @@ class RTPPayloadAudioStrategy : public RTPPayloadStrategy { 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 @@ class RTPPayloadVideoStrategy : public RTPPayloadStrategy { 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 7153ba2512..7ba4c25179 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 @@ class RTPPayloadStrategy { 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 RTPPayloadStrategy { 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 @@ class RTPPayloadRegistry { } // 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 @@ class RTPPayloadRegistry { 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 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 eb34673f42..f18529c0ce 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::RTPPayloadParser; 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 @@ RtpVideoCodecTypes RTPReceiver::VideoCodecType() const { 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 @@ void RTPReceiver::PacketTimeout() { 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::PacketTimeout() { } 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 @@ void RTPReceiver::ProcessDeadOrAlive(const bool rtcp_alive, 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 @@ WebRtc_Word32 RTPReceiver::RegisterReceivePayload( 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 @@ NACKMethod RTPReceiver::NACK() const { } // 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 @@ WebRtc_Word32 RTPReceiver::SetNACKStatus(const NACKMethod method, } 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 @@ WebRtc_Word32 RTPReceiver::IncomingRTPPacket( 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 @@ WebRtc_Word32 RTPReceiver::IncomingRTPPacket( } 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 @@ WebRtc_Word32 RTPReceiver::IncomingRTPPacket( 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 @@ WebRtc_Word32 RTPReceiver::IncomingRTPPacket( // 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 @@ void RTPReceiver::UpdateStatistics(const WebRtcRTPHeader* rtp_header, // 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 @@ void RTPReceiver::UpdateStatistics(const WebRtcRTPHeader* rtp_header, 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 @@ void RTPReceiver::UpdateStatistics(const WebRtcRTPHeader* rtp_header, // 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 @@ void RTPReceiver::UpdateStatistics(const WebRtcRTPHeader* rtp_header, 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 @@ void RTPReceiver::UpdateStatistics(const WebRtcRTPHeader* rtp_header, } } - 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 @@ void RTPReceiver::UpdateStatistics(const WebRtcRTPHeader* rtp_header, // 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(rtp_time_stamp - last_received_timestamp_) / + int32_t rtp_time_stamp_diff_ms = + static_cast(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 @@ bool RTPReceiver::RetransmitOfOldPacket( // 2 times the standard deviation => 95% confidence. // And transform to milliseconds by dividing by the frequency in kHz. - max_delay_ms = static_cast((2 * jitter_std) / frequency_khz); + max_delay_ms = static_cast((2 * jitter_std) / frequency_khz); // Min max_delay_ms is 1. if (max_delay_ms == 0) { @@ -583,7 +583,7 @@ bool RTPReceiver::RetransmitOfOldPacket( 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 @@ bool RTPReceiver::InOrderPacket(const WebRtc_UWord16 sequence_number) const { 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 @@ int32_t RTPReceiver::LastReceivedTimeMs() const { // 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 @@ WebRtc_Word32 RTPReceiver::EstimatedRemoteTimeStamp( 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 @@ WebRtc_Word32 RTPReceiver::EstimatedRemoteTimeStamp( } // 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 @@ WebRtc_Word32 RTPReceiver::SSRCFilter(WebRtc_UWord32& allowed_ssrc) const { } // 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 @@ void RTPReceiver::CheckSSRCChanged(const WebRtcRTPHeader* rtp_header) { 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 @@ void RTPReceiver::CheckSSRCChanged(const WebRtcRTPHeader* rtp_header) { // 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 @@ WebRtc_Word32 RTPReceiver::CheckPayloadChanged( // 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 @@ void RTPReceiver::CheckCSRC(const WebRtcRTPHeader* rtp_header) { 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 @@ void RTPReceiver::CheckCSRC(const WebRtcRTPHeader* rtp_header) { 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 @@ void RTPReceiver::CheckCSRC(const WebRtcRTPHeader* rtp_header) { } } // 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 @@ void RTPReceiver::CheckCSRC(const WebRtcRTPHeader* rtp_header) { } } -WebRtc_Word32 RTPReceiver::ResetStatistics() { +int32_t RTPReceiver::ResetStatistics() { CriticalSectionScoped lock(critical_section_rtp_receiver_); last_report_inorder_packets_ = 0; @@ -957,7 +957,7 @@ WebRtc_Word32 RTPReceiver::ResetStatistics() { return 0; } -WebRtc_Word32 RTPReceiver::ResetDataCounters() { +int32_t RTPReceiver::ResetDataCounters() { CriticalSectionScoped lock(critical_section_rtp_receiver_); received_byte_count_ = 0; @@ -968,15 +968,15 @@ WebRtc_Word32 RTPReceiver::ResetDataCounters() { 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 @@ WebRtc_Word32 RTPReceiver::Statistics( 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 @@ WebRtc_Word32 RTPReceiver::Statistics( 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 @@ WebRtc_Word32 RTPReceiver::Statistics( // 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 @@ WebRtc_Word32 RTPReceiver::Statistics( 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 @@ WebRtc_Word32 RTPReceiver::Statistics( 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 d859297235..8d794ced3a 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_receiver.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver.h @@ -37,7 +37,7 @@ class RTPReceiver : public Bitrate { // 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 @@ class RTPReceiver : public Bitrate { 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 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 55894ebd03..ea921ccedf 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 @@ RTPReceiverAudio::RTPReceiverAudio(const WebRtc_Word32 id, 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::TelephoneEventForwardToDecoder() const { } 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::CNGPayloadType(const WebRtc_Word8 payload_type, } 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 @@ bool RTPReceiverAudio::ShouldReportCsrcChanges( // - 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 @@ WebRtc_Word32 RTPReceiverAudio::OnNewPayloadTypeCreated( 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 @@ WebRtc_Word32 RTPReceiverAudio::ParseRtpPacket( 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 @@ RTPAliveType RTPReceiverAudio::ProcessDeadOrAlive( } 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 @@ void RTPReceiverAudio::CheckPayloadChanged( } } -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 @@ WebRtc_Word32 RTPReceiverAudio::InvokeOnInitializeDecoder( } // 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 @@ WebRtc_Word32 RTPReceiverAudio::ParseAudioCodecSpecific( 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 @@ WebRtc_Word32 RTPReceiverAudio::ParseAudioCodecSpecific( for (int n = 0; n < number_of_events; ++n) { bool end = (payload_data[(4 * n) + 1] & 0x80) ? true : false; - std::set::iterator event = + std::set::iterator event = telephone_event_reported_.find(payload_data[4 * n]); if (event != telephone_event_reported_.end()) { @@ -340,7 +340,7 @@ WebRtc_Word32 RTPReceiverAudio::ParseAudioCodecSpecific( } // 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 @@ WebRtc_Word32 RTPReceiverAudio::ParseAudioCodecSpecific( // don't forward event to decoder return 0; } - std::set::iterator first = + std::set::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 96df5f1776..67b30c0200 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 @@ class CriticalSectionWrapper; // 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 @@ class RTPReceiverAudio : public RTPReceiverStrategy { 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 @@ class RTPReceiverAudio : public RTPReceiverStrategy { 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 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 telephone_event_reported_; + int8_t telephone_event_payload_type_; + std::set 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 19b64888ed..8e8fa1d0da 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 @@ class RTPReceiverStrategy { // 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 09180d8b79..ca6e05b972 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 @@ RTPReceiverVideo::~RTPReceiverVideo() { } 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 @@ WebRtc_Word32 RTPReceiverVideo::OnNewPayloadTypeCreated( 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 @@ WebRtc_Word32 RTPReceiverVideo::ParseRtpPacket( 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 @@ WebRtc_Word32 RTPReceiverVideo::InvokeOnInitializeDecoder( // 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 @@ WebRtc_Word32 RTPReceiverVideo::ParseVideoCodecSpecific( // 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 @@ WebRtc_Word32 RTPReceiverVideo::ParseVideoCodecSpecific( 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(0x80); // version 2 - data_buffer[1] = static_cast(rtp_header->header.payloadType); + uint8_t* data_buffer) const { + data_buffer[0] = static_cast(0x80); // version 2 + data_buffer[1] = static_cast(rtp_header->header.payloadType); if (rtp_header->header.markerBit) { data_buffer[1] |= kRtpMarkerBitMask; // MarkerBit is 1 } @@ -193,7 +193,7 @@ WebRtc_Word32 RTPReceiverVideo::BuildRTPheader( 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 @@ WebRtc_Word32 RTPReceiverVideo::BuildRTPheader( // 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 @@ WebRtc_Word32 RTPReceiverVideo::ReceiveRecoveredPacketCallback( } // 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 @@ WebRtc_Word32 RTPReceiverVideo::ReceiveRecoveredPacketCallback( 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 @@ WebRtc_Word32 RTPReceiverVideo::SetCodecType( 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 @@ WebRtc_Word32 RTPReceiverVideo::ParseVideoCodecSpecificSwitch( 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 @@ WebRtc_Word32 RTPReceiverVideo::ReceiveVp8Codec( 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 d5bbb81d06..520e201266 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 RTPPayloadRegistry; 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 71d79408e6..1597ab2cd1 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 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration) 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 @@ void ModuleRtpRtcpImpl::DeRegisterChildModule(RtpRtcp* remove_module) { // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::Process() { } 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 @@ void ModuleRtpRtcpImpl::ProcessDeadOrAliveTimer() { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetPeriodicDeadOrAliveStatus( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::PeriodicDeadOrAliveStatus( enable = dead_or_alive_active_; sample_time_seconds = - static_cast(dead_or_alive_timeout_ms_ / 1000); + static_cast(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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetPacketTimeout( return -1; } -WebRtc_Word32 ModuleRtpRtcpImpl::RegisterReceivePayload( +int32_t ModuleRtpRtcpImpl::RegisterReceivePayload( const CodecInst& voice_codec) { WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, @@ -409,7 +408,7 @@ WebRtc_Word32 ModuleRtpRtcpImpl::RegisterReceivePayload( (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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::RegisterReceivePayload( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::ReceivePayloadType( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::ReceivePayloadType( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::DeRegisterReceivePayload( } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetSSRCFilter( } // 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 @@ int64_t ModuleRtpRtcpImpl::LocalTimeOfRemoteTimeStamp() const { } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::EstimatedRemoteTimeStamp( } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::IncomingPacket( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::IncomingPacket( 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::IncomingPacket( } } -WebRtc_Word32 ModuleRtpRtcpImpl::RegisterSendPayload( +int32_t ModuleRtpRtcpImpl::RegisterSendPayload( const CodecInst& voice_codec) { WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, @@ -652,7 +650,7 @@ WebRtc_Word32 ModuleRtpRtcpImpl::RegisterSendPayload( (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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::RegisterSendPayload( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::DeRegisterSendPayload( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetStartTimestamp( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetSequenceNumber( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetSSRC(const WebRtc_UWord32 ssrc) { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetCSRCs( 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 @@ int ModuleRtpRtcpImpl::CurrentSendFrequencyHz() const { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetSendingStatus(const bool sending) { // 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 @@ bool ModuleRtpRtcpImpl::Sending() const { 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 @@ bool ModuleRtpRtcpImpl::SendingMedia() const { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SendOutgoingData( 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 @@ void ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc, } } -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 @@ WebRtc_UWord16 ModuleRtpRtcpImpl::MaxDataPayloadLength() const { 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 ModuleRtpRtcpImpl::MaxDataPayloadLength() const { } } - 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetTransportOverhead( "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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetTransportOverhead( 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 @@ RTCPMethod ModuleRtpRtcpImpl::RTCP() const { } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetRTCPStatus(const RTCPMethod method) { } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::AddMixedCNAME( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::RemoteCNAME( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::RemoteNTP( } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::ResetRTT(const WebRtc_UWord32 remote_ssrc) { void ModuleRtpRtcpImpl:: SetRtt(uint32_t rtt) { WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SetRtt(rtt: %u)", rtt); - rtcp_receiver_.SetRTT(static_cast(rtt)); + rtcp_receiver_.SetRTT(static_cast(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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::ResetReceiveDataCountersRTP() { } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::ResetSendDataCountersRTP() { // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData( } // (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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetRTCPVoIPMetrics( } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::StatisticsRTP( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::DataCountersRTP( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::ReportBlockStatistics( 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* 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 @@ bool ModuleRtpRtcpImpl::REMB() const { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetREMBStatus(const bool enable) { 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 @@ bool ModuleRtpRtcpImpl::IJ() const { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetIJStatus(const bool enable) { 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 @@ bool ModuleRtpRtcpImpl::TMMBR() const { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetTMMBRStatus(const bool enable) { 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 @@ NACKMethod ModuleRtpRtcpImpl::NACK() const { } // 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 @@ int ModuleRtpRtcpImpl::SetSelectiveRetransmissions(uint8_t settings) { } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SendNACK(const WebRtc_UWord16* nack_list, // 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 @@ bool ModuleRtpRtcpImpl::TelephoneEventForwardToDecoder() const { } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SendTelephoneEventOutband( } bool ModuleRtpRtcpImpl::SendTelephoneEventActive( - WebRtc_Word8& telephone_event) const { + int8_t& telephone_event) const { WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, @@ -1655,8 +1653,8 @@ bool ModuleRtpRtcpImpl::SendTelephoneEventActive( // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetAudioPacketSize( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetRTPAudioLevelIndicationStatus( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::GetRTPAudioLevelIndicationStatus( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetAudioLevel( } // 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetSendREDPayloadType( } // 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 @@ void ModuleRtpRtcpImpl::SetTargetSendBitrate(const uint32_t bitrate) { } } -WebRtc_Word32 ModuleRtpRtcpImpl::SetKeyFrameRequestMethod( +int32_t ModuleRtpRtcpImpl::SetKeyFrameRequestMethod( const KeyFrameRequestMethod method) { WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, @@ -1786,7 +1784,7 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetKeyFrameRequestMethod( return 0; } -WebRtc_Word32 ModuleRtpRtcpImpl::RequestKeyFrame() { +int32_t ModuleRtpRtcpImpl::RequestKeyFrame() { WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, @@ -1803,8 +1801,8 @@ WebRtc_Word32 ModuleRtpRtcpImpl::RequestKeyFrame() { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SendRTCPSliceLossIndication( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetCameraDelay(const WebRtc_Word32 delay_ms) { 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetGenericFECStatus( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::GenericFECStatus( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::GenericFECStatus( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::GenericFECStatus( 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 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SetFecParameters( 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 @@ void ModuleRtpRtcpImpl::SetRemoteSSRC(const WebRtc_UWord32 ssrc) { 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 @@ void ModuleRtpRtcpImpl::SetRemoteSSRC(const WebRtc_UWord32 ssrc) { } } -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 @@ void ModuleRtpRtcpImpl::BitrateSent(WebRtc_UWord32* total_rate, 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 @@ void ModuleRtpRtcpImpl::OnRequestSendReport() { 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 @@ void ModuleRtpRtcpImpl::OnReceivedNACK( 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 @@ bool ModuleRtpRtcpImpl::UpdateRTCPReceiveInformationTimers() { } // 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 b15b9aa704..3d0be8be48 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 @@ class ModuleRtpRtcpImpl : public RtpRtcp { // 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 @@ class ModuleRtpRtcpImpl : public RtpRtcp { 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* 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 @@ class ModuleRtpRtcpImpl : public RtpRtcp { 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 @@ class ModuleRtpRtcpImpl : public RtpRtcp { // 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 @@ class ModuleRtpRtcpImpl : public RtpRtcp { 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 @@ class ModuleRtpRtcpImpl : public RtpRtcp { 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& nack_sequence_numbers); @@ -455,13 +452,13 @@ class ModuleRtpRtcpImpl : public RtpRtcp { 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 @@ class ModuleRtpRtcpImpl : public RtpRtcp { 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 critical_section_module_ptrs_; scoped_ptr critical_section_module_ptrs_feedback_; @@ -494,12 +491,12 @@ class ModuleRtpRtcpImpl : public RtpRtcp { // 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 2b43af14fb..9c5cfe02ef 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 @@ RTPSender::RTPSender(const WebRtc_Word32 id, const bool audio, Clock *clock, memset(nack_byte_count_, 0, sizeof(nack_byte_count_)); memset(csrc_, 0, sizeof(csrc_)); // We need to seed the random generator. - srand(static_cast(clock_->TimeInMilliseconds())); + srand(static_cast(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 @@ RTPSender::~RTPSender() { SSRCDatabase::ReturnSSRCDatabase(); delete send_critsect_; while (!payload_type_map_.empty()) { - std::map::iterator it = + std::map::iterator it = payload_type_map_.begin(); delete it->second; payload_type_map_.erase(it); @@ -82,34 +82,34 @@ RTPSender::~RTPSender() { 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(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 @@ WebRtc_Word32 RTPSender::SetTransmissionTimeOffset( 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::iterator it = + std::map::iterator it = payload_type_map_.find(payload_number); if (payload_type_map_.end() != it) { @@ -168,7 +168,7 @@ WebRtc_Word32 RTPSender::RegisterPayload( } 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 @@ WebRtc_Word32 RTPSender::RegisterPayload( 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::iterator it = + std::map::iterator it = payload_type_map_.find(payload_type); if (payload_type_map_.end() == it) { @@ -199,13 +199,13 @@ WebRtc_Word32 RTPSender::DeRegisterSendPayload( 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 @@ WebRtc_Word32 RTPSender::SetMaxPayloadLength( 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::MaxDataPayloadLength() const { } } -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::SetRTXStatus(const RtxMode mode, const bool set_ssrc, } } -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 @@ WebRtc_Word32 RTPSender::CheckPayloadType(const WebRtc_Word8 payload_type, 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 @@ WebRtc_Word32 RTPSender::CheckPayloadType(const WebRtc_Word8 payload_type, } return 0; } - std::map::iterator it = + std::map::iterator it = payload_type_map_.find(payload_type); if (it == payload_type_map_.end()) { WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_, @@ -299,10 +299,10 @@ WebRtc_Word32 RTPSender::CheckPayloadType(const WebRtc_Word8 payload_type, 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::SendOutgoingData( } } -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 @@ WebRtc_Word32 RTPSender::SendPaddingAccordingToBitrate( 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 @@ WebRtc_Word32 RTPSender::SendPadData( capture_timestamp, true, // Timestamp provided. true); // Increment sequence number. data_buffer[0] |= 0x20; // Set padding bit. - WebRtc_Word32 *data = - reinterpret_cast(&(data_buffer[header_length])); + int32_t *data = + reinterpret_cast(&(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 @@ WebRtc_Word32 RTPSender::SendPadData( } 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 @@ WebRtc_Word32 RTPSender::ReSendPacket(WebRtc_UWord16 packet_id, // 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 @@ WebRtc_Word32 RTPSender::ReSendPacket(WebRtc_UWord16 packet_id, 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 @@ int RTPSender::SetSelectiveRetransmissions(uint8_t settings) { void RTPSender::OnReceivedNACK( const std::list& 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 @@ void RTPSender::OnReceivedNACK( for (std::list::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 @@ void RTPSender::OnReceivedNACK( // 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(target_send_bitrate_) * avg_rtt) >> 3; + uint32_t target_bytes = + (static_cast(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 @@ void RTPSender::OnReceivedNACK( } } -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 @@ bool RTPSender::ProcessNACKBitRate(const WebRtc_UWord32 now) { 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 @@ bool RTPSender::ProcessNACKBitRate(const WebRtc_UWord32 now) { 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 @@ void RTPSender::TimeToSendPacket(uint16_t sequence_number, } // 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 @@ WebRtc_Word32 RTPSender::SendToNetwork( 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 @@ void RTPSender::ProcessBitrate() { 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 @@ void RTPSender::ResetDataCounters() { 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(0x80); // version 2. - data_buffer[1] = static_cast(payload_type); + data_buffer[0] = static_cast(0x80); // version 2. + data_buffer[1] = static_cast(payload_type); if (marker_bit) { data_buffer[1] |= kRtpMarkerBitMask; // Marker bit is set. } @@ -764,7 +762,7 @@ WebRtc_Word32 RTPSender::BuildRTPheader( 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 @@ WebRtc_Word32 RTPSender::BuildRTPheader( 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 @@ WebRtc_Word32 RTPSender::BuildRTPheader( 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 @@ WebRtc_UWord16 RTPSender::BuildRTPHeaderExtension( // | 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 @@ WebRtc_UWord16 RTPSender::BuildRTPHeaderExtension( 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 @@ WebRtc_UWord8 RTPSender::BuildTransmissionTimeOffsetExtension( // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // 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 @@ WebRtc_UWord8 RTPSender::BuildTransmissionTimeOffsetExtension( } 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 @@ bool RTPSender::UpdateTransmissionTimeOffset( 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 @@ bool RTPSender::UpdateTransmissionTimeOffset( 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 @@ bool RTPSender::UpdateTransmissionTimeOffset( 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 @@ void RTPSender::SetSendingStatus(const bool enabled) { } 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 @@ bool RTPSender::SendingMedia() const { 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 @@ void RTPSender::SetStartTimestamp(WebRtc_UWord32 timestamp, bool force) { } } -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 @@ WebRtc_UWord32 RTPSender::GenerateNewSSRC() { 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 @@ void RTPSender::SetSSRC(WebRtc_UWord32 ssrc) { } } -WebRtc_UWord32 RTPSender::SSRC() const { +uint32_t RTPSender::SSRC() const { CriticalSectionScoped cs(send_critsect_); return ssrc_; } @@ -1036,8 +1033,8 @@ void RTPSender::SetCSRCStatus(const bool include) { 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 @@ void RTPSender::SetCSRCs(const WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize], 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 @@ WebRtc_Word32 RTPSender::CSRCs(WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const { 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 @@ RtpVideoCodecTypes RTPSender::VideoCodecType() const { 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 @@ WebRtc_Word32 RTPSender::SetGenericFECStatus( 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 @@ WebRtc_Word32 RTPSender::GenericFECStatus( *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 @@ WebRtc_Word32 RTPSender::SetFecParameters( 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(buffer), *length); + reinterpret_cast(buffer), *length); WebRtcRTPHeader rtp_header; rtp_parser.Parse(rtp_header); @@ -1194,7 +1191,7 @@ void RTPSender::BuildRtxPacket(WebRtc_UWord8* buffer, WebRtc_UWord16* length, 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 b101a3df1c..b57bcf4840 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h @@ -38,55 +38,55 @@ class RTPSenderInterface { 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 @@ class RTPSender : public Bitrate, public RTPSenderInterface { 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 @@ class RTPSender : public Bitrate, public RTPSenderInterface { int SelectiveRetransmissions() const; int SetSelectiveRetransmissions(uint8_t settings); void OnReceivedNACK(const std::list& 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 @@ class RTPSender : public Bitrate, public RTPSenderInterface { 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 payload_type_map_; + int8_t payload_type_; + std::map 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 34f650ff8c..8589874885 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 //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 @@ RTPSenderAudio::~RTPSenderAudio() delete _audioFeedbackCritsect; } -WebRtc_Word32 +int32_t RTPSenderAudio::RegisterAudioCallback(RtpAudioFeedback* messagesCallback) { CriticalSectionScoped cs(_audioFeedbackCritsect); @@ -60,7 +60,7 @@ RTPSenderAudio::RegisterAudioCallback(RtpAudioFeedback* messagesCallback) } void -RTPSenderAudio::SetAudioFrequency(const WebRtc_UWord32 f) +RTPSenderAudio::SetAudioFrequency(const uint32_t f) { CriticalSectionScoped cs(_sendAudioCritsect); _frequency = f; @@ -74,8 +74,8 @@ RTPSenderAudio::AudioFrequency() const } // 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 @@ RTPSenderAudio::SetAudioPacketSize(const WebRtc_UWord16 packetSizeSamples) 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 @@ WebRtc_Word32 RTPSenderAudio::RegisterAudioPayload( bool RTPSenderAudio::MarkerBit(const FrameType frameType, - const WebRtc_Word8 payloadType) + const int8_t payloadType) { CriticalSectionScoped cs(_sendAudioCritsect); @@ -210,14 +210,14 @@ RTPSenderAudio::MarkerBit(const FrameType frameType, } 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 @@ RTPSenderAudio::SendTelephoneEventActive(WebRtc_Word8& telephoneEvent) const 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(dataSize); - WebRtc_UWord16 maxPayloadLength = _rtpSender->MaxPayloadLength(); + uint16_t payloadSize = static_cast(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 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( } } _dtmfTimestampLastSent = captureTimeStamp; - WebRtc_UWord32 dtmfDurationSamples = captureTimeStamp - _dtmfTimestamp; + uint32_t dtmfDurationSamples = captureTimeStamp - _dtmfTimestamp; bool ended = false; bool send = true; @@ -305,7 +305,7 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( if (dtmfDurationSamples > 0xffff) { // RFC 4733 2.5.2.3 Long-Duration Events SendTelephoneEventPacket(ended, _dtmfTimestamp, - static_cast(0xffff), false); + static_cast(0xffff), false); // set new timestap for this segment _dtmfTimestamp = captureTimeStamp; @@ -315,7 +315,7 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( return SendTelephoneEventPacket( ended, _dtmfTimestamp, - static_cast(dtmfDurationSamples), + static_cast(dtmfDurationSamples), false); } else { // set markerBit on the first packet in the burst @@ -323,7 +323,7 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( return SendTelephoneEventPacket( ended, _dtmfTimestamp, - static_cast(dtmfDurationSamples), + static_cast(dtmfDurationSamples), !_dtmfEventFirstPacketSent); } } @@ -339,21 +339,21 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( } 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 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( 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 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( // 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 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( payloadData + fragmentation->fragmentationOffset[0], fragmentation->fragmentationLength[0]); - payloadSize = static_cast( + payloadSize = static_cast( fragmentation->fragmentationLength[0] + fragmentation->fragmentationLength[1]); } else { @@ -452,7 +452,7 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( payloadData + fragmentation->fragmentationOffset[0], fragmentation->fragmentationLength[0]); - payloadSize = static_cast( + payloadSize = static_cast( fragmentation->fragmentationLength[0]); } } else { @@ -463,7 +463,7 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( payloadData + fragmentation->fragmentationOffset[0], fragmentation->fragmentationLength[0]); - payloadSize = static_cast( + payloadSize = static_cast( fragmentation->fragmentationLength[0]); } else { memcpy(dataBuffer+rtpHeaderLength, payloadData, payloadSize); @@ -473,14 +473,14 @@ WebRtc_Word32 RTPSenderAudio::SendAudio( } // end critical section return _rtpSender->SendToNetwork(dataBuffer, payloadSize, - static_cast(rtpHeaderLength), + static_cast(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 @@ RTPSenderAudio::SetAudioLevelIndicationStatus(const bool enable, 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 @@ RTPSenderAudio::AudioLevelIndicationStatus(bool& enable, } // 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 @@ RTPSenderAudio::SetAudioLevel(const WebRtc_UWord8 level_dBov) } // 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 @@ RTPSenderAudio::SetRED(const WebRtc_Word8 payloadType) } // 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 @@ RTPSenderAudio::RED(WebRtc_Word8& payloadType) const } // 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 @@ RTPSenderAudio::SendTelephoneEvent(const WebRtc_UWord8 key, 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 @@ RTPSenderAudio::SendTelephoneEventPacket(const bool ended, +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ // 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 535c0d0537..c7b36728ed 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 @@ namespace webrtc { 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 @@ private: 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 4d38bec77b..2c2220167b 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, RegisterRtpHeaderExtension) { } 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 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) { 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 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) { 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, BuildRTPPacketWithNegativeTransmissionOffsetExtension) { } 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 @@ TEST_F(RtpSenderTest, DISABLED_TrafficSmoothing) { 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 59d4403fa9..034b3df344 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 @@ namespace webrtc { 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 @@ RTPSenderVideo::VideoCodecType() const 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 @@ WebRtc_Word32 RTPSenderVideo::RegisterVideoPayload( 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 @@ RTPSenderVideo::SendVideoPacket(WebRtc_UWord8* data_buffer, 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 @@ RTPSenderVideo::SendRTPIntraRequest() 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 @@ RTPSenderVideo::SetGenericFECStatus(const bool enable, 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 @@ RTPSenderVideo::GenericFECStatus(bool& enable, return 0; } -WebRtc_UWord16 +uint16_t RTPSenderVideo::FECPacketOverhead() const { if (_fecEnabled) @@ -244,7 +244,7 @@ RTPSenderVideo::FECPacketOverhead() const 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 @@ WebRtc_Word32 RTPSenderVideo::SetFecParameters( 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 @@ RTPSenderVideo::SendVideo(const RtpVideoCodecTypes videoType, // 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 @@ RTPSenderVideo::CodecInformationVideo() } 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 @@ RTPSenderVideo::SendVP8(const FrameType frameType, 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 @@ void RTPSenderVideo::ProcessBitrate() { _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 9ddd860be2..e1dc942c4d 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 @@ struct RtpPacket; 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 08743b3b2a..c9af76ca69 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_utility.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_utility.cc @@ -54,13 +54,13 @@ enum { * 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 @@ WebRtc_UWord32 GetCurrentRTP(Clock* clock, WebRtc_UWord32 freq) { 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 @@ bool OldTimestamp(uint32_t newTimestamp, * 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(length); + return static_cast(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 @@ bool StringCompare(const char* str1, const char* str2, 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(value >> 24); - dataBuffer[1] = static_cast(value >> 16); - dataBuffer[2] = static_cast(value >> 8); - dataBuffer[3] = static_cast(value); + dataBuffer[0] = static_cast(value >> 24); + dataBuffer[1] = static_cast(value >> 16); + dataBuffer[2] = static_cast(value >> 8); + dataBuffer[3] = static_cast(value); #else - WebRtc_UWord32* ptr = reinterpret_cast(dataBuffer); + uint32_t* ptr = reinterpret_cast(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(value >> 16); - dataBuffer[1] = static_cast(value >> 8); - dataBuffer[2] = static_cast(value); + dataBuffer[0] = static_cast(value >> 16); + dataBuffer[1] = static_cast(value >> 8); + dataBuffer[2] = static_cast(value); #else - dataBuffer[0] = static_cast(value); - dataBuffer[1] = static_cast(value >> 8); - dataBuffer[2] = static_cast(value >> 16); + dataBuffer[0] = static_cast(value); + dataBuffer[1] = static_cast(value >> 8); + dataBuffer[2] = static_cast(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(value >> 8); - dataBuffer[1] = static_cast(value); + dataBuffer[0] = static_cast(value >> 8); + dataBuffer[1] = static_cast(value); #else - WebRtc_UWord16* ptr = reinterpret_cast(dataBuffer); + uint16_t* ptr = reinterpret_cast(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(dataBuffer); + return *reinterpret_cast(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(dataBuffer); + return *reinterpret_cast(dataBuffer); #endif } -WebRtc_UWord32 pow2(WebRtc_UWord8 exp) { +uint32_t pow2(uint8_t exp) { return 1 << exp; } @@ -225,8 +222,8 @@ void RTPPayload::SetType(RtpVideoCodecTypes videoType) { } } -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 @@ bool RTPHeaderParser::RTCP() const { 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 @@ bool RTPHeaderParser::Parse(WebRtcRTPHeader& parsedPacket, } // 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 @@ bool RTPHeaderParser::Parse(WebRtcRTPHeader& parsedPacket, return false; } - const WebRtc_UWord8 CSRCocts = CC * 4; + const uint8_t CSRCocts = CC * 4; if ((ptr + CSRCocts) > _ptrRTPDataEnd) { return false; @@ -362,7 +359,7 @@ bool RTPHeaderParser::Parse(WebRtcRTPHeader& parsedPacket, 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 @@ bool RTPHeaderParser::Parse(WebRtcRTPHeader& parsedPacket, 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 @@ bool RTPHeaderParser::Parse(WebRtcRTPHeader& parsedPacket, 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 @@ bool RTPHeaderParser::Parse(WebRtcRTPHeader& parsedPacket, 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 @@ void RTPHeaderParser::ParseOneByteExtensionHeader( // | 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 @@ void RTPHeaderParser::ParseOneByteExtensionHeader( // | 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 @@ void RTPHeaderParser::ParseOneByteExtensionHeader( // // 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 @@ void RTPHeaderParser::ParseOneByteExtensionHeader( 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 @@ WebRtc_UWord8 RTPHeaderParser::ParsePaddingBytes( // 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::ParseGeneric(RTPPayload& /*parsedPacket*/) const { 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 @@ bool RTPPayloadParser::ParseVP8(RTPPayload& parsedPacket) const { } 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::ParseVP8FrameSize(RTPPayload& parsedPacket, } 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::ParseVP8Extension(RTPPayloadVP8* vp8, } 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::ParseVP8PictureID(RTPPayloadVP8* vp8, } 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::ParseVP8Tl0PicIdx(RTPPayloadVP8* vp8, } 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 255c0802a3..7614ca66b7 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_utility.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_utility.h @@ -26,7 +26,7 @@ enum RtpVideoCodecTypes kRtpVp8Video = 11 }; -const WebRtc_UWord8 kRtpMarkerBitMask = 0x80; +const uint8_t kRtpMarkerBitMask = 0x80; namespace ModuleRTPUtility { @@ -38,14 +38,14 @@ namespace ModuleRTPUtility 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 @@ namespace ModuleRTPUtility PayloadUnion typeSpecific; }; - typedef std::map PayloadTypeMap; + typedef std::map 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 @@ namespace ModuleRTPUtility 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 @@ namespace ModuleRTPUtility 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 @@ namespace ModuleRTPUtility int frameWidth; int frameHeight; - const WebRtc_UWord8* data; - WebRtc_UWord16 dataLength; + const uint8_t* data; + uint16_t dataLength; }; union RTPPayloadUnion @@ -193,9 +193,9 @@ namespace ModuleRTPUtility { 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 @@ namespace ModuleRTPUtility 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 eabc812980..b20eb6a76d 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 @@ void VerifyExtensions(const RTPPayloadVP8 &header, } 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, BasicHeader) { } 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, PictureID) { } 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, Tl0PicIdx) { } 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, TIDAndLayerSync) { } 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, KeyIdx) { } 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, MultipleExtensions) { } 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, TooShortHeader) { } 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 b3e9ab007c..b51efb5d0c 100644 --- a/webrtc/modules/rtp_rtcp/source/ssrc_database.cc +++ b/webrtc/modules/rtp_rtcp/source/ssrc_database.cc @@ -51,12 +51,12 @@ SSRCDatabase::ReturnSSRCDatabase() 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 @@ SSRCDatabase::CreateSSRC() { // 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 @@ SSRCDatabase::CreateSSRC() 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 @@ SSRCDatabase::RegisterSSRC(const WebRtc_UWord32 ssrc) { // 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 @@ SSRCDatabase::RegisterSSRC(const WebRtc_UWord32 ssrc) 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 @@ SSRCDatabase::SSRCDatabase() #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 @@ SSRCDatabase::~SSRCDatabase() 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 370e549e4a..555fe0995e 100644 --- a/webrtc/modules/rtp_rtcp/source/ssrc_database.h +++ b/webrtc/modules/rtp_rtcp/source/ssrc_database.h @@ -27,9 +27,9 @@ public: 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 @@ private: 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 _ssrcMap; + std::map _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 ab85cdcaee..5bd6221425 100644 --- a/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc +++ b/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc @@ -29,7 +29,7 @@ TMMBRSet::~TMMBRSet() } void -TMMBRSet::VerifyAndAllocateSet(WebRtc_UWord32 minimumSize) +TMMBRSet::VerifyAndAllocateSet(uint32_t minimumSize) { if(minimumSize > _sizeOfSet) { @@ -38,7 +38,7 @@ TMMBRSet::VerifyAndAllocateSet(WebRtc_UWord32 minimumSize) _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 @@ TMMBRSet::VerifyAndAllocateSet(WebRtc_UWord32 minimumSize) } void -TMMBRSet::VerifyAndAllocateSetKeepingData(WebRtc_UWord32 minimumSize) +TMMBRSet::VerifyAndAllocateSetKeepingData(uint32_t minimumSize) { if(minimumSize > _sizeOfSet) { @@ -60,9 +60,9 @@ TMMBRSet::VerifyAndAllocateSetKeepingData(WebRtc_UWord32 minimumSize) } 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::SetEntry(unsigned int i, } } -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 @@ TMMBRHelp::~TMMBRHelp() { } TMMBRSet* -TMMBRHelp::VerifyAndAllocateBoundingSet(WebRtc_UWord32 minimumSize) +TMMBRHelp::VerifyAndAllocateBoundingSet(uint32_t minimumSize) { CriticalSectionScoped lock(_criticalSection); @@ -138,9 +138,9 @@ TMMBRSet* TMMBRHelp::BoundingSet() { 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 @@ TMMBRHelp::SetTMMBRBoundingSetToSend(const TMMBRSet* boundingSetToSend, 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 @@ TMMBRHelp::SetTMMBRBoundingSetToSend(const TMMBRSet* boundingSetToSend, return 0; } -WebRtc_Word32 -TMMBRHelp::VerifyAndAllocateBoundingSetToSend(WebRtc_UWord32 minimumSize) +int32_t +TMMBRHelp::VerifyAndAllocateBoundingSetToSend(uint32_t minimumSize) { CriticalSectionScoped lock(_criticalSection); @@ -181,7 +181,7 @@ TMMBRHelp::VerifyAndAllocateBoundingSetToSend(WebRtc_UWord32 minimumSize) } TMMBRSet* -TMMBRHelp::VerifyAndAllocateCandidateSet(WebRtc_UWord32 minimumSize) +TMMBRHelp::VerifyAndAllocateCandidateSet(uint32_t minimumSize) { CriticalSectionScoped lock(_criticalSection); @@ -201,7 +201,7 @@ TMMBRHelp::BoundingSetToSend() return &_boundingSetToSend; } -WebRtc_Word32 +int32_t TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet) { CriticalSectionScoped lock(_criticalSection); @@ -211,7 +211,7 @@ TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet) 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 @@ TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet) } // 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 @@ TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet) } -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 @@ TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidate } } // 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 @@ TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidate } } // 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 @@ TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidate } // 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 @@ TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidate } } - 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 @@ TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidate // 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 @@ TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidate 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 @@ TMMBRHelp::FindTMMBRBoundingSet(WebRtc_Word32 numCandidates, TMMBRSet& candidate 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 @@ bool TMMBRHelp::IsOwner(const WebRtc_UWord32 ssrc, 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 @@ bool TMMBRHelp::CalcMinBitRate( WebRtc_UWord32* minBitrateKbit) const { } *minBitrateKbit = std::numeric_limits::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 45ce1c47a5..055c9ed36c 100644 --- a/webrtc/modules/rtp_rtcp/source/tmmbr_help.h +++ b/webrtc/modules/rtp_rtcp/source/tmmbr_help.h @@ -27,56 +27,56 @@ public: 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 _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 @@ public: 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 1a55e4e65c..e917e93f0f 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.cc @@ -38,7 +38,7 @@ BWEConvergenceTestUp::~BWEConvergenceTestUp() } -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 b830d14bd8..0226787279 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEConvergenceTest.h @@ -25,7 +25,7 @@ public: 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 1fd19fef00..886ad8517e 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.cc @@ -35,7 +35,7 @@ BWEStabilityTest::~BWEStabilityTest() } -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 8f213b1cf2..dc23557554 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStabilityTest.h @@ -25,7 +25,7 @@ public: 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 471ea5fde5..1f01c70050 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc @@ -32,36 +32,36 @@ public: 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(rtpPacketLength)); + _rtpMod->IncomingPacket((uint8_t *) incomingRtpPacket, static_cast(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(rtcpPacketLength)); + _rtpMod->IncomingPacket((uint8_t *) incomingRtcpPacket, static_cast(rtcpPacketLength)); } @@ -69,7 +69,7 @@ int main(int argc, char* argv[]) { 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 @@ int main(int argc, char* argv[]) 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 @@ int main(int argc, char* argv[]) 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 @@ int main(int argc, char* argv[]) // 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 @@ int main(int argc, char* argv[]) - // 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 2940abd90f..8b289a5f15 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.cc @@ -235,7 +235,7 @@ bool BWETest::SetMaster(bool isMaster /*= true*/) } -int BWETest::Init(std::string ip, WebRtc_UWord16 port) +int BWETest::Init(std::string ip, uint16_t port) { if (_initialized) { @@ -403,17 +403,17 @@ void BWETest::Report(std::fstream &log) // 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 @@ void BWETest::OnOnNetworkChanged(const WebRtc_UWord32 bitrateTargetBps, } -int BWEOneWayTest::Init(std::string ip, WebRtc_UWord16 port) +int BWEOneWayTest::Init(std::string ip, uint16_t port) { if (!_master) @@ -442,10 +442,10 @@ bool BWEOneWayTest::Start() 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(TickTime::MillisecondTimestamp()*90), + static_cast(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 bab1b94fd4..06dd803e1f 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETestBase.h @@ -41,7 +41,7 @@ public: 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 @@ public: 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 @@ protected: 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 @@ public: 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 f1d79feec9..7f19410bf5 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETester.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETester.cc @@ -148,7 +148,7 @@ int main(int argc, char* argv[]) { 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 043c7b083d..1c0acc23d8 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.cc @@ -38,7 +38,7 @@ BWETwoWayLimitFinding::~BWETwoWayLimitFinding() } -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 @@ bool BWETwoWayLimitFinding::StoppingCriterionMaster() _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 fc790e564a..4fef0e66eb 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWETwoWayLimitFinding.h @@ -23,7 +23,7 @@ public: 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 9c81fd0d24..939cd8a8b3 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.cc @@ -66,7 +66,7 @@ MatlabLine::~MatlabLine() void MatlabLine::Append(double x, double y) { - if (_maxLen > 0 && _xData.size() > static_cast(_maxLen)) + if (_maxLen > 0 && _xData.size() > static_cast(_maxLen)) { _xData.resize(_maxLen); _yData.resize(_maxLen); @@ -312,7 +312,7 @@ double MatlabLine::yMax() 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 @@ void MatlabTimeLine::PurgeOldData() - _timeHorizon; // remove data points older than this std::list::reverse_iterator ritx = _xData.rbegin(); - WebRtc_UWord32 removeCount = 0; + uint32_t removeCount = 0; while (ritx != _xData.rend()) { if (*ritx >= historyLimit) @@ -366,7 +366,7 @@ void MatlabTimeLine::PurgeOldData() } -WebRtc_Word64 MatlabTimeLine::GetRefTime() +int64_t MatlabTimeLine::GetRefTime() { return(_refTimeMs); } @@ -433,7 +433,7 @@ int MatlabPlot::AddLine(int maxLen /*= -1*/, const char *plotAttrib /*= NULL*/, 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 @@ bool MatlabEngine::PlotThread(void *obj) // 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 08c7006652..fdf382dca3 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/MatlabPlot.h @@ -74,14 +74,14 @@ class MatlabTimeLine : public MatlabLine { 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 @@ public: 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 @@ public: 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 d322242332..cc494022a3 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc @@ -31,7 +31,7 @@ bool SenderThreadFunction(void *obj) } -TestLoadGenerator::TestLoadGenerator(TestSenderReceiver *sender, WebRtc_Word32 rtpSampleRate) +TestLoadGenerator::TestLoadGenerator(TestSenderReceiver *sender, int32_t rtpSampleRate) : _critSect(CriticalSectionWrapper::CreateCriticalSection()), _eventPtr(NULL), @@ -53,7 +53,7 @@ TestLoadGenerator::~TestLoadGenerator () 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::SetBitrate (WebRtc_Word32 newBitrateKbps) } -WebRtc_Word32 TestLoadGenerator::Start (const char *threadName) +int32_t TestLoadGenerator::Start (const char *threadName) { CriticalSectionScoped cs(_critSect); @@ -92,7 +92,7 @@ WebRtc_Word32 TestLoadGenerator::Start (const char *threadName) } -WebRtc_Word32 TestLoadGenerator::Stop () +int32_t TestLoadGenerator::Stop () { _critSect.Enter(); @@ -123,13 +123,13 @@ WebRtc_Word32 TestLoadGenerator::Stop () int TestLoadGenerator::generatePayload () { - return(generatePayload( static_cast( TickTime::MillisecondTimestamp() * _rtpSampleRate / 1000 ))); + return(generatePayload( static_cast( 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 @@ int TestLoadGenerator::sendPayload (const WebRtc_UWord32 timeStamp, } -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 @@ CBRGenerator::~CBRGenerator () 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(nextSendTime * _rtpSampleRate / 1000) ); + generatePayload( static_cast(nextSendTime * _rtpSampleRate / 1000) ); // calculate wait time periodMs = 8.0 * _payloadSizeBytes / ( _bitrateKbps ); - nextSendTime = static_cast(nextSendTime + periodMs); + nextSendTime = static_cast(nextSendTime + periodMs); - WebRtc_Word32 waitTime = static_cast(nextSendTime - TickTime::MillisecondTimestamp()); + int32_t waitTime = static_cast(nextSendTime - TickTime::MillisecondTimestamp()); if (waitTime < 0) { waitTime = 0; } // wait - _eventPtr->Wait(static_cast(waitTime)); + _eventPtr->Wait(static_cast(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 @@ int CBRGenerator::generatePayload ( WebRtc_UWord32 timestamp ) ///////////////////// -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 @@ CBRFixFRGenerator::~CBRFixFRGenerator () bool CBRFixFRGenerator::GeneratorLoop () { double periodMs; - WebRtc_Word64 nextSendTime = TickTime::MillisecondTimestamp(); + int64_t nextSendTime = TickTime::MillisecondTimestamp(); _critSect.Enter(); @@ -271,22 +271,22 @@ bool CBRFixFRGenerator::GeneratorLoop () _payload = NULL; } - _payloadAllocLen = static_cast((_payloadSizeBytes * (1 + _spreadFactor) * 3) / 2 + .5); // 50% extra to avoid frequent re-alloc - _payload = new WebRtc_UWord8[_payloadAllocLen]; + _payloadAllocLen = static_cast((_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(nextSendTime * _rtpSampleRate / 1000) ); + generatePayload( static_cast(nextSendTime * _rtpSampleRate / 1000) ); } _critSect.Leave(); // calculate wait time periodMs = 1000.0 / _frameRateFps; - nextSendTime = static_cast(nextSendTime + periodMs + 0.5); + nextSendTime = static_cast(nextSendTime + periodMs + 0.5); - WebRtc_Word32 waitTime = static_cast(nextSendTime - TickTime::MillisecondTimestamp()); + int32_t waitTime = static_cast(nextSendTime - TickTime::MillisecondTimestamp()); if (waitTime < 0) { waitTime = 0; @@ -298,20 +298,20 @@ bool CBRFixFRGenerator::GeneratorLoop () return true; } -WebRtc_Word32 CBRFixFRGenerator::nextPayloadSize() +int32_t CBRFixFRGenerator::nextPayloadSize() { const double periodMs = 1000.0 / _frameRateFps; - return static_cast(_bitrateKbps * periodMs / 8 + 0.5); + return static_cast(_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(_payloadSizeBytes * factor); + int32_t thisPayloadBytes = static_cast(_payloadSizeBytes * factor); // sanity if (thisPayloadBytes > _payloadAllocLen) { @@ -325,9 +325,9 @@ int CBRFixFRGenerator::generatePayload ( WebRtc_UWord32 timestamp ) ///////////////////// -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 @@ CBRFixFRGenerator(sender, bitrateKbps, rtpSampleRate, frameRateFps, spread) { } -WebRtc_Word32 PeriodicKeyFixFRGenerator::nextPayloadSize() +int32_t PeriodicKeyFixFRGenerator::nextPayloadSize() { // calculate payload size for a delta frame - WebRtc_Word32 payloadSizeBytes = static_cast(1000 * _bitrateKbps / (8.0 * _frameRateFps * (1.0 + (_keyFactor - 1.0) / _keyPeriod)) + 0.5); + int32_t payloadSizeBytes = static_cast(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(_keyFactor * _payloadSizeBytes + 0.5); + payloadSizeBytes = static_cast(_keyFactor * _payloadSizeBytes + 0.5); } _frameCount++; @@ -353,8 +353,8 @@ WebRtc_Word32 PeriodicKeyFixFRGenerator::nextPayloadSize() //////////////////// -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 @@ _numFrameRates(numFrameRates), _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 @@ CBRVarFRGenerator::~CBRVarFRGenerator() 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(static_cast(rand()) / RAND_MAX + uint16_t frIndex = static_cast(static_cast(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(1000.0 * factor * - _avgFrPeriodMs + 0.5); + _frChangeTimeMs = nowMs + static_cast(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 @@ WebRtc_Word32 CBRVarFRGenerator::nextPayloadSize() //////////////////// -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 @@ CBRFrameDropGenerator::~CBRFrameDropGenerator() { } -WebRtc_Word32 CBRFrameDropGenerator::nextPayloadSize() +int32_t CBRFrameDropGenerator::nextPayloadSize() { _accBits -= 1000 * _bitrateKbps / _frameRateFps; if (_accBits < 0) @@ -430,8 +430,8 @@ WebRtc_Word32 CBRFrameDropGenerator::nextPayloadSize() { //printf("keep\n"); const double periodMs = 1000.0 / _frameRateFps; - WebRtc_Word32 frameSize = static_cast(_bitrateKbps * periodMs / 8 + 0.5); - frameSize = std::max(frameSize, static_cast(300 * periodMs / 8 + 0.5)); + int32_t frameSize = static_cast(_bitrateKbps * periodMs / 8 + 0.5); + frameSize = std::max(frameSize, static_cast(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 c22591cfc6..232796a608 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h @@ -26,85 +26,85 @@ class ThreadWrapper; 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 @@ protected: 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 1fc0fd37ad..85666c5cad 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc @@ -71,7 +71,7 @@ _lastTime(-1) } // SocketTransport module - WebRtc_UWord8 numberOfThreads = 1; + uint8_t numberOfThreads = 1; _transport = UdpTransport::Create(0, numberOfThreads); if (!_transport) { @@ -104,9 +104,9 @@ TestSenderReceiver::~TestSenderReceiver (void) } -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::InitReceiver (const WebRtc_UWord16 rtpPort, } -WebRtc_Word32 TestSenderReceiver::Start() +int32_t TestSenderReceiver::Start() { CriticalSectionScoped cs(_critSect); @@ -191,7 +191,7 @@ WebRtc_Word32 TestSenderReceiver::Start() } -WebRtc_Word32 TestSenderReceiver::Stop () +int32_t TestSenderReceiver::Stop () { CriticalSectionScoped cs(_critSect); @@ -232,12 +232,12 @@ bool TestSenderReceiver::ProcLoop(void) 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 @@ bool TestSenderReceiver::ProcLoop(void) } -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( + kbps = static_cast( (8 * (bytesReceived - _lastBytesReceived)) / (now - _lastTime)); } _lastTime = now; @@ -283,13 +283,13 @@ WebRtc_Word32 TestSenderReceiver::ReceiveBitrateKbps () } -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::OnPacketTimeout(const WebRtc_Word32 id) } -void TestSenderReceiver::OnReceivedPacket(const WebRtc_Word32 id, +void TestSenderReceiver::OnReceivedPacket(const int32_t id, const RtpRtcpPacketType packetType) { // do nothing @@ -305,31 +305,31 @@ void TestSenderReceiver::OnReceivedPacket(const WebRtc_Word32 id, } -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(rtpPacketLength)); + _rtp->IncomingPacket((uint8_t *) incomingRtpPacket, static_cast(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(rtcpPacketLength)); + _rtp->IncomingPacket((uint8_t *) incomingRtcpPacket, static_cast(rtcpPacketLength)); } @@ -339,11 +339,11 @@ void TestSenderReceiver::IncomingRTCPPacket(const WebRtc_Word8* incomingRtcpPack /////////////////// -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::InitSender (const WebRtc_UWord32 startBitrateK -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 @@ WebRtc_Word32 TestSenderReceiver::SetLoadGenerator(TestLoadGenerator *generator) } -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 7f7f2f0011..e9c65ae4b1 100644 --- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h +++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h @@ -31,11 +31,11 @@ using namespace webrtc; 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 @@ public: 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 @@ private: 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 38b6e1508b..e947142b5f 100644 --- a/webrtc/modules/rtp_rtcp/test/bitstreamTest/bitstreamTest.cc +++ b/webrtc/modules/rtp_rtcp/test/bitstreamTest/bitstreamTest.cc @@ -17,12 +17,12 @@ #include #include -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 @@ WebRtc_UWord16 BitRateBPSInv(WebRtc_UWord32 x ) 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 @@ WebRtc_UWord16 BitRateBPSInv(WebRtc_UWord32 x ) 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 @@ int _tmain(int argc, _TCHAR* argv[]) 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 @@ int _tmain(int argc, _TCHAR* argv[]) 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 @@ int _tmain(int argc, _TCHAR* argv[]) // 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 @@ int _tmain(int argc, _TCHAR* argv[]) 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 @@ int _tmain(int argc, _TCHAR* argv[]) 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 @@ int _tmain(int argc, _TCHAR* argv[]) } 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 @@ int _tmain(int argc, _TCHAR* argv[]) } 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 @@ int _tmain(int argc, _TCHAR* argv[]) 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 @@ int _tmain(int argc, _TCHAR* argv[]) } 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 @@ int _tmain(int argc, _TCHAR* argv[]) } 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 fb1b337ec0..4a00935d63 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 @@ class RtpRtcpAPITest : public ::testing::Test { 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, SSRC) { 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 d3698d4c90..040ed06337 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 @@ class LoopBackTransport : public webrtc::Transport { 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 @@ class RtpReceiver : public RtpData { 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 @@ class RtpReceiver : public RtpData { 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 @@ class RtpReceiver : public RtpData { } 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 f59b192fe3..0d1ed9d797 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 @@ using namespace webrtc; 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 VerifyingAudioReceiver : public RtpData { 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 @@ class AudioFeedback : public RtpAudioFeedback { 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 @@ class RtpRtcpAudioTest : public ::testing::Test { 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 @@ TEST_F(RtpRtcpAudioTest, Basic) { 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 @@ TEST_F(RtpRtcpAudioTest, RED) { 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 @@ TEST_F(RtpRtcpAudioTest, RED) { 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 @@ TEST_F(RtpRtcpAudioTest, DTMF) { 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 @@ TEST_F(RtpRtcpAudioTest, DTMF) { } 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 1a859c2a4d..92663fac41 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 @@ using 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 VerifyingNackReceiver : public RtpData @@ -34,9 +34,9 @@ class VerifyingNackReceiver : public RtpData 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 @@ class NackLoopBackTransport : public webrtc::Transport { 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 @@ class RtpRtcpNackTest : public ::testing::Test { 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 @@ class RtpRtcpNackTest : public ::testing::Test { 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 @@ TEST_F(RtpRtcpNackTest, LongNackList) { 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 d15dcc85d2..681f74e590 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 @@ class RtcpCallback : public RtcpFeedback, public RtcpIntraFrameObserver { 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(name >> 24); print_name[1] = static_cast(name >> 16); @@ -50,16 +50,16 @@ class RtcpCallback : public RtcpFeedback, public RtcpIntraFrameObserver { 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 @@ class RtpRtcpRtcpTest : public ::testing::Test { // 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 @@ class RtpRtcpRtcpTest : public ::testing::Test { 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_PLI_RPSI) { } 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 @@ TEST_F(RtpRtcpRtcpTest, RTCP) { 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 @@ TEST_F(RtpRtcpRtcpTest, RTCP) { 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 @@ TEST_F(RtpRtcpRtcpTest, RTCP) { EXPECT_EQ(test_sequence_number, reportBlockReceived.extendedHighSeqNum); EXPECT_EQ(0, reportBlockReceived.fractionLost); - EXPECT_EQ(static_cast(0), + EXPECT_EQ(static_cast(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 cf181a66e1..ea22738775 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 @@ class RtpRtcpVideoTest : public ::testing::Test { } } - WebRtc_Word32 BuildRTPheader(WebRtc_UWord8* dataBuffer, - WebRtc_UWord32 timestamp, - WebRtc_UWord32 sequence_number) { - dataBuffer[0] = static_cast(0x80); // version 2 - dataBuffer[1] = static_cast(kPayloadType); + int32_t BuildRTPheader(uint8_t* dataBuffer, + uint32_t timestamp, + uint32_t sequence_number) { + dataBuffer[0] = static_cast(0x80); // version 2 + dataBuffer[1] = static_cast(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 @@ class RtpRtcpVideoTest : public ::testing::Test { int header_length = BuildRTPheader(buffer, timestamp, sequence_number); buffer[0] |= 0x20; // Set padding bit. - WebRtc_Word32* data = - reinterpret_cast(&(buffer[header_length])); + int32_t* data = + reinterpret_cast(&(buffer[header_length])); // Fill data buffer with random data. for (int j = 0; j < (padding_bytes_in_packet >> 2); j++) { @@ -120,17 +120,17 @@ class RtpRtcpVideoTest : public ::testing::Test { 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 1918ff8004..3110a0db39 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 @@ using namespace webrtc; 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 @@ int main() { return -1; } - WebRtc_UWord32 id = 0; + uint32_t id = 0; ForwardErrorCorrection fec(id); ForwardErrorCorrection::PacketList mediaPacketList; @@ -66,18 +66,18 @@ int main() { ForwardErrorCorrection::ReceivedPacketList toDecodeList; ForwardErrorCorrection::ReceivedPacketList receivedPacketList; ForwardErrorCorrection::RecoveredPacketList recoveredPacketList; - std::list fecMaskList; + std::list 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 @@ int main() { fclose(randomSeedFile); randomSeedFile = NULL; - WebRtc_UWord16 seqNum = static_cast(rand()); - WebRtc_UWord32 timeStamp = static_cast(rand()); - const WebRtc_UWord32 ssrc = static_cast(rand()); + uint16_t seqNum = static_cast(rand()); + uint32_t timeStamp = static_cast(rand()); + const uint32_t ssrc = static_cast(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 + uint8_t protectionFactor = static_cast (numFecPackets * 255 / numMediaPackets); - const WebRtc_UWord32 maskBytesPerFecPacket = + const uint32_t maskBytesPerFecPacket = (numMediaPackets > 16) ? kNumMaskBytesL1 : kNumMaskBytesL0; memset(packetMask, 0, numMediaPackets * maskBytesPerFecPacket); @@ -151,11 +151,11 @@ int main() { 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 @@ int main() { 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 @@ int main() { 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 @@ int main() { } // 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((static_cast(rand()) / + static_cast((static_cast(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(rand() % 256); - mediaPacket->data[1] = static_cast(rand() % 256); + mediaPacket->data[0] = static_cast(rand() % 256); + mediaPacket->data[1] = static_cast(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 @@ int main() { 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 (rand() % 256); + static_cast (rand() % 256); } seqNum++; } @@ -249,14 +249,14 @@ int main() { printf("Error: we requested %u FEC packets, " "but GenerateFEC() produced %u\n", numFecPackets, - static_cast(fecPacketList.size())); + static_cast(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 @@ int main() { 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 @@ int main() { #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::iterator fecMaskIt = fecMaskList.begin(); - WebRtc_UWord8* fecMask; + std::list::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::iterator itemToDelete = fecMaskIt; + std::list::iterator itemToDelete = fecMaskIt; ++fecMaskIt; if (hammingDist == 1) { @@ -353,7 +353,7 @@ int main() { } #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 @@ int main() { // For error-checking frame completion. bool fecPacketReceived = false; while (!receivedPacketList.empty()) { - WebRtc_UWord32 numPacketsToDecode = static_cast + uint32_t numPacketsToDecode = static_cast ((static_cast(rand()) / RAND_MAX) * receivedPacketList.size() + 0.5); if (numPacketsToDecode < 1) { @@ -428,7 +428,7 @@ int main() { if (!recoveredPacketList.empty()) { printf("Error: excessive number of recovered packets.\n"); printf("\t size is:%u\n", - static_cast(recoveredPacketList.size())); + static_cast(recoveredPacketList.size())); return -1; } // -- Teardown -- @@ -482,12 +482,12 @@ int main() { 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(rand()) / RAND_MAX; diff --git a/webrtc/modules/rtp_rtcp/test/testRateControl/testRateControl.cc b/webrtc/modules/rtp_rtcp/test/testRateControl/testRateControl.cc index c2825577c0..2fdaedfd44 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 @@ const InputSet set00 = { 0, 40, 66666}; -WebRtc_Word32 GetFile(char* fileName) +int32_t GetFile(char* fileName) { if (!fileName[0]) { @@ -58,7 +58,7 @@ WebRtc_Word32 GetFile(char* fileName) 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 @@ public: } 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 @@ public: } // 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 @@ public: } 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 @@ public: } // 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 @@ public: //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 @@ public: 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 @@ public: 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 @@ public: 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 d1e1572aa7..c77015a4a7 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 @@ void Verify(TMMBRSet* boundingSet, int index, InputSet set) 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 @@ int ParseRTCPPacket(const void *data, int len, TMMBRSet*& boundingSet) return numItems; }; -WebRtc_Word32 GetFile(char* fileName) +int32_t GetFile(char* fileName) { if (!fileName[0]) { @@ -89,7 +89,7 @@ WebRtc_Word32 GetFile(char* fileName) 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 @@ public: } 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 @@ public: } // 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 @@ public: } 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 @@ public: } // 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 @@ public: } RtpRtcp* _rtpRtcpModule; - WebRtc_UWord32 _cnt; + uint32_t _cnt; }; class TestTMMBR : private TMMBRHelp @@ -363,14 +363,14 @@ public: 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 @@ public: 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 @@ int _tmain(int argc, _TCHAR* argv[]) // 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));