qrtplib::RTCPPacketBuilder Class Reference

#include <rtcppacketbuilder.h>

Collaboration diagram for qrtplib::RTCPPacketBuilder:

Classes
class	RTCPSDESInfoInternal

Public Member Functions
	RTCPPacketBuilder (RTPSources &sources, RTPPacketBuilder &rtppackbuilder)
	~RTCPPacketBuilder ()
int	Init (std::size_t maxpacksize, double timestampunit, const void *cname, std::size_t cnamelen)
void	Destroy ()
int	SetTimestampUnit (double tsunit)
int	SetMaximumPacketSize (std::size_t maxpacksize)
int	SetPreTransmissionDelay (const RTPTime &delay)
int	BuildNextPacket (RTCPCompoundPacket **pack)
int	BuildBYEPacket (RTCPCompoundPacket **pack, const void *reason, std::size_t reasonlength, bool useSRifpossible=true)
void	SetNameInterval (int count)
void	SetEMailInterval (int count)
void	SetLocationInterval (int count)
void	SetPhoneInterval (int count)
void	SetToolInterval (int count)
void	SetNoteInterval (int count)
int	SetLocalName (const void *s, std::size_t len)
int	SetLocalEMail (const void *s, std::size_t len)
int	SetLocalLocation (const void *s, std::size_t len)
int	SetLocalPhone (const void *s, std::size_t len)
int	SetLocalTool (const void *s, std::size_t len)
int	SetLocalNote (const void *s, std::size_t len)
uint8_t *	GetLocalCNAME (std::size_t *len) const

Private Member Functions
void	ClearAllSourceFlags ()
int	FillInReportBlocks (RTCPCompoundPacketBuilder *pack, const RTPTime &curtime, int maxcount, bool *full, int *added, int *skipped, bool *atendoflist)
int	FillInSDES (RTCPCompoundPacketBuilder *pack, bool *full, bool *processedall, int *added)
void	ClearAllSDESFlags ()

Private Attributes
RTPSources &	sources
RTPPacketBuilder &	rtppacketbuilder
bool	init
std::size_t	maxpacketsize
double	timestampunit
bool	firstpacket
RTPTime	prevbuildtime
RTPTime	transmissiondelay
RTCPSDESInfoInternal	ownsdesinfo
int	interval_name
int	interval_email
int	interval_location
int	interval_phone
int	interval_tool
int	interval_note
bool	doname
bool	doemail
bool	doloc
bool	dophone
bool	dotool
bool	donote
bool	processingsdes
int	sdesbuildcount

Detailed Description

This class can be used to build RTCP compound packets, on a higher level than the RTCPCompoundPacketBuilder. The class RTCPPacketBuilder can be used to build RTCP compound packets. This class is more high-level than the RTCPCompoundPacketBuilder class: it uses the information of an RTPPacketBuilder instance and of an RTPSources instance to automatically generate the next compound packet which should be sent. It also provides functions to determine when SDES items other than the CNAME item should be sent.

Definition at line 64 of file rtcppacketbuilder.h.

Constructor & Destructor Documentation

RTCPPacketBuilder()

qrtplib::RTCPPacketBuilder::RTCPPacketBuilder	(	RTPSources &	sources,
		RTPPacketBuilder &	rtppackbuilder
	)

Creates an RTCPPacketBuilder instance. Creates an instance which will use the source table sources and the RTP packet builder rtppackbuilder to determine the information for the next RTCP compound packet. Optionally, the memory manager mgr can be installed.

Definition at line 43 of file rtcppacketbuilder.cpp.

References qrtplib::RTPTimeInitializerObject::Dummy(), init, and qrtplib::timeinit.

                                                                        :
        sources(s), rtppacketbuilder(pb), prevbuildtime(0, 0), transmissiondelay(0, 0)
{
    init = false;
    timeinit.Dummy();
}

Here is the call graph for this function:

~RTCPPacketBuilder()

qrtplib::RTCPPacketBuilder::~RTCPPacketBuilder

(

)

Definition at line 50 of file rtcppacketbuilder.cpp.

References Destroy().

{
    Destroy();
}

Here is the call graph for this function:

Member Function Documentation

BuildBYEPacket()

int qrtplib::RTCPPacketBuilder::BuildBYEPacket	(	RTCPCompoundPacket **	pack,
		const void *	reason,
		std::size_t	reasonlength,
		bool	useSRifpossible = true
	)

Builds a BYE packet with reason for leaving specified by reason and length reasonlength. Builds a BYE packet with reason for leaving specified by reason and length reasonlength. If useSRifpossible is set to true, the RTCP compound packet will start with a sender report if allowed. Otherwise, a receiver report is used.

Definition at line 627 of file rtcppacketbuilder.cpp.

