qrtplib::RTPSources Class Reference

#include <rtpsources.h>

Inheritance diagram for qrtplib::RTPSources:

Collaboration diagram for qrtplib::RTPSources:

Public Types
enum	ProbationType { NoProbation, ProbationDiscard, ProbationStore }

Public Member Functions
	RTPSources ()
virtual	~RTPSources ()
void	Clear ()
int	CreateOwnSSRC (uint32_t ssrc)
int	DeleteOwnSSRC ()
void	SentRTPPacket ()
int	ProcessRawPacket (RTPRawPacket *rawpack, RTPTransmitter *trans, bool acceptownpackets)
int	ProcessRawPacket (RTPRawPacket *rawpack, RTPTransmitter *trans[], int numtrans, bool acceptownpackets)
int	ProcessRTPPacket (RTPPacket *rtppack, const RTPTime &receivetime, const RTPAddress *senderaddress, bool *stored)
int	ProcessRTCPCompoundPacket (RTCPCompoundPacket *rtcpcomppack, const RTPTime &receivetime, const RTPAddress *senderaddress)
int	ProcessRTCPSenderInfo (uint32_t ssrc, const RTPNTPTime &ntptime, uint32_t rtptime, uint32_t packetcount, uint32_t octetcount, const RTPTime &receivetime, const RTPAddress *senderaddress)
int	ProcessRTCPReportBlock (uint32_t ssrc, uint8_t fractionlost, int32_t lostpackets, uint32_t exthighseqnr, uint32_t jitter, uint32_t lsr, uint32_t dlsr, const RTPTime &receivetime, const RTPAddress *senderaddress)
int	ProcessSDESNormalItem (uint32_t ssrc, RTCPSDESPacket::ItemType t, std::size_t itemlength, const void *itemdata, const RTPTime &receivetime, const RTPAddress *senderaddress)
int	ProcessSDESPrivateItem (uint32_t ssrc, std::size_t prefixlen, const void *prefixdata, std::size_t valuelen, const void *valuedata, const RTPTime &receivetime, const RTPAddress *senderaddress)
int	ProcessBYE (uint32_t ssrc, std::size_t reasonlength, const void *reasondata, const RTPTime &receivetime, const RTPAddress *senderaddress)
int	UpdateReceiveTime (uint32_t ssrc, const RTPTime &receivetime, const RTPAddress *senderaddress)
bool	GotoFirstSource ()
bool	GotoNextSource ()
bool	GotoPreviousSource ()
bool	GotoFirstSourceWithData ()
bool	GotoNextSourceWithData ()
bool	GotoPreviousSourceWithData ()
RTPSourceData *	GetCurrentSourceInfo ()
RTPSourceData *	GetSourceInfo (uint32_t ssrc)
RTPPacket *	GetNextPacket ()
bool	GotEntry (uint32_t ssrc)
RTPSourceData *	GetOwnSourceInfo ()
void	Timeout (const RTPTime &curtime, const RTPTime &timeoutdelay)
void	SenderTimeout (const RTPTime &curtime, const RTPTime &timeoutdelay)
void	BYETimeout (const RTPTime &curtime, const RTPTime &timeoutdelay)
void	NoteTimeout (const RTPTime &curtime, const RTPTime &timeoutdelay)
void	MultipleTimeouts (const RTPTime &curtime, const RTPTime &sendertimeout, const RTPTime &byetimeout, const RTPTime &generaltimeout, const RTPTime &notetimeout)
int	GetSenderCount () const
int	GetTotalCount () const
int	GetActiveMemberCount () const

Protected Member Functions
virtual void	OnRTPPacket (RTPPacket *pack, const RTPTime &receivetime, const RTPAddress *senderaddress)
virtual void	OnRTCPCompoundPacket (RTCPCompoundPacket *pack, const RTPTime &receivetime, const RTPAddress *senderaddress)
virtual void	OnSSRCCollision (RTPSourceData *srcdat, const RTPAddress *senderaddress, bool isrtp)
virtual void	OnCNAMECollision (RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, std::size_t cnamelength)
virtual void	OnNewSource (RTPSourceData *srcdat)
virtual void	OnRemoveSource (RTPSourceData *srcdat)
virtual void	OnTimeout (RTPSourceData *srcdat)
virtual void	OnBYETimeout (RTPSourceData *srcdat)
virtual void	OnBYEPacket (RTPSourceData *srcdat)
virtual void	OnRTCPSenderReport (RTPSourceData *srcdat)
virtual void	OnRTCPReceiverReport (RTPSourceData *srcdat)
virtual void	OnRTCPSDESItem (RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, std::size_t itemlength)
virtual void	OnRTCPSDESPrivateItem (RTPSourceData *srcdat, const void *prefixdata, std::size_t prefixlen, const void *valuedata, std::size_t valuelen)
virtual void	OnAPPPacket (RTCPAPPPacket *apppacket, const RTPTime &receivetime, const RTPAddress *senderaddress)
virtual void	OnUnknownPacketType (RTCPPacket *rtcppack, const RTPTime &receivetime, const RTPAddress *senderaddress)
virtual void	OnUnknownPacketFormat (RTCPPacket *rtcppack, const RTPTime &receivetime, const RTPAddress *senderaddress)
virtual void	OnNoteTimeout (RTPSourceData *srcdat)
virtual void	OnValidatedRTPPacket (RTPSourceData *srcdat, RTPPacket *rtppack, bool isonprobation, bool *ispackethandled)

Private Member Functions
void	ClearSourceList ()
int	ObtainSourceDataInstance (uint32_t ssrc, RTPInternalSourceData **srcdat, bool *created)
int	GetRTCPSourceData (uint32_t ssrc, const RTPAddress *senderaddress, RTPInternalSourceData **srcdat, bool *newsource)
bool	CheckCollision (RTPInternalSourceData *srcdat, const RTPAddress *senderaddress, bool isrtp)

Private Attributes
RTPKeyHashTable< const uint32_t, RTPInternalSourceData *, RTPSources_GetHashIndex, RTPSOURCES_HASHSIZE >	sourcelist
int	sendercount
int	totalcount
int	activecount
RTPInternalSourceData *	owndata

Friends
class	RTPInternalSourceData

Detailed Description

Represents a table in which information about the participating sources is kept. Represents a table in which information about the participating sources is kept. The class has member functions to process RTP and RTCP data and to iterate over the participants. Note that a NULL address is used to identify packets from our own session. The class also provides some overridable functions which can be used to catch certain events (new SSRC, SSRC collision, ...).

Definition at line 78 of file rtpsources.h.

Member Enumeration Documentation

ProbationType

enum qrtplib::RTPSources::ProbationType

Type of probation to use for new sources.

Enumerator
NoProbation	Don't use the probation algorithm; accept RTP packets immediately.
ProbationDiscard	Discard incoming RTP packets originating from a source that's on probation.
ProbationStore	Store incoming RTP packet from a source that's on probation for later retrieval.

Definition at line 82 of file rtpsources.h.

    {
        NoProbation, 
        ProbationDiscard, 
        ProbationStore 
    };

Constructor & Destructor Documentation

RTPSources()

qrtplib::RTPSources::RTPSources

(

)

In the constructor you can select the probation type you'd like to use and also a memory manager.

Definition at line 51 of file rtpsources.cpp.

References activecount, owndata, sendercount, and totalcount.

{
    totalcount = 0;
    sendercount = 0;
    activecount = 0;
    owndata = 0;
}

~RTPSources()

qrtplib::RTPSources::~RTPSources ( )

virtual

Definition at line 59 of file rtpsources.cpp.

References Clear().

{
    Clear();
}

Here is the call graph for this function:

Member Function Documentation

BYETimeout()

void qrtplib::RTPSources::BYETimeout	(	const RTPTime &	curtime,
		const RTPTime &	timeoutdelay
	)

Assuming that the current time is curtime, remove the members who sent a BYE packet more than the time interval timeoutdelay ago.

Definition at line 960 of file rtpsources.cpp.

References activecount, qrtplib::RTPSourceData::GetBYETime(), qrtplib::RTPSourceData::IsActive(), qrtplib::RTPSourceData::IsSender(), OnBYETimeout(), OnRemoveSource(), owndata, qrtplib::RTPSourceData::ReceivedBYE(), sendercount, sourcelist, and totalcount.

{
    int newtotalcount = 0;
    int newsendercount = 0;
    int newactivecount = 0;
    RTPTime checktime = curtime;
    checktime -= timeoutdelay;

    sourcelist.GotoFirstElement();
    while (sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat = sourcelist.GetCurrentElement();

        if (srcdat->ReceivedBYE())
        {
            RTPTime byetime = srcdat->GetBYETime();

            if ((srcdat != owndata) && (checktime > byetime))
            {
                totalcount--;
                if (srcdat->IsSender())
                    sendercount--;
                if (srcdat->IsActive())
                    activecount--;
                sourcelist.DeleteCurrentElement();
                OnBYETimeout(srcdat);
                OnRemoveSource(srcdat);
                delete srcdat;
            }
            else
            {
                newtotalcount++;
                if (srcdat->IsSender())
                    newsendercount++;
                if (srcdat->IsActive())
                    newactivecount++;
                sourcelist.GotoNextElement();
            }
        }
        else
        {
            newtotalcount++;
            if (srcdat->IsSender())
                newsendercount++;
            if (srcdat->IsActive())
                newactivecount++;
            sourcelist.GotoNextElement();
        }
    }

    totalcount = newtotalcount; // just to play it safe
    sendercount = newsendercount;
    activecount = newactivecount;
}

