From 26f8d9c7f3865b9f94ea83d8b67b2ebee1d93f7d Mon Sep 17 00:00:00 2001 From: "pwestin@webrtc.org" Date: Thu, 19 Jan 2012 15:53:09 +0000 Subject: [PATCH] Removed list and map wrappers, for RTCP handling. Review URL: https://webrtc-codereview.appspot.com/349011 git-svn-id: http://webrtc.googlecode.com/svn/trunk@1473 4adac7df-926f-26a2-2b94-8c16560cd09d --- src/modules/rtp_rtcp/source/rtcp_receiver.cc | 519 ++++++++--------- src/modules/rtp_rtcp/source/rtcp_receiver.h | 49 +- src/modules/rtp_rtcp/source/rtcp_sender.cc | 574 +++++++++---------- src/modules/rtp_rtcp/source/rtcp_sender.h | 14 +- 4 files changed, 522 insertions(+), 634 deletions(-) diff --git a/src/modules/rtp_rtcp/source/rtcp_receiver.cc b/src/modules/rtp_rtcp/source/rtcp_receiver.cc index 7306567448..468d16b61d 100644 --- a/src/modules/rtp_rtcp/source/rtcp_receiver.cc +++ b/src/modules/rtp_rtcp/source/rtcp_receiver.cc @@ -52,66 +52,30 @@ RTCPReceiver::RTCPReceiver(const WebRtc_Word32 id, WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id, "%s created", __FUNCTION__); } -RTCPReceiver::~RTCPReceiver() -{ - delete _criticalSectionRTCPReceiver; - delete _criticalSectionFeedbacks; +RTCPReceiver::~RTCPReceiver() { + delete _criticalSectionRTCPReceiver; + delete _criticalSectionFeedbacks; - bool loop = true; - do - { - MapItem* item = _receivedReportBlockMap.First(); - if(item) - { - // delete - RTCPReportBlockInformation* block= ((RTCPReportBlockInformation*)item->GetItem()); - delete block; - - // remove from map and delete Item - _receivedReportBlockMap.Erase(item); - } else - { - loop = false; - } - } while (loop); - - loop = true; - do - { - MapItem* item = _receivedInfoMap.First(); - if(item) - { - // delete - RTCPReceiveInformation* block= ((RTCPReceiveInformation*)item->GetItem()); - delete block; - - // remove from map and delete Item - _receivedInfoMap.Erase(item); - } else - { - loop = false; - } - } while (loop); - - loop = true; - do - { - MapItem* item = _receivedCnameMap.First(); - if(item) - { - // delete - RTCPCnameInformation* block= ((RTCPCnameInformation*)item->GetItem()); - delete block; - - // remove from map and delete Item - _receivedCnameMap.Erase(item); - } else - { - loop = false; - } - } while (loop); - - WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, "%s deleted", __FUNCTION__); + while (!_receivedReportBlockMap.empty()) { + std::map::iterator first = + _receivedReportBlockMap.begin(); + delete first->second; + _receivedReportBlockMap.erase(first); + } + while (!_receivedInfoMap.empty()) { + std::map::iterator first = + _receivedInfoMap.begin(); + delete first->second; + _receivedInfoMap.erase(first); + } + while (!_receivedCnameMap.empty()) { + std::map::iterator first = + _receivedCnameMap.begin(); + delete first->second; + _receivedCnameMap.erase(first); + } + WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, + "%s deleted", __FUNCTION__); } void @@ -285,21 +249,15 @@ RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const // we can get multiple receive reports when we receive the report from a CE WebRtc_Word32 RTCPReceiver::StatisticsReceived( std::vector* receiveBlocks) const { - if (receiveBlocks == NULL) { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", - __FUNCTION__); - return -1; - } + assert(receiveBlocks); CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - MapItem* ptrReportBlockInfoItem = _receivedReportBlockMap.First(); - while (ptrReportBlockInfoItem != NULL) { - RTCPReportBlockInformation* item = - static_cast ( - ptrReportBlockInfoItem->GetItem()); - receiveBlocks->push_back(item->remoteReceiveBlock); - ptrReportBlockInfoItem = - _receivedReportBlockMap.Next(ptrReportBlockInfoItem); + std::map::const_iterator it = + _receivedReportBlockMap.begin(); + + while (it != _receivedReportBlockMap.end()) { + receiveBlocks->push_back(it->second->remoteReceiveBlock); + it++; } return 0; } @@ -566,190 +524,174 @@ RTCPReceiver::HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket, } RTCPReportBlockInformation* -RTCPReceiver::CreateReportBlockInformation(WebRtc_UWord32 remoteSSRC) -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +RTCPReceiver::CreateReportBlockInformation(WebRtc_UWord32 remoteSSRC) { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - RTCPReportBlockInformation* ptrReportBlockInfo = NULL; - MapItem* ptrReportBlockInfoItem = _receivedReportBlockMap.Find(remoteSSRC); - if (ptrReportBlockInfoItem == NULL) - { - ptrReportBlockInfo = new RTCPReportBlockInformation; - _receivedReportBlockMap.Insert(remoteSSRC, ptrReportBlockInfo); - } else - { - ptrReportBlockInfo = static_cast(ptrReportBlockInfoItem->GetItem()); - } - return ptrReportBlockInfo; + std::map::iterator it = + _receivedReportBlockMap.find(remoteSSRC); + RTCPReportBlockInformation* ptrReportBlockInfo = NULL; + if (it != _receivedReportBlockMap.end()) { + ptrReportBlockInfo = it->second; + } else { + ptrReportBlockInfo = new RTCPReportBlockInformation; + _receivedReportBlockMap[remoteSSRC] = ptrReportBlockInfo; + } + return ptrReportBlockInfo; } RTCPReportBlockInformation* -RTCPReceiver::GetReportBlockInformation(WebRtc_UWord32 remoteSSRC) const -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +RTCPReceiver::GetReportBlockInformation(WebRtc_UWord32 remoteSSRC) const { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - MapItem* ptrReportBlockInfoItem = _receivedReportBlockMap.Find(remoteSSRC); - if (ptrReportBlockInfoItem == NULL) - { - return NULL; - } - return static_cast(ptrReportBlockInfoItem->GetItem()); + std::map::const_iterator it = + _receivedReportBlockMap.find(remoteSSRC); + + if (it == _receivedReportBlockMap.end()) { + return NULL; + } + return it->second; } RTCPCnameInformation* -RTCPReceiver::CreateCnameInformation(WebRtc_UWord32 remoteSSRC) -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +RTCPReceiver::CreateCnameInformation(WebRtc_UWord32 remoteSSRC) { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - RTCPCnameInformation* ptrCnameInfo = NULL; - MapItem* ptrCnameInfoItem = _receivedCnameMap.Find(remoteSSRC); - if (ptrCnameInfoItem == NULL) - { - ptrCnameInfo = new RTCPCnameInformation; - _receivedCnameMap.Insert(remoteSSRC, ptrCnameInfo); - } else - { - ptrCnameInfo = static_cast(ptrCnameInfoItem->GetItem()); - } - return ptrCnameInfo; + std::map::iterator it = + _receivedCnameMap.find(remoteSSRC); + + if (it != _receivedCnameMap.end()) { + return it->second; + } + RTCPCnameInformation* cnameInfo = new RTCPCnameInformation; + _receivedCnameMap[remoteSSRC] = cnameInfo; + return cnameInfo; } RTCPCnameInformation* -RTCPReceiver::GetCnameInformation(WebRtc_UWord32 remoteSSRC) const -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +RTCPReceiver::GetCnameInformation(WebRtc_UWord32 remoteSSRC) const { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - MapItem* ptrCnameInfoItem = _receivedCnameMap.Find(remoteSSRC); - if (ptrCnameInfoItem == NULL) - { - return NULL; - } - return static_cast(ptrCnameInfoItem->GetItem()); + std::map::const_iterator it = + _receivedCnameMap.find(remoteSSRC); + + if (it == _receivedCnameMap.end()) { + return NULL; + } + return it->second; } RTCPReceiveInformation* -RTCPReceiver::CreateReceiveInformation(WebRtc_UWord32 remoteSSRC) -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +RTCPReceiver::CreateReceiveInformation(WebRtc_UWord32 remoteSSRC) { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - RTCPReceiveInformation* ptrReceiveInfo = NULL; - MapItem* ptrReceiveInfoItem = _receivedInfoMap.Find(remoteSSRC); - if (ptrReceiveInfoItem == NULL) - { - ptrReceiveInfo = new RTCPReceiveInformation; - _receivedInfoMap.Insert(remoteSSRC, ptrReceiveInfo); - } else - { - ptrReceiveInfo = static_cast(ptrReceiveInfoItem->GetItem()); - } - return ptrReceiveInfo; + std::map::iterator it = + _receivedInfoMap.find(remoteSSRC); + + if (it != _receivedInfoMap.end()) { + return it->second; + } + RTCPReceiveInformation* receiveInfo = new RTCPReceiveInformation; + _receivedInfoMap[remoteSSRC] = receiveInfo; + return receiveInfo; } RTCPReceiveInformation* -RTCPReceiver::GetReceiveInformation(WebRtc_UWord32 remoteSSRC) -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +RTCPReceiver::GetReceiveInformation(WebRtc_UWord32 remoteSSRC) { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - MapItem* ptrReceiveInfoItem = _receivedInfoMap.Find(remoteSSRC); - if (ptrReceiveInfoItem == NULL) - { - return NULL; - } - return static_cast(ptrReceiveInfoItem->GetItem()); + std::map::iterator it = + _receivedInfoMap.find(remoteSSRC); + if (it == _receivedInfoMap.end()) { + return NULL; + } + return it->second; } -void -RTCPReceiver::UpdateReceiveInformation( RTCPReceiveInformation& receiveInformation) -{ - // Update that this remote is alive - receiveInformation.lastTimeReceived = _clock.GetTimeInMS(); +void RTCPReceiver::UpdateReceiveInformation( + RTCPReceiveInformation& receiveInformation) { + // Update that this remote is alive + receiveInformation.lastTimeReceived = _clock.GetTimeInMS(); } -bool -RTCPReceiver::UpdateRTCPReceiveInformationTimers() -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - bool updateBoundingSet = false; - WebRtc_UWord32 timeNow = _clock.GetTimeInMS(); - MapItem* receiveInfoItem=_receivedInfoMap.First(); + bool updateBoundingSet = false; + WebRtc_UWord32 timeNow = _clock.GetTimeInMS(); - while(receiveInfoItem) - { - RTCPReceiveInformation* receiveInfo = (RTCPReceiveInformation*)receiveInfoItem->GetItem(); - if(receiveInfo == NULL) - { - return updateBoundingSet; - } - // time since last received rtcp packet - // when we dont have a lastTimeReceived and the object is marked readyForDelete - // it's removed from the map - if( receiveInfo->lastTimeReceived) - { - if((timeNow - receiveInfo->lastTimeReceived) > 5*RTCP_INTERVAL_AUDIO_MS) // use audio define since we don't know what interval the remote peer is using - { - // no rtcp packet for the last five regular intervals, reset limitations - receiveInfo->TmmbrSet.lengthOfSet = 0; - receiveInfo->lastTimeReceived = 0; // prevent that we call this over and over again - updateBoundingSet = true; // send new TMMBN to all channels using the default codec - } - receiveInfoItem = _receivedInfoMap.Next(receiveInfoItem); - }else - { - if(receiveInfo->readyForDelete) - { - // store our current receiveInfoItem - MapItem* receiveInfoItemToBeErased = receiveInfoItem; - - // iterate - receiveInfoItem = _receivedInfoMap.Next(receiveInfoItem); - - // delete current - delete receiveInfo; - _receivedInfoMap.Erase(receiveInfoItemToBeErased); - }else - { - receiveInfoItem = _receivedInfoMap.Next(receiveInfoItem); - } - } + std::map::iterator receiveInfoIt = + _receivedInfoMap.begin(); + while (receiveInfoIt != _receivedInfoMap.end()) { + RTCPReceiveInformation* receiveInfo = receiveInfoIt->second; + if (receiveInfo == NULL) { + return updateBoundingSet; } - return updateBoundingSet; + // time since last received rtcp packet + // when we dont have a lastTimeReceived and the object is marked + // readyForDelete it's removed from the map + if (receiveInfo->lastTimeReceived) { + /// use audio define since we don't know what interval the remote peer is + // using + if ((timeNow - receiveInfo->lastTimeReceived) > + 5 * RTCP_INTERVAL_AUDIO_MS) { + // no rtcp packet for the last five regular intervals, reset limitations + receiveInfo->TmmbrSet.lengthOfSet = 0; + // prevent that we call this over and over again + receiveInfo->lastTimeReceived = 0; + // send new TMMBN to all channels using the default codec + updateBoundingSet = true; + } + receiveInfoIt++; + } else if (receiveInfo->readyForDelete) { + // store our current receiveInfoItem + std::map::iterator + receiveInfoItemToBeErased = receiveInfoIt; + receiveInfoIt++; + delete receiveInfoItemToBeErased->second; + _receivedInfoMap.erase(receiveInfoItemToBeErased); + } else { + receiveInfoIt++; + } + } + return updateBoundingSet; } -WebRtc_Word32 -RTCPReceiver::BoundingSet(bool &tmmbrOwner, TMMBRSet*& boundingSetRec) -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +WebRtc_Word32 RTCPReceiver::BoundingSet(bool &tmmbrOwner, + TMMBRSet*& boundingSetRec) { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - MapItem* receiveInfoItem=_receivedInfoMap.Find(_remoteSSRC); - if(receiveInfoItem ) - { - RTCPReceiveInformation* receiveInfo = (RTCPReceiveInformation*)receiveInfoItem->GetItem(); - if(receiveInfo == NULL) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s failed to get RTCPReceiveInformation", __FUNCTION__); - return -1; - } - if(receiveInfo->TmmbnBoundingSet.lengthOfSet > 0) - { - boundingSetRec->VerifyAndAllocateSet(receiveInfo->TmmbnBoundingSet.lengthOfSet + 1); - for(WebRtc_UWord32 i=0; i< receiveInfo->TmmbnBoundingSet.lengthOfSet; i++) - { - if(receiveInfo->TmmbnBoundingSet.ptrSsrcSet[i] == _SSRC) - { - // owner of bounding set - tmmbrOwner = true; - } - boundingSetRec->ptrTmmbrSet[i] = receiveInfo->TmmbnBoundingSet.ptrTmmbrSet[i]; - boundingSetRec->ptrPacketOHSet[i] = receiveInfo->TmmbnBoundingSet.ptrPacketOHSet[i]; - boundingSetRec->ptrSsrcSet[i] = receiveInfo->TmmbnBoundingSet.ptrSsrcSet[i]; - } - return receiveInfo->TmmbnBoundingSet.lengthOfSet; - } - } + std::map::iterator receiveInfoIt = + _receivedInfoMap.find(_remoteSSRC); + + if (receiveInfoIt == _receivedInfoMap.end()) { return -1; + } + RTCPReceiveInformation* receiveInfo = receiveInfoIt->second; + if (receiveInfo == NULL) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s failed to get RTCPReceiveInformation", + __FUNCTION__); + return -1; + } + if (receiveInfo->TmmbnBoundingSet.lengthOfSet > 0) { + boundingSetRec->VerifyAndAllocateSet( + receiveInfo->TmmbnBoundingSet.lengthOfSet + 1); + for(WebRtc_UWord32 i=0; i< receiveInfo->TmmbnBoundingSet.lengthOfSet; i++) { + if(receiveInfo->TmmbnBoundingSet.ptrSsrcSet[i] == _SSRC) { + // owner of bounding set + tmmbrOwner = true; + } + boundingSetRec->ptrTmmbrSet[i] = + receiveInfo->TmmbnBoundingSet.ptrTmmbrSet[i]; + boundingSetRec->ptrPacketOHSet[i] = + receiveInfo->TmmbnBoundingSet.ptrPacketOHSet[i]; + boundingSetRec->ptrSsrcSet[i] = + receiveInfo->TmmbnBoundingSet.ptrSsrcSet[i]; + } + } + return receiveInfo->TmmbnBoundingSet.lengthOfSet; } // no need for critsect we have _criticalSectionRTCPReceiver @@ -833,34 +775,35 @@ RTCPReceiver::HandleNACKItem(const RTCPUtility::RTCPPacket& rtcpPacket, } // no need for critsect we have _criticalSectionRTCPReceiver -void -RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) -{ - const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); +void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) { + const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); - // clear our lists - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); + // clear our lists + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); + std::map::iterator + reportBlockInfoIt = _receivedReportBlockMap.find( + rtcpPacket.BYE.SenderSSRC); - MapItem* ptrReportBlockInfoItem = _receivedReportBlockMap.Find(rtcpPacket.BYE.SenderSSRC); - if (ptrReportBlockInfoItem != NULL) - { - delete static_cast(ptrReportBlockInfoItem->GetItem()); - _receivedReportBlockMap.Erase(ptrReportBlockInfoItem); - } - // we can't delete it due to TMMBR - MapItem* ptrReceiveInfoItem = _receivedInfoMap.Find(rtcpPacket.BYE.SenderSSRC); - if (ptrReceiveInfoItem != NULL) - { - static_cast(ptrReceiveInfoItem->GetItem())->readyForDelete = true; - } + if (reportBlockInfoIt != _receivedReportBlockMap.end()) { + delete reportBlockInfoIt->second; + _receivedReportBlockMap.erase(reportBlockInfoIt); + } + // we can't delete it due to TMMBR + std::map::iterator receiveInfoIt = + _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC); - MapItem* ptrCnameInfoItem = _receivedCnameMap.Find(rtcpPacket.BYE.SenderSSRC); - if (ptrCnameInfoItem != NULL) - { - delete static_cast(ptrCnameInfoItem->GetItem()); - _receivedCnameMap.Erase(ptrCnameInfoItem); - } - rtcpParser.Iterate(); + if (receiveInfoIt != _receivedInfoMap.end()) { + receiveInfoIt->second->readyForDelete = true; + } + + std::map::iterator cnameInfoIt = + _receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC); + + if (cnameInfoIt != _receivedCnameMap.end()) { + delete cnameInfoIt->second; + _receivedCnameMap.erase(cnameInfoIt); + } + rtcpParser.Iterate(); } // no need for critsect we have _criticalSectionRTCPReceiver @@ -1464,54 +1407,46 @@ 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 -{ - CriticalSectionScoped lock(_criticalSectionRTCPReceiver); +WebRtc_Word32 RTCPReceiver::TMMBRReceived(const WebRtc_UWord32 size, + const WebRtc_UWord32 accNumCandidates, + TMMBRSet* candidateSet) const { + CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - MapItem* receiveInfoItem=_receivedInfoMap.First(); - if(receiveInfoItem == NULL) - { + std::map::const_iterator + receiveInfoIt = _receivedInfoMap.begin(); + if (receiveInfoIt == _receivedInfoMap.end()) { + return -1; + } + WebRtc_UWord32 num = accNumCandidates; + if (candidateSet) { + while( num < size && receiveInfoIt != _receivedInfoMap.end()) { + RTCPReceiveInformation* receiveInfo = receiveInfoIt->second; + if (receiveInfo == NULL) { + return 0; + } + for (WebRtc_UWord32 i = 0; + (num < size) && (i < receiveInfo->TmmbrSet.lengthOfSet); i++) { + if (receiveInfo->GetTMMBRSet(i, num, candidateSet, + _clock.GetTimeInMS()) == 0) { + num++; + } + } + receiveInfoIt++; + } + } else { + while (receiveInfoIt != _receivedInfoMap.end()) { + RTCPReceiveInformation* receiveInfo = receiveInfoIt->second; + if(receiveInfo == NULL) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s failed to get RTCPReceiveInformation", + __FUNCTION__); return -1; + } + num += receiveInfo->TmmbrSet.lengthOfSet; + receiveInfoIt++; } - WebRtc_UWord32 num = accNumCandidates; - if(candidateSet) - { - while( num < size && receiveInfoItem) - { - RTCPReceiveInformation* receiveInfo = (RTCPReceiveInformation*)receiveInfoItem->GetItem(); - if(receiveInfo == NULL) - { - return 0; - } - for (WebRtc_UWord32 i = 0; (num < size) && (i < receiveInfo->TmmbrSet.lengthOfSet); i++) - { - if(receiveInfo->GetTMMBRSet(i, num, candidateSet, - _clock.GetTimeInMS()) == 0) - { - num++; - } - } - receiveInfoItem = _receivedInfoMap.Next(receiveInfoItem); - } - } else - { - while(receiveInfoItem) - { - RTCPReceiveInformation* receiveInfo = (RTCPReceiveInformation*)receiveInfoItem->GetItem(); - if(receiveInfo == NULL) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s failed to get RTCPReceiveInformation", __FUNCTION__); - return -1; - } - num += receiveInfo->TmmbrSet.lengthOfSet; - - receiveInfoItem = _receivedInfoMap.Next(receiveInfoItem); - } - } - return num; + } + return num; } WebRtc_Word32 diff --git a/src/modules/rtp_rtcp/source/rtcp_receiver.h b/src/modules/rtp_rtcp/source/rtcp_receiver.h index 8b856f00d2..738b030912 100644 --- a/src/modules/rtp_rtcp/source/rtcp_receiver.h +++ b/src/modules/rtp_rtcp/source/rtcp_receiver.h @@ -11,10 +11,10 @@ #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_ #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_ +#include #include #include "typedefs.h" -#include "map_wrapper.h" #include "rtp_utility.h" #include "rtcp_utility.h" #include "rtp_rtcp_defines.h" @@ -189,33 +189,36 @@ protected: void HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser, RTCPHelp::RTCPPacketInformation& rtcpPacketInformation); -private: - WebRtc_Word32 _id; - RtpRtcpClock& _clock; - RTCPMethod _method; - WebRtc_UWord32 _lastReceived; - ModuleRtpRtcpImpl& _rtpRtcp; + private: + WebRtc_Word32 _id; + RtpRtcpClock& _clock; + RTCPMethod _method; + WebRtc_UWord32 _lastReceived; + ModuleRtpRtcpImpl& _rtpRtcp; - CriticalSectionWrapper* _criticalSectionFeedbacks; - RtcpFeedback* _cbRtcpFeedback; - RtpVideoFeedback* _cbVideoFeedback; + CriticalSectionWrapper* _criticalSectionFeedbacks; + RtcpFeedback* _cbRtcpFeedback; + RtpVideoFeedback* _cbVideoFeedback; - CriticalSectionWrapper* _criticalSectionRTCPReceiver; - WebRtc_UWord32 _SSRC; - WebRtc_UWord32 _remoteSSRC; + CriticalSectionWrapper* _criticalSectionRTCPReceiver; + WebRtc_UWord32 _SSRC; + WebRtc_UWord32 _remoteSSRC; - // Received send report - RTCPSenderInfo _remoteSenderInfo; - WebRtc_UWord32 _lastReceivedSRNTPsecs; // when did we receive the last send report - WebRtc_UWord32 _lastReceivedSRNTPfrac; + // Received send report + RTCPSenderInfo _remoteSenderInfo; + // when did we receive the last send report + WebRtc_UWord32 _lastReceivedSRNTPsecs; + WebRtc_UWord32 _lastReceivedSRNTPfrac; - // Received report block - MapWrapper _receivedReportBlockMap; // pair SSRC to report block - MapWrapper _receivedInfoMap; // pair SSRC of sender to might not be a SSRC that have any data (i.e. a conference) - MapWrapper _receivedCnameMap; // pair SSRC to Cname + // Received report blocks. + std::map + _receivedReportBlockMap; + std::map + _receivedInfoMap; + std::map + _receivedCnameMap; - // timeout - WebRtc_UWord32 _packetTimeOutMS; + WebRtc_UWord32 _packetTimeOutMS; }; } // namespace webrtc #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_ diff --git a/src/modules/rtp_rtcp/source/rtcp_sender.cc b/src/modules/rtp_rtcp/source/rtcp_sender.cc index 750dd65579..f8ad39f282 100644 --- a/src/modules/rtp_rtcp/source/rtcp_sender.cc +++ b/src/modules/rtp_rtcp/source/rtcp_sender.cc @@ -9,7 +9,6 @@ */ #include "rtcp_sender.h" -#include "rtcp_utility.h" #include // memcpy #include // assert @@ -22,6 +21,9 @@ #include "rtp_rtcp_impl.h" namespace webrtc { + +using RTCPUtility::RTCPCnameInformation; + RTCPSender::RTCPSender(const WebRtc_Word32 id, const bool audio, RtpRtcpClock* clock, @@ -87,37 +89,26 @@ RTCPSender::RTCPSender(const WebRtc_Word32 id, WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id, "%s created", __FUNCTION__); } -RTCPSender::~RTCPSender() -{ - delete [] _rembSSRC; - delete [] _appData; +RTCPSender::~RTCPSender() { + delete [] _rembSSRC; + delete [] _appData; - MapItem* item = _reportBlocks.First(); - while(item) - { - RTCPReportBlock* ptr = (RTCPReportBlock*)(item->GetItem()); - if(ptr) - { - delete ptr; - } - _reportBlocks.Erase(item); - item = _reportBlocks.First(); - } - item = _csrcCNAMEs.First(); - while(item) - { - RTCPUtility::RTCPCnameInformation* ptr = (RTCPUtility::RTCPCnameInformation*)(item->GetItem()); - if(ptr) - { - delete ptr; - } - _csrcCNAMEs.Erase(item); - item = _csrcCNAMEs.First(); - } - delete _criticalSectionTransport; - delete _criticalSectionRTCPSender; + while (!_reportBlocks.empty()) { + std::map::iterator it = + _reportBlocks.begin(); + delete it->second; + _reportBlocks.erase(it); + } + while (!_csrcCNAMEs.empty()) { + std::map::iterator it = + _csrcCNAMEs.begin(); + delete it->second; + _csrcCNAMEs.erase(it); + } + delete _criticalSectionTransport; + delete _criticalSectionRTCPSender; - WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, "%s deleted", __FUNCTION__); + WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, "%s deleted", __FUNCTION__); } WebRtc_Word32 @@ -367,71 +358,50 @@ RTCPSender::CNAME(WebRtc_Word8 cName[RTCP_CNAME_SIZE]) return 0; } -WebRtc_Word32 -RTCPSender::SetCNAME(const WebRtc_Word8 cName[RTCP_CNAME_SIZE]) -{ - if(cName == NULL) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__); - return -1; - } - WebRtc_Word32 length = (WebRtc_Word32)strlen(cName); - if(length > RTCP_CNAME_SIZE) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument, too long cName", __FUNCTION__); - return -1; - } - CriticalSectionScoped lock(_criticalSectionRTCPSender); - - memcpy(_CNAME, cName, length+1); - return 0; -} - -WebRtc_Word32 -RTCPSender::AddMixedCNAME(const WebRtc_UWord32 SSRC, - const WebRtc_Word8 cName[RTCP_CNAME_SIZE]) -{ - if(cName == NULL) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__); - return -1; - } - WebRtc_Word32 length = (WebRtc_Word32)strlen(cName); - if(length > RTCP_CNAME_SIZE) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument, too long cName", __FUNCTION__); - return -1; - } - - CriticalSectionScoped lock(_criticalSectionRTCPSender); - if(_csrcCNAMEs.Size() == kRtpCsrcSize) - { - return -1; - } - RTCPUtility::RTCPCnameInformation* ptr= new RTCPUtility::RTCPCnameInformation(); - - memcpy(ptr->name, cName, length+1); - ptr->length = (WebRtc_UWord8)length; - _csrcCNAMEs.Insert(SSRC, ptr); - return 0; -} - -WebRtc_Word32 -RTCPSender::RemoveMixedCNAME(const WebRtc_UWord32 SSRC) -{ - CriticalSectionScoped lock(_criticalSectionRTCPSender); - MapItem* item= _csrcCNAMEs.Find(SSRC); - if(item) - { - RTCPUtility::RTCPCnameInformation* ptr= (RTCPUtility::RTCPCnameInformation*)(item->GetItem()); - if(ptr) - { - delete ptr; - } - _csrcCNAMEs.Erase(item); - return 0; - } +WebRtc_Word32 RTCPSender::SetCNAME(const WebRtc_Word8 cName[RTCP_CNAME_SIZE]) { + size_t length = strlen(cName); + if (length >= RTCP_CNAME_SIZE) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s invalid argument, too long cName", __FUNCTION__); return -1; + } + CriticalSectionScoped lock(_criticalSectionRTCPSender); + memcpy(_CNAME, cName, length + 1); + return 0; +} + +WebRtc_Word32 RTCPSender::AddMixedCNAME( + const WebRtc_UWord32 SSRC, + const WebRtc_Word8 cName[RTCP_CNAME_SIZE]) { + size_t length = strlen(cName); + if (length >= RTCP_CNAME_SIZE) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s invalid argument, too long cName", __FUNCTION__); + return -1; + } + CriticalSectionScoped lock(_criticalSectionRTCPSender); + if (_csrcCNAMEs.size() >= kRtpCsrcSize) { + return -1; + } + RTCPCnameInformation* ptr = new RTCPCnameInformation(); + memcpy(ptr->name, cName, length + 1); + ptr->length = static_cast(length); + _csrcCNAMEs[SSRC] = ptr; + return 0; +} + +WebRtc_Word32 RTCPSender::RemoveMixedCNAME(const WebRtc_UWord32 SSRC) { + CriticalSectionScoped lock(_criticalSectionRTCPSender); + + std::map::iterator it = + _csrcCNAMEs.find(SSRC); + + if (it == _csrcCNAMEs.end()) { + return -1; + } + delete it->second; + _csrcCNAMEs.erase(it); + return 0; } bool @@ -553,46 +523,38 @@ RTCPSender::SendTimeOfSendReport(const WebRtc_UWord32 sendReport) return 0; } -WebRtc_Word32 -RTCPSender::AddReportBlock(const WebRtc_UWord32 SSRC, - const RTCPReportBlock* reportBlock) -{ - if(reportBlock == NULL) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__); - return -1; - } +WebRtc_Word32 RTCPSender::AddReportBlock(const WebRtc_UWord32 SSRC, + const RTCPReportBlock* reportBlock) { + if (reportBlock == NULL) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s invalid argument", __FUNCTION__); + return -1; + } + CriticalSectionScoped lock(_criticalSectionRTCPSender); - CriticalSectionScoped lock(_criticalSectionRTCPSender); - - if(_reportBlocks.Size() >= RTCP_MAX_REPORT_BLOCKS) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__); - return -1; - } - RTCPReportBlock* copyReportBlock = new RTCPReportBlock(); - memcpy(copyReportBlock, reportBlock, sizeof(RTCPReportBlock)); - _reportBlocks.Insert(SSRC, copyReportBlock); - return 0; + if (_reportBlocks.size() >= RTCP_MAX_REPORT_BLOCKS) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s invalid argument", __FUNCTION__); + return -1; + } + RTCPReportBlock* copyReportBlock = new RTCPReportBlock(); + memcpy(copyReportBlock, reportBlock, sizeof(RTCPReportBlock)); + _reportBlocks[SSRC] = copyReportBlock; + return 0; } -WebRtc_Word32 -RTCPSender::RemoveReportBlock(const WebRtc_UWord32 SSRC) -{ - CriticalSectionScoped lock(_criticalSectionRTCPSender); +WebRtc_Word32 RTCPSender::RemoveReportBlock(const WebRtc_UWord32 SSRC) { + CriticalSectionScoped lock(_criticalSectionRTCPSender); - MapItem* item= _reportBlocks.Find(SSRC); - if(item) - { - RTCPReportBlock* ptr= (RTCPReportBlock*)(item->GetItem()); - if(ptr) - { - delete ptr; - } - _reportBlocks.Erase(item); - return 0; - } + std::map::iterator it = + _reportBlocks.find(SSRC); + + if (it == _reportBlocks.end()) { return -1; + } + delete it->second; + _reportBlocks.erase(it); + return 0; } WebRtc_Word32 @@ -721,108 +683,95 @@ RTCPSender::BuildSR(WebRtc_UWord8* rtcpbuffer, } -WebRtc_Word32 -RTCPSender::BuildSDEC(WebRtc_UWord8* rtcpbuffer, WebRtc_UWord32& pos) -{ - WebRtc_UWord32 lengthCname =(WebRtc_UWord32)strlen((char*)_CNAME); +WebRtc_Word32 RTCPSender::BuildSDEC(WebRtc_UWord8* rtcpbuffer, + WebRtc_UWord32& pos) { + size_t lengthCname = strlen(_CNAME); + assert(lengthCname < RTCP_CNAME_SIZE); - // sanity max is 255 - if(lengthCname > RTCP_CNAME_SIZE) - { - lengthCname = RTCP_CNAME_SIZE; - } - // sanity - if(pos + 12+ lengthCname >= IP_PACKET_SIZE) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__); - return -2; - } - // SDEC Source Description + // sanity + if(pos + 12 + lengthCname >= IP_PACKET_SIZE) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s invalid argument", __FUNCTION__); + return -2; + } + // SDEC Source Description - // We always need to add SDES CNAME - rtcpbuffer[pos++]=(WebRtc_UWord8)0x80 + 1 + _csrcCNAMEs.Size(); // source counts - rtcpbuffer[pos++]=(WebRtc_UWord8)202; + // We always need to add SDES CNAME + rtcpbuffer[pos++] = static_cast(0x80 + 1 + _csrcCNAMEs.size()); + rtcpbuffer[pos++] = static_cast(202); - // handle SDES length later on - WebRtc_UWord32 SDESLengthPos = pos; - pos++; - pos++; + // handle SDES length later on + WebRtc_UWord32 SDESLengthPos = pos; + pos++; + pos++; - // Add our own SSRC - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC); + // Add our own SSRC + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _SSRC); + pos += 4; + + // CNAME = 1 + rtcpbuffer[pos++] = static_cast(1); + + // + rtcpbuffer[pos++] = static_cast(lengthCname); + + WebRtc_UWord16 SDESLength = 10; + + memcpy(&rtcpbuffer[pos], _CNAME, lengthCname); + pos += lengthCname; + SDESLength += (WebRtc_UWord16)lengthCname; + + WebRtc_UWord16 padding = 0; + // We must have a zero field even if we have an even multiple of 4 bytes + if ((pos % 4) == 0) { + padding++; + rtcpbuffer[pos++]=0; + } + while ((pos % 4) != 0) { + padding++; + rtcpbuffer[pos++]=0; + } + SDESLength += padding; + + std::map::iterator it = + _csrcCNAMEs.begin(); + + for(; it != _csrcCNAMEs.end(); it++) { + RTCPCnameInformation* cname = it->second; + WebRtc_UWord32 SSRC = it->first; + + // Add SSRC + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, SSRC); pos += 4; // CNAME = 1 - rtcpbuffer[pos++]=(WebRtc_UWord8)1; + rtcpbuffer[pos++] = static_cast(1); - // - rtcpbuffer[pos++]=(WebRtc_UWord8)lengthCname; + rtcpbuffer[pos++]= cname->length; - WebRtc_UWord16 SDESLength = 10; + SDESLength += 6; - memcpy(&rtcpbuffer[pos],_CNAME,lengthCname); - pos += lengthCname; - SDESLength += (WebRtc_UWord16)lengthCname; + memcpy(&rtcpbuffer[pos], cname->name, cname->length); + pos += cname->length; + SDESLength += cname->length; - WebRtc_UWord16 padding =0; + WebRtc_UWord16 padding = 0; // We must have a zero field even if we have an even multiple of 4 bytes - if((pos % 4) ==0) - { - padding++; - rtcpbuffer[pos++]=0; + if((pos % 4) == 0){ + padding++; + rtcpbuffer[pos++]=0; } - while((pos % 4) !=0) - { - padding++; - rtcpbuffer[pos++]=0; + while((pos % 4) != 0){ + padding++; + rtcpbuffer[pos++] = 0; } SDESLength += padding; - - MapItem* item = _csrcCNAMEs.First(); - - for(int i = 0; item && i < _csrcCNAMEs.Size(); i++) - { - RTCPUtility::RTCPCnameInformation* cname = (RTCPUtility::RTCPCnameInformation*)(item->GetItem()); - WebRtc_UWord32 SSRC = item->GetUnsignedId(); - - // Add SSRC - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, SSRC); - pos += 4; - - // CNAME = 1 - rtcpbuffer[pos++]=(WebRtc_UWord8)1; - - rtcpbuffer[pos++]= cname->length; - - SDESLength += 6; - - memcpy(&rtcpbuffer[pos],cname->name, cname->length); - pos += cname->length; - SDESLength += cname->length; - - WebRtc_UWord16 padding =0; - - // We must have a zero field even if we have an even multiple of 4 bytes - if((pos % 4) ==0) - { - padding++; - rtcpbuffer[pos++]=0; - } - while((pos % 4) !=0) - { - padding++; - rtcpbuffer[pos++]=0; - } - SDESLength += padding; - - item = _csrcCNAMEs.Next(item); - } - WebRtc_UWord16 length = SDESLength; - length= (length/4) - 1; // in 32-bit words minus one and we dont count the header - - ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer+SDESLengthPos, length); - return 0; + } + // in 32-bit words minus one and we don't count the header + WebRtc_UWord16 length = (SDESLength / 4) - 1; + ModuleRTPUtility::AssignUWord16ToBuffer(rtcpbuffer + SDESLengthPos, length); + return 0; } WebRtc_Word32 @@ -887,7 +836,7 @@ RTCPSender::BuildExtendedJitterReport( WebRtc_UWord32& pos, const WebRtc_UWord32 jitterTransmissionTimeOffset) { - if (_reportBlocks.Size() > 0) + if (_reportBlocks.size() > 0) { WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, _id, "Not implemented."); return 0; @@ -2125,104 +2074,103 @@ 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) -{ - // sanity one block - if(pos + 24 >= IP_PACKET_SIZE) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__); - return -1; +WebRtc_Word32 RTCPSender::AddReportBlocks(WebRtc_UWord8* rtcpbuffer, + WebRtc_UWord32& pos, + WebRtc_UWord8& numberOfReportBlocks, + const RTCPReportBlock* received, + const WebRtc_UWord32 NTPsec, + const WebRtc_UWord32 NTPfrac) { + // sanity one block + if(pos + 24 >= IP_PACKET_SIZE) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s invalid argument", __FUNCTION__); + return -1; + } + numberOfReportBlocks = _reportBlocks.size(); + if (received) { + // add our multiple RR to numberOfReportBlocks + numberOfReportBlocks++; + } + if (received) { + // answer to the one that sends to me + _lastRTCPTime[0] = ModuleRTPUtility::ConvertNTPTimeToMS(NTPsec, NTPfrac); + + // Remote SSRC + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC); + pos += 4; + + // fraction lost + rtcpbuffer[pos++]=received->fractionLost; + + // cumulative loss + ModuleRTPUtility::AssignUWord24ToBuffer(rtcpbuffer+pos, + received->cumulativeLost); + pos += 3; + // extended highest seq_no, contain the highest sequence number received + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, + received->extendedHighSeqNum); + pos += 4; + + //Jitter + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, received->jitter); + pos += 4; + + // Last SR timestamp, our NTP time when we received the last report + // This is the value that we read from the send report packet not when we + // received it... + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, received->lastSR); + pos += 4; + + // Delay since last received report,time since we received the report + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, + received->delaySinceLastSR); + pos += 4; + } + if ((pos + _reportBlocks.size() * 24) >= IP_PACKET_SIZE) { + WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, + "%s invalid argument", __FUNCTION__); + return -1; + } + 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; + RTCPReportBlock* reportBlock = it->second; + if (reportBlock) { + // Remote SSRC + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, remoteSSRC); + pos += 4; + + // fraction lost + rtcpbuffer[pos++] = reportBlock->fractionLost; + + // cumulative loss + ModuleRTPUtility::AssignUWord24ToBuffer(rtcpbuffer+pos, + reportBlock->cumulativeLost); + pos += 3; + + // extended highest seq_no, contain the highest sequence number received + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, + reportBlock->extendedHighSeqNum); + pos += 4; + + //Jitter + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, + reportBlock->jitter); + pos += 4; + + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, + reportBlock->lastSR); + pos += 4; + + ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, + reportBlock->delaySinceLastSR); + pos += 4; } - - numberOfReportBlocks = _reportBlocks.Size(); - if(received) - { - // add our multiple RR to numberOfReportBlocks - numberOfReportBlocks++; - } - - if(received) - { - // answer to the one that sends to me - _lastRTCPTime[0] = ModuleRTPUtility::ConvertNTPTimeToMS(NTPsec, NTPfrac); - - // Remote SSRC - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC); - pos += 4; - - // fraction lost - rtcpbuffer[pos++]=received->fractionLost; - - // cumulative loss - ModuleRTPUtility::AssignUWord24ToBuffer(rtcpbuffer+pos, received->cumulativeLost); - pos += 3; - - // extended highest seq_no, contain the highest sequence number received - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, received->extendedHighSeqNum); - pos += 4; - - //Jitter - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, received->jitter); - pos += 4; - - // Last SR timestamp, our NTP time when we received the last report - // This is the value that we read from the send report packet not when we received it... - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, received->lastSR); - pos += 4; - - // Delay since last received report,time since we received the report - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, received->delaySinceLastSR); - pos += 4; - } - - if(pos + _reportBlocks.Size()*24 >= IP_PACKET_SIZE) - { - WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__); - return -1; - } - - MapItem* item = _reportBlocks.First(); - for(int i = 0; i < _reportBlocks.Size() && item; i++) - { - // we can have multiple report block in a conference - WebRtc_UWord32 remoteSSRC = item->GetId(); - RTCPReportBlock* reportBlock = (RTCPReportBlock*)item->GetItem(); - if(reportBlock) - { - // Remote SSRC - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, remoteSSRC); - pos += 4; - - // fraction lost - rtcpbuffer[pos++]=(WebRtc_UWord8)(reportBlock->fractionLost); - - // cumulative loss - ModuleRTPUtility::AssignUWord24ToBuffer(rtcpbuffer+pos, reportBlock->cumulativeLost); - pos += 3; - - // extended highest seq_no, contain the highest sequence number received - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, reportBlock->extendedHighSeqNum); - pos += 4; - - //Jitter - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, reportBlock->jitter); - pos += 4; - - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, reportBlock->lastSR); - pos += 4; - - ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, reportBlock->delaySinceLastSR); - pos += 4; - } - item = _reportBlocks.Next(item); - } - return pos; + } + return pos; } // no callbacks allowed inside this function diff --git a/src/modules/rtp_rtcp/source/rtcp_sender.h b/src/modules/rtp_rtcp/source/rtcp_sender.h index 833aa54709..c7c163f1da 100644 --- a/src/modules/rtp_rtcp/source/rtcp_sender.h +++ b/src/modules/rtp_rtcp/source/rtcp_sender.h @@ -11,9 +11,11 @@ #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_ #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_ +#include + #include "typedefs.h" +#include "rtcp_utility.h" #include "rtp_utility.h" -#include "map_wrapper.h" #include "rtp_rtcp_defines.h" #include "remote_rate_control.h" #include "tmmbr_help.h" @@ -213,12 +215,12 @@ private: WebRtc_UWord32 _nextTimeToSendRTCP; - WebRtc_UWord32 _SSRC; - WebRtc_UWord32 _remoteSSRC; // SSRC that we receive on our RTP channel - WebRtc_UWord8 _CNAME[RTCP_CNAME_SIZE]; + WebRtc_UWord32 _SSRC; + WebRtc_UWord32 _remoteSSRC; // SSRC that we receive on our RTP channel + char _CNAME[RTCP_CNAME_SIZE]; - MapWrapper _reportBlocks; // map of SSRC to RTCPReportBlock - MapWrapper _csrcCNAMEs; // map of SSRC to Cnames + std::map _reportBlocks; + std::map _csrcCNAMEs; WebRtc_Word32 _cameraDelayMS;