References qrtplib::RTCPCompoundPacketBuilder::AddBYEPacket(), qrtplib::RTCPCompoundPacketBuilder::AddSDESNormalItem(), qrtplib::RTCPCompoundPacketBuilder::AddSDESSource(), qrtplib::RTCPSDESPacket::CNAME, qrtplib::RTPTime::CurrentTime(), qrtplib::RTCPCompoundPacketBuilder::EndBuild(), ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, ERR_RTP_RTCPPACKETBUILDER_NOTINIT, ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON, qrtplib::RTCPSDESInfo::GetCNAME(), qrtplib::RTPTime::GetDouble(), qrtplib::RTPTime::GetNTPTime(), qrtplib::RTPSources::GetOwnSourceInfo(), qrtplib::RTPPacketBuilder::GetPacketCount(), qrtplib::RTPPacketBuilder::GetPacketTime(), qrtplib::RTPPacketBuilder::GetPacketTimestamp(), qrtplib::RTPPacketBuilder::GetPayloadOctetCount(), qrtplib::RTPPacketBuilder::GetSSRC(), init, qrtplib::RTCPCompoundPacketBuilder::InitBuild(), qrtplib::RTPSourceData::IsSender(), maxpacketsize, ownsdesinfo, rtppacketbuilder, sources, qrtplib::RTCPCompoundPacketBuilder::StartReceiverReport(), qrtplib::RTCPCompoundPacketBuilder::StartSenderReport(), and timestampunit.

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

{
    if (!init)
        return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;

    RTCPCompoundPacketBuilder *rtcpcomppack;
    int status;

    if (reasonlength > 255)
        reasonlength = 255;

    *pack = 0;

    rtcpcomppack = new RTCPCompoundPacketBuilder();

    if ((status = rtcpcomppack->InitBuild(maxpacketsize)) < 0)
    {
        delete rtcpcomppack;
        return status;
    }

    uint32_t ssrc = rtppacketbuilder.GetSSRC();
    bool useSR = false;

    if (useSRifpossible)
    {
        RTPSourceData *srcdat;

        if ((srcdat = sources.GetOwnSourceInfo()) != 0)
        {
            if (srcdat->IsSender())
                useSR = true;
        }
    }

    if (useSR)
    {
        RTPTime curtime = RTPTime::CurrentTime();
        RTPTime rtppacktime = rtppacketbuilder.GetPacketTime();
        uint32_t rtppacktimestamp = rtppacketbuilder.GetPacketTimestamp();
        uint32_t packcount = rtppacketbuilder.GetPacketCount();
        uint32_t octetcount = rtppacketbuilder.GetPayloadOctetCount();
        RTPTime diff = curtime;
        diff -= rtppacktime;

        uint32_t tsdiff = (uint32_t) ((diff.GetDouble() / timestampunit) + 0.5);
        uint32_t rtptimestamp = rtppacktimestamp + tsdiff;
        RTPNTPTime ntptimestamp = curtime.GetNTPTime();

        if ((status = rtcpcomppack->StartSenderReport(ssrc, ntptimestamp, rtptimestamp, packcount, octetcount)) < 0)
        {
            delete rtcpcomppack;
            if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
            return status;
        }
    }
    else
    {
        if ((status = rtcpcomppack->StartReceiverReport(ssrc)) < 0)
        {
            delete rtcpcomppack;
            if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
            return status;
        }
    }

    uint8_t *owncname;
    std::size_t owncnamelen;

    owncname = ownsdesinfo.GetCNAME(&owncnamelen);

    if ((status = rtcpcomppack->AddSDESSource(ssrc)) < 0)
    {
        delete rtcpcomppack;
        if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
            return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
        return status;
    }
    if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::CNAME, owncname, owncnamelen)) < 0)
    {
        delete rtcpcomppack;
        if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
            return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
        return status;
    }

    uint32_t ssrcs[1];

    ssrcs[0] = ssrc;

    if ((status = rtcpcomppack->AddBYEPacket(ssrcs, 1, (const uint8_t *) reason, reasonlength)) < 0)
    {
        delete rtcpcomppack;
        if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
            return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
        return status;
    }

    if ((status = rtcpcomppack->EndBuild()) < 0)
    {
        delete rtcpcomppack;
        return status;
    }

    *pack = rtcpcomppack;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildNextPacket()

int qrtplib::RTCPPacketBuilder::BuildNextPacket

(

RTCPCompoundPacket **

pack

)

Builds the next RTCP compound packet which should be sent and stores it in pack.

Definition at line 101 of file rtcppacketbuilder.cpp.

References qrtplib::RTCPCompoundPacketBuilder::AddSDESNormalItem(), qrtplib::RTCPCompoundPacketBuilder::AddSDESSource(), ClearAllSDESFlags(), ClearAllSourceFlags(), qrtplib::RTCPSDESPacket::CNAME, qrtplib::RTPTime::CurrentTime(), doemail, doloc, doname, donote, dophone, dotool, qrtplib::RTCPCompoundPacketBuilder::EndBuild(), ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, ERR_RTP_RTCPPACKETBUILDER_NOTINIT, ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON, FillInReportBlocks(), FillInSDES(), firstpacket, qrtplib::RTCPSDESInfo::GetCNAME(), qrtplib::RTPTime::GetDouble(), qrtplib::RTPTime::GetNTPTime(), qrtplib::RTPSources::GetOwnSourceInfo(), qrtplib::RTPPacketBuilder::GetPacketCount(), qrtplib::RTPPacketBuilder::GetPacketTime(), qrtplib::RTPPacketBuilder::GetPacketTimestamp(), qrtplib::RTPPacketBuilder::GetPayloadOctetCount(), qrtplib::RTPPacketBuilder::GetSSRC(), qrtplib::RTPSources::GetTotalCount(), init, qrtplib::RTCPCompoundPacketBuilder::InitBuild(), interval_email, interval_location, interval_name, interval_note, interval_phone, interval_tool, qrtplib::RTPSourceData::IsSender(), maxpacketsize, ownsdesinfo, prevbuildtime, processingsdes, rtppacketbuilder, sdesbuildcount, sources, qrtplib::RTCPCompoundPacketBuilder::StartReceiverReport(), qrtplib::RTCPCompoundPacketBuilder::StartSenderReport(), timestampunit, and transmissiondelay.

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