Here is the call graph for this function:

CheckCollision()

bool qrtplib::RTPSources::CheckCollision ( RTPInternalSourceData *  srcdat, const RTPAddress *  senderaddress, bool  isrtp  )

private

Definition at line 1168 of file rtpsources.cpp.

References qrtplib::RTPSourceData::GetRTCPDataAddress(), qrtplib::RTPSourceData::GetRTPDataAddress(), qrtplib::RTPAddress::IsFromSameHost(), qrtplib::RTPSourceData::IsRTCPAddressSet(), qrtplib::RTPSourceData::IsRTPAddressSet(), qrtplib::RTPAddress::IsSameAddress(), OnSSRCCollision(), qrtplib::RTPInternalSourceData::SetRTCPDataAddress(), and qrtplib::RTPInternalSourceData::SetRTPDataAddress().

Referenced by GetRTCPSourceData(), and ProcessRTPPacket().

{
    bool isset, otherisset;
    const RTPAddress *addr, *otheraddr;

    if (isrtp)
    {
        isset = srcdat->IsRTPAddressSet();
        addr = srcdat->GetRTPDataAddress();
        otherisset = srcdat->IsRTCPAddressSet();
        otheraddr = srcdat->GetRTCPDataAddress();
    }
    else
    {
        isset = srcdat->IsRTCPAddressSet();
        addr = srcdat->GetRTCPDataAddress();
        otherisset = srcdat->IsRTPAddressSet();
        otheraddr = srcdat->GetRTPDataAddress();
    }

    if (!isset)
    {
        if (otherisset) // got other address, can check if it comes from same host
        {
            if (otheraddr == 0) // other came from our own session
            {
                if (senderaddress != 0)
                {
                    OnSSRCCollision(srcdat, senderaddress, isrtp);
                    return true;
                }

                // Ok, store it

                if (isrtp)
                    srcdat->SetRTPDataAddress(senderaddress);
                else
                    srcdat->SetRTCPDataAddress(senderaddress);
            }
            else
            {
                if (!otheraddr->IsFromSameHost(senderaddress))
                {
                    OnSSRCCollision(srcdat, senderaddress, isrtp);
                    return true;
                }

                // Ok, comes from same host, store the address

                if (isrtp)
                    srcdat->SetRTPDataAddress(senderaddress);
                else
                    srcdat->SetRTCPDataAddress(senderaddress);
            }
        }
        else // no other address, store this one
        {
            if (isrtp)
                srcdat->SetRTPDataAddress(senderaddress);
            else
                srcdat->SetRTCPDataAddress(senderaddress);
        }
    }
    else // already got an address
    {
        if (addr == 0)
        {
            if (senderaddress != 0)
            {
                OnSSRCCollision(srcdat, senderaddress, isrtp);
                return true;
            }
        }
        else
        {
            if (!addr->IsSameAddress(senderaddress))
            {
                OnSSRCCollision(srcdat, senderaddress, isrtp);
                return true;
            }
        }
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void qrtplib::RTPSources::Clear

(

)

Clears the source table.

Definition at line 64 of file rtpsources.cpp.

References ClearSourceList().

Referenced by qrtplib::RTPSession::BYEDestroy(), qrtplib::RTPSession::Destroy(), qrtplib::RTPSession::InternalCreate(), and ~RTPSources().

{
    ClearSourceList();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ClearSourceList()

void qrtplib::RTPSources::ClearSourceList ( )

private

Definition at line 69 of file rtpsources.cpp.

References activecount, owndata, sendercount, sourcelist, and totalcount.

Referenced by Clear().

{
    sourcelist.GotoFirstElement();
    while (sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *sourcedata;

        sourcedata = sourcelist.GetCurrentElement();
        delete sourcedata;
        sourcelist.GotoNextElement();
    }
    sourcelist.Clear();
    owndata = 0;
    totalcount = 0;
    sendercount = 0;
    activecount = 0;
}

Here is the caller graph for this function:

CreateOwnSSRC()

int qrtplib::RTPSources::CreateOwnSSRC

(

uint32_t

ssrc

)

Creates an entry for our own SSRC identifier.

Definition at line 87 of file rtpsources.cpp.

References activecount, ERR_RTP_SOURCES_ALREADYHAVEOWNSSRC, ERR_RTP_SOURCES_SSRCEXISTS, GotEntry(), ObtainSourceDataInstance(), OnNewSource(), owndata, qrtplib::RTPInternalSourceData::SetOwnSSRC(), qrtplib::RTPInternalSourceData::SetRTCPDataAddress(), and qrtplib::RTPInternalSourceData::SetRTPDataAddress().

Referenced by qrtplib::RTPSession::InternalCreate(), and qrtplib::RTPSession::ProcessPolledData().

{
    if (owndata != 0)
        return ERR_RTP_SOURCES_ALREADYHAVEOWNSSRC;
    if (GotEntry(ssrc))
        return ERR_RTP_SOURCES_SSRCEXISTS;

    int status;
    bool created;

    status = ObtainSourceDataInstance(ssrc, &owndata, &created);
    if (status < 0)
    {
        owndata = 0; // just to make sure
        return status;
    }
    owndata->SetOwnSSRC();
    owndata->SetRTPDataAddress(0);
    owndata->SetRTCPDataAddress(0);

    // we've created a validated ssrc, so we should increase activecount
    activecount++;

    OnNewSource(owndata);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteOwnSSRC()

int qrtplib::RTPSources::DeleteOwnSSRC

(

)

Deletes the entry for our own SSRC identifier.

Definition at line 114 of file rtpsources.cpp.

References activecount, ERR_RTP_SOURCES_DONTHAVEOWNSSRC, qrtplib::RTPSourceData::GetSSRC(), qrtplib::RTPSourceData::IsActive(), qrtplib::RTPSourceData::IsSender(), OnRemoveSource(), owndata, sendercount, sourcelist, and totalcount.

Referenced by qrtplib::RTPSession::ProcessPolledData().

{
    if (owndata == 0)
        return ERR_RTP_SOURCES_DONTHAVEOWNSSRC;

    uint32_t ssrc = owndata->GetSSRC();

    sourcelist.GotoElement(ssrc);
    sourcelist.DeleteCurrentElement();

    totalcount--;
    if (owndata->IsSender())
        sendercount--;
    if (owndata->IsActive())
        activecount--;

    OnRemoveSource(owndata);

    delete owndata;
    owndata = 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetActiveMemberCount()

int qrtplib::RTPSources::GetActiveMemberCount ( ) const

inline

Returns the number of members which have been validated and which haven't sent a BYE packet yet.

Definition at line 287 of file rtpsources.h.

Referenced by qrtplib::RTCPScheduler::ActiveMemberDecrease(), qrtplib::RTCPScheduler::CalculateDeterministicInterval(), qrtplib::RTCPScheduler::GetTransmissionDelay(), qrtplib::RTCPScheduler::IsTime(), qrtplib::RTCPScheduler::PerformReverseReconsideration(), and qrtplib::RTCPScheduler::ScheduleBYEPacket().

    {
        return activecount;
    }

Here is the caller graph for this function:

GetCurrentSourceInfo()

RTPSourceData * qrtplib::RTPSources::GetCurrentSourceInfo

(

)

Returns the RTPSourceData instance for the currently selected participant.

Definition at line 609 of file rtpsources.cpp.

References sourcelist.

Referenced by qrtplib::RTCPPacketBuilder::ClearAllSourceFlags(), qrtplib::RTCPPacketBuilder::FillInReportBlocks(), and qrtplib::RTPSession::GetCurrentSourceInfo().

{
    if (!sourcelist.HasCurrentElement())
        return 0;
    return sourcelist.GetCurrentElement();
}

Here is the caller graph for this function:

GetNextPacket()

RTPPacket * qrtplib::RTPSources::GetNextPacket

(

)

Extracts the next packet from the received packets queue of the current participant.

Definition at line 630 of file rtpsources.cpp.

References qrtplib::RTPSourceData::GetNextPacket(), and sourcelist.

Referenced by qrtplib::RTPSession::GetNextPacket().

{
    if (!sourcelist.HasCurrentElement())
        return 0;

    RTPInternalSourceData *srcdat = sourcelist.GetCurrentElement();
    RTPPacket *pack = srcdat->GetNextPacket();
    return pack;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetOwnSourceInfo()

RTPSourceData* qrtplib::RTPSources::GetOwnSourceInfo ( )

inline

If present, it returns the RTPSourceData instance of the entry which was created by CreateOwnSSRC.

Definition at line 243 of file rtpsources.h.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket(), qrtplib::RTCPPacketBuilder::BuildNextPacket(), qrtplib::RTCPScheduler::CalculateNextRTCPTime(), and qrtplib::RTCPScheduler::IsTime().

    {
        return (RTPSourceData *) owndata;
    }

Here is the caller graph for this function:

GetRTCPSourceData()

int qrtplib::RTPSources::GetRTCPSourceData ( uint32_t  ssrc, const RTPAddress *  senderaddress, RTPInternalSourceData **  srcdat, bool *  newsource  )

private

Definition at line 827 of file rtpsources.cpp.

References CheckCollision(), ObtainSourceDataInstance(), and qrtplib::RTPInternalSourceData::SetRTCPDataAddress().

Referenced by ProcessBYE(), ProcessRTCPReportBlock(), ProcessRTCPSenderInfo(), ProcessSDESNormalItem(), ProcessSDESPrivateItem(), and UpdateReceiveTime().

{
    int status;
    bool created;
    RTPInternalSourceData *srcdat;

    *srcdat2 = 0;

    if ((status = ObtainSourceDataInstance(ssrc, &srcdat, &created)) < 0)
        return status;

    if (created)
    {
        if ((status = srcdat->SetRTCPDataAddress(senderaddress)) < 0)
            return status;
    }
    else // got a previously existing source
    {
        if (CheckCollision(srcdat, senderaddress, false))
            return 0; // ignore packet on collision
    }

    *srcdat2 = srcdat;
    *newsource = created;

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetSenderCount()

int qrtplib::RTPSources::GetSenderCount ( ) const

inline

Returns the number of participants which are marked as a sender.

Definition at line 275 of file rtpsources.h.

Referenced by qrtplib::RTCPScheduler::CalculateDeterministicInterval().

    {
        return sendercount;
    }

Here is the caller graph for this function:

GetSourceInfo()

RTPSourceData * qrtplib::RTPSources::GetSourceInfo

(

uint32_t

ssrc

)

Returns the RTPSourceData instance for the participant identified by ssrc, or NULL if no such entry exists.

Definition at line 616 of file rtpsources.cpp.

References sourcelist.

Referenced by qrtplib::RTPSession::GetSourceInfo().

{
    if (sourcelist.GotoElement(ssrc) < 0)
        return 0;
    if (!sourcelist.HasCurrentElement())
        return 0;
    return sourcelist.GetCurrentElement();
}

Here is the caller graph for this function:

GetTotalCount()

int qrtplib::RTPSources::GetTotalCount ( ) const

inline

Returns the total number of entries in the source table.

Definition at line 281 of file rtpsources.h.

Referenced by qrtplib::RTCPPacketBuilder::BuildNextPacket().

    {
        return totalcount;
    }

Here is the caller graph for this function:

GotEntry()

bool qrtplib::RTPSources::GotEntry

(

uint32_t

ssrc

)

Returns true if an entry for participant ssrc exists and false otherwise.

Definition at line 625 of file rtpsources.cpp.

References sourcelist.

Referenced by qrtplib::RTPPacketBuilder::CreateNewSSRC(), and CreateOwnSSRC().

{
    return sourcelist.HasElement(ssrc);
}

Here is the caller graph for this function:

GotoFirstSource()

bool qrtplib::RTPSources::GotoFirstSource

(

)

Starts the iteration over the participants by going to the first member in the table. Starts the iteration over the participants by going to the first member in the table. If a member was found, the function returns true, otherwise it returns false.

Definition at line 528 of file rtpsources.cpp.

References sourcelist.

Referenced by qrtplib::RTCPPacketBuilder::ClearAllSourceFlags(), qrtplib::RTCPPacketBuilder::FillInReportBlocks(), and qrtplib::RTPSession::GotoFirstSource().

{
    sourcelist.GotoFirstElement();
    if (sourcelist.HasCurrentElement())
        return true;
    return false;
}

Here is the caller graph for this function:

GotoFirstSourceWithData()

bool qrtplib::RTPSources::GotoFirstSourceWithData

(

)

Sets the current source to be the first source in the table which has RTPPacket instances that we haven't extracted yet. Sets the current source to be the first source in the table which has RTPPacket instances that we haven't extracted yet. If no such member was found, the function returns false, otherwise it returns true.

Definition at line 552 of file rtpsources.cpp.

References qrtplib::RTPSourceData::HasData(), and sourcelist.

Referenced by qrtplib::RTPSession::GotoFirstSourceWithData().

{
    bool found = false;

    sourcelist.GotoFirstElement();
    while (!found && sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat;

        srcdat = sourcelist.GetCurrentElement();
        if (srcdat->HasData())
            found = true;
        else
            sourcelist.GotoNextElement();
    }

    return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GotoNextSource()

bool qrtplib::RTPSources::GotoNextSource

(

)

Sets the current source to be the next source in the table. Sets the current source to be the next source in the table. If we're already at the last source, the function returns false, otherwise it returns true.

Definition at line 536 of file rtpsources.cpp.

References sourcelist.

Referenced by qrtplib::RTCPPacketBuilder::ClearAllSourceFlags(), qrtplib::RTCPPacketBuilder::FillInReportBlocks(), and qrtplib::RTPSession::GotoNextSource().

{
    sourcelist.GotoNextElement();
    if (sourcelist.HasCurrentElement())
        return true;
    return false;
}

Here is the caller graph for this function:

GotoNextSourceWithData()

bool qrtplib::RTPSources::GotoNextSourceWithData

(

)

Sets the current source to be the next source in the table which has RTPPacket instances that we haven't extracted yet. Sets the current source to be the next source in the table which has RTPPacket instances that we haven't extracted yet. If no such member was found, the function returns false, otherwise it returns true.

Definition at line 571 of file rtpsources.cpp.

References qrtplib::RTPSourceData::HasData(), and sourcelist.

Referenced by qrtplib::RTPSession::GotoNextSourceWithData().

{
    bool found = false;

    sourcelist.GotoNextElement();
    while (!found && sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat;

        srcdat = sourcelist.GetCurrentElement();
        if (srcdat->HasData())
            found = true;
        else
            sourcelist.GotoNextElement();
    }

    return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GotoPreviousSource()

bool qrtplib::RTPSources::GotoPreviousSource

(

)

Sets the current source to be the previous source in the table. Sets the current source to be the previous source in the table. If we're at the first source, the function returns false, otherwise it returns true.

Definition at line 544 of file rtpsources.cpp.

References sourcelist.

Referenced by qrtplib::RTPSession::GotoPreviousSource().

{
    sourcelist.GotoPreviousElement();
    if (sourcelist.HasCurrentElement())
        return true;
    return false;
}

Here is the caller graph for this function:

GotoPreviousSourceWithData()

bool qrtplib::RTPSources::GotoPreviousSourceWithData

(

)

Sets the current source to be the previous source in the table which has RTPPacket instances that we haven't extracted yet. Sets the current source to be the previous source in the table which has RTPPacket instances that we haven't extracted yet. If no such member was found, the function returns false, otherwise it returns true.

Definition at line 590 of file rtpsources.cpp.

References qrtplib::RTPSourceData::HasData(), and sourcelist.

Referenced by qrtplib::RTPSession::GotoPreviousSourceWithData().

{
    bool found = false;

    sourcelist.GotoPreviousElement();
    while (!found && sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat;

        srcdat = sourcelist.GetCurrentElement();
        if (srcdat->HasData())
            found = true;
        else
            sourcelist.GotoPreviousElement();
    }

    return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MultipleTimeouts()

void qrtplib::RTPSources::MultipleTimeouts	(	const RTPTime &	curtime,
		const RTPTime &	sendertimeout,
		const RTPTime &	byetimeout,
		const RTPTime &	generaltimeout,
		const RTPTime &	notetimeout
	)

Combines the functions SenderTimeout, BYETimeout, Timeout and NoteTimeout. Combines the functions SenderTimeout, BYETimeout, Timeout and NoteTimeout. This is more efficient than calling all four functions since only one iteration is needed in this function.

Definition at line 1055 of file rtpsources.cpp.

References activecount, qrtplib::RTPInternalSourceData::ClearNote(), qrtplib::RTPInternalSourceData::ClearSenderFlag(), qrtplib::RTPSourceData::GetBYETime(), qrtplib::RTPSourceData::INF_GetLastMessageTime(), qrtplib::RTPSourceData::INF_GetLastRTPPacketTime(), qrtplib::RTPSourceData::INF_GetLastSDESNoteTime(), qrtplib::RTPSourceData::IsActive(), qrtplib::RTPSourceData::IsSender(), OnBYETimeout(), OnNoteTimeout(), OnRemoveSource(), OnTimeout(), owndata, qrtplib::RTPSourceData::ReceivedBYE(), qrtplib::RTPSourceData::SDES_GetNote(), sendercount, sourcelist, and totalcount.

Referenced by qrtplib::RTPSession::ProcessPolledData().

{
    int newtotalcount = 0;
    int newsendercount = 0;
    int newactivecount = 0;
    RTPTime senderchecktime = curtime;
    RTPTime byechecktime = curtime;
    RTPTime generaltchecktime = curtime;
    RTPTime notechecktime = curtime;
    senderchecktime -= sendertimeout;
    byechecktime -= byetimeout;
    generaltchecktime -= generaltimeout;
    notechecktime -= notetimeout;

    sourcelist.GotoFirstElement();
    while (sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat = sourcelist.GetCurrentElement();
        bool deleted, issender, isactive;
        bool byetimeout, normaltimeout, notetimeout;

        std::size_t notelen;

        issender = srcdat->IsSender();
        isactive = srcdat->IsActive();
        deleted = false;
        byetimeout = false;
        normaltimeout = false;
        notetimeout = false;

        srcdat->SDES_GetNote(&notelen);
        if (notelen != 0) // Note has been set
        {
            RTPTime notetime = srcdat->INF_GetLastSDESNoteTime();

            if (notechecktime > notetime)
            {
                notetimeout = true;
                srcdat->ClearNote();
            }
        }

        if (srcdat->ReceivedBYE())
        {
            RTPTime byetime = srcdat->GetBYETime();

            if ((srcdat != owndata) && (byechecktime > byetime))
            {
                sourcelist.DeleteCurrentElement();
                deleted = true;
                byetimeout = true;
            }
        }

        if (!deleted)
        {
            RTPTime lastmsgtime = srcdat->INF_GetLastMessageTime();

            if ((srcdat != owndata) && (lastmsgtime < generaltchecktime))
            {
                sourcelist.DeleteCurrentElement();
                deleted = true;
                normaltimeout = true;
            }
        }

        if (!deleted)
        {
            newtotalcount++;

            if (issender)
            {
                RTPTime lastrtppacktime = srcdat->INF_GetLastRTPPacketTime();

                if (lastrtppacktime < senderchecktime)
                {
                    srcdat->ClearSenderFlag();
                    sendercount--;
                }
                else
                    newsendercount++;
            }

            if (isactive)
                newactivecount++;

            if (notetimeout)
                OnNoteTimeout(srcdat);

            sourcelist.GotoNextElement();
        }
        else // deleted entry
        {
            if (issender)
                sendercount--;
            if (isactive)
                activecount--;
            totalcount--;

            if (byetimeout)
                OnBYETimeout(srcdat);
            if (normaltimeout)
                OnTimeout(srcdat);
            OnRemoveSource(srcdat);
            delete srcdat;
        }
    }

    totalcount = newtotalcount; // just to play it safe
    sendercount = newsendercount;
    activecount = newactivecount;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NoteTimeout()

void qrtplib::RTPSources::NoteTimeout	(	const RTPTime &	curtime,
		const RTPTime &	timeoutdelay
	)

Assuming that the current time is curtime, clear the SDES NOTE items which haven't been updated during the previous time interval timeoutdelay.

Definition at line 1015 of file rtpsources.cpp.

References activecount, qrtplib::RTPInternalSourceData::ClearNote(), qrtplib::RTPSourceData::INF_GetLastSDESNoteTime(), qrtplib::RTPSourceData::IsActive(), qrtplib::RTPSourceData::IsSender(), OnNoteTimeout(), qrtplib::RTPSourceData::SDES_GetNote(), sendercount, sourcelist, and totalcount.

{
    int newtotalcount = 0;
    int newsendercount = 0;
    int newactivecount = 0;
    RTPTime checktime = curtime;
    checktime -= timeoutdelay;

    sourcelist.GotoFirstElement();
    while (sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat = sourcelist.GetCurrentElement();
        std::size_t notelen;

        srcdat->SDES_GetNote(&notelen);
        if (notelen != 0) // Note has been set
        {
            RTPTime notetime = srcdat->INF_GetLastSDESNoteTime();

            if (checktime > notetime)
            {
                srcdat->ClearNote();
                OnNoteTimeout(srcdat);
            }
        }

        newtotalcount++;
        if (srcdat->IsSender())
            newsendercount++;
        if (srcdat->IsActive())
            newactivecount++;
        sourcelist.GotoNextElement();
    }

    totalcount = newtotalcount; // just to play it safe
    sendercount = newsendercount;
    activecount = newactivecount;

}

Here is the call graph for this function:

ObtainSourceDataInstance()

int qrtplib::RTPSources::ObtainSourceDataInstance ( uint32_t  ssrc, RTPInternalSourceData **  srcdat, bool *  created  )

private

Definition at line 802 of file rtpsources.cpp.

References RTPInternalSourceData, sourcelist, and totalcount.

Referenced by CreateOwnSSRC(), GetRTCPSourceData(), and ProcessRTPPacket().

{
    RTPInternalSourceData *srcdat2;
    int status;

    if (sourcelist.GotoElement(ssrc) < 0) // No entry for this source
    {
        srcdat2 = new RTPInternalSourceData(ssrc);
        if ((status = sourcelist.AddElement(ssrc, srcdat2)) < 0)
        {
            delete srcdat2;
            return status;
        }
        *srcdat = srcdat2;
        *created = true;
        totalcount++;
    }
    else
    {
        *srcdat = sourcelist.GetCurrentElement();
        *created = false;
    }
    return 0;
}

Here is the caller graph for this function:

OnAPPPacket()

void qrtplib::RTPSources::OnAPPPacket ( RTCPAPPPacket *  apppacket, const RTPTime &  receivetime, const RTPAddress *  senderaddress  )

inlineprotectedvirtual

Is called when an RTCP APP packet apppacket has been received at time receivetime from address senderaddress.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 415 of file rtpsources.h.

Referenced by ProcessRTCPCompoundPacket().

{
}

Here is the caller graph for this function:

OnBYEPacket()

void qrtplib::RTPSources::OnBYEPacket ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when a BYE packet has been processed for source srcdat.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 398 of file rtpsources.h.

Referenced by ProcessBYE().

{
}

Here is the caller graph for this function:

OnBYETimeout()

void qrtplib::RTPSources::OnBYETimeout ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when participant srcdat is timed after having sent a BYE packet.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 395 of file rtpsources.h.

Referenced by BYETimeout(), and MultipleTimeouts().

{
}

Here is the caller graph for this function:

OnCNAMECollision()

void qrtplib::RTPSources::OnCNAMECollision ( RTPSourceData *  srcdat, const RTPAddress *  senderaddress, const uint8_t *  cname, std::size_t  cnamelength  )

inlineprotectedvirtual

Is called when another CNAME was received than the one already present for source srcdat.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 383 of file rtpsources.h.

Referenced by ProcessSDESNormalItem().

{
}

Here is the caller graph for this function:

OnNewSource()

void qrtplib::RTPSources::OnNewSource ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when a new entry srcdat is added to the source table.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 386 of file rtpsources.h.

Referenced by CreateOwnSSRC(), ProcessBYE(), ProcessRTCPReportBlock(), ProcessRTCPSenderInfo(), ProcessRTPPacket(), ProcessSDESNormalItem(), ProcessSDESPrivateItem(), and UpdateReceiveTime().

{
}

Here is the caller graph for this function:

OnNoteTimeout()

void qrtplib::RTPSources::OnNoteTimeout ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when the SDES NOTE item for source srcdat has been timed out.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 424 of file rtpsources.h.

Referenced by MultipleTimeouts(), and NoteTimeout().

{
}

Here is the caller graph for this function:

OnRemoveSource()

void qrtplib::RTPSources::OnRemoveSource ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when the entry srcdat is about to be deleted from the source table.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 389 of file rtpsources.h.

Referenced by BYETimeout(), DeleteOwnSSRC(), MultipleTimeouts(), and Timeout().

{
}

Here is the caller graph for this function:

OnRTCPCompoundPacket()

void qrtplib::RTPSources::OnRTCPCompoundPacket ( RTCPCompoundPacket *  pack, const RTPTime &  receivetime, const RTPAddress *  senderaddress  )

inlineprotectedvirtual

Is called when an RTCP compound packet is about to be processed.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 377 of file rtpsources.h.

Referenced by ProcessRTCPCompoundPacket().

{
}

Here is the caller graph for this function:

OnRTCPReceiverReport()

void qrtplib::RTPSources::OnRTCPReceiverReport ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when an RTCP receiver report has been processed for this source.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 404 of file rtpsources.h.

Referenced by ProcessRTCPReportBlock().

{
}

Here is the caller graph for this function:

OnRTCPSDESItem()

void qrtplib::RTPSources::OnRTCPSDESItem ( RTPSourceData *  srcdat, RTCPSDESPacket::ItemType  t, const void *  itemdata, std::size_t  itemlength  )

inlineprotectedvirtual

Is called when a specific SDES item was received for this source.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 407 of file rtpsources.h.

Referenced by ProcessSDESNormalItem().

{
}

Here is the caller graph for this function:

OnRTCPSDESPrivateItem()

void qrtplib::RTPSources::OnRTCPSDESPrivateItem ( RTPSourceData *  srcdat, const void *  prefixdata, std::size_t  prefixlen, const void *  valuedata, std::size_t  valuelen  )

inlineprotectedvirtual

Is called when a specific SDES item of 'private' type was received for this source.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 411 of file rtpsources.h.

Referenced by ProcessSDESPrivateItem().

{
}

Here is the caller graph for this function:

OnRTCPSenderReport()

void qrtplib::RTPSources::OnRTCPSenderReport ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when an RTCP sender report has been processed for this source.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 401 of file rtpsources.h.

Referenced by ProcessRTCPSenderInfo().

{
}

Here is the caller graph for this function:

OnRTPPacket()

void qrtplib::RTPSources::OnRTPPacket ( RTPPacket *  pack, const RTPTime &  receivetime, const RTPAddress *  senderaddress  )

inlineprotectedvirtual

Is called when an RTP packet is about to be processed.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 374 of file rtpsources.h.

Referenced by ProcessRTPPacket().

{
}

Here is the caller graph for this function:

OnSSRCCollision()

void qrtplib::RTPSources::OnSSRCCollision ( RTPSourceData *  srcdat, const RTPAddress *  senderaddress, bool  isrtp  )

inlineprotectedvirtual

Is called when an SSRC collision was detected. Is called when an SSRC collision was detected. The instance srcdat is the one present in the table, the address senderaddress is the one that collided with one of the addresses and isrtp indicates against which address of srcdat the check failed.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 380 of file rtpsources.h.

Referenced by CheckCollision().

{
}

Here is the caller graph for this function:

OnTimeout()

void qrtplib::RTPSources::OnTimeout ( RTPSourceData *  srcdat )

inlineprotectedvirtual

Is called when participant srcdat is timed out.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 392 of file rtpsources.h.

Referenced by MultipleTimeouts(), and Timeout().

{
}

Here is the caller graph for this function:

OnUnknownPacketFormat()

void qrtplib::RTPSources::OnUnknownPacketFormat ( RTCPPacket *  rtcppack, const RTPTime &  receivetime, const RTPAddress *  senderaddress  )

inlineprotectedvirtual

Is called when an unknown packet format for a known packet type was detected.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 421 of file rtpsources.h.

Referenced by ProcessRTCPCompoundPacket().

{
}

Here is the caller graph for this function:

OnUnknownPacketType()

void qrtplib::RTPSources::OnUnknownPacketType ( RTCPPacket *  rtcppack, const RTPTime &  receivetime, const RTPAddress *  senderaddress  )

inlineprotectedvirtual

Is called when an unknown RTCP packet type was detected.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 418 of file rtpsources.h.

Referenced by ProcessRTCPCompoundPacket().

{
}

Here is the caller graph for this function:

OnValidatedRTPPacket()

void qrtplib::RTPSources::OnValidatedRTPPacket ( RTPSourceData *  srcdat, RTPPacket *  rtppack, bool  isonprobation, bool *  ispackethandled  )

inlineprotectedvirtual

Allows you to use an RTP packet from the specified source directly. Allows you to use an RTP packet from the specified source directly. If ispackethandled is set to true, the packet will no longer be stored in this source's packet list.

Reimplemented in qrtplib::RTPSessionSources.

Definition at line 427 of file rtpsources.h.

Referenced by qrtplib::RTPInternalSourceData::ProcessRTPPacket().

{
}

Here is the caller graph for this function:

ProcessBYE()

int qrtplib::RTPSources::ProcessBYE	(	uint32_t	ssrc,
		std::size_t	reasonlength,
		const void *	reasondata,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress
	)

Processes the BYE message for SSRC ssrc. Processes the BYE message for SSRC ssrc. The information was received at time receivetime from address senderaddress. The senderaddress parameter must be NULL if the packet was sent by the local participant.

Definition at line 773 of file rtpsources.cpp.

References activecount, GetRTCPSourceData(), qrtplib::RTPSourceData::IsActive(), OnBYEPacket(), OnNewSource(), owndata, and qrtplib::RTPInternalSourceData::ProcessBYEPacket().

Referenced by ProcessRTCPCompoundPacket().

{
    RTPInternalSourceData *srcdat;
    bool created;
    int status;
    bool prevactive;

    status = GetRTCPSourceData(ssrc, senderaddress, &srcdat, &created);
    if (status < 0)
        return status;
    if (srcdat == 0)
        return 0;

    // we'll ignore BYE packets for our own ssrc
    if (srcdat == owndata)
        return 0;

    prevactive = srcdat->IsActive();
    srcdat->ProcessBYEPacket((const uint8_t *) reasondata, reasonlength, receivetime);
    if (prevactive && !srcdat->IsActive())
        activecount--;

    // Call the callback
    if (created)
        OnNewSource(srcdat);
    OnBYEPacket(srcdat);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessRawPacket() [1/2]

int qrtplib::RTPSources::ProcessRawPacket	(	RTPRawPacket *	rawpack,
		RTPTransmitter *	trans,
		bool	acceptownpackets
	)

Processes a raw packet rawpack. Processes a raw packet rawpack. The instance trans will be used to check if this packet is one of our own packets. The flag acceptownpackets indicates whether own packets should be accepted or ignored.

Definition at line 149 of file rtpsources.cpp.

Referenced by qrtplib::RTPSession::ProcessPolledData().

{
    RTPTransmitter *transmitters[1];
    int num;

    transmitters[0] = rtptrans;
    if (rtptrans == 0)
        num = 0;
    else
        num = 1;
    return ProcessRawPacket(rawpack, transmitters, num, acceptownpackets);
}

Here is the caller graph for this function:

ProcessRawPacket() [2/2]

int qrtplib::RTPSources::ProcessRawPacket	(	RTPRawPacket *	rawpack,
		RTPTransmitter *	trans[],
		int	numtrans,
		bool	acceptownpackets
	)

Processes a raw packet rawpack. Processes a raw packet rawpack. Every transmitter in the array trans of length numtrans is used to check if the packet is from our own session. The flag acceptownpackets indicates whether own packets should be accepted or ignored.

Definition at line 162 of file rtpsources.cpp.

References ERR_RTP_PACKET_INVALIDPACKET, ERR_RTP_RTCPCOMPOUND_INVALIDPACKET, qrtplib::RTCPCompoundPacket::GetCreationError(), qrtplib::RTPPacket::GetCreationError(), qrtplib::RTPRawPacket::GetReceiveTime(), qrtplib::RTPRawPacket::GetSenderAddress(), i, qrtplib::RTPRawPacket::IsRTP(), ProcessRTCPCompoundPacket(), and ProcessRTPPacket().

{
    int status;

    if (rawpack->IsRTP()) // RTP packet
    {
        RTPPacket *rtppack;

        // First, we'll see if the packet can be parsed
        rtppack = new RTPPacket(*rawpack);

        if ((status = rtppack->GetCreationError()) < 0)
        {
            if (status == ERR_RTP_PACKET_INVALIDPACKET)
            {
                delete rtppack;
                rtppack = 0;
            }
            else
            {
                delete rtppack;
                return status;
            }
        }

        // Check if the packet was valid
        if (rtppack != 0)
        {
            bool stored = false;
            bool ownpacket = false;
            int i;
            const RTPAddress& senderaddress = rawpack->GetSenderAddress();

            for (i = 0; !ownpacket && i < numtrans; i++)
            {
                if (rtptrans[i]->ComesFromThisTransmitter(senderaddress))
                    ownpacket = true;
            }

            // Check if the packet is our own.
            if (ownpacket)
            {
                // Now it depends on the user's preference
                // what to do with this packet:
                if (acceptownpackets)
                {
                    // sender addres for own packets has to be NULL!
                    if ((status = ProcessRTPPacket(rtppack, rawpack->GetReceiveTime(), 0, &stored)) < 0)
                    {
                        if (!stored)
                            delete rtppack;
                        return status;
                    }
                }
            }
            else
            {
                if ((status = ProcessRTPPacket(rtppack, rawpack->GetReceiveTime(), &senderaddress, &stored)) < 0)
                {
                    if (!stored)
                        delete rtppack;
                    return status;
                }
            }
            if (!stored)
                delete rtppack;
        }
    }
    else // RTCP packet
    {
        RTCPCompoundPacket rtcpcomppack(*rawpack);
        bool valid = false;

        if ((status = rtcpcomppack.GetCreationError()) < 0)
        {
            if (status != ERR_RTP_RTCPCOMPOUND_INVALIDPACKET)
                return status;
        }
        else
            valid = true;

        if (valid)
        {
            bool ownpacket = false;
            int i;
            const RTPAddress& senderaddress = rawpack->GetSenderAddress();

            for (i = 0; !ownpacket && i < numtrans; i++)
            {
                if (rtptrans[i]->ComesFromThisTransmitter(senderaddress))
                    ownpacket = true;
            }

            // First check if it's a packet of this session.
            if (ownpacket)
            {
                if (acceptownpackets)
                {
                    // sender address for own packets has to be NULL
                    status = ProcessRTCPCompoundPacket(&rtcpcomppack, rawpack->GetReceiveTime(), 0);
                    if (status < 0)
                        return status;
                }
            }
            else // not our own packet
            {
                status = ProcessRTCPCompoundPacket(&rtcpcomppack, rawpack->GetReceiveTime(), &rawpack->GetSenderAddress());
                if (status < 0)
                    return status;
            }
        }
    }

    return 0;
}

Here is the call graph for this function:

ProcessRTCPCompoundPacket()

int qrtplib::RTPSources::ProcessRTCPCompoundPacket	(	RTCPCompoundPacket *	rtcpcomppack,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress
	)

Processes the RTCP compound packet rtcpcomppack which was received at time receivetime from senderaddress. Processes the RTCP compound packet rtcpcomppack which was received at time receivetime from senderaddress. The senderaddress parameter must be NULL if the packet was sent by the local participant.

Definition at line 362 of file rtpsources.cpp.

References qrtplib::RTCPPacket::APP, qrtplib::RTCPPacket::BYE, qrtplib::RTCPSDESPacket::GetChunkSSRC(), qrtplib::RTCPRRPacket::GetDLSR(), qrtplib::RTCPSRPacket::GetDLSR(), qrtplib::RTCPRRPacket::GetExtendedHighestSequenceNumber(), qrtplib::RTCPSRPacket::GetExtendedHighestSequenceNumber(), qrtplib::RTCPRRPacket::GetFractionLost(), qrtplib::RTCPSRPacket::GetFractionLost(), qrtplib::RTCPSDESPacket::GetItemData(), qrtplib::RTCPSDESPacket::GetItemLength(), qrtplib::RTCPSDESPacket::GetItemType(), qrtplib::RTCPRRPacket::GetJitter(), qrtplib::RTCPSRPacket::GetJitter(), qrtplib::RTCPRRPacket::GetLostPacketCount(), qrtplib::RTCPSRPacket::GetLostPacketCount(), qrtplib::RTCPRRPacket::GetLSR(), qrtplib::RTCPSRPacket::GetLSR(), qrtplib::RTCPCompoundPacket::GetNextPacket(), qrtplib::RTCPSRPacket::GetNTPTimestamp(), qrtplib::RTCPPacket::GetPacketType(), qrtplib::RTCPSDESPacket::GetPRIVPrefixData(), qrtplib::RTCPSDESPacket::GetPRIVPrefixLength(), qrtplib::RTCPSDESPacket::GetPRIVValueData(), qrtplib::RTCPSDESPacket::GetPRIVValueLength(), qrtplib::RTCPBYEPacket::GetReasonData(), qrtplib::RTCPBYEPacket::GetReasonLength(), qrtplib::RTCPRRPacket::GetReceptionReportCount(), qrtplib::RTCPSRPacket::GetReceptionReportCount(), qrtplib::RTCPSRPacket::GetRTPTimestamp(), qrtplib::RTCPSRPacket::GetSenderOctetCount(), qrtplib::RTCPSRPacket::GetSenderPacketCount(), qrtplib::RTCPRRPacket::GetSenderSSRC(), qrtplib::RTCPSRPacket::GetSenderSSRC(), qrtplib::RTCPBYEPacket::GetSSRC(), qrtplib::RTCPRRPacket::GetSSRC(), qrtplib::RTCPSRPacket::GetSSRC(), qrtplib::RTPSourceData::GetSSRC(), qrtplib::RTCPBYEPacket::GetSSRCCount(), qrtplib::RTCPSDESPacket::GotoFirstChunk(), qrtplib::RTCPSDESPacket::GotoFirstItem(), qrtplib::RTCPCompoundPacket::GotoFirstPacket(), qrtplib::RTCPSDESPacket::GotoNextChunk(), qrtplib::RTCPSDESPacket::GotoNextItem(), i, qrtplib::RTCPPacket::IsKnownFormat(), OnAPPPacket(), OnRTCPCompoundPacket(), OnUnknownPacketFormat(), OnUnknownPacketType(), owndata, qrtplib::RTCPSDESPacket::PRIV, ProcessBYE(), ProcessRTCPReportBlock(), ProcessRTCPSenderInfo(), ProcessSDESNormalItem(), ProcessSDESPrivateItem(), qrtplib::RTCPPacket::RR, qrtplib::RTCPPacket::SDES, qrtplib::RTCPPacket::SR, qrtplib::RTCPPacket::Unknown, and UpdateReceiveTime().

Referenced by ProcessRawPacket().

{
    RTCPPacket *rtcppack;
    int status;
    bool gotownssrc = ((owndata == 0) ? false : true);
    uint32_t ownssrc = ((owndata != 0) ? owndata->GetSSRC() : 0);

    OnRTCPCompoundPacket(rtcpcomppack, receivetime, senderaddress);

    rtcpcomppack->GotoFirstPacket();
    while ((rtcppack = rtcpcomppack->GetNextPacket()) != 0)
    {
        if (rtcppack->IsKnownFormat())
        {
            switch (rtcppack->GetPacketType())
            {
            case RTCPPacket::SR:
            {
                RTCPSRPacket *p = (RTCPSRPacket *) rtcppack;
                uint32_t senderssrc = p->GetSenderSSRC();

                status = ProcessRTCPSenderInfo(senderssrc, p->GetNTPTimestamp(), p->GetRTPTimestamp(), p->GetSenderPacketCount(), p->GetSenderOctetCount(), receivetime,
                        senderaddress);
                if (status < 0)
                    return status;

                bool gotinfo = false;
                if (gotownssrc)
                {
                    int i;
                    int num = p->GetReceptionReportCount();
                    for (i = 0; i < num; i++)
                    {
                        if (p->GetSSRC(i) == ownssrc) // data is meant for us
                        {
                            gotinfo = true;
                            status = ProcessRTCPReportBlock(senderssrc, p->GetFractionLost(i), p->GetLostPacketCount(i), p->GetExtendedHighestSequenceNumber(i), p->GetJitter(i),
                                    p->GetLSR(i), p->GetDLSR(i), receivetime, senderaddress);
                            if (status < 0)
                                return status;
                        }
                    }
                }
                if (!gotinfo)
                {
                    status = UpdateReceiveTime(senderssrc, receivetime, senderaddress);
                    if (status < 0)
                        return status;
                }
            }
                break;
            case RTCPPacket::RR:
            {
                RTCPRRPacket *p = (RTCPRRPacket *) rtcppack;
                uint32_t senderssrc = p->GetSenderSSRC();

                bool gotinfo = false;

                if (gotownssrc)
                {
                    int i;
                    int num = p->GetReceptionReportCount();
                    for (i = 0; i < num; i++)
                    {
                        if (p->GetSSRC(i) == ownssrc)
                        {
                            gotinfo = true;
                            status = ProcessRTCPReportBlock(senderssrc, p->GetFractionLost(i), p->GetLostPacketCount(i), p->GetExtendedHighestSequenceNumber(i), p->GetJitter(i),
                                    p->GetLSR(i), p->GetDLSR(i), receivetime, senderaddress);
                            if (status < 0)
                                return status;
                        }
                    }
                }
                if (!gotinfo)
                {
                    status = UpdateReceiveTime(senderssrc, receivetime, senderaddress);
                    if (status < 0)
                        return status;
                }
            }
                break;
            case RTCPPacket::SDES:
            {
                RTCPSDESPacket *p = (RTCPSDESPacket *) rtcppack;

                if (p->GotoFirstChunk())
                {
                    do
                    {
                        uint32_t sdesssrc = p->GetChunkSSRC();
                        bool updated = false;
                        if (p->GotoFirstItem())
                        {
                            do
                            {
                                RTCPSDESPacket::ItemType t;

                                if ((t = p->GetItemType()) != RTCPSDESPacket::PRIV)
                                {
                                    updated = true;
                                    status = ProcessSDESNormalItem(sdesssrc, t, p->GetItemLength(), p->GetItemData(), receivetime, senderaddress);
                                    if (status < 0)
                                        return status;
                                }
#ifdef RTP_SUPPORT_SDESPRIV
                                else
                                {
                                    updated = true;
                                    status = ProcessSDESPrivateItem(sdesssrc, p->GetPRIVPrefixLength(), p->GetPRIVPrefixData(), p->GetPRIVValueLength(), p->GetPRIVValueData(),
                                            receivetime, senderaddress);
                                    if (status < 0)
                                        return status;
                                }
#endif // RTP_SUPPORT_SDESPRIV
                            } while (p->GotoNextItem());
                        }
                        if (!updated)
                        {
                            status = UpdateReceiveTime(sdesssrc, receivetime, senderaddress);
                            if (status < 0)
                                return status;
                        }
                    } while (p->GotoNextChunk());
                }
            }
                break;
            case RTCPPacket::BYE:
            {
                RTCPBYEPacket *p = (RTCPBYEPacket *) rtcppack;
                int i;
                int num = p->GetSSRCCount();

                for (i = 0; i < num; i++)
                {
                    uint32_t byessrc = p->GetSSRC(i);
                    status = ProcessBYE(byessrc, p->GetReasonLength(), p->GetReasonData(), receivetime, senderaddress);
                    if (status < 0)
                        return status;
                }
            }
                break;
            case RTCPPacket::APP:
            {
                RTCPAPPPacket *p = (RTCPAPPPacket *) rtcppack;

                OnAPPPacket(p, receivetime, senderaddress);
            }
                break;
            case RTCPPacket::Unknown:
            default:
            {
                OnUnknownPacketType(rtcppack, receivetime, senderaddress);
            }
                break;
            }
        }
        else
        {
            OnUnknownPacketFormat(rtcppack, receivetime, senderaddress);
        }
    }

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessRTCPReportBlock()

int qrtplib::RTPSources::ProcessRTCPReportBlock	(	uint32_t	ssrc,
		uint8_t	fractionlost,
		int32_t	lostpackets,
		uint32_t	exthighseqnr,
		uint32_t	jitter,
		uint32_t	lsr,
		uint32_t	dlsr,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress
	)

Processes the report block information which was sent by participant ssrc into the source table. Processes the report block information which was sent by participant ssrc into the source table. The information was received at time receivetime from address senderaddress The senderaddress parameter must be NULL if the packet was sent by the local participant.

Definition at line 664 of file rtpsources.cpp.

References GetRTCPSourceData(), OnNewSource(), OnRTCPReceiverReport(), and qrtplib::RTPInternalSourceData::ProcessReportBlock().

Referenced by ProcessRTCPCompoundPacket().

{
    RTPInternalSourceData *srcdat;
    bool created;
    int status;

    status = GetRTCPSourceData(ssrc, senderaddress, &srcdat, &created);
    if (status < 0)
        return status;
    if (srcdat == 0)
        return 0;

    srcdat->ProcessReportBlock(fractionlost, lostpackets, exthighseqnr, jitter, lsr, dlsr, receivetime);

    // Call the callback
    if (created)
        OnNewSource(srcdat);

    OnRTCPReceiverReport(srcdat);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessRTCPSenderInfo()

int qrtplib::RTPSources::ProcessRTCPSenderInfo	(	uint32_t	ssrc,
		const RTPNTPTime &	ntptime,
		uint32_t	rtptime,
		uint32_t	packetcount,
		uint32_t	octetcount,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress
	)

Process the sender information of SSRC ssrc into the source table. Process the sender information of SSRC ssrc into the source table. The information was received at time receivetime from address senderaddress. The senderaddress} parameter must be NULL if the packet was sent by the local participant.

Definition at line 640 of file rtpsources.cpp.

References GetRTCPSourceData(), OnNewSource(), OnRTCPSenderReport(), and qrtplib::RTPInternalSourceData::ProcessSenderInfo().

Referenced by ProcessRTCPCompoundPacket().

{
    RTPInternalSourceData *srcdat;
    bool created;
    int status;

    status = GetRTCPSourceData(ssrc, senderaddress, &srcdat, &created);
    if (status < 0)
        return status;
    if (srcdat == 0)
        return 0;

    srcdat->ProcessSenderInfo(ntptime, rtptime, packetcount, octetcount, receivetime);

    // Call the callback
    if (created)
        OnNewSource(srcdat);

    OnRTCPSenderReport(srcdat);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessRTPPacket()

int qrtplib::RTPSources::ProcessRTPPacket	(	RTPPacket *	rtppack,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress,
		bool *	stored
	)

Processes an RTPPacket instance rtppack which was received at time receivetime and which originated from senderaddres. Processes an RTPPacket instance rtppack which was received at time receivetime and which originated from senderaddres. The senderaddress parameter must be NULL if the packet was sent by the local participant. The flag stored indicates whether the packet was stored in the table or not. If so, the rtppack instance may not be deleted.

Definition at line 278 of file rtpsources.cpp.

References activecount, CheckCollision(), qrtplib::RTPPacket::GetCSRC(), qrtplib::RTPPacket::GetCSRCCount(), qrtplib::RTPPacket::GetSSRC(), i, qrtplib::RTPSourceData::IsActive(), qrtplib::RTPSourceData::IsSender(), qrtplib::RTPSourceData::IsValidated(), ObtainSourceDataInstance(), OnNewSource(), OnRTPPacket(), qrtplib::RTPInternalSourceData::ProcessRTPPacket(), RTP_MAXCSRCS, sendercount, qrtplib::RTPInternalSourceData::SetCSRC(), and qrtplib::RTPInternalSourceData::SetRTPDataAddress().

Referenced by ProcessRawPacket().

{
    uint32_t ssrc;
    RTPInternalSourceData *srcdat;
    int status;
    bool created;

    OnRTPPacket(rtppack, receivetime, senderaddress);

    *stored = false;

    ssrc = rtppack->GetSSRC();
    if ((status = ObtainSourceDataInstance(ssrc, &srcdat, &created)) < 0)
        return status;

    if (created)
    {
        if ((status = srcdat->SetRTPDataAddress(senderaddress)) < 0)
            return status;
    }
    else // got a previously existing source
    {
        if (CheckCollision(srcdat, senderaddress, true))
            return 0; // ignore packet on collision
    }

    bool prevsender = srcdat->IsSender();
    bool prevactive = srcdat->IsActive();

    uint32_t CSRCs[RTP_MAXCSRCS];
    int numCSRCs = rtppack->GetCSRCCount();
    if (numCSRCs > RTP_MAXCSRCS) // shouldn't happen, but better to check than go out of bounds
        numCSRCs = RTP_MAXCSRCS;

    for (int i = 0; i < numCSRCs; i++)
        CSRCs[i] = rtppack->GetCSRC(i);

    // The packet comes from a valid source, we can process it further now
    // The following function should delete rtppack itself if something goes
    // wrong
    if ((status = srcdat->ProcessRTPPacket(rtppack, receivetime, stored, this)) < 0)
        return status;

    // NOTE: we cannot use 'rtppack' anymore since it may have been deleted in
    //       OnValidatedRTPPacket

    if (!prevsender && srcdat->IsSender())
        sendercount++;
    if (!prevactive && srcdat->IsActive())
        activecount++;

    if (created)
        OnNewSource(srcdat);

    if (srcdat->IsValidated()) // process the CSRCs
    {
        RTPInternalSourceData *csrcdat;
        bool createdcsrc;

        int num = numCSRCs;
        int i;

        for (i = 0; i < num; i++)
        {
            if ((status = ObtainSourceDataInstance(CSRCs[i], &csrcdat, &createdcsrc)) < 0)
                return status;
            if (createdcsrc)
            {
                csrcdat->SetCSRC();
                if (csrcdat->IsActive())
                    activecount++;
                OnNewSource(csrcdat);
            }
            else // already found an entry, possibly because of RTCP data
            {
                if (!CheckCollision(csrcdat, senderaddress, true))
                    csrcdat->SetCSRC();
            }
        }
    }

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessSDESNormalItem()

int qrtplib::RTPSources::ProcessSDESNormalItem	(	uint32_t	ssrc,
		RTCPSDESPacket::ItemType	t,
		std::size_t	itemlength,
		const void *	itemdata,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress
	)

Processes the non-private SDES item from source ssrc into the source table. Processes the non-private SDES item from source ssrc into the source table. The information was received at time receivetime from address senderaddress. The senderaddress parameter must be NULL if the packet was sent by the local participant.

Definition at line 688 of file rtpsources.cpp.

References activecount, qrtplib::RTCPSDESPacket::CNAME, qrtplib::RTCPSDESPacket::EMAIL, ERR_RTP_SOURCES_ILLEGALSDESTYPE, GetRTCPSourceData(), qrtplib::RTPSourceData::IsActive(), qrtplib::RTCPSDESPacket::LOC, qrtplib::RTCPSDESPacket::NAME, qrtplib::RTCPSDESPacket::NOTE, OnCNAMECollision(), OnNewSource(), OnRTCPSDESItem(), qrtplib::RTCPSDESPacket::PHONE, qrtplib::RTPInternalSourceData::ProcessSDESItem(), RTCP_SDES_ID_CNAME, RTCP_SDES_ID_EMAIL, RTCP_SDES_ID_LOCATION, RTCP_SDES_ID_NAME, RTCP_SDES_ID_NOTE, RTCP_SDES_ID_PHONE, RTCP_SDES_ID_TOOL, and qrtplib::RTCPSDESPacket::TOOL.

Referenced by ProcessRTCPCompoundPacket().

{
    RTPInternalSourceData *srcdat;
    bool created, cnamecollis;
    int status;
    uint8_t sdesid;
    bool prevactive;

    switch (t)
    {
    case RTCPSDESPacket::CNAME:
        sdesid = RTCP_SDES_ID_CNAME;
        break;
    case RTCPSDESPacket::NAME:
        sdesid = RTCP_SDES_ID_NAME;
        break;
    case RTCPSDESPacket::EMAIL:
        sdesid = RTCP_SDES_ID_EMAIL;
        break;
    case RTCPSDESPacket::PHONE:
        sdesid = RTCP_SDES_ID_PHONE;
        break;
    case RTCPSDESPacket::LOC:
        sdesid = RTCP_SDES_ID_LOCATION;
        break;
    case RTCPSDESPacket::TOOL:
        sdesid = RTCP_SDES_ID_TOOL;
        break;
    case RTCPSDESPacket::NOTE:
        sdesid = RTCP_SDES_ID_NOTE;
        break;
    default:
        return ERR_RTP_SOURCES_ILLEGALSDESTYPE;
    }

    status = GetRTCPSourceData(ssrc, senderaddress, &srcdat, &created);
    if (status < 0)
        return status;
    if (srcdat == 0)
        return 0;

    prevactive = srcdat->IsActive();
    status = srcdat->ProcessSDESItem(sdesid, (const uint8_t *) itemdata, itemlength, receivetime, &cnamecollis);
    if (!prevactive && srcdat->IsActive())
        activecount++;

    // Call the callback
    if (created)
        OnNewSource(srcdat);
    if (cnamecollis)
        OnCNAMECollision(srcdat, senderaddress, (const uint8_t *) itemdata, itemlength);

    if (status >= 0)
        OnRTCPSDESItem(srcdat, t, itemdata, itemlength);

    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessSDESPrivateItem()

int qrtplib::RTPSources::ProcessSDESPrivateItem	(	uint32_t	ssrc,
		std::size_t	prefixlen,
		const void *	prefixdata,
		std::size_t	valuelen,
		const void *	valuedata,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress
	)

Processes the SDES private item from source ssrc into the source table. Processes the SDES private item from source ssrc into the source table. The information was received at time receivetime from address senderaddress. The senderaddress parameter must be NULL if the packet was sent by the local participant.

Definition at line 748 of file rtpsources.cpp.

References GetRTCPSourceData(), OnNewSource(), OnRTCPSDESPrivateItem(), and qrtplib::RTPInternalSourceData::ProcessPrivateSDESItem().

Referenced by ProcessRTCPCompoundPacket().

{
    RTPInternalSourceData *srcdat;
    bool created;
    int status;

    status = GetRTCPSourceData(ssrc, senderaddress, &srcdat, &created);
    if (status < 0)
        return status;
    if (srcdat == 0)
        return 0;

    status = srcdat->ProcessPrivateSDESItem((const uint8_t *) prefixdata, prefixlen, (const uint8_t *) valuedata, valuelen, receivetime);
    // Call the callback
    if (created)
        OnNewSource(srcdat);

    if (status >= 0)
        OnRTCPSDESPrivateItem(srcdat, prefixdata, prefixlen, valuedata, valuelen);

    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SenderTimeout()

void qrtplib::RTPSources::SenderTimeout	(	const RTPTime &	curtime,
		const RTPTime &	timeoutdelay
	)

Assuming that the current time is curtime, remove the sender flag for senders from whom we haven't received any RTP packets during the previous time interval timeoutdelay.

Definition at line 923 of file rtpsources.cpp.

References activecount, qrtplib::RTPInternalSourceData::ClearSenderFlag(), qrtplib::RTPSourceData::INF_GetLastRTPPacketTime(), qrtplib::RTPSourceData::IsActive(), qrtplib::RTPSourceData::IsSender(), sendercount, sourcelist, and totalcount.

{
    int newtotalcount = 0;
    int newsendercount = 0;
    int newactivecount = 0;
    RTPTime checktime = curtime;
    checktime -= timeoutdelay;

    sourcelist.GotoFirstElement();
    while (sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat = sourcelist.GetCurrentElement();

        newtotalcount++;
        if (srcdat->IsActive())
            newactivecount++;

        if (srcdat->IsSender())
        {
            RTPTime lastrtppacktime = srcdat->INF_GetLastRTPPacketTime();

            if (lastrtppacktime < checktime) // timeout
            {
                srcdat->ClearSenderFlag();
                sendercount--;
            }
            else
                newsendercount++;
        }
        sourcelist.GotoNextElement();
    }

    totalcount = newtotalcount; // just to play it safe
    sendercount = newsendercount;
    activecount = newactivecount;
}

Here is the call graph for this function:

SentRTPPacket()

void qrtplib::RTPSources::SentRTPPacket

(

)

This function should be called if our own session has sent an RTP packet. This function should be called if our own session has sent an RTP packet. For our own SSRC entry, the sender flag is updated based upon outgoing packets instead of incoming packets.

Definition at line 137 of file rtpsources.cpp.

References qrtplib::RTPSourceData::IsSender(), owndata, sendercount, and qrtplib::RTPInternalSourceData::SentRTPPacket().

Referenced by qrtplib::RTPSession::SendPacket(), and qrtplib::RTPSession::SendPacketEx().

{
    if (owndata == 0)
        return;

    bool prevsender = owndata->IsSender();

    owndata->SentRTPPacket();
    if (!prevsender && owndata->IsSender())
        sendercount++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Timeout()

void qrtplib::RTPSources::Timeout	(	const RTPTime &	curtime,
		const RTPTime &	timeoutdelay
	)

Assuming that the current time is curtime, time out the members from whom we haven't heard during the previous time interval timeoutdelay.

Definition at line 877 of file rtpsources.cpp.

References activecount, qrtplib::RTPSourceData::INF_GetLastMessageTime(), qrtplib::RTPSourceData::IsActive(), qrtplib::RTPSourceData::IsSender(), OnRemoveSource(), OnTimeout(), owndata, sendercount, sourcelist, and totalcount.

{
    int newtotalcount = 0;
    int newsendercount = 0;
    int newactivecount = 0;
    RTPTime checktime = curtime;
    checktime -= timeoutdelay;

    sourcelist.GotoFirstElement();
    while (sourcelist.HasCurrentElement())
    {
        RTPInternalSourceData *srcdat = sourcelist.GetCurrentElement();
        RTPTime lastmsgtime = srcdat->INF_GetLastMessageTime();

        // we don't want to time out ourselves
        if ((srcdat != owndata) && (lastmsgtime < checktime)) // timeout
        {

            totalcount--;
            if (srcdat->IsSender())
                sendercount--;
            if (srcdat->IsActive())
                activecount--;

            sourcelist.DeleteCurrentElement();

            OnTimeout(srcdat);
            OnRemoveSource(srcdat);
            delete srcdat;
        }
        else
        {
            newtotalcount++;
            if (srcdat->IsSender())
                newsendercount++;
            if (srcdat->IsActive())
                newactivecount++;
            sourcelist.GotoNextElement();
        }
    }

    totalcount = newtotalcount; // just to play it safe
    sendercount = newsendercount;
    activecount = newactivecount;
}

Here is the call graph for this function:

UpdateReceiveTime()

int qrtplib::RTPSources::UpdateReceiveTime	(	uint32_t	ssrc,
		const RTPTime &	receivetime,
		const RTPAddress *	senderaddress
	)

If we heard from source ssrc, but no actual data was added to the source table (for example, if no report block was meant for us), this function can e used to indicate that something was received from this source. If we heard from source ssrc, but no actual data was added to the source table (for example, if no report block was meant for us), this function can e used to indicate that something was received from this source. This will prevent a premature timeout for this participant. The message was received at time receivetime from address senderaddress. The senderaddress parameter must be NULL if the packet was sent by the local participant.

Definition at line 855 of file rtpsources.cpp.

References GetRTCPSourceData(), OnNewSource(), and qrtplib::RTPInternalSourceData::UpdateMessageTime().

Referenced by ProcessRTCPCompoundPacket().

{
    RTPInternalSourceData *srcdat;
    bool created;
    int status;

    status = GetRTCPSourceData(ssrc, senderaddress, &srcdat, &created);
    if (status < 0)
        return status;
    if (srcdat == 0)
        return 0;

    // We got valid SSRC info
    srcdat->UpdateMessageTime(receivetime);

    // Call the callback
    if (created)
        OnNewSource(srcdat);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

RTPInternalSourceData

friend class RTPInternalSourceData

friend

Definition at line 370 of file rtpsources.h.

Referenced by ObtainSourceDataInstance().

Member Data Documentation

activecount

int qrtplib::RTPSources::activecount

private

Definition at line 366 of file rtpsources.h.

Referenced by BYETimeout(), ClearSourceList(), CreateOwnSSRC(), DeleteOwnSSRC(), MultipleTimeouts(), NoteTimeout(), ProcessBYE(), ProcessRTPPacket(), ProcessSDESNormalItem(), RTPSources(), SenderTimeout(), and Timeout().

owndata

RTPInternalSourceData* qrtplib::RTPSources::owndata

private

Definition at line 368 of file rtpsources.h.

Referenced by BYETimeout(), ClearSourceList(), CreateOwnSSRC(), DeleteOwnSSRC(), MultipleTimeouts(), ProcessBYE(), ProcessRTCPCompoundPacket(), RTPSources(), SentRTPPacket(), and Timeout().

sendercount

int qrtplib::RTPSources::sendercount

private

Definition at line 364 of file rtpsources.h.

Referenced by BYETimeout(), ClearSourceList(), DeleteOwnSSRC(), MultipleTimeouts(), NoteTimeout(), ProcessRTPPacket(), RTPSources(), SenderTimeout(), SentRTPPacket(), and Timeout().

sourcelist

RTPKeyHashTable<const uint32_t, RTPInternalSourceData*, RTPSources_GetHashIndex, RTPSOURCES_HASHSIZE> qrtplib::RTPSources::sourcelist

private

Definition at line 362 of file rtpsources.h.

Referenced by BYETimeout(), ClearSourceList(), DeleteOwnSSRC(), GetCurrentSourceInfo(), GetNextPacket(), GetSourceInfo(), GotEntry(), GotoFirstSource(), GotoFirstSourceWithData(), GotoNextSource(), GotoNextSourceWithData(), GotoPreviousSource(), GotoPreviousSourceWithData(), MultipleTimeouts(), NoteTimeout(), ObtainSourceDataInstance(), SenderTimeout(), and Timeout().

totalcount

int qrtplib::RTPSources::totalcount

private

Definition at line 365 of file rtpsources.h.

Referenced by BYETimeout(), ClearSourceList(), DeleteOwnSSRC(), MultipleTimeouts(), NoteTimeout(), ObtainSourceDataInstance(), RTPSources(), SenderTimeout(), and Timeout().

---

The documentation for this class was generated from the following files:

• qrtplib/rtpsources.h
• qrtplib/rtpsources.cpp