From 43da54a458a7a992c702d85f0327e1d394ec5cf3 Mon Sep 17 00:00:00 2001 From: "phoglund@webrtc.org" Date: Fri, 25 Jan 2013 10:53:38 +0000 Subject: [PATCH] Reformatted rtp_sender: made lint clean. TESTED=rtp_rtcp_unittests BUG= Review URL: https://webrtc-codereview.appspot.com/1062004 git-svn-id: http://webrtc.googlecode.com/svn/trunk@3412 4adac7df-926f-26a2-2b94-8c16560cd09d --- .../modules/rtp_rtcp/source/rtp_rtcp_impl.cc | 18 +- .../modules/rtp_rtcp/source/rtp_rtcp_impl.h | 4 +- webrtc/modules/rtp_rtcp/source/rtp_sender.cc | 1099 ++++++++--------- webrtc/modules/rtp_rtcp/source/rtp_sender.h | 283 ++--- 4 files changed, 652 insertions(+), 752 deletions(-) diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc index f5817f8de..2cc17a3cc 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc @@ -123,11 +123,10 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration) simulcast_(false), key_frame_req_method_(kKeyFrameReqFirRtp), remote_bitrate_(configuration.remote_bitrate_estimator), - rtt_observer_(configuration.rtt_observer) #ifdef MATLAB - , plot1_(NULL) + , plot1_(NULL), #endif -{ + rtt_observer_(configuration.rtt_observer) { RTPReceiverStrategy* rtp_receiver_strategy; if (configuration.audio) { // If audio, we need to be able to handle telephone events too, so stash @@ -1645,7 +1644,7 @@ bool ModuleRtpRtcpImpl::SendTelephoneEventActive( id_, "SendTelephoneEventActive()"); - return rtp_sender_.SendTelephoneEventActive(telephone_event); + return rtp_sender_.SendTelephoneEventActive(&telephone_event); } // Set audio packet size, used to determine when it's time to send a DTMF @@ -1689,7 +1688,7 @@ WebRtc_Word32 ModuleRtpRtcpImpl::GetRTPAudioLevelIndicationStatus( kTraceRtpRtcp, id_, "GetRTPAudioLevelIndicationStatus()"); - return rtp_sender_.AudioLevelIndicationStatus(enable, id); + return rtp_sender_.AudioLevelIndicationStatus(&enable, &id); } WebRtc_Word32 ModuleRtpRtcpImpl::SetAudioLevel( @@ -1719,7 +1718,7 @@ WebRtc_Word32 ModuleRtpRtcpImpl::SendREDPayloadType( WebRtc_Word8& payload_type) const { WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SendREDPayloadType()"); - return rtp_sender_.RED(payload_type); + return rtp_sender_.RED(&payload_type); } RtpVideoCodecTypes ModuleRtpRtcpImpl::ReceivedVideoCodec() const { @@ -1882,9 +1881,9 @@ WebRtc_Word32 ModuleRtpRtcpImpl::GenericFECStatus( it++; } } - WebRtc_Word32 ret_val = rtp_sender_.GenericFECStatus(enable, - payload_type_red, - payload_type_fec); + WebRtc_Word32 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; @@ -2083,5 +2082,4 @@ int64_t ModuleRtpRtcpImpl::RtcpReportInterval() { else return RTCP_INTERVAL_VIDEO_MS; } - } // Namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h index 5adb85254..5883a1152 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h @@ -515,11 +515,11 @@ class ModuleRtpRtcpImpl : public RtpRtcp { RemoteBitrateEstimator* remote_bitrate_; - RtcpRttObserver* rtt_observer_; - #ifdef MATLAB MatlabPlot* plot1_; #endif + + RtcpRttObserver* rtt_observer_; }; } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc index bb778f7e7..ae67e323d 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc @@ -10,7 +10,7 @@ #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" -#include // srand +#include // srand #include "webrtc/modules/pacing/include/paced_sender.h" #include "webrtc/modules/rtp_rtcp/source/rtp_packet_history.h" @@ -20,380 +20,329 @@ #include "webrtc/system_wrappers/interface/trace.h" namespace webrtc { -RTPSender::RTPSender(const WebRtc_Word32 id, - const bool audio, - Clock* clock, - Transport* transport, - RtpAudioFeedback* audio_feedback, - PacedSender* paced_sender) - : Bitrate(clock), - _id(id), - _audioConfigured(audio), - _audio(NULL), - _video(NULL), - paced_sender_(paced_sender), - _sendCritsect(CriticalSectionWrapper::CreateCriticalSection()), - _transport(transport), - _sendingMedia(true), // Default to sending media - _maxPayloadLength(IP_PACKET_SIZE-28), // default is IP-v4/UDP - _targetSendBitrate(0), - _packetOverHead(28), - - _payloadType(-1), - _payloadTypeMap(), - - _rtpHeaderExtensionMap(), - _transmissionTimeOffset(0), - - // NACK - _nackByteCountTimes(), - _nackByteCount(), - _nackBitrate(clock), - _packetHistory(new RTPPacketHistory(clock)), - - // statistics - _packetsSent(0), - _payloadBytesSent(0), - - _startTimeStampForced(false), - _startTimeStamp(0), - _ssrcDB(*SSRCDatabase::GetSSRCDatabase()), - _remoteSSRC(0), - _sequenceNumberForced(false), - _sequenceNumber(0), - _sequenceNumberRTX(0), - _ssrcForced(false), - _ssrc(0), - _timeStamp(0), - _CSRCs(0), - _CSRC(), - _includeCSRCs(true), - _RTX(false), - _ssrcRTX(0) { - memset(_nackByteCountTimes, 0, sizeof(_nackByteCountTimes)); - memset(_nackByteCount, 0, sizeof(_nackByteCount)); - memset(_CSRC, 0, sizeof(_CSRC)); +RTPSender::RTPSender(const WebRtc_Word32 id, const bool audio, Clock *clock, + Transport *transport, RtpAudioFeedback *audio_feedback, + PacedSender *paced_sender) + : Bitrate(clock), id_(id), audio_configured_(audio), audio_(NULL), + video_(NULL), paced_sender_(paced_sender), + send_critsect_(CriticalSectionWrapper::CreateCriticalSection()), + transport_(transport), sending_media_(true), // Default to sending media. + max_payload_length_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP. + target_send_bitrate_(0), packet_over_head_(28), payload_type_(-1), + payload_type_map_(), rtp_header_extension_map_(), + transmission_time_offset_(0), + // NACK. + nack_byte_count_times_(), nack_byte_count_(), nack_bitrate_(clock), + packet_history_(new RTPPacketHistory(clock)), + // Statistics + packets_sent_(0), payload_bytes_sent_(0), start_time_stamp_forced_(false), + start_time_stamp_(0), ssrc_db_(*SSRCDatabase::GetSSRCDatabase()), + remote_ssrc_(0), sequence_number_forced_(false), sequence_number_(0), + sequence_number_rtx_(0), ssrc_forced_(false), ssrc_(0), time_stamp_(0), + csrcs_(0), csrc_(), include_csrcs_(true), rtx_(false), ssrc_rtx_(0) { + memset(nack_byte_count_times_, 0, sizeof(nack_byte_count_times_)); + 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())); - _ssrc = _ssrcDB.CreateSSRC(); // Can't be 0. + ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. if (audio) { - _audio = new RTPSenderAudio(id, clock_, this); - _audio->RegisterAudioCallback(audio_feedback); + audio_ = new RTPSenderAudio(id, clock_, this); + audio_->RegisterAudioCallback(audio_feedback); } else { - _video = new RTPSenderVideo(id, clock_, this); + video_ = new RTPSenderVideo(id, clock_, this); } WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id, "%s created", __FUNCTION__); } RTPSender::~RTPSender() { - if (_remoteSSRC != 0) { - _ssrcDB.ReturnSSRC(_remoteSSRC); + if (remote_ssrc_ != 0) { + ssrc_db_.ReturnSSRC(remote_ssrc_); } - _ssrcDB.ReturnSSRC(_ssrc); + ssrc_db_.ReturnSSRC(ssrc_); SSRCDatabase::ReturnSSRCDatabase(); - delete _sendCritsect; - while (!_payloadTypeMap.empty()) { - std::map::iterator it = - _payloadTypeMap.begin(); + delete send_critsect_; + while (!payload_type_map_.empty()) { + std::map::iterator it = + payload_type_map_.begin(); delete it->second; - _payloadTypeMap.erase(it); + payload_type_map_.erase(it); } - delete _packetHistory; - delete _audio; - delete _video; + delete packet_history_; + delete audio_; + delete video_; - WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, "%s deleted", __FUNCTION__); + WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id_, "%s deleted", __FUNCTION__); } void RTPSender::SetTargetSendBitrate(const WebRtc_UWord32 bits) { - _targetSendBitrate = static_cast(bits / 1000); + target_send_bitrate_ = static_cast(bits / 1000); } WebRtc_UWord16 RTPSender::ActualSendBitrateKbit() const { - return (WebRtc_UWord16) (Bitrate::BitrateNow() / 1000); + return (WebRtc_UWord16)(Bitrate::BitrateNow() / 1000); } WebRtc_UWord32 RTPSender::VideoBitrateSent() const { - if (_video) { - return _video->VideoBitrateSent(); + if (video_) { + return video_->VideoBitrateSent(); } return 0; } WebRtc_UWord32 RTPSender::FecOverheadRate() const { - if (_video) { - return _video->FecOverheadRate(); + if (video_) { + return video_->FecOverheadRate(); } return 0; } WebRtc_UWord32 RTPSender::NackOverheadRate() const { - return _nackBitrate.BitrateLast(); + return nack_bitrate_.BitrateLast(); } WebRtc_Word32 RTPSender::SetTransmissionTimeOffset( - const WebRtc_Word32 transmissionTimeOffset) { - if (transmissionTimeOffset > (0x800000 - 1) || - transmissionTimeOffset < -(0x800000 - 1)) { // Word24 + const WebRtc_Word32 transmission_time_offset) { + if (transmission_time_offset > (0x800000 - 1) || + transmission_time_offset < -(0x800000 - 1)) { // Word24. return -1; } - CriticalSectionScoped cs(_sendCritsect); - _transmissionTimeOffset = transmissionTimeOffset; + CriticalSectionScoped cs(send_critsect_); + transmission_time_offset_ = transmission_time_offset; return 0; } WebRtc_Word32 RTPSender::RegisterRtpHeaderExtension(const RTPExtensionType type, const WebRtc_UWord8 id) { - CriticalSectionScoped cs(_sendCritsect); - return _rtpHeaderExtensionMap.Register(type, id); + CriticalSectionScoped cs(send_critsect_); + return rtp_header_extension_map_.Register(type, id); } WebRtc_Word32 RTPSender::DeregisterRtpHeaderExtension( const RTPExtensionType type) { - CriticalSectionScoped cs(_sendCritsect); - return _rtpHeaderExtensionMap.Deregister(type); + CriticalSectionScoped cs(send_critsect_); + return rtp_header_extension_map_.Deregister(type); } WebRtc_UWord16 RTPSender::RtpHeaderExtensionTotalLength() const { - CriticalSectionScoped cs(_sendCritsect); - return _rtpHeaderExtensionMap.GetTotalLengthInBytes(); + CriticalSectionScoped cs(send_critsect_); + return rtp_header_extension_map_.GetTotalLengthInBytes(); } WebRtc_Word32 RTPSender::RegisterPayload( - const char payloadName[RTP_PAYLOAD_NAME_SIZE], - const WebRtc_Word8 payloadNumber, - const WebRtc_UWord32 frequency, - const WebRtc_UWord8 channels, - const WebRtc_UWord32 rate) { - assert(payloadName); - CriticalSectionScoped cs(_sendCritsect); + 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) { + assert(payload_name); + CriticalSectionScoped cs(send_critsect_); - std::map::iterator it = - _payloadTypeMap.find(payloadNumber); + std::map::iterator it = + payload_type_map_.find(payload_number); - if (_payloadTypeMap.end() != it) { - // we already use this payload type - ModuleRTPUtility::Payload* payload = it->second; + if (payload_type_map_.end() != it) { + // We already use this payload type. + ModuleRTPUtility::Payload *payload = it->second; assert(payload); - // check if it's the same as we already have - if (ModuleRTPUtility::StringCompare(payload->name, payloadName, + // Check if it's the same as we already have. + if (ModuleRTPUtility::StringCompare(payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1)) { - if (_audioConfigured && payload->audio && + if (audio_configured_ && payload->audio && payload->typeSpecific.Audio.frequency == frequency && (payload->typeSpecific.Audio.rate == rate || - payload->typeSpecific.Audio.rate == 0 || rate == 0)) { + payload->typeSpecific.Audio.rate == 0 || rate == 0)) { payload->typeSpecific.Audio.rate = rate; - // Ensure that we update the rate if new or old is zero + // Ensure that we update the rate if new or old is zero. return 0; } - if (!_audioConfigured && !payload->audio) { + if (!audio_configured_ && !payload->audio) { return 0; } } return -1; } - WebRtc_Word32 retVal = -1; - ModuleRTPUtility::Payload* payload = NULL; - if (_audioConfigured) { - retVal = _audio->RegisterAudioPayload(payloadName, payloadNumber, frequency, - channels, rate, payload); + WebRtc_Word32 ret_val = -1; + ModuleRTPUtility::Payload *payload = NULL; + if (audio_configured_) { + ret_val = audio_->RegisterAudioPayload(payload_name, payload_number, + frequency, channels, rate, payload); } else { - retVal = _video->RegisterVideoPayload(payloadName, payloadNumber, rate, - payload); + ret_val = video_->RegisterVideoPayload(payload_name, payload_number, rate, + payload); } if (payload) { - _payloadTypeMap[payloadNumber] = payload; + payload_type_map_[payload_number] = payload; } - return retVal; + return ret_val; } -WebRtc_Word32 RTPSender::DeRegisterSendPayload(const WebRtc_Word8 payloadType) { - CriticalSectionScoped lock(_sendCritsect); +WebRtc_Word32 RTPSender::DeRegisterSendPayload( + const WebRtc_Word8 payload_type) { + CriticalSectionScoped lock(send_critsect_); - std::map::iterator it = - _payloadTypeMap.find(payloadType); + std::map::iterator it = + payload_type_map_.find(payload_type); - if (_payloadTypeMap.end() == it) { + if (payload_type_map_.end() == it) { return -1; } - ModuleRTPUtility::Payload* payload = it->second; + ModuleRTPUtility::Payload *payload = it->second; delete payload; - _payloadTypeMap.erase(it); + payload_type_map_.erase(it); return 0; } -WebRtc_Word8 RTPSender::SendPayloadType() const { - return _payloadType; -} +WebRtc_Word8 RTPSender::SendPayloadType() const { return payload_type_; } -int RTPSender::SendPayloadFrequency() const { - return _audio->AudioFrequency(); -} +int RTPSender::SendPayloadFrequency() const { return audio_->AudioFrequency(); } WebRtc_Word32 RTPSender::SetMaxPayloadLength( - const WebRtc_UWord16 maxPayloadLength, - const WebRtc_UWord16 packetOverHead) { - // sanity check - if (maxPayloadLength < 100 || maxPayloadLength > IP_PACKET_SIZE) { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, - "%s invalid argument", __FUNCTION__); + const WebRtc_UWord16 max_payload_length, + const WebRtc_UWord16 packet_over_head) { + // Sanity check. + if (max_payload_length < 100 || max_payload_length > IP_PACKET_SIZE) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_, "%s invalid argument", + __FUNCTION__); return -1; } - CriticalSectionScoped cs(_sendCritsect); - _maxPayloadLength = maxPayloadLength; - _packetOverHead = packetOverHead; + CriticalSectionScoped cs(send_critsect_); + max_payload_length_ = max_payload_length; + packet_over_head_ = packet_over_head; - WEBRTC_TRACE(kTraceInfo, kTraceRtpRtcp, _id, - "SetMaxPayloadLength to %d.", maxPayloadLength); + WEBRTC_TRACE(kTraceInfo, kTraceRtpRtcp, id_, "SetMaxPayloadLength to %d.", + max_payload_length); return 0; } WebRtc_UWord16 RTPSender::MaxDataPayloadLength() const { - if (_audioConfigured) { - return _maxPayloadLength - RTPHeaderLength(); + if (audio_configured_) { + return max_payload_length_ - RTPHeaderLength(); } else { - return _maxPayloadLength - RTPHeaderLength() - - _video->FECPacketOverhead() - ((_RTX) ? 2 : 0); - // Include the FEC/ULP/RED overhead. + return max_payload_length_ - RTPHeaderLength() - + video_->FECPacketOverhead() - ((rtx_) ? 2 : 0); + // Include the FEC/ULP/RED overhead. } } WebRtc_UWord16 RTPSender::MaxPayloadLength() const { - return _maxPayloadLength; + return max_payload_length_; } -WebRtc_UWord16 RTPSender::PacketOverHead() const { - return _packetOverHead; -} +WebRtc_UWord16 RTPSender::PacketOverHead() const { return packet_over_head_; } -void RTPSender::SetRTXStatus(const bool enable, - const bool setSSRC, - const WebRtc_UWord32 SSRC) { - CriticalSectionScoped cs(_sendCritsect); - _RTX = enable; +void RTPSender::SetRTXStatus(const bool enable, const bool set_ssrc, + const WebRtc_UWord32 ssrc) { + CriticalSectionScoped cs(send_critsect_); + rtx_ = enable; if (enable) { - if (setSSRC) { - _ssrcRTX = SSRC; + if (set_ssrc) { + ssrc_rtx_ = ssrc; } else { - _ssrcRTX = _ssrcDB.CreateSSRC(); // can't be 0 + ssrc_rtx_ = ssrc_db_.CreateSSRC(); // Can't be 0. } } } -void RTPSender::RTXStatus(bool* enable, WebRtc_UWord32* SSRC) const { - CriticalSectionScoped cs(_sendCritsect); - *enable = _RTX; - *SSRC = _ssrcRTX; +void RTPSender::RTXStatus(bool *enable, WebRtc_UWord32 *SSRC) const { + CriticalSectionScoped cs(send_critsect_); + *enable = rtx_; + *SSRC = ssrc_rtx_; } -WebRtc_Word32 RTPSender::CheckPayloadType(const WebRtc_Word8 payloadType, - RtpVideoCodecTypes& videoType) { - CriticalSectionScoped cs(_sendCritsect); +WebRtc_Word32 RTPSender::CheckPayloadType(const WebRtc_Word8 payload_type, + RtpVideoCodecTypes *video_type) { + CriticalSectionScoped cs(send_critsect_); - if (payloadType < 0) { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, - "\tinvalid payloadType (%d)", payloadType); + if (payload_type < 0) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_, "\tinvalid payload_type (%d)", + payload_type); return -1; } - if (_audioConfigured) { - WebRtc_Word8 redPlType = -1; - if (_audio->RED(redPlType) == 0) { + if (audio_configured_) { + WebRtc_Word8 red_pl_type = -1; + if (audio_->RED(red_pl_type) == 0) { // We have configured RED. - if (redPlType == payloadType) { + if (red_pl_type == payload_type) { // And it's a match... return 0; } } } - if (_payloadType == payloadType) { - if (!_audioConfigured) { - videoType = _video->VideoCodecType(); + if (payload_type_ == payload_type) { + if (!audio_configured_) { + *video_type = video_->VideoCodecType(); } return 0; } - std::map::iterator it = - _payloadTypeMap.find(payloadType); - if (it == _payloadTypeMap.end()) { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, - "\tpayloadType:%d not registered", payloadType); + std::map::iterator it = + payload_type_map_.find(payload_type); + if (it == payload_type_map_.end()) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_, + "\tpayloadType:%d not registered", payload_type); return -1; } - _payloadType = payloadType; - ModuleRTPUtility::Payload* payload = it->second; + payload_type_ = payload_type; + ModuleRTPUtility::Payload *payload = it->second; assert(payload); - if (!payload->audio && !_audioConfigured) { - _video->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType); - videoType = payload->typeSpecific.Video.videoCodecType; - _video->SetMaxConfiguredBitrateVideo(payload->typeSpecific.Video.maxRate); + if (!payload->audio && !audio_configured_) { + video_->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType); + *video_type = payload->typeSpecific.Video.videoCodecType; + video_->SetMaxConfiguredBitrateVideo(payload->typeSpecific.Video.maxRate); } 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, - const RTPFragmentationHeader* fragmentation, - VideoCodecInformation* codec_info, - const RTPVideoTypeHeader* rtp_type_hdr) { + 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, + const RTPFragmentationHeader *fragmentation, + VideoCodecInformation *codec_info, const RTPVideoTypeHeader *rtp_type_hdr) { { // Drop this packet if we're not sending media packets. - CriticalSectionScoped cs(_sendCritsect); - if (!_sendingMedia) { + CriticalSectionScoped cs(send_critsect_); + if (!sending_media_) { return 0; } } RtpVideoCodecTypes video_type = kRtpNoVideo; - if (CheckPayloadType(payload_type, video_type) != 0) { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, - "%s invalid argument failed to find payloadType:%d", + if (CheckPayloadType(payload_type, &video_type) != 0) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_, + "%s invalid argument failed to find payload_type:%d", __FUNCTION__, payload_type); return -1; } - if (_audioConfigured) { - assert(frame_type == kAudioFrameSpeech || - frame_type == kAudioFrameCN || + if (audio_configured_) { + assert(frame_type == kAudioFrameSpeech || frame_type == kAudioFrameCN || frame_type == kFrameEmpty); - return _audio->SendAudio(frame_type, payload_type, capture_timestamp, - payload_data, payload_size,fragmentation); + return audio_->SendAudio(frame_type, payload_type, capture_timestamp, + payload_data, payload_size, fragmentation); } else { - assert(frame_type != kAudioFrameSpeech && - frame_type != kAudioFrameCN); + assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN); if (frame_type == kFrameEmpty) { return SendPaddingAccordingToBitrate(payload_type, capture_timestamp, capture_time_ms); } - return _video->SendVideo(video_type, - frame_type, - payload_type, - capture_timestamp, - capture_time_ms, - payload_data, - payload_size, - fragmentation, - codec_info, + return video_->SendVideo(video_type, frame_type, payload_type, + capture_timestamp, capture_time_ms, payload_data, + payload_size, fragmentation, codec_info, rtp_type_hdr); } } WebRtc_Word32 RTPSender::SendPaddingAccordingToBitrate( - WebRtc_Word8 payload_type, - WebRtc_UWord32 capture_timestamp, + WebRtc_Word8 payload_type, WebRtc_UWord32 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. uint32_t current_bitrate = BitrateNow(); - int bitrate_diff = _targetSendBitrate * 1000 - current_bitrate; + int bitrate_diff = target_send_bitrate_ * 1000 - current_bitrate; if (bitrate_diff <= 0) { return 0; } @@ -404,7 +353,7 @@ WebRtc_Word32 RTPSender::SendPaddingAccordingToBitrate( } else { bytes = (bitrate_diff / 8); // Cap at 200 ms of target send data. - int bytes_cap = _targetSendBitrate * 25; // 1000 / 8 / 5 + int bytes_cap = target_send_bitrate_ * 25; // 1000 / 8 / 5. if (bytes > bytes_cap) { bytes = bytes_cap; } @@ -412,12 +361,11 @@ 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) { - // Drop this packet if we're not sending media packets - if (!_sendingMedia) { +WebRtc_Word32 RTPSender::SendPadData( + WebRtc_Word8 payload_type, WebRtc_UWord32 capture_timestamp, + int64_t capture_time_ms, WebRtc_Word32 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. @@ -430,33 +378,28 @@ WebRtc_Word32 RTPSender::SendPadData(WebRtc_Word8 payload_type, padding_bytes_in_packet = (bytes + 16) & 0xffe0; // Keep our modulus 32. } if (padding_bytes_in_packet < 32) { - // Sanity don't send empty packets. - break; + // Sanity don't send empty packets. + break; } // Correct seq num, timestamp and payload type. - int header_length = BuildRTPheader(data_buffer, - payload_type, - false, // No markerbit. - capture_timestamp, - true, // Timestamp provided. - true); // Increment sequence number. + int header_length = BuildRTPheader( + data_buffer, payload_type, false, // No markerbit. + 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])); + WebRtc_Word32 *data = + reinterpret_cast(&(data_buffer[header_length])); // Fill data buffer with random data. - for (int j = 0; j < (padding_bytes_in_packet >> 2); j++) { - data[j] = rand(); + for (int j = 0; j < (padding_bytes_in_packet >> 2); ++j) { + data[j] = rand(); // NOLINT } // Set number of padding bytes in the last byte of the packet. data_buffer[header_length + padding_bytes_in_packet - 1] = padding_bytes_in_packet; - // Send the packet - if (0 > SendToNetwork(data_buffer, - padding_bytes_in_packet, - header_length, - capture_time_ms, - kDontRetransmit)) { + // Send the packet. + if (0 > SendToNetwork(data_buffer, padding_bytes_in_packet, header_length, + capture_time_ms, kDontRetransmit)) { // Error sending the packet. break; } @@ -468,27 +411,24 @@ WebRtc_Word32 RTPSender::SendPadData(WebRtc_Word8 payload_type, return 0; } -void RTPSender::SetStorePacketsStatus( - const bool enable, - const WebRtc_UWord16 numberToStore) { - _packetHistory->SetStorePacketsStatus(enable, numberToStore); +void RTPSender::SetStorePacketsStatus(const bool enable, + const WebRtc_UWord16 number_to_store) { + packet_history_->SetStorePacketsStatus(enable, number_to_store); } -bool RTPSender::StorePackets() const { - return _packetHistory->StorePackets(); -} +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; + WebRtc_UWord8 *buffer_to_send_ptr = data_buffer; int64_t stored_time_in_ms; StorageType type; - bool found = _packetHistory->GetRTPPacket(packet_id, - min_resend_time, data_buffer, &length, &stored_time_in_ms, &type); + bool found = packet_history_->GetRTPPacket(packet_id, min_resend_time, + data_buffer, &length, + &stored_time_in_ms, &type); if (!found) { // Packet not found. return 0; @@ -499,182 +439,179 @@ WebRtc_Word32 RTPSender::ReSendPacket(WebRtc_UWord16 packet_id, return 0; } WebRtc_UWord8 data_buffer_rtx[IP_PACKET_SIZE]; - if (_RTX) { + if (rtx_) { buffer_to_send_ptr = data_buffer_rtx; - CriticalSectionScoped cs(_sendCritsect); + CriticalSectionScoped cs(send_critsect_); // Add RTX header. - ModuleRTPUtility::RTPHeaderParser rtpParser( - reinterpret_cast(data_buffer), - length); + ModuleRTPUtility::RTPHeaderParser rtp_parser( + reinterpret_cast(data_buffer), length); WebRtcRTPHeader rtp_header; - rtpParser.Parse(rtp_header); + rtp_parser.Parse(rtp_header); // Add original RTP header. memcpy(data_buffer_rtx, data_buffer, rtp_header.header.headerLength); // Replace sequence number. - WebRtc_UWord8* ptr = data_buffer_rtx + 2; - ModuleRTPUtility::AssignUWord16ToBuffer(ptr, _sequenceNumberRTX++); + WebRtc_UWord8 *ptr = data_buffer_rtx + 2; + ModuleRTPUtility::AssignUWord16ToBuffer(ptr, sequence_number_rtx_++); // Replace SSRC. ptr += 6; - ModuleRTPUtility::AssignUWord32ToBuffer(ptr, _ssrcRTX); + ModuleRTPUtility::AssignUWord32ToBuffer(ptr, ssrc_rtx_); // Add OSN (original sequence number). ptr = data_buffer_rtx + rtp_header.header.headerLength; - ModuleRTPUtility::AssignUWord16ToBuffer( - ptr, rtp_header.header.sequenceNumber); + ModuleRTPUtility::AssignUWord16ToBuffer(ptr, + rtp_header.header.sequenceNumber); ptr += 2; // Add original payload data. - memcpy(ptr, - data_buffer + rtp_header.header.headerLength, + memcpy(ptr, data_buffer + rtp_header.header.headerLength, length - rtp_header.header.headerLength); length += 2; } WebRtc_Word32 bytes_sent = ReSendToNetwork(buffer_to_send_ptr, length); if (bytes_sent <= 0) { - WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, _id, + WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_, "Transport failed to resend packet_id %u", packet_id); return -1; } // Store the time when the packet was last resent. - _packetHistory->UpdateResendTime(packet_id); + packet_history_->UpdateResendTime(packet_id); return bytes_sent; } -WebRtc_Word32 RTPSender::ReSendToNetwork(const WebRtc_UWord8* packet, +WebRtc_Word32 RTPSender::ReSendToNetwork(const WebRtc_UWord8 *packet, const WebRtc_UWord32 size) { WebRtc_Word32 bytes_sent = -1; - if (_transport) { - bytes_sent = _transport->SendPacket(_id, packet, size); + if (transport_) { + bytes_sent = transport_->SendPacket(id_, packet, size); } if (bytes_sent <= 0) { return -1; } - // Update send statistics - CriticalSectionScoped cs(_sendCritsect); + // Update send statistics. + CriticalSectionScoped cs(send_critsect_); Bitrate::Update(bytes_sent); - _packetsSent++; - // We on purpose don't add to _payloadBytesSent since this is a + packets_sent_++; + // We on purpose don't add to payload_bytes_sent_ since this is a // re-transmit and not new payload data. return bytes_sent; } int RTPSender::SelectiveRetransmissions() const { - if (!_video) return -1; - return _video->SelectiveRetransmissions(); + if (!video_) + return -1; + return video_->SelectiveRetransmissions(); } int RTPSender::SetSelectiveRetransmissions(uint8_t settings) { - if (!_video) return -1; - return _video->SetSelectiveRetransmissions(settings); + if (!video_) + return -1; + return video_->SetSelectiveRetransmissions(settings); } -void RTPSender::OnReceivedNACK(const WebRtc_UWord16 nackSequenceNumbersLength, - const WebRtc_UWord16* nackSequenceNumbers, - const WebRtc_UWord16 avgRTT) { +void RTPSender::OnReceivedNACK( + const WebRtc_UWord16 nack_sequence_numbers_length, + const WebRtc_UWord16 *nack_sequence_numbers, + const WebRtc_UWord16 avg_rtt) { const WebRtc_Word64 now = clock_->TimeInMilliseconds(); - WebRtc_UWord32 bytesReSent = 0; + WebRtc_UWord32 bytes_re_sent = 0; // Enough bandwidth to send NACK? if (!ProcessNACKBitRate(now)) { - WEBRTC_TRACE(kTraceStream, - kTraceRtpRtcp, - _id, + WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_, "NACK bitrate reached. Skip sending NACK response. Target %d", - _targetSendBitrate); + target_send_bitrate_); return; } - for (WebRtc_UWord16 i = 0; i < nackSequenceNumbersLength; ++i) { - const WebRtc_Word32 bytesSent = ReSendPacket(nackSequenceNumbers[i], - 5+avgRTT); - if (bytesSent > 0) { - bytesReSent += bytesSent; - } else if (bytesSent == 0) { + for (WebRtc_UWord16 i = 0; i < nack_sequence_numbers_length; ++i) { + const WebRtc_Word32 bytes_sent = ReSendPacket(nack_sequence_numbers[i], + 5 + avg_rtt); + if (bytes_sent > 0) { + bytes_re_sent += bytes_sent; + } else if (bytes_sent == 0) { // The packet has previously been resent. // Try resending next packet in the list. continue; - } else if (bytesSent < 0) { + } else if (bytes_sent < 0) { // Failed to send one Sequence number. Give up the rest in this nack. - WEBRTC_TRACE(kTraceWarning, - kTraceRtpRtcp, - _id, + WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_, "Failed resending RTP packet %d, Discard rest of packets", - nackSequenceNumbers[i]); + nack_sequence_numbers[i]); break; } - // delay bandwidth estimate (RTT * BW) - if (_targetSendBitrate != 0 && avgRTT) { + // Delay bandwidth estimate (RTT * BW). + if (target_send_bitrate_ != 0 && avg_rtt) { // kbits/s * ms = bits => bits/8 = bytes - WebRtc_UWord32 targetBytes = - (static_cast(_targetSendBitrate) * avgRTT) >> 3; - if (bytesReSent > targetBytes) { - break; // ignore the rest of the packets in the list + WebRtc_UWord32 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. } } } - if (bytesReSent > 0) { + if (bytes_re_sent > 0) { // TODO(pwestin) consolidate these two methods. - UpdateNACKBitRate(bytesReSent, now); - _nackBitrate.Update(bytesReSent); + UpdateNACKBitRate(bytes_re_sent, now); + nack_bitrate_.Update(bytes_re_sent); } } bool RTPSender::ProcessNACKBitRate(const WebRtc_UWord32 now) { WebRtc_UWord32 num = 0; - WebRtc_Word32 byteCount = 0; - const WebRtc_UWord32 avgInterval=1000; + WebRtc_Word32 byte_count = 0; + const WebRtc_UWord32 avg_interval = 1000; - CriticalSectionScoped cs(_sendCritsect); + CriticalSectionScoped cs(send_critsect_); - if (_targetSendBitrate == 0) { + if (target_send_bitrate_ == 0) { return true; } - for (num = 0; num < NACK_BYTECOUNT_SIZE; num++) { - if ((now - _nackByteCountTimes[num]) > avgInterval) { - // don't use data older than 1sec + for (num = 0; num < NACK_BYTECOUNT_SIZE; ++num) { + if ((now - nack_byte_count_times_[num]) > avg_interval) { + // Don't use data older than 1sec. break; } else { - byteCount += _nackByteCount[num]; + byte_count += nack_byte_count_[num]; } } - WebRtc_Word32 timeInterval = avgInterval; + WebRtc_Word32 time_interval = avg_interval; if (num == NACK_BYTECOUNT_SIZE) { // More than NACK_BYTECOUNT_SIZE nack messages has been received - // during the last msgInterval - timeInterval = now - _nackByteCountTimes[num-1]; - if (timeInterval < 0) { - timeInterval = avgInterval; + // during the last msg_interval. + time_interval = now - nack_byte_count_times_[num - 1]; + if (time_interval < 0) { + time_interval = avg_interval; } } - return (byteCount*8) < (_targetSendBitrate * timeInterval); + return (byte_count * 8) < (target_send_bitrate_ * time_interval); } void RTPSender::UpdateNACKBitRate(const WebRtc_UWord32 bytes, const WebRtc_UWord32 now) { - CriticalSectionScoped cs(_sendCritsect); + CriticalSectionScoped cs(send_critsect_); - // save bitrate statistics + // Save bitrate statistics. if (bytes > 0) { if (now == 0) { - // add padding length - _nackByteCount[0] += bytes; + // Add padding length. + nack_byte_count_[0] += bytes; } else { - if (_nackByteCountTimes[0] == 0) { - // first no shift + if (nack_byte_count_times_[0] == 0) { + // First no shift. } else { - // shift - for (int i = (NACK_BYTECOUNT_SIZE-2); i >= 0 ; i--) { - _nackByteCount[i+1] = _nackByteCount[i]; - _nackByteCountTimes[i+1] = _nackByteCountTimes[i]; + // Shift. + for (int i = (NACK_BYTECOUNT_SIZE - 2); i >= 0; i--) { + nack_byte_count_[i + 1] = nack_byte_count_[i]; + nack_byte_count_times_[i + 1] = nack_byte_count_times_[i]; } } - _nackByteCount[0] = bytes; - _nackByteCountTimes[0] = now; + nack_byte_count_[0] = bytes; + nack_byte_count_times_[0] = now; } } } @@ -684,55 +621,53 @@ void RTPSender::TimeToSendPacket(uint16_t sequence_number, StorageType type; uint16_t length = IP_PACKET_SIZE; uint8_t data_buffer[IP_PACKET_SIZE]; - int64_t stored_time_ms; // TODO(pwestin) can we depricate this? + int64_t stored_time_ms; // TODO(pwestin) can we deprecate this? - if (_packetHistory == NULL) { + if (packet_history_ == NULL) { return; } - if (!_packetHistory->GetRTPPacket(sequence_number, 0, data_buffer, - &length, &stored_time_ms, &type)) { + if (!packet_history_->GetRTPPacket(sequence_number, 0, data_buffer, &length, + &stored_time_ms, &type)) { assert(false); return; } assert(length > 0); - ModuleRTPUtility::RTPHeaderParser rtpParser(data_buffer, length); + ModuleRTPUtility::RTPHeaderParser rtp_parser(data_buffer, length); WebRtcRTPHeader rtp_header; - rtpParser.Parse(rtp_header); + rtp_parser.Parse(rtp_header); int64_t diff_ms = clock_->TimeInMilliseconds() - capture_time_ms; if (UpdateTransmissionTimeOffset(data_buffer, length, rtp_header, diff_ms)) { // Update stored packet in case of receiving a re-transmission request. - _packetHistory->ReplaceRTPHeader(data_buffer, - rtp_header.header.sequenceNumber, - rtp_header.header.headerLength); + packet_history_->ReplaceRTPHeader(data_buffer, + rtp_header.header.sequenceNumber, + rtp_header.header.headerLength); } int bytes_sent = -1; - if (_transport) { - bytes_sent = _transport->SendPacket(_id, data_buffer, length); + if (transport_) { + bytes_sent = transport_->SendPacket(id_, data_buffer, length); } if (bytes_sent <= 0) { return; } - // Update send statistics - CriticalSectionScoped cs(_sendCritsect); + // Update send statistics. + CriticalSectionScoped cs(send_critsect_); Bitrate::Update(bytes_sent); - _packetsSent++; + packets_sent_++; if (bytes_sent > rtp_header.header.headerLength) { - _payloadBytesSent += bytes_sent - rtp_header.header.headerLength; + payload_bytes_sent_ += bytes_sent - rtp_header.header.headerLength; } } -// TODO(pwestin): send in the RTPHeaderParser to avoid parsing it again -WebRtc_Word32 RTPSender::SendToNetwork(uint8_t* buffer, - int payload_length, - int rtp_header_length, - int64_t capture_time_ms, - StorageType storage) { - ModuleRTPUtility::RTPHeaderParser rtpParser(buffer, - payload_length + rtp_header_length); +// TODO(pwestin): send in the RTPHeaderParser to avoid parsing it again. +WebRtc_Word32 RTPSender::SendToNetwork( + uint8_t *buffer, int payload_length, int rtp_header_length, + int64_t capture_time_ms, StorageType storage) { + ModuleRTPUtility::RTPHeaderParser rtp_parser( + buffer, payload_length + rtp_header_length); WebRtcRTPHeader rtp_header; - rtpParser.Parse(rtp_header); + rtp_parser.Parse(rtp_header); // |capture_time_ms| <= 0 is considered invalid. // TODO(holmer): This should be changed all over Video Engine so that negative @@ -743,168 +678,165 @@ WebRtc_Word32 RTPSender::SendToNetwork(uint8_t* buffer, rtp_header, time_now - capture_time_ms); } // Used for NACK and to spread out the transmission of packets. - if (_packetHistory->PutRTPPacket(buffer, rtp_header_length + payload_length, - _maxPayloadLength, capture_time_ms, storage) != 0) { + if (packet_history_->PutRTPPacket(buffer, rtp_header_length + payload_length, + max_payload_length_, capture_time_ms, + storage) != 0) { return -1; } if (paced_sender_) { - if (!paced_sender_ ->SendPacket(PacedSender::kNormalPriority, - rtp_header.header.ssrc, - rtp_header.header.sequenceNumber, - capture_time_ms, - payload_length + rtp_header_length)) { + if (!paced_sender_->SendPacket( + PacedSender::kNormalPriority, rtp_header.header.ssrc, + rtp_header.header.sequenceNumber, capture_time_ms, + payload_length + rtp_header_length)) { // We can't send the packet right now. // We will be called when it is time. return payload_length + rtp_header_length; } } - // Send packet + // Send packet. WebRtc_Word32 bytes_sent = -1; - if (_transport) { - bytes_sent = _transport->SendPacket(_id, - buffer, + if (transport_) { + bytes_sent = transport_->SendPacket(id_, buffer, payload_length + rtp_header_length); } if (bytes_sent <= 0) { return -1; } - // Update send statistics - CriticalSectionScoped cs(_sendCritsect); + // Update send statistics. + CriticalSectionScoped cs(send_critsect_); Bitrate::Update(bytes_sent); - _packetsSent++; + packets_sent_++; if (bytes_sent > rtp_header_length) { - _payloadBytesSent += bytes_sent - rtp_header_length; + payload_bytes_sent_ += bytes_sent - rtp_header_length; } return 0; } void RTPSender::ProcessBitrate() { - CriticalSectionScoped cs(_sendCritsect); + CriticalSectionScoped cs(send_critsect_); Bitrate::Process(); - _nackBitrate.Process(); - if (_audioConfigured) { + nack_bitrate_.Process(); + if (audio_configured_) { return; } - _video->ProcessBitrate(); + video_->ProcessBitrate(); } WebRtc_UWord16 RTPSender::RTPHeaderLength() const { - WebRtc_UWord16 rtpHeaderLength = 12; - if (_includeCSRCs) { - rtpHeaderLength += sizeof(WebRtc_UWord32)*_CSRCs; + WebRtc_UWord16 rtp_header_length = 12; + if (include_csrcs_) { + rtp_header_length += sizeof(WebRtc_UWord32) * csrcs_; } - rtpHeaderLength += RtpHeaderExtensionTotalLength(); - return rtpHeaderLength; + rtp_header_length += RtpHeaderExtensionTotalLength(); + return rtp_header_length; } WebRtc_UWord16 RTPSender::IncrementSequenceNumber() { - CriticalSectionScoped cs(_sendCritsect); - return _sequenceNumber++; + CriticalSectionScoped cs(send_critsect_); + return sequence_number_++; } void RTPSender::ResetDataCounters() { - _packetsSent = 0; - _payloadBytesSent = 0; + packets_sent_ = 0; + payload_bytes_sent_ = 0; } WebRtc_UWord32 RTPSender::Packets() const { - // Don't use critsect to avoid potental deadlock - return _packetsSent; + // Don't use critsect to avoid potential deadlock. + return packets_sent_; } -// number of sent RTP bytes -// dont use critsect to avoid potental deadlock +// Number of sent RTP bytes. +// Don't use critsect to avoid potental deadlock. WebRtc_UWord32 RTPSender::Bytes() const { - return _payloadBytesSent; + return payload_bytes_sent_; } -WebRtc_Word32 RTPSender::BuildRTPheader(WebRtc_UWord8* dataBuffer, - const WebRtc_Word8 payloadType, - const bool markerBit, - const WebRtc_UWord32 captureTimeStamp, - const bool timeStampProvided, - const bool incSequenceNumber) { - assert(payloadType>=0); - CriticalSectionScoped cs(_sendCritsect); +WebRtc_Word32 RTPSender::BuildRTPheader( + WebRtc_UWord8 *data_buffer, const WebRtc_Word8 payload_type, + const bool marker_bit, const WebRtc_UWord32 capture_time_stamp, + const bool time_stamp_provided, const bool inc_sequence_number) { + assert(payload_type >= 0); + CriticalSectionScoped cs(send_critsect_); - dataBuffer[0] = static_cast(0x80); // version 2 - dataBuffer[1] = static_cast(payloadType); - if (markerBit) { - dataBuffer[1] |= kRtpMarkerBitMask; // MarkerBit is set + 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. } - if (timeStampProvided) { - _timeStamp = _startTimeStamp + captureTimeStamp; + if (time_stamp_provided) { + time_stamp_ = start_time_stamp_ + capture_time_stamp; } else { - // make a unique time stamp - // we can't inc by the actual time, since then we increase the risk of back + // Make a unique time stamp. + // We can't inc by the actual time, since then we increase the risk of back // timing. - _timeStamp++; + time_stamp_++; } - ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer+2, _sequenceNumber); - ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer+4, _timeStamp); - ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer+8, _ssrc); - WebRtc_Word32 rtpHeaderLength = 12; + 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; - // Add the CSRCs if any - if (_includeCSRCs && _CSRCs > 0) { - if (_CSRCs > kRtpCsrcSize) { + // Add the CSRCs if any. + if (include_csrcs_ && csrcs_ > 0) { + if (csrcs_ > kRtpCsrcSize) { // error assert(false); return -1; } - WebRtc_UWord8* ptr = &dataBuffer[rtpHeaderLength]; - for (WebRtc_UWord32 i = 0; i < _CSRCs; ++i) { - ModuleRTPUtility::AssignUWord32ToBuffer(ptr, _CSRC[i]); - ptr +=4; + WebRtc_UWord8 *ptr = &data_buffer[rtp_header_length]; + for (WebRtc_UWord32 i = 0; i < csrcs_; ++i) { + ModuleRTPUtility::AssignUWord32ToBuffer(ptr, csrc_[i]); + ptr += 4; } - dataBuffer[0] = (dataBuffer[0]&0xf0) | _CSRCs; + data_buffer[0] = (data_buffer[0] & 0xf0) | csrcs_; - // Update length of header - rtpHeaderLength += sizeof(WebRtc_UWord32)*_CSRCs; + // Update length of header. + rtp_header_length += sizeof(WebRtc_UWord32) * csrcs_; } - _sequenceNumber++; // prepare for next packet + sequence_number_++; // Prepare for next packet. - WebRtc_UWord16 len = BuildRTPHeaderExtension(dataBuffer + rtpHeaderLength); + WebRtc_UWord16 len = BuildRTPHeaderExtension(data_buffer + rtp_header_length); if (len) { - dataBuffer[0] |= 0x10; // set eXtension bit - rtpHeaderLength += len; + data_buffer[0] |= 0x10; // Set extension bit. + rtp_header_length += len; } - return rtpHeaderLength; + return rtp_header_length; } WebRtc_UWord16 RTPSender::BuildRTPHeaderExtension( - WebRtc_UWord8* dataBuffer) const { - if (_rtpHeaderExtensionMap.Size() <= 0) { + WebRtc_UWord8 *data_buffer) const { + if (rtp_header_extension_map_.Size() <= 0) { return 0; } - /* RTP header extension, RFC 3550. - 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 - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | defined by profile | length | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | header extension | - | .... | - */ + // RTP header extension, RFC 3550. + // 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 + // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // | defined by profile | length | + // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + // | header extension | + // | .... | + // const WebRtc_UWord32 kPosLength = 2; const WebRtc_UWord32 kHeaderLength = RTP_ONE_BYTE_HEADER_LENGTH_IN_BYTES; // Add extension ID (0xBEDE). - ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer, + ModuleRTPUtility::AssignUWord16ToBuffer(data_buffer, RTP_ONE_BYTE_HEADER_EXTENSION); // Add extensions. WebRtc_UWord16 total_block_length = 0; - RTPExtensionType type = _rtpHeaderExtensionMap.First(); + RTPExtensionType type = rtp_header_extension_map_.First(); while (type != kRtpExtensionNone) { WebRtc_UWord8 block_length = 0; if (type == kRtpExtensionTransmissionTimeOffset) { block_length = BuildTransmissionTimeOffsetExtension( - dataBuffer + kHeaderLength + total_block_length); + data_buffer + kHeaderLength + total_block_length); } total_block_length += block_length; - type = _rtpHeaderExtensionMap.Next(type); + type = rtp_header_extension_map_.Next(type); } if (total_block_length == 0) { // No extension added. @@ -912,14 +844,14 @@ WebRtc_UWord16 RTPSender::BuildRTPHeaderExtension( } // Set header length (in number of Word32, header excluded). assert(total_block_length % 4 == 0); - ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer + kPosLength, + ModuleRTPUtility::AssignUWord16ToBuffer(data_buffer + kPosLength, total_block_length / 4); // Total added length. return kHeaderLength + total_block_length; } WebRtc_UWord8 RTPSender::BuildTransmissionTimeOffsetExtension( - WebRtc_UWord8* dataBuffer) const { + WebRtc_UWord8* data_buffer) const { // From RFC 5450: Transmission Time Offsets in RTP Streams. // // The transmission time is signaled to the receiver in-band using the @@ -939,63 +871,62 @@ WebRtc_UWord8 RTPSender::BuildTransmissionTimeOffsetExtension( // Get id defined by user. WebRtc_UWord8 id; - if (_rtpHeaderExtensionMap.GetId(kRtpExtensionTransmissionTimeOffset, &id) - != 0) { + if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset, + &id) != 0) { // Not registered. return 0; } int pos = 0; const WebRtc_UWord8 len = 2; - dataBuffer[pos++] = (id << 4) + len; - ModuleRTPUtility::AssignUWord24ToBuffer(dataBuffer + pos, - _transmissionTimeOffset); + data_buffer[pos++] = (id << 4) + len; + ModuleRTPUtility::AssignUWord24ToBuffer(data_buffer + pos, + transmission_time_offset_); pos += 3; assert(pos == TRANSMISSION_TIME_OFFSET_LENGTH_IN_BYTES); return TRANSMISSION_TIME_OFFSET_LENGTH_IN_BYTES; } bool RTPSender::UpdateTransmissionTimeOffset( - WebRtc_UWord8* rtp_packet, - const WebRtc_UWord16 rtp_packet_length, - const WebRtcRTPHeader& rtp_header, - const WebRtc_Word64 time_diff_ms) const { - CriticalSectionScoped cs(_sendCritsect); + WebRtc_UWord8 *rtp_packet, const WebRtc_UWord16 rtp_packet_length, + const WebRtcRTPHeader &rtp_header, const WebRtc_Word64 time_diff_ms) const { + CriticalSectionScoped cs(send_critsect_); // Get length until start of transmission block. int transmission_block_pos = - _rtpHeaderExtensionMap.GetLengthUntilBlockStartInBytes( + rtp_header_extension_map_.GetLengthUntilBlockStartInBytes( kRtpExtensionTransmissionTimeOffset); if (transmission_block_pos < 0) { - WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, _id, + WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_, "Failed to update transmission time offset, not registered."); return false; } int block_pos = 12 + rtp_header.header.numCSRCs + transmission_block_pos; if (rtp_packet_length < block_pos + 4 || rtp_header.header.headerLength < block_pos + 4) { - WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, _id, + WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_, "Failed to update transmission time offset, invalid length."); return false; } // Verify that header contains extension. if (!((rtp_packet[12 + rtp_header.header.numCSRCs] == 0xBE) && - (rtp_packet[12 + rtp_header.header.numCSRCs + 1] == 0xDE))) { - WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, _id, + (rtp_packet[12 + rtp_header.header.numCSRCs + 1] == 0xDE))) { + WEBRTC_TRACE( + kTraceStream, kTraceRtpRtcp, id_, "Failed to update transmission time offset, hdr extension not found."); return false; } // Get id. WebRtc_UWord8 id = 0; - if (_rtpHeaderExtensionMap.GetId(kRtpExtensionTransmissionTimeOffset, - &id) != 0) { - WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, _id, + if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset, + &id) != 0) { + WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_, "Failed to update transmission time offset, no id."); return false; } // Verify first byte in block. const WebRtc_UWord8 first_block_byte = (id << 4) + 2; if (rtp_packet[block_pos] != first_block_byte) { - WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, _id, + WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_, "Failed to update transmission time offset."); return false; } @@ -1008,20 +939,20 @@ bool RTPSender::UpdateTransmissionTimeOffset( void RTPSender::SetSendingStatus(const bool enabled) { if (enabled) { WebRtc_UWord32 frequency_hz; - if (_audioConfigured) { - WebRtc_UWord32 frequency = _audio->AudioFrequency(); + if (audio_configured_) { + WebRtc_UWord32 frequency = audio_->AudioFrequency(); // sanity - switch(frequency) { - case 8000: - case 12000: - case 16000: - case 24000: - case 32000: - break; - default: - assert(false); - return; + switch (frequency) { + case 8000: + case 12000: + case 16000: + case 24000: + case 32000: + break; + default: + assert(false); + return; } frequency_hz = frequency; } else { @@ -1030,237 +961,235 @@ void RTPSender::SetSendingStatus(const bool enabled) { WebRtc_UWord32 RTPtime = ModuleRTPUtility::GetCurrentRTP(clock_, frequency_hz); - // will be ignored if it's already configured via API + // Will be ignored if it's already configured via API. SetStartTimestamp(RTPtime, false); } else { - if (!_ssrcForced) { - // generate a new SSRC - _ssrcDB.ReturnSSRC(_ssrc); - _ssrc = _ssrcDB.CreateSSRC(); // can't be 0 - + if (!ssrc_forced_) { + // Generate a new SSRC. + ssrc_db_.ReturnSSRC(ssrc_); + ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. } // Don't initialize seq number if SSRC passed externally. - if (!_sequenceNumberForced && !_ssrcForced) { - // generate a new sequence number - _sequenceNumber = rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER); + if (!sequence_number_forced_ && !ssrc_forced_) { + // Generate a new sequence number. + sequence_number_ = + rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER); // NOLINT } } } void RTPSender::SetSendingMediaStatus(const bool enabled) { - CriticalSectionScoped cs(_sendCritsect); - _sendingMedia = enabled; + CriticalSectionScoped cs(send_critsect_); + sending_media_ = enabled; } bool RTPSender::SendingMedia() const { - CriticalSectionScoped cs(_sendCritsect); - return _sendingMedia; + CriticalSectionScoped cs(send_critsect_); + return sending_media_; } WebRtc_UWord32 RTPSender::Timestamp() const { - CriticalSectionScoped cs(_sendCritsect); - return _timeStamp; + CriticalSectionScoped cs(send_critsect_); + return time_stamp_; } void RTPSender::SetStartTimestamp(WebRtc_UWord32 timestamp, bool force) { - CriticalSectionScoped cs(_sendCritsect); + CriticalSectionScoped cs(send_critsect_); if (force) { - _startTimeStampForced = force; - _startTimeStamp = timestamp; + start_time_stamp_forced_ = force; + start_time_stamp_ = timestamp; } else { - if (!_startTimeStampForced) { - _startTimeStamp = timestamp; + if (!start_time_stamp_forced_) { + start_time_stamp_ = timestamp; } } } WebRtc_UWord32 RTPSender::StartTimestamp() const { - CriticalSectionScoped cs(_sendCritsect); - return _startTimeStamp; + CriticalSectionScoped cs(send_critsect_); + return start_time_stamp_; } WebRtc_UWord32 RTPSender::GenerateNewSSRC() { - // if configured via API, return 0 - CriticalSectionScoped cs(_sendCritsect); + // If configured via API, return 0. + CriticalSectionScoped cs(send_critsect_); - if (_ssrcForced) { + if (ssrc_forced_) { return 0; } - _ssrc = _ssrcDB.CreateSSRC(); // can't be 0 - return _ssrc; + ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. + return ssrc_; } void RTPSender::SetSSRC(WebRtc_UWord32 ssrc) { - // this is configured via the API - CriticalSectionScoped cs(_sendCritsect); + // This is configured via the API. + CriticalSectionScoped cs(send_critsect_); - if (_ssrc == ssrc && _ssrcForced) { - return; // since it's same ssrc, don't reset anything + if (ssrc_ == ssrc && ssrc_forced_) { + return; // Since it's same ssrc, don't reset anything. } - _ssrcForced = true; - _ssrcDB.ReturnSSRC(_ssrc); - _ssrcDB.RegisterSSRC(ssrc); - _ssrc = ssrc; - if (!_sequenceNumberForced) { - _sequenceNumber = rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER); + ssrc_forced_ = true; + ssrc_db_.ReturnSSRC(ssrc_); + ssrc_db_.RegisterSSRC(ssrc); + ssrc_ = ssrc; + if (!sequence_number_forced_) { + sequence_number_ = + rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER); // NOLINT } } WebRtc_UWord32 RTPSender::SSRC() const { - CriticalSectionScoped cs(_sendCritsect); - return _ssrc; + CriticalSectionScoped cs(send_critsect_); + return ssrc_; } void RTPSender::SetCSRCStatus(const bool include) { - _includeCSRCs = include; + include_csrcs_ = include; } -void RTPSender::SetCSRCs(const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize], - const WebRtc_UWord8 arrLength) { - assert(arrLength <= kRtpCsrcSize); - CriticalSectionScoped cs(_sendCritsect); +void RTPSender::SetCSRCs(const WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize], + const WebRtc_UWord8 arr_length) { + assert(arr_length <= kRtpCsrcSize); + CriticalSectionScoped cs(send_critsect_); - for (int i = 0; i < arrLength;i++) { - _CSRC[i] = arrOfCSRC[i]; + for (int i = 0; i < arr_length; i++) { + csrc_[i] = arr_of_csrc[i]; } - _CSRCs = arrLength; + csrcs_ = arr_length; } -WebRtc_Word32 RTPSender::CSRCs(WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]) const { - assert(arrOfCSRC); - CriticalSectionScoped cs(_sendCritsect); - for (int i = 0; i < _CSRCs && i < kRtpCsrcSize;i++) { - arrOfCSRC[i] = _CSRC[i]; +WebRtc_Word32 RTPSender::CSRCs(WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const { + assert(arr_of_csrc); + CriticalSectionScoped cs(send_critsect_); + for (int i = 0; i < csrcs_ && i < kRtpCsrcSize; i++) { + arr_of_csrc[i] = csrc_[i]; } - return _CSRCs; + return csrcs_; } void RTPSender::SetSequenceNumber(WebRtc_UWord16 seq) { - CriticalSectionScoped cs(_sendCritsect); - _sequenceNumberForced = true; - _sequenceNumber = seq; + CriticalSectionScoped cs(send_critsect_); + sequence_number_forced_ = true; + sequence_number_ = seq; } WebRtc_UWord16 RTPSender::SequenceNumber() const { - CriticalSectionScoped cs(_sendCritsect); - return _sequenceNumber; + CriticalSectionScoped cs(send_critsect_); + return sequence_number_; } -/* - * Audio - */ +// Audio. WebRtc_Word32 RTPSender::SendTelephoneEvent(const WebRtc_UWord8 key, const WebRtc_UWord16 time_ms, const WebRtc_UWord8 level) { - if (!_audioConfigured) { + if (!audio_configured_) { return -1; } - return _audio->SendTelephoneEvent(key, time_ms, level); + return audio_->SendTelephoneEvent(key, time_ms, level); } -bool RTPSender::SendTelephoneEventActive(WebRtc_Word8& telephoneEvent) const { - if (!_audioConfigured) { +bool RTPSender::SendTelephoneEventActive(WebRtc_Word8 *telephone_event) const { + if (!audio_configured_) { return false; } - return _audio->SendTelephoneEventActive(telephoneEvent); + return audio_->SendTelephoneEventActive(*telephone_event); } WebRtc_Word32 RTPSender::SetAudioPacketSize( - const WebRtc_UWord16 packetSizeSamples) { - if (!_audioConfigured) { + const WebRtc_UWord16 packet_size_samples) { + if (!audio_configured_) { return -1; } - return _audio->SetAudioPacketSize(packetSizeSamples); + return audio_->SetAudioPacketSize(packet_size_samples); } -WebRtc_Word32 -RTPSender::SetAudioLevelIndicationStatus(const bool enable, - const WebRtc_UWord8 ID) { - if (!_audioConfigured) { +WebRtc_Word32 RTPSender::SetAudioLevelIndicationStatus(const bool enable, + const WebRtc_UWord8 ID) { + if (!audio_configured_) { return -1; } - return _audio->SetAudioLevelIndicationStatus(enable, ID); + return audio_->SetAudioLevelIndicationStatus(enable, ID); } -WebRtc_Word32 RTPSender::AudioLevelIndicationStatus(bool& enable, - WebRtc_UWord8& ID) const { - return _audio->AudioLevelIndicationStatus(enable, ID); +WebRtc_Word32 RTPSender::AudioLevelIndicationStatus(bool *enable, + WebRtc_UWord8* id) const { + return audio_->AudioLevelIndicationStatus(*enable, *id); } -WebRtc_Word32 RTPSender::SetAudioLevel(const WebRtc_UWord8 level_dBov) { - return _audio->SetAudioLevel(level_dBov); +WebRtc_Word32 RTPSender::SetAudioLevel(const WebRtc_UWord8 level_d_bov) { + return audio_->SetAudioLevel(level_d_bov); } -WebRtc_Word32 RTPSender::SetRED(const WebRtc_Word8 payloadType) { - if (!_audioConfigured) { +WebRtc_Word32 RTPSender::SetRED(const WebRtc_Word8 payload_type) { + if (!audio_configured_) { return -1; } - return _audio->SetRED(payloadType); + return audio_->SetRED(payload_type); } -WebRtc_Word32 RTPSender::RED(WebRtc_Word8& payloadType) const { - if (!_audioConfigured) { +WebRtc_Word32 RTPSender::RED(WebRtc_Word8 *payload_type) const { + if (!audio_configured_) { return -1; } - return _audio->RED(payloadType); + return audio_->RED(*payload_type); } -/* - * Video - */ -VideoCodecInformation* RTPSender::CodecInformationVideo() { - if (_audioConfigured) { +// Video +VideoCodecInformation *RTPSender::CodecInformationVideo() { + if (audio_configured_) { return NULL; } - return _video->CodecInformationVideo(); + return video_->CodecInformationVideo(); } RtpVideoCodecTypes RTPSender::VideoCodecType() const { - if (_audioConfigured) { + if (audio_configured_) { return kRtpNoVideo; } - return _video->VideoCodecType(); + return video_->VideoCodecType(); } WebRtc_UWord32 RTPSender::MaxConfiguredBitrateVideo() const { - if (_audioConfigured) { + if (audio_configured_) { return 0; } - return _video->MaxConfiguredBitrateVideo(); + return video_->MaxConfiguredBitrateVideo(); } WebRtc_Word32 RTPSender::SendRTPIntraRequest() { - if (_audioConfigured) { + if (audio_configured_) { return -1; } - return _video->SendRTPIntraRequest(); + return video_->SendRTPIntraRequest(); } WebRtc_Word32 RTPSender::SetGenericFECStatus( - const bool enable, - const WebRtc_UWord8 payloadTypeRED, - const WebRtc_UWord8 payloadTypeFEC) { - if (_audioConfigured) { + const bool enable, const WebRtc_UWord8 payload_type_red, + const WebRtc_UWord8 payload_type_fec) { + if (audio_configured_) { return -1; } - return _video->SetGenericFECStatus(enable, payloadTypeRED, payloadTypeFEC); + return video_->SetGenericFECStatus(enable, payload_type_red, + payload_type_fec); } -WebRtc_Word32 RTPSender::GenericFECStatus(bool& enable, - WebRtc_UWord8& payloadTypeRED, - WebRtc_UWord8& payloadTypeFEC) const { - if (_audioConfigured) { +WebRtc_Word32 RTPSender::GenericFECStatus( + bool *enable, WebRtc_UWord8 *payload_type_red, + WebRtc_UWord8 *payload_type_fec) const { + if (audio_configured_) { return -1; } - return _video->GenericFECStatus(enable, payloadTypeRED, payloadTypeFEC); + return video_->GenericFECStatus( + *enable, *payload_type_red, *payload_type_fec); } WebRtc_Word32 RTPSender::SetFecParameters( - const FecProtectionParams* delta_params, - const FecProtectionParams* key_params) { - if (_audioConfigured) { + const FecProtectionParams *delta_params, + const FecProtectionParams *key_params) { + if (audio_configured_) { return -1; } - return _video->SetFecParameters(delta_params, key_params); + return video_->SetFecParameters(delta_params, key_params); } + } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h index cee5247d2..33d91c794 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h @@ -23,9 +23,10 @@ #include "webrtc/modules/rtp_rtcp/source/ssrc_database.h" #include "webrtc/modules/rtp_rtcp/source/video_codec_information.h" -#define MAX_INIT_RTP_SEQ_NUMBER 32767 // 2^15 -1 +#define MAX_INIT_RTP_SEQ_NUMBER 32767 // 2^15 -1. namespace webrtc { + class CriticalSectionWrapper; class PacedSender; class RTPPacketHistory; @@ -40,36 +41,30 @@ class RTPSenderInterface { virtual WebRtc_UWord32 SSRC() const = 0; virtual WebRtc_UWord32 Timestamp() const = 0; - virtual WebRtc_Word32 BuildRTPheader(WebRtc_UWord8* dataBuffer, - const WebRtc_Word8 payloadType, - const bool markerBit, - const WebRtc_UWord32 captureTimeStamp, - const bool timeStampProvided = true, - const bool incSequenceNumber = true) = 0; + virtual WebRtc_Word32 BuildRTPheader( + WebRtc_UWord8 *data_buffer, const WebRtc_Word8 payload_type, + const bool marker_bit, const WebRtc_UWord32 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 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 WebRtc_Word32 SendToNetwork(uint8_t* data_buffer, - int payload_length, - int rtp_header_length, - int64_t capture_time_ms, - StorageType storage) = 0; + virtual WebRtc_Word32 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, - Transport* transport, - RtpAudioFeedback* audio_feedback, - PacedSender* paced_sender); + RTPSender(const WebRtc_Word32 id, const bool audio, Clock *clock, + Transport *transport, RtpAudioFeedback *audio_feedback, + PacedSender *paced_sender); virtual ~RTPSender(); void ProcessBitrate(); @@ -82,16 +77,14 @@ class RTPSender : public Bitrate, public RTPSenderInterface { void SetTargetSendBitrate(const WebRtc_UWord32 bits); - WebRtc_UWord16 MaxDataPayloadLength() const; // with RTP and FEC headers + WebRtc_UWord16 MaxDataPayloadLength() const; // with RTP and FEC headers. WebRtc_Word32 RegisterPayload( - const char payloadName[RTP_PAYLOAD_NAME_SIZE], - const WebRtc_Word8 payloadType, - const WebRtc_UWord32 frequency, - const WebRtc_UWord8 channels, - const WebRtc_UWord32 rate); + 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); - WebRtc_Word32 DeRegisterSendPayload(const WebRtc_Word8 payloadType); + WebRtc_Word32 DeRegisterSendPayload(const WebRtc_Word8 payload_type); WebRtc_Word8 SendPayloadType() const; @@ -102,10 +95,10 @@ class RTPSender : public Bitrate, public RTPSenderInterface { void SetSendingMediaStatus(const bool enabled); bool SendingMedia() const; - // number of sent RTP packets + // Number of sent RTP packets. WebRtc_UWord32 Packets() const; - // number of sent RTP bytes + // Number of sent RTP bytes. WebRtc_UWord32 Bytes() const; void ResetDataCounters(); @@ -119,35 +112,30 @@ class RTPSender : public Bitrate, public RTPSenderInterface { WebRtc_UWord16 SequenceNumber() const; void SetSequenceNumber(WebRtc_UWord16 seq); - WebRtc_Word32 CSRCs(WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]) const; + WebRtc_Word32 CSRCs(WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize]) const; void SetCSRCStatus(const bool include); - void SetCSRCs(const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize], - const WebRtc_UWord8 arrLength); + void SetCSRCs(const WebRtc_UWord32 arr_of_csrc[kRtpCsrcSize], + const WebRtc_UWord8 arr_length); WebRtc_Word32 SetMaxPayloadLength(const WebRtc_UWord16 length, - const WebRtc_UWord16 packetOverHead); + const WebRtc_UWord16 packet_over_head); - WebRtc_Word32 SendOutgoingData(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, - VideoCodecInformation* codecInfo = NULL, - const RTPVideoTypeHeader* rtpTypeHdr = NULL); + 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, + 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); - /* - * RTP header extension - */ + int64_t capture_time_ms, WebRtc_Word32 bytes); + // RTP header extension WebRtc_Word32 SetTransmissionTimeOffset( - const WebRtc_Word32 transmissionTimeOffset); + const WebRtc_Word32 transmission_time_offset); WebRtc_Word32 RegisterRtpHeaderExtension(const RTPExtensionType type, const WebRtc_UWord8 id); @@ -156,109 +144,97 @@ class RTPSender : public Bitrate, public RTPSenderInterface { WebRtc_UWord16 RtpHeaderExtensionTotalLength() const; - WebRtc_UWord16 BuildRTPHeaderExtension(WebRtc_UWord8* dataBuffer) const; + WebRtc_UWord16 BuildRTPHeaderExtension(WebRtc_UWord8 *data_buffer) const; WebRtc_UWord8 BuildTransmissionTimeOffsetExtension( - WebRtc_UWord8* dataBuffer) const; + WebRtc_UWord8 *data_buffer) const; - bool UpdateTransmissionTimeOffset(WebRtc_UWord8* rtp_packet, + bool UpdateTransmissionTimeOffset(WebRtc_UWord8 *rtp_packet, const WebRtc_UWord16 rtp_packet_length, - const WebRtcRTPHeader& rtp_header, + const WebRtcRTPHeader &rtp_header, const WebRtc_Word64 time_diff_ms) const; void TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms); - /* - * NACK - */ + // NACK. int SelectiveRetransmissions() const; int SetSelectiveRetransmissions(uint8_t settings); - void OnReceivedNACK(const WebRtc_UWord16 nackSequenceNumbersLength, - const WebRtc_UWord16* nackSequenceNumbers, - const WebRtc_UWord16 avgRTT); + void OnReceivedNACK(const WebRtc_UWord16 nack_sequence_numbers_length, + const WebRtc_UWord16 *nack_sequence_numbers, + const WebRtc_UWord16 avg_rtt); void SetStorePacketsStatus(const bool enable, - const WebRtc_UWord16 numberToStore); + const WebRtc_UWord16 number_to_store); bool StorePackets() const; WebRtc_Word32 ReSendPacket(WebRtc_UWord16 packet_id, WebRtc_UWord32 min_resend_time = 0); - WebRtc_Word32 ReSendToNetwork(const WebRtc_UWord8* packet, + WebRtc_Word32 ReSendToNetwork(const WebRtc_UWord8 *packet, const WebRtc_UWord32 size); bool ProcessNACKBitRate(const WebRtc_UWord32 now); - /* - * RTX - */ - void SetRTXStatus(const bool enable, - const bool setSSRC, + // RTX. + void SetRTXStatus(const bool enable, const bool set_ssrc, const WebRtc_UWord32 SSRC); - void RTXStatus(bool* enable, WebRtc_UWord32* SSRC) const; + void RTXStatus(bool *enable, WebRtc_UWord32 *SSRC) const; - /* - * Functions wrapping RTPSenderInterface - */ - virtual WebRtc_Word32 BuildRTPheader(WebRtc_UWord8* dataBuffer, - const WebRtc_Word8 payloadType, - const bool markerBit, - const WebRtc_UWord32 captureTimeStamp, - const bool timeStampProvided = true, - const bool incSequenceNumber = true); + // 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, + const bool time_stamp_provided = true, + const bool inc_sequence_number = true); - virtual WebRtc_UWord16 RTPHeaderLength() const ; + virtual WebRtc_UWord16 RTPHeaderLength() const; virtual WebRtc_UWord16 IncrementSequenceNumber(); virtual WebRtc_UWord16 MaxPayloadLength() const; virtual WebRtc_UWord16 PacketOverHead() const; - // current timestamp + // Current timestamp. virtual WebRtc_UWord32 Timestamp() const; virtual WebRtc_UWord32 SSRC() const; - virtual WebRtc_Word32 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) + virtual WebRtc_Word32 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); - bool SendTelephoneEventActive(WebRtc_Word8& telephoneEvent) const; + bool SendTelephoneEventActive(WebRtc_Word8 *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 packetSizeSamples); + // packet in silence (CNG). + WebRtc_Word32 SetAudioPacketSize(const WebRtc_UWord16 packet_size_samples); // Set status and ID for header-extension-for-audio-level-indication. WebRtc_Word32 SetAudioLevelIndicationStatus(const bool enable, const WebRtc_UWord8 ID); // Get status and ID for header-extension-for-audio-level-indication. - WebRtc_Word32 AudioLevelIndicationStatus(bool& enable, - WebRtc_UWord8& ID) const; + WebRtc_Word32 AudioLevelIndicationStatus(bool *enable, + WebRtc_UWord8 *id) const; - // Store the audio level in dBov for + // Store the audio level in d_bov for // header-extension-for-audio-level-indication. - WebRtc_Word32 SetAudioLevel(const WebRtc_UWord8 level_dBov); + WebRtc_Word32 SetAudioLevel(const WebRtc_UWord8 level_d_bov); - // Set payload type for Redundant Audio Data RFC 2198 - WebRtc_Word32 SetRED(const WebRtc_Word8 payloadType); + // Set payload type for Redundant Audio Data RFC 2198. + WebRtc_Word32 SetRED(const WebRtc_Word8 payload_type); - // Get payload type for Redundant Audio Data RFC 2198 - WebRtc_Word32 RED(WebRtc_Word8& payloadType) const; + // Get payload type for Redundant Audio Data RFC 2198. + WebRtc_Word32 RED(WebRtc_Word8 *payload_type) const; - /* - * Video - */ - VideoCodecInformation* CodecInformationVideo(); + // Video. + VideoCodecInformation *CodecInformationVideo(); RtpVideoCodecTypes VideoCodecType() const; @@ -266,81 +242,78 @@ class RTPSender : public Bitrate, public RTPSenderInterface { WebRtc_Word32 SendRTPIntraRequest(); - // FEC + // FEC. WebRtc_Word32 SetGenericFECStatus(const bool enable, - const WebRtc_UWord8 payloadTypeRED, - const WebRtc_UWord8 payloadTypeFEC); + const WebRtc_UWord8 payload_type_red, + const WebRtc_UWord8 payload_type_fec); - WebRtc_Word32 GenericFECStatus(bool& enable, - WebRtc_UWord8& payloadTypeRED, - WebRtc_UWord8& payloadTypeFEC) const; + WebRtc_Word32 GenericFECStatus(bool *enable, WebRtc_UWord8 *payload_type_red, + WebRtc_UWord8 *payload_type_fec) const; - WebRtc_Word32 SetFecParameters( - const FecProtectionParams* delta_params, - const FecProtectionParams* key_params); + WebRtc_Word32 SetFecParameters(const FecProtectionParams *delta_params, + const FecProtectionParams *key_params); protected: - WebRtc_Word32 CheckPayloadType(const WebRtc_Word8 payloadType, - RtpVideoCodecTypes& videoType); + WebRtc_Word32 CheckPayloadType(const WebRtc_Word8 payload_type, + RtpVideoCodecTypes *video_type); private: - void UpdateNACKBitRate(const WebRtc_UWord32 bytes, - const WebRtc_UWord32 now); + void UpdateNACKBitRate(const WebRtc_UWord32 bytes, const WebRtc_UWord32 now); - WebRtc_Word32 SendPaddingAccordingToBitrate( - WebRtc_Word8 payload_type, - WebRtc_UWord32 capture_timestamp, - int64_t capture_time_ms); + WebRtc_Word32 SendPaddingAccordingToBitrate(WebRtc_Word8 payload_type, + WebRtc_UWord32 capture_timestamp, + int64_t capture_time_ms); - WebRtc_Word32 _id; - const bool _audioConfigured; - RTPSenderAudio* _audio; - RTPSenderVideo* _video; + WebRtc_Word32 id_; + const bool audio_configured_; + RTPSenderAudio *audio_; + RTPSenderVideo *video_; - PacedSender* paced_sender_; - CriticalSectionWrapper* _sendCritsect; + PacedSender *paced_sender_; + CriticalSectionWrapper *send_critsect_; - Transport* _transport; - bool _sendingMedia; + Transport *transport_; + bool sending_media_; - WebRtc_UWord16 _maxPayloadLength; - WebRtc_UWord16 _targetSendBitrate; - WebRtc_UWord16 _packetOverHead; + WebRtc_UWord16 max_payload_length_; + WebRtc_UWord16 target_send_bitrate_; + WebRtc_UWord16 packet_over_head_; - WebRtc_Word8 _payloadType; - std::map _payloadTypeMap; + WebRtc_Word8 payload_type_; + std::map payload_type_map_; - RtpHeaderExtensionMap _rtpHeaderExtensionMap; - WebRtc_Word32 _transmissionTimeOffset; + RtpHeaderExtensionMap rtp_header_extension_map_; + WebRtc_Word32 transmission_time_offset_; // NACK - WebRtc_UWord32 _nackByteCountTimes[NACK_BYTECOUNT_SIZE]; - WebRtc_Word32 _nackByteCount[NACK_BYTECOUNT_SIZE]; - Bitrate _nackBitrate; + WebRtc_UWord32 nack_byte_count_times_[NACK_BYTECOUNT_SIZE]; + WebRtc_Word32 nack_byte_count_[NACK_BYTECOUNT_SIZE]; + Bitrate nack_bitrate_; - RTPPacketHistory* _packetHistory; + RTPPacketHistory *packet_history_; // Statistics - WebRtc_UWord32 _packetsSent; - WebRtc_UWord32 _payloadBytesSent; + WebRtc_UWord32 packets_sent_; + WebRtc_UWord32 payload_bytes_sent_; // RTP variables - bool _startTimeStampForced; - WebRtc_UWord32 _startTimeStamp; - SSRCDatabase& _ssrcDB; - WebRtc_UWord32 _remoteSSRC; - bool _sequenceNumberForced; - WebRtc_UWord16 _sequenceNumber; - WebRtc_UWord16 _sequenceNumberRTX; - bool _ssrcForced; - WebRtc_UWord32 _ssrc; - WebRtc_UWord32 _timeStamp; - WebRtc_UWord8 _CSRCs; - WebRtc_UWord32 _CSRC[kRtpCsrcSize]; - bool _includeCSRCs; - bool _RTX; - WebRtc_UWord32 _ssrcRTX; + bool start_time_stamp_forced_; + WebRtc_UWord32 start_time_stamp_; + SSRCDatabase &ssrc_db_; + WebRtc_UWord32 remote_ssrc_; + bool sequence_number_forced_; + WebRtc_UWord16 sequence_number_; + WebRtc_UWord16 sequence_number_rtx_; + bool ssrc_forced_; + WebRtc_UWord32 ssrc_; + WebRtc_UWord32 time_stamp_; + WebRtc_UWord8 csrcs_; + WebRtc_UWord32 csrc_[kRtpCsrcSize]; + bool include_csrcs_; + bool rtx_; + WebRtc_UWord32 ssrc_rtx_; }; -} // namespace webrtc -#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_ +} // namespace webrtc + +#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_