{
    if (!init)
        return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;

    RTCPCompoundPacketBuilder *rtcpcomppack;
    int status;
    bool sender = false;
    RTPSourceData *srcdat;

    *pack = 0;

    rtcpcomppack = new RTCPCompoundPacketBuilder();

    if ((status = rtcpcomppack->InitBuild(maxpacketsize)) < 0)
    {
        delete rtcpcomppack;
        return status;
    }

    if ((srcdat = sources.GetOwnSourceInfo()) != 0)
    {
        if (srcdat->IsSender())
            sender = true;
    }

    uint32_t ssrc = rtppacketbuilder.GetSSRC();
    RTPTime curtime = RTPTime::CurrentTime();

    if (sender)
    {
        RTPTime rtppacktime = rtppacketbuilder.GetPacketTime();
        uint32_t rtppacktimestamp = rtppacketbuilder.GetPacketTimestamp();
        uint32_t packcount = rtppacketbuilder.GetPacketCount();
        uint32_t octetcount = rtppacketbuilder.GetPayloadOctetCount();
        RTPTime diff = curtime;
        diff -= rtppacktime;
        diff += transmissiondelay; // the sample being sampled at this very instant will need a larger timestamp

        uint32_t tsdiff = (uint32_t) ((diff.GetDouble() / timestampunit) + 0.5);
        uint32_t rtptimestamp = rtppacktimestamp + tsdiff;
        RTPNTPTime ntptimestamp = curtime.GetNTPTime();

        if ((status = rtcpcomppack->StartSenderReport(ssrc, ntptimestamp, rtptimestamp, packcount, octetcount)) < 0)
        {
            delete rtcpcomppack;
            if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
            return status;
        }
    }
    else
    {
        if ((status = rtcpcomppack->StartReceiverReport(ssrc)) < 0)
        {
            delete rtcpcomppack;
            if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
            return status;
        }
    }

    uint8_t *owncname;
    std::size_t owncnamelen;

    owncname = ownsdesinfo.GetCNAME(&owncnamelen);

    if ((status = rtcpcomppack->AddSDESSource(ssrc)) < 0)
    {
        delete rtcpcomppack;
        if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
            return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
        return status;
    }
    if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::CNAME, owncname, owncnamelen)) < 0)
    {
        delete rtcpcomppack;
        if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
            return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
        return status;
    }

    if (!processingsdes)
    {
        int added, skipped;
        bool full, atendoflist;

        if ((status = FillInReportBlocks(rtcpcomppack, curtime, sources.GetTotalCount(), &full, &added, &skipped, &atendoflist)) < 0)
        {
            delete rtcpcomppack;
            return status;
        }

        if (full && added == 0)
        {
            delete rtcpcomppack;
            return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
        }

        if (!full)
        {
            processingsdes = true;
            sdesbuildcount++;

            ClearAllSourceFlags();

            doname = false;
            doemail = false;
            doloc = false;
            dophone = false;
            dotool = false;
            donote = false;
            if (interval_name > 0 && ((sdesbuildcount % interval_name) == 0))
                doname = true;
            if (interval_email > 0 && ((sdesbuildcount % interval_email) == 0))
                doemail = true;
            if (interval_location > 0 && ((sdesbuildcount % interval_location) == 0))
                doloc = true;
            if (interval_phone > 0 && ((sdesbuildcount % interval_phone) == 0))
                dophone = true;
            if (interval_tool > 0 && ((sdesbuildcount % interval_tool) == 0))
                dotool = true;
            if (interval_note > 0 && ((sdesbuildcount % interval_note) == 0))
                donote = true;

            bool processedall;
            int itemcount;

            if ((status = FillInSDES(rtcpcomppack, &full, &processedall, &itemcount)) < 0)
            {
                delete rtcpcomppack;
                return status;
            }

            if (processedall)
            {
                processingsdes = false;
                ClearAllSDESFlags();
                if (!full && skipped > 0)
                {
                    // if the packet isn't full and we skipped some
                    // sources that we already got in a previous packet,
                    // we can add some of them now

                    bool atendoflist;

                    if ((status = FillInReportBlocks(rtcpcomppack, curtime, skipped, &full, &added, &skipped, &atendoflist)) < 0)
                    {
                        delete rtcpcomppack;
                        return status;
                    }
                }
            }
        }
    }
    else // previous sdes processing wasn't finished
    {
        bool processedall;
        int itemcount;
        bool full;

        if ((status = FillInSDES(rtcpcomppack, &full, &processedall, &itemcount)) < 0)
        {
            delete rtcpcomppack;
            return status;
        }

        if (itemcount == 0) // Big problem: packet size is too small to let any progress happen
        {
            delete rtcpcomppack;
            return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
        }

        if (processedall)
        {
            processingsdes = false;
            ClearAllSDESFlags();
            if (!full)
            {
                // if the packet isn't full and we skipped some
                // we can add some report blocks

                int added, skipped;
                bool atendoflist;

                if ((status = FillInReportBlocks(rtcpcomppack, curtime, sources.GetTotalCount(), &full, &added, &skipped, &atendoflist)) < 0)
                {
                    delete rtcpcomppack;
                    return status;
                }
                if (atendoflist) // filled in all possible sources
                    ClearAllSourceFlags();
            }
        }
    }

    if ((status = rtcpcomppack->EndBuild()) < 0)
    {
        delete rtcpcomppack;
        return status;
    }

    *pack = rtcpcomppack;
    firstpacket = false;
    prevbuildtime = curtime;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ClearAllSDESFlags()

