1548 lines
41 KiB
C++
1548 lines
41 KiB
C++
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include <cstdlib> // srand
|
|
|
|
#include "rtp_sender.h"
|
|
|
|
#include "critical_section_wrapper.h"
|
|
#include "trace.h"
|
|
#include "tick_util.h"
|
|
|
|
#include "rtp_sender_audio.h"
|
|
#include "rtp_sender_video.h"
|
|
|
|
namespace webrtc {
|
|
RTPSender::RTPSender(const WebRtc_Word32 id, const bool audio) :
|
|
_id(id),
|
|
_audioConfigured(audio),
|
|
_audio(NULL),
|
|
_video(NULL),
|
|
_sendCritsect(*CriticalSectionWrapper::CreateCriticalSection()),
|
|
_transportCritsect(*CriticalSectionWrapper::CreateCriticalSection()),
|
|
|
|
_transport(NULL),
|
|
|
|
_sendingMedia(true), // Default to sending media
|
|
|
|
_maxPayloadLength(IP_PACKET_SIZE-28), // default is IP/UDP
|
|
_targetSendBitrate(0),
|
|
_packetOverHead(28),
|
|
|
|
_payloadType(-1),
|
|
_payloadTypeMap(),
|
|
|
|
_keepAliveIsActive(false),
|
|
_keepAlivePayloadType(-1),
|
|
_keepAliveLastSent(0),
|
|
_keepAliveDeltaTimeSend(0),
|
|
|
|
_storeSentPackets(false),
|
|
_storeSentPacketsNumber(0),
|
|
_prevSentPacketsCritsect(*CriticalSectionWrapper::CreateCriticalSection()),
|
|
_prevSentPacketsIndex(0),
|
|
_ptrPrevSentPackets(NULL),
|
|
_prevSentPacketsSeqNum(NULL),
|
|
_prevSentPacketsLength(NULL),
|
|
_prevSentPacketsResendTime(NULL),
|
|
|
|
// NACK
|
|
_nackByteCountTimes(),
|
|
_nackByteCount(),
|
|
|
|
// statistics
|
|
_packetsSent(0),
|
|
_payloadBytesSent(0),
|
|
|
|
// RTP variables
|
|
_startTimeStampForced(false),
|
|
_startTimeStamp(0),
|
|
_ssrcDB(*SSRCDatabase::GetSSRCDatabase()),
|
|
_remoteSSRC(0),
|
|
_sequenceNumberForced(false),
|
|
_sequenceNumber(0),
|
|
_ssrcForced(false),
|
|
_ssrc(0),
|
|
_timeStamp(0),
|
|
_CSRCs(0),
|
|
_CSRC(),
|
|
_includeCSRCs(true)
|
|
{
|
|
memset(_nackByteCountTimes, 0, sizeof(_nackByteCountTimes));
|
|
memset(_nackByteCount, 0, sizeof(_nackByteCount));
|
|
|
|
memset(_CSRC, 0, sizeof(_CSRC));
|
|
|
|
// we need to seed the random generator, otherwise we get 26500 each time, hardly a random value :)
|
|
srand( (WebRtc_UWord32)ModuleRTPUtility::GetTimeInMS() );
|
|
|
|
_ssrc = _ssrcDB.CreateSSRC(); // can't be 0
|
|
|
|
if(audio)
|
|
{
|
|
_audio = new RTPSenderAudio(id, this);
|
|
} else
|
|
{
|
|
_video = new RTPSenderVideo(id, this); //
|
|
}
|
|
WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id, "%s created", __FUNCTION__);
|
|
}
|
|
|
|
RTPSender::~RTPSender()
|
|
{
|
|
if(_remoteSSRC != 0)
|
|
{
|
|
_ssrcDB.ReturnSSRC(_remoteSSRC);
|
|
}
|
|
_ssrcDB.ReturnSSRC(_ssrc);
|
|
|
|
SSRCDatabase::ReturnSSRCDatabase();
|
|
delete &_prevSentPacketsCritsect;
|
|
delete &_sendCritsect;
|
|
delete &_transportCritsect;
|
|
|
|
// empty map
|
|
bool loop = true;
|
|
do
|
|
{
|
|
MapItem* item = _payloadTypeMap.First();
|
|
if(item)
|
|
{
|
|
// delete
|
|
ModuleRTPUtility::Payload* payload= ((ModuleRTPUtility::Payload*)item->GetItem());
|
|
delete payload;
|
|
|
|
// remove from map and delete Item
|
|
_payloadTypeMap.Erase(item);
|
|
} else
|
|
{
|
|
loop = false;
|
|
}
|
|
} while (loop);
|
|
|
|
for(WebRtc_Word32 i=0; i< _storeSentPacketsNumber; i++)
|
|
{
|
|
if(_ptrPrevSentPackets[i])
|
|
{
|
|
delete [] _ptrPrevSentPackets[i];
|
|
_ptrPrevSentPackets[i] = 0;
|
|
}
|
|
}
|
|
delete [] _ptrPrevSentPackets;
|
|
delete [] _prevSentPacketsSeqNum;
|
|
delete [] _prevSentPacketsLength;
|
|
delete [] _prevSentPacketsResendTime;
|
|
|
|
delete _audio;
|
|
delete _video;
|
|
|
|
WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, _id, "%s deleted", __FUNCTION__);
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::Init(const WebRtc_UWord32 remoteSSRC)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
// reset to default generation
|
|
_ssrcForced = false;
|
|
_startTimeStampForced = false;
|
|
|
|
// register a remote SSRC if we have it to avoid collisions
|
|
if(remoteSSRC != 0)
|
|
{
|
|
if(_ssrc == remoteSSRC)
|
|
{
|
|
// collision detected
|
|
_ssrc = _ssrcDB.CreateSSRC(); // can't be 0
|
|
}
|
|
_remoteSSRC = remoteSSRC;
|
|
_ssrcDB.RegisterSSRC(remoteSSRC);
|
|
}
|
|
_sequenceNumber = rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER);
|
|
_packetsSent = 0;
|
|
_payloadBytesSent = 0;
|
|
_packetOverHead = 28;
|
|
|
|
_keepAlivePayloadType = -1;
|
|
|
|
bool loop = true;
|
|
do
|
|
{
|
|
MapItem* item = _payloadTypeMap.First();
|
|
if(item)
|
|
{
|
|
ModuleRTPUtility::Payload* payload= ((ModuleRTPUtility::Payload*)item->GetItem());
|
|
delete payload;
|
|
_payloadTypeMap.Erase(item);
|
|
} else
|
|
{
|
|
loop = false;
|
|
}
|
|
} while (loop);
|
|
|
|
memset(_CSRC, 0, sizeof(_CSRC));
|
|
|
|
memset(_nackByteCount, 0, sizeof(_nackByteCount));
|
|
memset(_nackByteCountTimes, 0, sizeof(_nackByteCountTimes));
|
|
|
|
SetStorePacketsStatus(false, 0);
|
|
|
|
Bitrate::Init();
|
|
|
|
if(_audioConfigured)
|
|
{
|
|
_audio->Init();
|
|
} else
|
|
{
|
|
_video->Init();
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
void
|
|
RTPSender::ChangeUniqueId(const WebRtc_Word32 id)
|
|
{
|
|
_id = id;
|
|
if(_audioConfigured)
|
|
{
|
|
_audio->ChangeUniqueId(id);
|
|
} else
|
|
{
|
|
_video->ChangeUniqueId(id);
|
|
}
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetTargetSendBitrate(const WebRtc_UWord32 bits)
|
|
{
|
|
_targetSendBitrate = (WebRtc_UWord16)(bits/1000);
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
RTPSender::TargetSendBitrateKbit() const
|
|
{
|
|
return _targetSendBitrate;
|
|
}
|
|
WebRtc_UWord16
|
|
RTPSender::ActualSendBitrateKbit() const
|
|
{
|
|
return (WebRtc_UWord16) (Bitrate::BitrateNow()/1000);
|
|
}
|
|
|
|
//can be called multiple times
|
|
WebRtc_Word32
|
|
RTPSender::RegisterPayload(const WebRtc_Word8 payloadName[RTP_PAYLOAD_NAME_SIZE],
|
|
const WebRtc_Word8 payloadNumber,
|
|
const WebRtc_UWord32 frequency,
|
|
const WebRtc_UWord8 channels,
|
|
const WebRtc_UWord32 rate)
|
|
{
|
|
if (!payloadName)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__);
|
|
return -1;
|
|
}
|
|
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if(payloadNumber == _keepAlivePayloadType)
|
|
{
|
|
WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, _id, "invalid state", __FUNCTION__);
|
|
return -1;
|
|
}
|
|
|
|
MapItem* item = _payloadTypeMap.Find(payloadNumber);
|
|
if( NULL != item)
|
|
{
|
|
// we already use this payload type
|
|
|
|
ModuleRTPUtility::Payload* payload = (ModuleRTPUtility::Payload*)item->GetItem();
|
|
assert(payload);
|
|
|
|
// check if it's the same as we already have
|
|
WebRtc_Word32 payloadNameLength = (WebRtc_Word32)strlen(payloadName);
|
|
WebRtc_Word32 nameLength = (WebRtc_Word32)strlen(payload->name);
|
|
if(payloadNameLength == nameLength && ModuleRTPUtility::StringCompare(payload->name, payloadName, nameLength))
|
|
{
|
|
if(_audioConfigured && payload->audio &&
|
|
payload->typeSpecific.Audio.frequency == frequency &&
|
|
(payload->typeSpecific.Audio.rate == rate || payload->typeSpecific.Audio.rate == 0 || rate == 0))
|
|
{
|
|
payload->typeSpecific.Audio.rate = rate; // Ensure that we update the rate if new or old is zero
|
|
return 0;
|
|
}
|
|
if(!_audioConfigured && !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);
|
|
} else
|
|
{
|
|
retVal = _video->RegisterVideoPayload(payloadName, payloadNumber, rate, payload);
|
|
}
|
|
if(payload)
|
|
{
|
|
_payloadTypeMap.Insert(payloadNumber, payload);
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::DeRegisterSendPayload(const WebRtc_Word8 payloadType)
|
|
{
|
|
CriticalSectionScoped lock(_sendCritsect);
|
|
|
|
MapItem* item = _payloadTypeMap.Find(payloadType);
|
|
if( NULL != item)
|
|
{
|
|
ModuleRTPUtility::Payload* payload = (ModuleRTPUtility::Payload*)item->GetItem();
|
|
delete payload;
|
|
|
|
_payloadTypeMap.Erase(item);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
WebRtc_Word8 RTPSender::SendPayloadType() const
|
|
{
|
|
return _payloadType;
|
|
}
|
|
|
|
|
|
int RTPSender::SendPayloadFrequency() const
|
|
{
|
|
return _audio->AudioFrequency();
|
|
}
|
|
|
|
|
|
// See http://www.ietf.org/internet-drafts/draft-ietf-avt-app-rtp-keepalive-04.txt
|
|
// for details about this method. Only Section 4.6 is implemented so far.
|
|
bool
|
|
RTPSender::RTPKeepalive() const
|
|
{
|
|
return _keepAliveIsActive;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::RTPKeepaliveStatus(bool* enable,
|
|
WebRtc_Word8* unknownPayloadType,
|
|
WebRtc_UWord16* deltaTransmitTimeMS) const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if(enable)
|
|
{
|
|
*enable = _keepAliveIsActive;
|
|
}
|
|
if(unknownPayloadType)
|
|
{
|
|
*unknownPayloadType = _keepAlivePayloadType;
|
|
}
|
|
if(deltaTransmitTimeMS)
|
|
{
|
|
*deltaTransmitTimeMS =_keepAliveDeltaTimeSend;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::EnableRTPKeepalive( const WebRtc_Word8 unknownPayloadType,
|
|
const WebRtc_UWord16 deltaTransmitTimeMS)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if( NULL != _payloadTypeMap.Find(unknownPayloadType))
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument", __FUNCTION__);
|
|
return -1;
|
|
}
|
|
|
|
_keepAliveIsActive = true;
|
|
_keepAlivePayloadType = unknownPayloadType;
|
|
_keepAliveLastSent = ModuleRTPUtility::GetTimeInMS();
|
|
_keepAliveDeltaTimeSend = deltaTransmitTimeMS;
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::DisableRTPKeepalive()
|
|
{
|
|
_keepAliveIsActive = false;
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
RTPSender::TimeToSendRTPKeepalive() const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
bool timeToSend(false);
|
|
|
|
WebRtc_UWord32 dT = ModuleRTPUtility::GetTimeInMS() - _keepAliveLastSent;
|
|
if (dT > _keepAliveDeltaTimeSend)
|
|
{
|
|
timeToSend = true;
|
|
}
|
|
return timeToSend;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// From the RFC draft:
|
|
//
|
|
// 4.6. RTP Packet with Unknown Payload Type
|
|
//
|
|
// The application sends an RTP packet of 0 length with a dynamic
|
|
// payload type that has not been negotiated by the peers (e.g. not
|
|
// negotiated within the SDP offer/answer, and thus not mapped to any
|
|
// media format).
|
|
//
|
|
// The sequence number is incremented by one for each packet, as it is
|
|
// sent within the same RTP session as the actual media. The timestamp
|
|
// contains the same value a media packet would have at this time. The
|
|
// marker bit is not significant for the keepalive packets and is thus
|
|
// set to zero.
|
|
//
|
|
// Normally the peer will ignore this packet, as RTP [RFC3550] states
|
|
// that "a receiver MUST ignore packets with payload types that it does
|
|
// not understand".
|
|
//
|
|
// Cons:
|
|
// o [RFC4566] and [RFC3264] mandate not to send media with inactive
|
|
// and recvonly attributes, however this is mitigated as no real
|
|
// media is sent with this mechanism.
|
|
//
|
|
// Recommendation:
|
|
// o This method should be used for RTP keepalive.
|
|
//
|
|
// 7. Timing and Transport Considerations
|
|
//
|
|
// An application supporting this specification must transmit keepalive
|
|
// packets every Tr seconds during the whole duration of the media
|
|
// session. Tr SHOULD be configurable, and otherwise MUST default to 15
|
|
// seconds.
|
|
//
|
|
// Keepalives packets within a particular RTP session MUST use the tuple
|
|
// (source IP address, source TCP/UDP ports, target IP address, target
|
|
// TCP/UDP Port) of the regular RTP packets.
|
|
//
|
|
// The agent SHOULD only send RTP keepalive when it does not send
|
|
// regular RTP packets.
|
|
//
|
|
// http://www.ietf.org/internet-drafts/draft-ietf-avt-app-rtp-keepalive-04.txt
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SendRTPKeepalivePacket()
|
|
{
|
|
// RFC summary:
|
|
//
|
|
// - Send an RTP packet of 0 length;
|
|
// - dynamic payload type has not been negotiated (not mapped to any media);
|
|
// - sequence number is incremented by one for each packet;
|
|
// - timestamp contains the same value a media packet would have at this time;
|
|
// - marker bit is set to zero.
|
|
|
|
WebRtc_UWord8 dataBuffer[IP_PACKET_SIZE];
|
|
WebRtc_UWord16 rtpHeaderLength = 12;
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
WebRtc_UWord32 now = ModuleRTPUtility::GetTimeInMS();
|
|
WebRtc_UWord32 dT = now -_keepAliveLastSent; // delta time in MS
|
|
|
|
WebRtc_UWord32 freqKHz = 90; // video
|
|
if(_audioConfigured)
|
|
{
|
|
freqKHz = _audio->AudioFrequency()/1000;
|
|
}
|
|
WebRtc_UWord32 dSamples = dT*freqKHz;
|
|
|
|
// set timestamp
|
|
_timeStamp += dSamples;
|
|
_keepAliveLastSent = now;
|
|
|
|
rtpHeaderLength = RTPHeaderLength();
|
|
|
|
// correct seq num, time stamp and payloadtype
|
|
BuildRTPheader(dataBuffer, _keepAlivePayloadType, false, 0, false);
|
|
}
|
|
|
|
return SendToNetwork(dataBuffer, 0, rtpHeaderLength);
|
|
}
|
|
|
|
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__);
|
|
return -1;
|
|
}
|
|
if(maxPayloadLength > _maxPayloadLength)
|
|
{
|
|
CriticalSectionScoped lock(_prevSentPacketsCritsect);
|
|
if(_storeSentPackets)
|
|
{
|
|
// we need to free the memmory allocated for storing sent packets
|
|
// will be allocated in SendToNetwork
|
|
for(WebRtc_Word32 i=0; i< _storeSentPacketsNumber; i++)
|
|
{
|
|
if(_ptrPrevSentPackets[i])
|
|
{
|
|
delete [] _ptrPrevSentPackets[i];
|
|
_ptrPrevSentPackets[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
_maxPayloadLength = maxPayloadLength;
|
|
_packetOverHead = packetOverHead;
|
|
|
|
WEBRTC_TRACE(kTraceInfo, kTraceRtpRtcp, _id, "SetMaxPayloadLength to %d.", maxPayloadLength);
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
RTPSender::MaxDataPayloadLength() const
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return _maxPayloadLength - RTPHeaderLength();
|
|
} else
|
|
{
|
|
return _maxPayloadLength - RTPHeaderLength() - _video->FECPacketOverhead(); // Include the FEC/ULP/RED overhead.
|
|
}
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
RTPSender::MaxPayloadLength() const
|
|
{
|
|
return _maxPayloadLength;
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
RTPSender::PacketOverHead() const
|
|
{
|
|
return _packetOverHead;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::CheckPayloadType(const WebRtc_Word8 payloadType,
|
|
RtpVideoCodecTypes& videoType)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if(payloadType < 0)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "\tinvalid payloadType (%d)", payloadType);
|
|
return -1;
|
|
}
|
|
|
|
if(_audioConfigured)
|
|
{
|
|
WebRtc_Word8 redPlType = -1;
|
|
if(_audio->RED(redPlType) == 0)
|
|
{
|
|
// we have configured RED
|
|
if(redPlType == payloadType)
|
|
{
|
|
// and it's a match
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(_payloadType != payloadType)
|
|
{
|
|
MapItem* item = _payloadTypeMap.Find(payloadType);
|
|
if( NULL == item)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "\tpayloadType:%d not registered", payloadType);
|
|
return -1;
|
|
}
|
|
_payloadType = payloadType;
|
|
ModuleRTPUtility::Payload* payload = (ModuleRTPUtility::Payload*)item->GetItem();
|
|
if(payload)
|
|
{
|
|
if(payload->audio)
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
// Extract payload frequency
|
|
int payloadFreqHz;
|
|
if(ModuleRTPUtility::StringCompare(payload->name,"g722",4)&&
|
|
(payload->name[4] == 0)) //Check that strings end there, g722.1...
|
|
{
|
|
// Special case for G.722, bug in spec
|
|
payloadFreqHz=8000;
|
|
}
|
|
else
|
|
{
|
|
payloadFreqHz=payload->typeSpecific.Audio.frequency;
|
|
}
|
|
|
|
//we don't do anything if it's CN
|
|
if((_audio->AudioFrequency() != payloadFreqHz)&&
|
|
(!ModuleRTPUtility::StringCompare(payload->name,"cn",2)))
|
|
{
|
|
_audio->SetAudioFrequency(payloadFreqHz);
|
|
// We need to correct the timestamp again,
|
|
// since this might happen after we've set it
|
|
WebRtc_UWord32 RTPtime =
|
|
ModuleRTPUtility::CurrentRTP(payloadFreqHz);
|
|
SetStartTimestamp(RTPtime);
|
|
// will be ignored if it's already configured via API
|
|
}
|
|
}
|
|
}else
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
_video->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType);
|
|
videoType = payload->typeSpecific.Video.videoCodecType;
|
|
_video->SetMaxConfiguredBitrateVideo(payload->typeSpecific.Video.maxRate);
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
videoType = _video->VideoCodecType();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SendOutgoingData(const FrameType frameType,
|
|
const WebRtc_Word8 payloadType,
|
|
const WebRtc_UWord32 captureTimeStamp,
|
|
const WebRtc_UWord8* payloadData,
|
|
const WebRtc_UWord32 payloadSize,
|
|
const RTPFragmentationHeader* fragmentation,
|
|
VideoCodecInformation* codecInfo)
|
|
{
|
|
{
|
|
// Drop this packet if we're not sending media packets
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
if (!_sendingMedia)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
RtpVideoCodecTypes videoType;
|
|
if(CheckPayloadType(payloadType, videoType) != 0)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument failed to find payloadType:%d", __FUNCTION__, payloadType);
|
|
return -1;
|
|
}
|
|
// update keepalive so that we don't trigger keepalive messages while sending data
|
|
_keepAliveLastSent = ModuleRTPUtility::GetTimeInMS();
|
|
|
|
if(_audioConfigured)
|
|
{
|
|
// assert video frameTypes
|
|
assert(frameType == kAudioFrameSpeech ||
|
|
frameType == kAudioFrameCN ||
|
|
frameType == kFrameEmpty);
|
|
|
|
return _audio->SendAudio(frameType, payloadType, captureTimeStamp, payloadData, payloadSize,fragmentation);
|
|
} else
|
|
{
|
|
// assert audio frameTypes
|
|
assert(frameType == kVideoFrameKey ||
|
|
frameType == kVideoFrameDelta ||
|
|
frameType == kVideoFrameGolden ||
|
|
frameType == kVideoFrameAltRef);
|
|
|
|
return _video->SendVideo(videoType,
|
|
frameType,
|
|
payloadType,
|
|
captureTimeStamp,
|
|
payloadData,
|
|
payloadSize,
|
|
fragmentation,
|
|
codecInfo);
|
|
}
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetStorePacketsStatus(const bool enable, const WebRtc_UWord16 numberToStore)
|
|
{
|
|
CriticalSectionScoped lock(_prevSentPacketsCritsect);
|
|
|
|
if(enable)
|
|
{
|
|
if(_storeSentPackets)
|
|
{
|
|
// already enabled
|
|
return -1;
|
|
}
|
|
if(numberToStore > 0)
|
|
{
|
|
_storeSentPackets = enable;
|
|
_storeSentPacketsNumber = numberToStore;
|
|
|
|
_ptrPrevSentPackets = new WebRtc_Word8*[numberToStore],
|
|
_prevSentPacketsSeqNum = new WebRtc_UWord16[numberToStore];
|
|
_prevSentPacketsLength = new WebRtc_UWord16[numberToStore];
|
|
_prevSentPacketsResendTime = new WebRtc_UWord32[numberToStore];
|
|
|
|
memset(_ptrPrevSentPackets,0, sizeof(WebRtc_Word8*)*numberToStore);
|
|
memset(_prevSentPacketsSeqNum,0, sizeof(WebRtc_UWord16)*numberToStore);
|
|
memset(_prevSentPacketsLength,0, sizeof(WebRtc_UWord16)*numberToStore);
|
|
memset(_prevSentPacketsResendTime,0,sizeof(WebRtc_UWord32)*numberToStore);
|
|
} else
|
|
{
|
|
// storing 0 packets does not make sence
|
|
return -1;
|
|
}
|
|
} else
|
|
{
|
|
_storeSentPackets = enable;
|
|
if(_storeSentPacketsNumber > 0)
|
|
{
|
|
for(WebRtc_Word32 i=0; i< _storeSentPacketsNumber; i++)
|
|
{
|
|
if(_ptrPrevSentPackets[i])
|
|
{
|
|
delete [] _ptrPrevSentPackets[i];
|
|
_ptrPrevSentPackets[i] = 0;
|
|
}
|
|
}
|
|
delete [] _ptrPrevSentPackets;
|
|
delete [] _prevSentPacketsSeqNum;
|
|
delete [] _prevSentPacketsLength;
|
|
delete [] _prevSentPacketsResendTime;
|
|
|
|
_ptrPrevSentPackets = NULL;
|
|
_prevSentPacketsSeqNum = NULL;
|
|
_prevSentPacketsLength = NULL;
|
|
_prevSentPacketsResendTime = NULL;
|
|
|
|
_storeSentPacketsNumber = 0;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
RTPSender::StorePackets() const
|
|
{
|
|
return _storeSentPackets;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::ReSendToNetwork(WebRtc_UWord16 packetID,
|
|
WebRtc_UWord32 minResendTime)
|
|
{
|
|
#ifdef DEBUG_RTP_SEQUENCE_NUMBER
|
|
char str[256];
|
|
sprintf(str,"Re-Send sequenceNumber %d\n", packetID) ;
|
|
OutputDebugString(str);
|
|
#endif
|
|
|
|
WebRtc_Word32 i = -1;
|
|
WebRtc_Word32 length = 0;
|
|
WebRtc_Word32 index =0;
|
|
WebRtc_UWord8 dataBuffer[IP_PACKET_SIZE];
|
|
|
|
{
|
|
CriticalSectionScoped lock(_prevSentPacketsCritsect);
|
|
|
|
if(_storeSentPackets)
|
|
{
|
|
WebRtc_UWord16 seqNum = 0;
|
|
if(_prevSentPacketsIndex)
|
|
{
|
|
seqNum = _prevSentPacketsSeqNum[_prevSentPacketsIndex-1];
|
|
}else
|
|
{
|
|
seqNum = _prevSentPacketsSeqNum[_storeSentPacketsNumber-1];
|
|
}
|
|
index = (_prevSentPacketsIndex-1) - (seqNum - packetID);
|
|
if (index >= 0 && index < _storeSentPacketsNumber)
|
|
{
|
|
seqNum = _prevSentPacketsSeqNum[index];
|
|
}
|
|
if(seqNum != packetID)
|
|
{
|
|
//we did not found a match, search all
|
|
for (WebRtc_Word32 m = 0; m < _storeSentPacketsNumber ;m++)
|
|
{
|
|
if(_prevSentPacketsSeqNum[m] == packetID)
|
|
{
|
|
index = m;
|
|
seqNum = _prevSentPacketsSeqNum[index];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(seqNum == packetID)
|
|
{
|
|
WebRtc_UWord32 timeNow= ModuleRTPUtility::GetTimeInMS();
|
|
if(minResendTime>0 && (timeNow-_prevSentPacketsResendTime[index]<minResendTime))
|
|
{
|
|
// No point in sending the packet again yet. Get out of here
|
|
WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, _id, "Skipping to resend RTP packet %d because it was just resent", seqNum);
|
|
return 0;
|
|
}
|
|
|
|
length = _prevSentPacketsLength[index];
|
|
|
|
if(length > _maxPayloadLength || _ptrPrevSentPackets[index] == 0)
|
|
{
|
|
return -1;
|
|
}
|
|
} else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
if(length ==0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// copy to local buffer for callback
|
|
memcpy(dataBuffer, _ptrPrevSentPackets[index], length);
|
|
}
|
|
{
|
|
CriticalSectionScoped lock(_transportCritsect);
|
|
if(_transport)
|
|
{
|
|
i = _transport->SendPacket(_id, dataBuffer, length);
|
|
}
|
|
}
|
|
if(i > 0)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
Bitrate::Update(i);
|
|
|
|
_packetsSent++;
|
|
|
|
// we on purpose don't add to _payloadBytesSent since this is a re-transmit and not new payload data
|
|
}
|
|
if(_storeSentPackets && i > 0)
|
|
{
|
|
CriticalSectionScoped lock(_prevSentPacketsCritsect);
|
|
|
|
if(_prevSentPacketsSeqNum[index] == packetID) // Make sure the packet is still in the array
|
|
{
|
|
_prevSentPacketsResendTime[index]= ModuleRTPUtility::GetTimeInMS(); // Store the time when the frame was last resent.
|
|
}
|
|
return i; //bytes sent over network
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
RTPSender::OnReceivedNACK(const WebRtc_UWord16 nackSequenceNumbersLength,
|
|
const WebRtc_UWord16* nackSequenceNumbers,
|
|
const WebRtc_UWord16 avgRTT)
|
|
{
|
|
const WebRtc_UWord32 now = ModuleRTPUtility::GetTimeInMS();
|
|
WebRtc_UWord32 bytesReSent = 0;
|
|
|
|
// Enough bandwith to send NACK?
|
|
if(ProcessNACKBitRate(now))
|
|
{
|
|
for (WebRtc_UWord16 i = 0; i < nackSequenceNumbersLength; ++i)
|
|
{
|
|
const WebRtc_Word32 bytesSent = ReSendToNetwork(nackSequenceNumbers[i],
|
|
5+avgRTT);
|
|
if (bytesSent > 0)
|
|
{
|
|
bytesReSent += bytesSent;
|
|
|
|
} else if(bytesSent==0)
|
|
{
|
|
continue; // The packet has previously been resent. Try resending next packet in the list.
|
|
|
|
} else if(bytesSent<0) // Failed to send one Sequence number. Give up the rest in this nack.
|
|
{
|
|
WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, _id, "Failed resending RTP packet %d, Discard rest of NACK RTP packets", nackSequenceNumbers[i]);
|
|
break;
|
|
}
|
|
// delay bandwidth estimate (RTT * BW)
|
|
if(TargetSendBitrateKbit() != 0 && avgRTT)
|
|
{
|
|
if(bytesReSent > (WebRtc_UWord32)(TargetSendBitrateKbit() * avgRTT)>>3 ) // kbits/s * ms= bits/8 = bytes
|
|
{
|
|
break; // ignore the rest of the packets in the list
|
|
}
|
|
}
|
|
}
|
|
if (bytesReSent > 0)
|
|
{
|
|
UpdateNACKBitRate(bytesReSent,now); // Update the nack bit rate
|
|
}
|
|
}else
|
|
{
|
|
WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, _id, "NACK bitrate reached. Skipp sending NACK response. Target %d",TargetSendBitrateKbit());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return true if the nack bitrate is lower than the requested max bitrate
|
|
*/
|
|
bool
|
|
RTPSender::ProcessNACKBitRate(const WebRtc_UWord32 now)
|
|
{
|
|
WebRtc_UWord32 num = 0;
|
|
WebRtc_Word32 byteCount = 0;
|
|
const WebRtc_UWord32 avgIntervall=1000;
|
|
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if(_targetSendBitrate == 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
for(num = 0; num < NACK_BYTECOUNT_SIZE; num++)
|
|
{
|
|
if((now - _nackByteCountTimes[num]) > avgIntervall) // don't use data older than 1sec
|
|
{
|
|
break;
|
|
} else
|
|
{
|
|
byteCount += _nackByteCount[num];
|
|
}
|
|
}
|
|
WebRtc_Word32 timeIntervall=avgIntervall;
|
|
if (num == NACK_BYTECOUNT_SIZE ) // More than NACK_BYTECOUNT_SIZE nack messages has been received during the last msgIntervall
|
|
{
|
|
timeIntervall= now - _nackByteCountTimes[num-1];
|
|
if(timeIntervall <0)
|
|
{
|
|
timeIntervall=avgIntervall;
|
|
}
|
|
}
|
|
return (byteCount*8)<(_targetSendBitrate*timeIntervall);
|
|
}
|
|
|
|
void
|
|
RTPSender::UpdateNACKBitRate(const WebRtc_UWord32 bytes,
|
|
const WebRtc_UWord32 now)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
// save bitrate statistics
|
|
if(bytes > 0)
|
|
{
|
|
if(now == 0)
|
|
{
|
|
// add padding length
|
|
_nackByteCount[0] += bytes;
|
|
} else
|
|
{
|
|
if(_nackByteCountTimes[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];
|
|
}
|
|
}
|
|
_nackByteCount[0] = bytes;
|
|
_nackByteCountTimes[0] = now;
|
|
}
|
|
}
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SendToNetwork(const WebRtc_UWord8* buffer,
|
|
const WebRtc_UWord16 length,
|
|
const WebRtc_UWord16 rtpLength,
|
|
const bool dontStore)
|
|
{
|
|
WebRtc_Word32 retVal = -1;
|
|
// sanity
|
|
if(length + rtpLength > _maxPayloadLength)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if(!dontStore)
|
|
{
|
|
// Store my packets
|
|
// Used for NACK
|
|
CriticalSectionScoped lock(_prevSentPacketsCritsect);
|
|
if(_storeSentPackets && length > 0)
|
|
{
|
|
if(_ptrPrevSentPackets[0] == NULL)
|
|
{
|
|
for(WebRtc_Word32 i=0; i< _storeSentPacketsNumber; i++)
|
|
{
|
|
_ptrPrevSentPackets[i] = new char[_maxPayloadLength];
|
|
memset(_ptrPrevSentPackets[i],0, _maxPayloadLength);
|
|
}
|
|
}
|
|
|
|
const WebRtc_UWord16 sequenceNumber = (buffer[2] << 8) + buffer[3];
|
|
|
|
memcpy(_ptrPrevSentPackets[_prevSentPacketsIndex], buffer, length + rtpLength);
|
|
_prevSentPacketsSeqNum[_prevSentPacketsIndex] = sequenceNumber;
|
|
_prevSentPacketsLength[_prevSentPacketsIndex]= length + rtpLength;
|
|
_prevSentPacketsResendTime[_prevSentPacketsIndex]=0; // Packet has not been re-sent.
|
|
_prevSentPacketsIndex++;
|
|
if(_prevSentPacketsIndex >= _storeSentPacketsNumber)
|
|
{
|
|
_prevSentPacketsIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
// Send packet
|
|
{
|
|
CriticalSectionScoped cs(_transportCritsect);
|
|
if(_transport)
|
|
{
|
|
retVal = _transport->SendPacket(_id, buffer, length + rtpLength);
|
|
}
|
|
}
|
|
// success?
|
|
if(retVal > 0)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
Bitrate::Update(retVal);
|
|
|
|
_packetsSent++;
|
|
|
|
if(retVal > rtpLength)
|
|
{
|
|
_payloadBytesSent += retVal-rtpLength;
|
|
}
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
RTPSender::ProcessBitrate()
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
Bitrate::Process();
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
RTPSender::RTPHeaderLength() const
|
|
{
|
|
WebRtc_UWord16 rtpHeaderLength = 12;
|
|
|
|
if(_includeCSRCs)
|
|
{
|
|
rtpHeaderLength += sizeof(WebRtc_UWord32)*_CSRCs;
|
|
}
|
|
return rtpHeaderLength;
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
RTPSender::IncrementSequenceNumber()
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
return _sequenceNumber++;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::ResetDataCounters()
|
|
{
|
|
_packetsSent = 0;
|
|
_payloadBytesSent = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
// number of sent RTP packets
|
|
// dont use critsect to avoid potental deadlock
|
|
WebRtc_UWord32
|
|
RTPSender::Packets() const
|
|
{
|
|
return _packetsSent;
|
|
}
|
|
|
|
// number of sent RTP bytes
|
|
// dont use critsect to avoid potental deadlock
|
|
WebRtc_UWord32
|
|
RTPSender::Bytes() const
|
|
{
|
|
return _payloadBytesSent;
|
|
}
|
|
|
|
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);
|
|
|
|
dataBuffer[0] = static_cast<WebRtc_UWord8>(0x80); // version 2
|
|
dataBuffer[1] = static_cast<WebRtc_UWord8>(payloadType);
|
|
if (markerBit)
|
|
{
|
|
dataBuffer[1] |= kRtpMarkerBitMask; // MarkerBit is set
|
|
}
|
|
|
|
if(timeStampProvided)
|
|
{
|
|
_timeStamp = _startTimeStamp + captureTimeStamp;
|
|
} else
|
|
{
|
|
// make a unique time stamp
|
|
// used for inband signaling
|
|
// we can't inc by the actual time, since then we increase the risk of back timing
|
|
_timeStamp++;
|
|
}
|
|
|
|
ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer+2, _sequenceNumber);
|
|
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer+4, _timeStamp);
|
|
ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer+8, _ssrc);
|
|
|
|
WebRtc_Word32 rtpHeaderLength = 12;
|
|
|
|
// Add the CSRCs if any
|
|
if (_includeCSRCs && _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;
|
|
}
|
|
dataBuffer[0] = (dataBuffer[0]&0xf0) | _CSRCs;
|
|
|
|
// Update length of header
|
|
rtpHeaderLength += sizeof(WebRtc_UWord32)*_CSRCs;
|
|
}
|
|
{
|
|
_sequenceNumber++; // prepare for next packet
|
|
}
|
|
|
|
return rtpHeaderLength;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::RegisterSendTransport(Transport* transport)
|
|
{
|
|
CriticalSectionScoped cs(_transportCritsect);
|
|
_transport = transport;
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
RTPSender::SetSendingStatus(const bool enabled)
|
|
{
|
|
if(enabled)
|
|
{
|
|
WebRtc_UWord32 freq;
|
|
if(_audioConfigured)
|
|
{
|
|
WebRtc_UWord32 frequency = _audio->AudioFrequency();
|
|
|
|
// sanity
|
|
switch(frequency)
|
|
{
|
|
case 8000:
|
|
case 12000:
|
|
case 16000:
|
|
case 24000:
|
|
case 32000:
|
|
break;
|
|
default:
|
|
assert(false);
|
|
return;
|
|
}
|
|
freq = frequency;
|
|
} else
|
|
{
|
|
freq = 90000; // 90 KHz for all video
|
|
}
|
|
WebRtc_UWord32 RTPtime = ModuleRTPUtility::CurrentRTP(freq);
|
|
|
|
SetStartTimestamp(RTPtime); // will be ignored if it's already configured via API
|
|
|
|
} else
|
|
{
|
|
if(!_ssrcForced)
|
|
{
|
|
// generate a new SSRC
|
|
_ssrcDB.ReturnSSRC(_ssrc);
|
|
_ssrc = _ssrcDB.CreateSSRC(); // can't be 0
|
|
|
|
}
|
|
if(!_sequenceNumberForced && !_ssrcForced) // don't initialize seq number if SSRC passed externally
|
|
{
|
|
// generate a new sequence number
|
|
_sequenceNumber = rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
RTPSender::SetSendingMediaStatus(const bool enabled)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
_sendingMedia = enabled;
|
|
}
|
|
|
|
bool
|
|
RTPSender::SendingMedia() const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
return _sendingMedia;
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
RTPSender::Timestamp() const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
return _timeStamp;
|
|
}
|
|
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetStartTimestamp( const WebRtc_UWord32 timestamp, const bool force)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
if(force)
|
|
{
|
|
_startTimeStampForced = force;
|
|
_startTimeStamp = timestamp;
|
|
} else
|
|
{
|
|
if(!_startTimeStampForced)
|
|
{
|
|
_startTimeStamp = timestamp;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
RTPSender::StartTimestamp() const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
return _startTimeStamp;
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
RTPSender::GenerateNewSSRC()
|
|
{
|
|
// if configured via API, return 0
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if(_ssrcForced)
|
|
{
|
|
return 0;
|
|
}
|
|
_ssrc = _ssrcDB.CreateSSRC(); // can't be 0
|
|
return _ssrc;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetSSRC(WebRtc_UWord32 ssrc)
|
|
{
|
|
// this is configured via the API
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if (_ssrc == ssrc && _ssrcForced)
|
|
{
|
|
return 0; // 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);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
RTPSender::SSRC() const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
return _ssrc;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetCSRCStatus(const bool include)
|
|
{
|
|
_includeCSRCs = include;
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetCSRCs(const WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize],
|
|
const WebRtc_UWord8 arrLength)
|
|
{
|
|
if(arrLength > kRtpCsrcSize)
|
|
{
|
|
assert(false);
|
|
return -1;
|
|
}
|
|
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
for(int i = 0; i < arrLength;i++)
|
|
{
|
|
_CSRC[i] = arrOfCSRC[i];
|
|
}
|
|
_CSRCs = arrLength;
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::CSRCs(WebRtc_UWord32 arrOfCSRC[kRtpCsrcSize]) const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
|
|
if(arrOfCSRC == NULL)
|
|
{
|
|
assert(false);
|
|
return -1;
|
|
}
|
|
for(int i = 0; i < _CSRCs && i < kRtpCsrcSize;i++)
|
|
{
|
|
arrOfCSRC[i] = _CSRC[i];
|
|
}
|
|
return _CSRCs;
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetSequenceNumber(WebRtc_UWord16 seq)
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
_sequenceNumberForced = true;
|
|
_sequenceNumber = seq;
|
|
return 0;
|
|
}
|
|
|
|
WebRtc_UWord16
|
|
RTPSender::SequenceNumber() const
|
|
{
|
|
CriticalSectionScoped cs(_sendCritsect);
|
|
return _sequenceNumber;
|
|
}
|
|
|
|
|
|
/*
|
|
* Audio
|
|
*/
|
|
WebRtc_Word32
|
|
RTPSender::RegisterAudioCallback(RtpAudioFeedback* messagesCallback)
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _audio->RegisterAudioCallback(messagesCallback);
|
|
}
|
|
|
|
// Send a DTMF tone, RFC 2833 (4733)
|
|
WebRtc_Word32
|
|
RTPSender::SendTelephoneEvent(const WebRtc_UWord8 key,
|
|
const WebRtc_UWord16 time_ms,
|
|
const WebRtc_UWord8 level)
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _audio->SendTelephoneEvent(key, time_ms, level);
|
|
}
|
|
|
|
bool
|
|
RTPSender::SendTelephoneEventActive(WebRtc_Word8& telephoneEvent) const
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
return false;
|
|
}
|
|
return _audio->SendTelephoneEventActive(telephoneEvent);
|
|
}
|
|
|
|
// set audio packet size, used to determine when it's time to send a DTMF packet in silence (CNG)
|
|
WebRtc_Word32
|
|
RTPSender::SetAudioPacketSize(const WebRtc_UWord16 packetSizeSamples)
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _audio->SetAudioPacketSize(packetSizeSamples);
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetAudioLevelIndicationStatus(const bool enable,
|
|
const WebRtc_UWord8 ID)
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _audio->SetAudioLevelIndicationStatus(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);
|
|
}
|
|
|
|
// Set payload type for Redundant Audio Data RFC 2198
|
|
WebRtc_Word32
|
|
RTPSender::SetRED(const WebRtc_Word8 payloadType)
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _audio->SetRED(payloadType);
|
|
}
|
|
|
|
// Get payload type for Redundant Audio Data RFC 2198
|
|
WebRtc_Word32
|
|
RTPSender::RED(WebRtc_Word8& payloadType) const
|
|
{
|
|
if(!_audioConfigured)
|
|
{
|
|
return NULL;
|
|
}
|
|
return _audio->RED(payloadType);
|
|
}
|
|
|
|
/*
|
|
* Video
|
|
*/
|
|
VideoCodecInformation*
|
|
RTPSender::CodecInformationVideo()
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return NULL;
|
|
}
|
|
return _video->CodecInformationVideo();
|
|
}
|
|
|
|
RtpVideoCodecTypes
|
|
RTPSender::VideoCodecType() const
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return kRtpNoVideo;
|
|
}
|
|
return _video->VideoCodecType();
|
|
}
|
|
|
|
WebRtc_UWord32
|
|
RTPSender::MaxConfiguredBitrateVideo() const
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return 0;
|
|
}
|
|
return _video->MaxConfiguredBitrateVideo();
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SendRTPIntraRequest()
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _video->SendRTPIntraRequest();
|
|
}
|
|
|
|
// FEC
|
|
WebRtc_Word32
|
|
RTPSender::SetGenericFECStatus(const bool enable,
|
|
const WebRtc_UWord8 payloadTypeRED,
|
|
const WebRtc_UWord8 payloadTypeFEC)
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _video->SetGenericFECStatus(enable, payloadTypeRED, payloadTypeFEC);
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::GenericFECStatus(bool& enable,
|
|
WebRtc_UWord8& payloadTypeRED,
|
|
WebRtc_UWord8& payloadTypeFEC) const
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _video->GenericFECStatus(enable, payloadTypeRED, payloadTypeFEC);
|
|
}
|
|
|
|
WebRtc_Word32
|
|
RTPSender::SetFECCodeRate(const WebRtc_UWord8 keyFrameCodeRate,
|
|
const WebRtc_UWord8 deltaFrameCodeRate)
|
|
{
|
|
if(_audioConfigured)
|
|
{
|
|
return -1;
|
|
}
|
|
return _video->SetFECCodeRate(keyFrameCodeRate, deltaFrameCodeRate);
|
|
}
|
|
} // namespace webrtc
|