void qrtplib::RTCPPacketBuilder::ClearAllSDESFlags ( )

private

Definition at line 622 of file rtcppacketbuilder.cpp.

References qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::ClearFlags(), and ownsdesinfo.

Referenced by BuildNextPacket().

{
    ownsdesinfo.ClearFlags();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ClearAllSourceFlags()

void qrtplib::RTCPPacketBuilder::ClearAllSourceFlags ( )

private

Definition at line 309 of file rtcppacketbuilder.cpp.

References qrtplib::RTPSources::GetCurrentSourceInfo(), qrtplib::RTPSources::GotoFirstSource(), qrtplib::RTPSources::GotoNextSource(), qrtplib::RTPSourceData::SetProcessedInRTCP(), and sources.

Referenced by BuildNextPacket(), and Init().

{
    if (sources.GotoFirstSource())
    {
        do
        {
            RTPSourceData *srcdat = sources.GetCurrentSourceInfo();
            srcdat->SetProcessedInRTCP(false);
        } while (sources.GotoNextSource());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Destroy()

void qrtplib::RTCPPacketBuilder::Destroy

(

)

Cleans up the builder.

Definition at line 93 of file rtcppacketbuilder.cpp.

References qrtplib::RTCPSDESInfo::Clear(), init, and ownsdesinfo.

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

{
    if (!init)
        return;
    ownsdesinfo.Clear();
    init = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FillInReportBlocks()

int qrtplib::RTCPPacketBuilder::FillInReportBlocks ( RTCPCompoundPacketBuilder *  pack, const RTPTime &  curtime, int  maxcount, bool *  full, int *  added, int *  skipped, bool *  atendoflist  )

private

Definition at line 321 of file rtcppacketbuilder.cpp.

References qrtplib::RTCPCompoundPacketBuilder::AddReportBlock(), ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, firstpacket, qrtplib::RTPSources::GetCurrentSourceInfo(), qrtplib::RTPTime::GetDouble(), qrtplib::RTPNTPTime::GetLSW(), qrtplib::RTPNTPTime::GetMSW(), qrtplib::RTPSourceData::GetSSRC(), qrtplib::RTPSources::GotoFirstSource(), qrtplib::RTPSources::GotoNextSource(), qrtplib::RTPSourceData::INF_GetBaseSequenceNumber(), qrtplib::RTPSourceData::INF_GetExtendedHighestSequenceNumber(), qrtplib::RTPSourceData::INF_GetJitter(), qrtplib::RTPSourceData::INF_GetLastRTPPacketTime(), qrtplib::RTPSourceData::INF_GetNumPacketsReceived(), qrtplib::RTPSourceData::INF_GetNumPacketsReceivedInInterval(), qrtplib::RTPSourceData::INF_GetSavedExtendedSequenceNumber(), qrtplib::RTPSourceData::INF_HasSentData(), qrtplib::RTPSourceData::INF_StartNewInterval(), qrtplib::RTPSourceData::IsCSRC(), qrtplib::RTPSourceData::IsOwnSSRC(), qrtplib::RTPSourceData::IsProcessedInRTCP(), prevbuildtime, qrtplib::RTPSourceData::SetProcessedInRTCP(), sources, qrtplib::RTPSourceData::SR_GetNTPTimestamp(), qrtplib::RTPSourceData::SR_GetReceiveTime(), and qrtplib::RTPSourceData::SR_HasInfo().

Referenced by BuildNextPacket().

{
    RTPSourceData *srcdat;
    int addedcount = 0;
    int skippedcount = 0;
    bool done = false;
    bool filled = false;
    bool atend = false;
    int status;

    if (sources.GotoFirstSource())
    {
        do
        {
            bool shouldprocess = false;

            srcdat = sources.GetCurrentSourceInfo();
            if (!srcdat->IsOwnSSRC()) // don't send to ourselves
            {
                if (!srcdat->IsCSRC()) // p 35: no reports should go to CSRCs
                {
                    if (srcdat->INF_HasSentData()) // if this isn't true, INF_GetLastRTPPacketTime() won't make any sense
                    {
                        if (firstpacket)
                            shouldprocess = true;
                        else
                        {
                            // p 35: only if rtp packets were received since the last RTP packet, a report block
                            // should be added

                            RTPTime lastrtptime = srcdat->INF_GetLastRTPPacketTime();

                            if (lastrtptime > prevbuildtime)
                                shouldprocess = true;
                        }
                    }
                }
            }

            if (shouldprocess)
            {
                if (srcdat->IsProcessedInRTCP()) // already covered this one
                {
                    skippedcount++;
                }
                else
                {
                    uint32_t rr_ssrc = srcdat->GetSSRC();
                    uint32_t num = srcdat->INF_GetNumPacketsReceivedInInterval();
                    uint32_t prevseq = srcdat->INF_GetSavedExtendedSequenceNumber();
                    uint32_t curseq = srcdat->INF_GetExtendedHighestSequenceNumber();
                    uint32_t expected = curseq - prevseq;
                    uint8_t fraclost;

                    if (expected < num) // got duplicates
                        fraclost = 0;
                    else
                    {
                        double lost = (double) (expected - num);
                        double frac = lost / ((double) expected);
                        fraclost = (uint8_t) (frac * 256.0);
                    }

                    expected = curseq - srcdat->INF_GetBaseSequenceNumber();
                    num = srcdat->INF_GetNumPacketsReceived();

                    uint32_t diff = expected - num;
                    int32_t *packlost = (int32_t *) &diff;

                    uint32_t jitter = srcdat->INF_GetJitter();
                    uint32_t lsr;
                    uint32_t dlsr;

                    if (!srcdat->SR_HasInfo())
                    {
                        lsr = 0;
                        dlsr = 0;
                    }
                    else
                    {
                        RTPNTPTime srtime = srcdat->SR_GetNTPTimestamp();
                        uint32_t m = (srtime.GetMSW() & 0xFFFF);
                        uint32_t l = ((srtime.GetLSW() >> 16) & 0xFFFF);
                        lsr = ((m << 16) | l);

                        RTPTime diff = curtime;
                        diff -= srcdat->SR_GetReceiveTime();
                        double diff2 = diff.GetDouble();
                        diff2 *= 65536.0;
                        dlsr = (uint32_t) diff2;
                    }

                    status = rtcpcomppack->AddReportBlock(rr_ssrc, fraclost, *packlost, curseq, jitter, lsr, dlsr);
                    if (status < 0)
                    {
                        if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                        {
                            done = true;
                            filled = true;
                        }
                        else
                            return status;
                    }
                    else
                    {
                        addedcount++;
                        if (addedcount >= maxcount)
                        {
                            done = true;
                            if (!sources.GotoNextSource())
                                atend = true;
                        }
                        srcdat->INF_StartNewInterval();
                        srcdat->SetProcessedInRTCP(true);
                    }
                }
            }

            if (!done)
            {
                if (!sources.GotoNextSource())
                {
                    atend = true;
                    done = true;
                }
            }

        } while (!done);
    }

    *added = addedcount;
    *skipped = skippedcount;
    *full = filled;

    if (!atend) // search for available sources
    {
        bool shouldprocess = false;

        do
        {
            srcdat = sources.GetCurrentSourceInfo();
            if (!srcdat->IsOwnSSRC()) // don't send to ourselves
            {
                if (!srcdat->IsCSRC()) // p 35: no reports should go to CSRCs
                {
                    if (srcdat->INF_HasSentData()) // if this isn't true, INF_GetLastRTPPacketTime() won't make any sense
                    {
                        if (firstpacket)
                            shouldprocess = true;
                        else
                        {
                            // p 35: only if rtp packets were received since the last RTP packet, a report block
                            // should be added

                            RTPTime lastrtptime = srcdat->INF_GetLastRTPPacketTime();

                            if (lastrtptime > prevbuildtime)
                                shouldprocess = true;
                        }
                    }
                }
            }

            if (shouldprocess)
            {
                if (srcdat->IsProcessedInRTCP())
                    shouldprocess = false;
            }

            if (!shouldprocess)
            {
                if (!sources.GotoNextSource())
                    atend = true;
            }

        } while (!atend && !shouldprocess);
    }

    *atendoflist = atend;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FillInSDES()

int qrtplib::RTCPPacketBuilder::FillInSDES ( RTCPCompoundPacketBuilder *  pack, bool *  full, bool *  processedall, int *  added  )

private

Definition at line 503 of file rtcppacketbuilder.cpp.

References qrtplib::RTCPCompoundPacketBuilder::AddSDESNormalItem(), doemail, doloc, doname, donote, dophone, dotool, qrtplib::RTCPSDESPacket::EMAIL, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, qrtplib::RTCPSDESInfo::GetEMail(), qrtplib::RTCPSDESInfo::GetLocation(), qrtplib::RTCPSDESInfo::GetName(), qrtplib::RTCPSDESInfo::GetNote(), qrtplib::RTCPSDESInfo::GetPhone(), qrtplib::RTCPSDESInfo::GetTool(), qrtplib::RTCPSDESPacket::LOC, qrtplib::RTCPSDESPacket::NAME, qrtplib::RTCPSDESPacket::NOTE, ownsdesinfo, qrtplib::RTCPSDESPacket::PHONE, qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::ProcessedEMail(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::ProcessedLocation(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::ProcessedName(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::ProcessedNote(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::ProcessedPhone(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::ProcessedTool(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::SetProcessedEMail(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::SetProcessedLocation(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::SetProcessedName(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::SetProcessedNote(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::SetProcessedPhone(), qrtplib::RTCPPacketBuilder::RTCPSDESInfoInternal::SetProcessedTool(), and qrtplib::RTCPSDESPacket::TOOL.

Referenced by BuildNextPacket().

{
    int status;
    uint8_t *data;
    std::size_t datalen;

    *full = false;
    *processedall = false;
    *added = 0;

    // We don't need to add a SSRC for our own data, this is still set
    // from adding the CNAME
    if (doname)
    {
        if (!ownsdesinfo.ProcessedName())
        {
            data = ownsdesinfo.GetName(&datalen);
            if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::NAME, data, datalen)) < 0)
            {
                if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                {
                    *full = true;
                    return 0;
                }
            }
            (*added)++;
            ownsdesinfo.SetProcessedName(true);
        }
    }
    if (doemail)
    {
        if (!ownsdesinfo.ProcessedEMail())
        {
            data = ownsdesinfo.GetEMail(&datalen);
            if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::EMAIL, data, datalen)) < 0)
            {
                if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                {
                    *full = true;
                    return 0;
                }
            }
            (*added)++;
            ownsdesinfo.SetProcessedEMail(true);
        }
    }
    if (doloc)
    {
        if (!ownsdesinfo.ProcessedLocation())
        {
            data = ownsdesinfo.GetLocation(&datalen);
            if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::LOC, data, datalen)) < 0)
            {
                if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                {
                    *full = true;
                    return 0;
                }
            }
            (*added)++;
            ownsdesinfo.SetProcessedLocation(true);
        }
    }
    if (dophone)
    {
        if (!ownsdesinfo.ProcessedPhone())
        {
            data = ownsdesinfo.GetPhone(&datalen);
            if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::PHONE, data, datalen)) < 0)
            {
                if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                {
                    *full = true;
                    return 0;
                }
            }
            (*added)++;
            ownsdesinfo.SetProcessedPhone(true);
        }
    }
    if (dotool)
    {
        if (!ownsdesinfo.ProcessedTool())
        {
            data = ownsdesinfo.GetTool(&datalen);
            if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::TOOL, data, datalen)) < 0)
            {
                if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                {
                    *full = true;
                    return 0;
                }
            }
            (*added)++;
            ownsdesinfo.SetProcessedTool(true);
        }
    }
    if (donote)
    {
        if (!ownsdesinfo.ProcessedNote())
        {
            data = ownsdesinfo.GetNote(&datalen);
            if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::NOTE, data, datalen)) < 0)
            {
                if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
                {
                    *full = true;
                    return 0;
                }
            }
            (*added)++;
            ownsdesinfo.SetProcessedNote(true);
        }
    }

    *processedall = true;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetLocalCNAME()

uint8_t* qrtplib::RTCPPacketBuilder::GetLocalCNAME ( std::size_t *  len ) const

inline

Returns the own CNAME item with length len

Definition at line 263 of file rtcppacketbuilder.h.

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

    {
        if (!init)
            return 0;
        return ownsdesinfo.GetCNAME(len);
    }

Here is the caller graph for this function:

Init()

int qrtplib::RTCPPacketBuilder::Init	(	std::size_t	maxpacksize,
		double	timestampunit,
		const void *	cname,
		std::size_t	cnamelen
	)

Initializes the builder. Initializes the builder to use the maximum allowed packet size maxpacksize, timestamp unit timestampunit and the SDES CNAME item specified by cname with length cnamelen. The timestamp unit is defined as a time interval divided by the timestamp interval corresponding to that interval: for 8000 Hz audio this would be 1/8000.

Definition at line 55 of file rtcppacketbuilder.cpp.

References ClearAllSourceFlags(), ERR_RTP_RTCPPACKETBUILDER_ALREADYINIT, ERR_RTP_RTCPPACKETBUILDER_ILLEGALMAXPACKSIZE, ERR_RTP_RTCPPACKETBUILDER_ILLEGALTIMESTAMPUNIT, firstpacket, init, interval_email, interval_location, interval_name, interval_note, interval_phone, interval_tool, maxpacketsize, ownsdesinfo, processingsdes, RTP_MINPACKETSIZE, sdesbuildcount, qrtplib::RTCPSDESInfo::SetCNAME(), timestampunit, and transmissiondelay.

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

{
    if (init)
        return ERR_RTP_RTCPPACKETBUILDER_ALREADYINIT;
    if (maxpacksize < RTP_MINPACKETSIZE)
        return ERR_RTP_RTCPPACKETBUILDER_ILLEGALMAXPACKSIZE;
    if (tsunit < 0.0)
        return ERR_RTP_RTCPPACKETBUILDER_ILLEGALTIMESTAMPUNIT;

    if (cnamelen > 255)
        cnamelen = 255;

    maxpacketsize = maxpacksize;
    timestampunit = tsunit;

    int status;

    if ((status = ownsdesinfo.SetCNAME((const uint8_t *) cname, cnamelen)) < 0)
        return status;

    ClearAllSourceFlags();

    interval_name = -1;
    interval_email = -1;
    interval_location = -1;
    interval_phone = -1;
    interval_tool = -1;
    interval_note = -1;

    sdesbuildcount = 0;
    transmissiondelay = RTPTime(0, 0);

    firstpacket = true;
    processingsdes = false;
    init = true;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetEMailInterval()

void qrtplib::RTCPPacketBuilder::SetEMailInterval ( int  count )

inline

Sets the RTCP interval for the SDES e-mail item. After all possible sources in the source table have been processed, the class will check if other SDES items need to be sent. If count is zero or negative, nothing will happen. If count is positive, an SDES e-mail item will be added after the sources in the source table have been processed count times.

Definition at line 155 of file rtcppacketbuilder.h.

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

    {
        if (!init)
            return;
        interval_email = count;
    }

Here is the caller graph for this function:

SetLocalEMail()

int qrtplib::RTCPPacketBuilder::SetLocalEMail ( const void *  s, std::size_t  len  )

inline

Sets the SDES e-mail item for the local participant to the value s with length len.

Definition at line 223 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        return ownsdesinfo.SetEMail((const uint8_t *) s, len);
    }

Here is the caller graph for this function:

SetLocalLocation()

int qrtplib::RTCPPacketBuilder::SetLocalLocation ( const void *  s, std::size_t  len  )

inline

Sets the SDES location item for the local participant to the value s with length len.

Definition at line 231 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        return ownsdesinfo.SetLocation((const uint8_t *) s, len);
    }

Here is the caller graph for this function:

SetLocalName()

int qrtplib::RTCPPacketBuilder::SetLocalName ( const void *  s, std::size_t  len  )

inline

Sets the SDES name item for the local participant to the value s with length len.

Definition at line 215 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        return ownsdesinfo.SetName((const uint8_t *) s, len);
    }

Here is the caller graph for this function:

SetLocalNote()

int qrtplib::RTCPPacketBuilder::SetLocalNote ( const void *  s, std::size_t  len  )

inline

Sets the SDES note item for the local participant to the value s with length len.

Definition at line 255 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        return ownsdesinfo.SetNote((const uint8_t *) s, len);
    }

Here is the caller graph for this function:

SetLocalPhone()

int qrtplib::RTCPPacketBuilder::SetLocalPhone ( const void *  s, std::size_t  len  )

inline

Sets the SDES phone item for the local participant to the value s with length len.

Definition at line 239 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        return ownsdesinfo.SetPhone((const uint8_t *) s, len);
    }

Here is the caller graph for this function:

SetLocalTool()

int qrtplib::RTCPPacketBuilder::SetLocalTool ( const void *  s, std::size_t  len  )

inline

Sets the SDES tool item for the local participant to the value s with length len.

Definition at line 247 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        return ownsdesinfo.SetTool((const uint8_t *) s, len);
    }

Here is the caller graph for this function:

SetLocationInterval()

void qrtplib::RTCPPacketBuilder::SetLocationInterval ( int  count )

inline

Sets the RTCP interval for the SDES location item. After all possible sources in the source table have been processed, the class will check if other SDES items need to be sent. If count is zero or negative, nothing will happen. If count is positive, an SDES location item will be added after the sources in the source table have been processed count times.

Definition at line 168 of file rtcppacketbuilder.h.

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

    {
        if (!init)
            return;
        interval_location = count;
    }

Here is the caller graph for this function:

SetMaximumPacketSize()

int qrtplib::RTCPPacketBuilder::SetMaximumPacketSize ( std::size_t  maxpacksize )

inline

Sets the maximum size allowed size of an RTCP compound packet to maxpacksize.

Definition at line 102 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_ILLEGALMAXPACKSIZE, ERR_RTP_RTCPPACKETBUILDER_NOTINIT, and RTP_MINPACKETSIZE.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        if (maxpacksize < RTP_MINPACKETSIZE)
            return ERR_RTP_RTCPPACKETBUILDER_ILLEGALMAXPACKSIZE;
        maxpacketsize = maxpacksize;
        return 0;
    }

Here is the caller graph for this function:

SetNameInterval()

void qrtplib::RTCPPacketBuilder::SetNameInterval ( int  count )

inline

Sets the RTCP interval for the SDES name item. After all possible sources in the source table have been processed, the class will check if other SDES items need to be sent. If count is zero or negative, nothing will happen. If count is positive, an SDES name item will be added after the sources in the source table have been processed count times.

Definition at line 142 of file rtcppacketbuilder.h.

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

    {
        if (!init)
            return;
        interval_name = count;
    }

Here is the caller graph for this function:

SetNoteInterval()

void qrtplib::RTCPPacketBuilder::SetNoteInterval ( int  count )

inline

Sets the RTCP interval for the SDES note item. After all possible sources in the source table have been processed, the class will check if other SDES items need to be sent. If count is zero or negative, nothing will happen. If count is positive, an SDES note item will be added after the sources in the source table have been processed count times.

Definition at line 207 of file rtcppacketbuilder.h.

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

    {
        if (!init)
            return;
        interval_note = count;
    }

Here is the caller graph for this function:

SetPhoneInterval()

void qrtplib::RTCPPacketBuilder::SetPhoneInterval ( int  count )

inline

Sets the RTCP interval for the SDES phone item. After all possible sources in the source table have been processed, the class will check if other SDES items need to be sent. If count is zero or negative, nothing will happen. If count is positive, an SDES phone item will be added after the sources in the source table have been processed count times.

Definition at line 181 of file rtcppacketbuilder.h.

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

    {
        if (!init)
            return;
        interval_phone = count;
    }

Here is the caller graph for this function:

SetPreTransmissionDelay()

int qrtplib::RTCPPacketBuilder::SetPreTransmissionDelay ( const RTPTime &  delay )

inline

This function allows you to inform RTCP packet builder about the delay between sampling the first sample of a packet and sending the packet. This function allows you to inform RTCP packet builder about the delay between sampling the first sample of a packet and sending the packet. This delay is taken into account when calculating the relation between RTP timestamp and wallclock time, used for inter-media synchronization.

Definition at line 118 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        transmissiondelay = delay;
        return 0;
    }

Here is the caller graph for this function:

SetTimestampUnit()

int qrtplib::RTCPPacketBuilder::SetTimestampUnit ( double  tsunit )

inline

Sets the timestamp unit to be used to tsunit. Sets the timestamp unit to be used to tsunit. The timestamp unit is defined as a time interval divided by the timestamp interval corresponding to that interval: for 8000 Hz audio this would be 1/8000.

Definition at line 91 of file rtcppacketbuilder.h.

References ERR_RTP_RTCPPACKETBUILDER_ILLEGALTIMESTAMPUNIT, and ERR_RTP_RTCPPACKETBUILDER_NOTINIT.

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

    {
        if (!init)
            return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
        if (tsunit < 0)
            return ERR_RTP_RTCPPACKETBUILDER_ILLEGALTIMESTAMPUNIT;
        timestampunit = tsunit;
        return 0;
    }

Here is the caller graph for this function:

SetToolInterval()

void qrtplib::RTCPPacketBuilder::SetToolInterval ( int  count )

inline

Sets the RTCP interval for the SDES tool item. After all possible sources in the source table have been processed, the class will check if other SDES items need to be sent. If count is zero or negative, nothing will happen. If count is positive, an SDES tool item will be added after the sources in the source table have been processed count times.

Definition at line 194 of file rtcppacketbuilder.h.

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

    {
        if (!init)
            return;
        interval_tool = count;
    }

Here is the caller graph for this function:

Member Data Documentation

doemail

bool qrtplib::RTCPPacketBuilder::doemail

private

Definition at line 355 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and FillInSDES().

doloc

bool qrtplib::RTCPPacketBuilder::doloc

private

Definition at line 355 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and FillInSDES().

doname

bool qrtplib::RTCPPacketBuilder::doname

private

Definition at line 355 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and FillInSDES().

donote

bool qrtplib::RTCPPacketBuilder::donote

private

Definition at line 355 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and FillInSDES().

dophone

bool qrtplib::RTCPPacketBuilder::dophone

private

Definition at line 355 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and FillInSDES().

dotool

bool qrtplib::RTCPPacketBuilder::dotool

private

Definition at line 355 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and FillInSDES().

firstpacket

bool qrtplib::RTCPPacketBuilder::firstpacket

private

Definition at line 281 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), FillInReportBlocks(), and Init().

init

bool qrtplib::RTCPPacketBuilder::init

private

Definition at line 278 of file rtcppacketbuilder.h.

Referenced by BuildBYEPacket(), BuildNextPacket(), Destroy(), Init(), and RTCPPacketBuilder().

interval_email

int qrtplib::RTCPPacketBuilder::interval_email

private

Definition at line 353 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

interval_location

int qrtplib::RTCPPacketBuilder::interval_location

private

Definition at line 353 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

interval_name

int qrtplib::RTCPPacketBuilder::interval_name

private

Definition at line 353 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

interval_note

int qrtplib::RTCPPacketBuilder::interval_note

private

Definition at line 354 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

interval_phone

int qrtplib::RTCPPacketBuilder::interval_phone

private

Definition at line 354 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

interval_tool

int qrtplib::RTCPPacketBuilder::interval_tool

private

Definition at line 354 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

maxpacketsize

std::size_t qrtplib::RTCPPacketBuilder::maxpacketsize

private

Definition at line 279 of file rtcppacketbuilder.h.

Referenced by BuildBYEPacket(), BuildNextPacket(), and Init().

ownsdesinfo

RTCPSDESInfoInternal qrtplib::RTCPPacketBuilder::ownsdesinfo

private

Definition at line 352 of file rtcppacketbuilder.h.

Referenced by BuildBYEPacket(), BuildNextPacket(), ClearAllSDESFlags(), Destroy(), FillInSDES(), and Init().

prevbuildtime

RTPTime qrtplib::RTCPPacketBuilder::prevbuildtime

private

Definition at line 282 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and FillInReportBlocks().

processingsdes

bool qrtplib::RTCPPacketBuilder::processingsdes

private

Definition at line 356 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

rtppacketbuilder

RTPPacketBuilder& qrtplib::RTCPPacketBuilder::rtppacketbuilder

private

Definition at line 276 of file rtcppacketbuilder.h.

Referenced by BuildBYEPacket(), and BuildNextPacket().

sdesbuildcount

int qrtplib::RTCPPacketBuilder::sdesbuildcount

private

Definition at line 358 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

sources

RTPSources& qrtplib::RTCPPacketBuilder::sources

private

Definition at line 275 of file rtcppacketbuilder.h.

Referenced by BuildBYEPacket(), BuildNextPacket(), ClearAllSourceFlags(), and FillInReportBlocks().

timestampunit

double qrtplib::RTCPPacketBuilder::timestampunit

private

Definition at line 280 of file rtcppacketbuilder.h.

Referenced by BuildBYEPacket(), BuildNextPacket(), and Init().

transmissiondelay

RTPTime qrtplib::RTCPPacketBuilder::transmissiondelay

private

Definition at line 282 of file rtcppacketbuilder.h.

Referenced by BuildNextPacket(), and Init().

---

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

• qrtplib/rtcppacketbuilder.h
• qrtplib/rtcppacketbuilder.cpp