qrtplib::RTCPScheduler Class Reference

#include <rtcpscheduler.h>

Collaboration diagram for qrtplib::RTCPScheduler:

Public Member Functions
	RTCPScheduler (RTPSources &sources, RTPRandom &rtprand)
	~RTCPScheduler ()
void	Reset ()
void	SetParameters (const RTCPSchedulerParams &params)
RTCPSchedulerParams	GetParameters () const
void	SetHeaderOverhead (std::size_t numbytes)
std::size_t	GetHeaderOverhead () const
void	AnalyseIncoming (RTCPCompoundPacket &rtcpcomppack)
void	AnalyseOutgoing (RTCPCompoundPacket &rtcpcomppack)
void	ActiveMemberDecrease ()
void	ScheduleBYEPacket (std::size_t packetsize)
RTPTime	GetTransmissionDelay ()
bool	IsTime ()
RTPTime	CalculateDeterministicInterval (bool sender=false)

Private Member Functions
void	CalculateNextRTCPTime ()
void	PerformReverseReconsideration ()
RTPTime	CalculateBYETransmissionInterval ()
RTPTime	CalculateTransmissionInterval (bool sender)

Private Attributes
RTPSources &	sources
RTCPSchedulerParams	schedparams
std::size_t	headeroverhead
std::size_t	avgrtcppacksize
bool	hassentrtcp
bool	firstcall
RTPTime	nextrtcptime
RTPTime	prevrtcptime
int	pmembers
bool	byescheduled
int	byemembers
int	pbyemembers
std::size_t	avgbyepacketsize
bool	sendbyenow
RTPRandom &	rtprand

Detailed Description

This class determines when RTCP compound packets should be sent.

Definition at line 125 of file rtcpscheduler.h.

Constructor & Destructor Documentation

RTCPScheduler()

qrtplib::RTCPScheduler::RTCPScheduler	(	RTPSources &	sources,
		RTPRandom &	rtprand
	)

Creates an instance which will use the source table RTPSources to determine when RTCP compound packets should be scheduled. Creates an instance which will use the source table RTPSources to determine when RTCP compound packets should be scheduled. Note that for correct operation the sources instance should have information about the own SSRC (added by RTPSources::CreateOwnSSRC). You must also supply a random number generator rtprand which will be used for adding randomness to the RTCP intervals.

Definition at line 87 of file rtcpscheduler.cpp.

References avgbyepacketsize, byemembers, pbyemembers, pmembers, and Reset().

                                                        :
        sources(s), nextrtcptime(0, 0), prevrtcptime(0, 0), rtprand(r)
{
    pmembers = 0;
    byemembers = 0;
    pbyemembers = 0;
    avgbyepacketsize = 0;
    
    Reset();

    //std::cout << (void *)(&rtprand) << std::endl;
}

Here is the call graph for this function:

~RTCPScheduler()

qrtplib::RTCPScheduler::~RTCPScheduler

(

)

Definition at line 100 of file rtcpscheduler.cpp.

{
}

Member Function Documentation

ActiveMemberDecrease()

void qrtplib::RTCPScheduler::ActiveMemberDecrease

(

)

This function has to be called each time a member times out or sends a BYE packet.

Definition at line 391 of file rtcpscheduler.cpp.

References qrtplib::RTPSources::GetActiveMemberCount(), PerformReverseReconsideration(), pmembers, and sources.

Referenced by qrtplib::RTPSessionSources::OnBYEPacket(), and qrtplib::RTPSessionSources::OnTimeout().

{
    if (sources.GetActiveMemberCount() < pmembers)
        PerformReverseReconsideration();
}

Here is the call graph for this function:

Here is the caller graph for this function:

AnalyseIncoming()

void qrtplib::RTCPScheduler::AnalyseIncoming

(

RTCPCompoundPacket &

rtcpcomppack

)

For each incoming RTCP compound packet, this function has to be called for the scheduler to work correctly.

Definition at line 114 of file rtcpscheduler.cpp.

References avgbyepacketsize, avgrtcppacksize, qrtplib::RTCPPacket::BYE, byemembers, byescheduled, qrtplib::RTCPCompoundPacket::GetCompoundPacketLength(), qrtplib::RTCPCompoundPacket::GetNextPacket(), qrtplib::RTCPPacket::GetPacketType(), qrtplib::RTCPCompoundPacket::GotoFirstPacket(), and headeroverhead.

Referenced by qrtplib::RTPSessionSources::OnRTCPCompoundPacket().

{
    bool isbye = false;
    RTCPPacket *p;

    rtcpcomppack.GotoFirstPacket();
    while (!isbye && ((p = rtcpcomppack.GetNextPacket()) != 0))
    {
        if (p->GetPacketType() == RTCPPacket::BYE)
            isbye = true;
    }

    if (!isbye)
    {
        std::size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
        avgrtcppacksize = (std::size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgrtcppacksize));
    }
    else
    {
        if (byescheduled)
        {
            std::size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
            avgbyepacketsize = (std::size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgbyepacketsize));
            byemembers++;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

AnalyseOutgoing()

void qrtplib::RTCPScheduler::AnalyseOutgoing

(

RTCPCompoundPacket &

rtcpcomppack

)

For each outgoing RTCP compound packet, this function has to be called for the scheduler to work correctly.

Definition at line 142 of file rtcpscheduler.cpp.

References avgrtcppacksize, qrtplib::RTCPPacket::BYE, qrtplib::RTCPCompoundPacket::GetCompoundPacketLength(), qrtplib::RTCPCompoundPacket::GetNextPacket(), qrtplib::RTCPPacket::GetPacketType(), qrtplib::RTCPCompoundPacket::GotoFirstPacket(), hassentrtcp, and headeroverhead.

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

{
    bool isbye = false;
    RTCPPacket *p;

    rtcpcomppack.GotoFirstPacket();
    while (!isbye && ((p = rtcpcomppack.GetNextPacket()) != 0))
    {
        if (p->GetPacketType() == RTCPPacket::BYE)
            isbye = true;
    }

    if (!isbye)
    {
        std::size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
        avgrtcppacksize = (std::size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgrtcppacksize));
    }

    hassentrtcp = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CalculateBYETransmissionInterval()

RTPTime qrtplib::RTCPScheduler::CalculateBYETransmissionInterval ( )

private

Definition at line 397 of file rtcpscheduler.cpp.

References avgbyepacketsize, byemembers, byescheduled, qrtplib::RTPTime::GetDouble(), qrtplib::RTCPSchedulerParams::GetMinimumTransmissionInterval(), qrtplib::RTPRandom::GetRandomDouble(), qrtplib::RTCPSchedulerParams::GetRTCPBandwidth(), qrtplib::RTCPSchedulerParams::GetSenderBandwidthFraction(), qrtplib::RTCPSchedulerParams::GetUseHalfAtStartup(), rtprand, schedparams, and sendbyenow.

Referenced by IsTime(), and ScheduleBYEPacket().

{
    if (!byescheduled)
        return RTPTime(0, 0);

    if (sendbyenow)
        return RTPTime(0, 0);

    double C, n;

    C = ((double) avgbyepacketsize) / ((1.0 - schedparams.GetSenderBandwidthFraction()) * schedparams.GetRTCPBandwidth());
    n = (double) byemembers;

    RTPTime Tmin = schedparams.GetMinimumTransmissionInterval();
    double tmin = Tmin.GetDouble();

    if (schedparams.GetUseHalfAtStartup())
        tmin /= 2.0;

    double ntimesC = n * C;
    double Td = (tmin > ntimesC) ? tmin : ntimesC;

    double mul = rtprand.GetRandomDouble() + 0.5; // gives random value between 0.5 and 1.5
    double T = (Td * mul) / 1.21828; // see RFC 3550 p 30

    return RTPTime(T);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CalculateDeterministicInterval()

RTPTime qrtplib::RTCPScheduler::CalculateDeterministicInterval

(

bool

sender = false

)

Calculates the deterministic interval at this time. Calculates the deterministic interval at this time. This is used - in combination with a certain multiplier - to time out members, senders etc.

Definition at line 253 of file rtcpscheduler.cpp.

References avgrtcppacksize, qrtplib::RTPSources::GetActiveMemberCount(), qrtplib::RTPTime::GetDouble(), qrtplib::RTCPSchedulerParams::GetMinimumTransmissionInterval(), qrtplib::RTCPSchedulerParams::GetRTCPBandwidth(), qrtplib::RTCPSchedulerParams::GetSenderBandwidthFraction(), qrtplib::RTPSources::GetSenderCount(), qrtplib::RTCPSchedulerParams::GetUseHalfAtStartup(), hassentrtcp, schedparams, and sources.

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

{
    int numsenders = sources.GetSenderCount();
    int numtotal = sources.GetActiveMemberCount();

//  std::cout << "CalculateDeterministicInterval" << std::endl;
//  std::cout << "  numsenders: " << numsenders << std::endl;
//  std::cout << "  numtotal: " << numtotal << std::endl;

    // Try to avoid division by zero:
    if (numtotal == 0)
        numtotal++;

    double sfraction = ((double) numsenders) / ((double) numtotal);
    double C, n;

    if (sfraction <= schedparams.GetSenderBandwidthFraction())
    {
        if (sender)
        {
            C = ((double) avgrtcppacksize) / (schedparams.GetSenderBandwidthFraction() * schedparams.GetRTCPBandwidth());
            n = (double) numsenders;
        }
        else
        {
            C = ((double) avgrtcppacksize) / ((1.0 - schedparams.GetSenderBandwidthFraction()) * schedparams.GetRTCPBandwidth());
            n = (double) (numtotal - numsenders);
        }
    }
    else
    {
        C = ((double) avgrtcppacksize) / schedparams.GetRTCPBandwidth();
        n = (double) numtotal;
    }

    RTPTime Tmin = schedparams.GetMinimumTransmissionInterval();
    double tmin = Tmin.GetDouble();

    if (!hassentrtcp && schedparams.GetUseHalfAtStartup())
        tmin /= 2.0;

    double ntimesC = n * C;
    double Td = (tmin > ntimesC) ? tmin : ntimesC;

    // TODO: for debugging
//  std::cout << "  Td: " << Td << std::endl;

    return RTPTime(Td);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CalculateNextRTCPTime()

void qrtplib::RTCPScheduler::CalculateNextRTCPTime ( )

private

Definition at line 241 of file rtcpscheduler.cpp.

References CalculateTransmissionInterval(), qrtplib::RTPTime::CurrentTime(), qrtplib::RTPSources::GetOwnSourceInfo(), qrtplib::RTPSourceData::IsSender(), nextrtcptime, and sources.

Referenced by GetTransmissionDelay(), and IsTime().

{
    bool aresender = false;
    RTPSourceData *srcdat;

    if ((srcdat = sources.GetOwnSourceInfo()) != 0)
        aresender = srcdat->IsSender();

    nextrtcptime = RTPTime::CurrentTime();
    nextrtcptime += CalculateTransmissionInterval(aresender);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CalculateTransmissionInterval()

RTPTime qrtplib::RTCPScheduler::CalculateTransmissionInterval ( bool  sender )

private

Definition at line 303 of file rtcpscheduler.cpp.

References CalculateDeterministicInterval(), qrtplib::RTPTime::GetDouble(), qrtplib::RTPRandom::GetRandomDouble(), and rtprand.

Referenced by CalculateNextRTCPTime(), and IsTime().

{
    RTPTime Td = CalculateDeterministicInterval(sender);
    double td, mul, T;

//  std::cout << "CalculateTransmissionInterval" << std::endl;

    td = Td.GetDouble();
    mul = rtprand.GetRandomDouble() + 0.5; // gives random value between 0.5 and 1.5
    T = (td * mul) / 1.21828; // see RFC 3550 p 30

//  std::cout << "  Td: " << td << std::endl;
//  std::cout << "  mul: " << mul << std::endl;
//  std::cout << "  T: " << T << std::endl;

    return RTPTime(T);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetHeaderOverhead()

std::size_t qrtplib::RTCPScheduler::GetHeaderOverhead ( ) const

inline

Returns the currently used header overhead.

Definition at line 160 of file rtcpscheduler.h.

    {
        return headeroverhead;
    }

GetParameters()

RTCPSchedulerParams qrtplib::RTCPScheduler::GetParameters ( ) const

inline

Returns the currently used scheduler parameters.

Definition at line 148 of file rtcpscheduler.h.

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

    {
        return schedparams;
    }

Here is the caller graph for this function:

GetTransmissionDelay()

RTPTime qrtplib::RTCPScheduler::GetTransmissionDelay

(

)

Returns the delay after which an RTCP compound will possibly have to be sent. Returns the delay after which an RTCP compound will possibly have to be sent. The IsTime member function should be called afterwards to make sure that it actually is time to send an RTCP compound packet.

Definition at line 163 of file rtcpscheduler.cpp.

References CalculateNextRTCPTime(), qrtplib::RTPTime::CurrentTime(), firstcall, qrtplib::RTPSources::GetActiveMemberCount(), nextrtcptime, pmembers, prevrtcptime, and sources.

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

{
    if (firstcall)
    {
        firstcall = false;
        prevrtcptime = RTPTime::CurrentTime();
        pmembers = sources.GetActiveMemberCount();
        CalculateNextRTCPTime();
    }

    RTPTime curtime = RTPTime::CurrentTime();

    if (curtime > nextrtcptime) // packet should be sent
        return RTPTime(0, 0);

    RTPTime diff = nextrtcptime;
    diff -= curtime;

    return diff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsTime()

bool qrtplib::RTCPScheduler::IsTime

(

)

This function returns true if it's time to send an RTCP compound packet and false otherwise. This function returns true if it's time to send an RTCP compound packet and false otherwise. If the function returns true, it will also have calculated the next time at which a packet should be sent, so if it is called again right away, it will return false.

Definition at line 184 of file rtcpscheduler.cpp.

References byescheduled, CalculateBYETransmissionInterval(), CalculateNextRTCPTime(), CalculateTransmissionInterval(), qrtplib::RTPTime::CurrentTime(), firstcall, qrtplib::RTPSources::GetActiveMemberCount(), qrtplib::RTPSources::GetOwnSourceInfo(), qrtplib::RTPSourceData::IsSender(), nextrtcptime, pmembers, prevrtcptime, and sources.

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

{
    if (firstcall)
    {
        firstcall = false;
        prevrtcptime = RTPTime::CurrentTime();
        pmembers = sources.GetActiveMemberCount();
        CalculateNextRTCPTime();
        return false;
    }

    RTPTime currenttime = RTPTime::CurrentTime();

//  // TODO: for debugging
//  double diff = nextrtcptime.GetDouble() - currenttime.GetDouble();
//
//  std::cout << "Delay till next RTCP interval: " << diff << std::endl;

    if (currenttime < nextrtcptime) // timer has not yet expired
        return false;

    RTPTime checktime(0, 0);

    if (!byescheduled)
    {
        bool aresender = false;
        RTPSourceData *srcdat;

        if ((srcdat = sources.GetOwnSourceInfo()) != 0)
            aresender = srcdat->IsSender();

        checktime = CalculateTransmissionInterval(aresender);
    }
    else
        checktime = CalculateBYETransmissionInterval();

//  std::cout << "Calculated checktime: " << checktime.GetDouble() << std::endl;

    checktime += prevrtcptime;

    if (checktime <= currenttime) // Okay
    {
        byescheduled = false;
        prevrtcptime = currenttime;
        pmembers = sources.GetActiveMemberCount();
        CalculateNextRTCPTime();
        return true;
    }

//  std::cout << "New delay: " << nextrtcptime.GetDouble() - currenttime.GetDouble() << std::endl;

    nextrtcptime = checktime;
    pmembers = sources.GetActiveMemberCount();

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PerformReverseReconsideration()

void qrtplib::RTCPScheduler::PerformReverseReconsideration ( )

private

Definition at line 321 of file rtcpscheduler.cpp.

References qrtplib::RTPTime::CurrentTime(), firstcall, qrtplib::RTPSources::GetActiveMemberCount(), qrtplib::RTPTime::GetDouble(), nextrtcptime, pmembers, prevrtcptime, and sources.

Referenced by ActiveMemberDecrease().

{
    if (firstcall)
        return;

    double diff1, diff2;
    int members = sources.GetActiveMemberCount();

    RTPTime tc = RTPTime::CurrentTime();
    RTPTime tn_min_tc = nextrtcptime;

    if (tn_min_tc > tc)
        tn_min_tc -= tc;
    else
        tn_min_tc = RTPTime(0, 0);

//  std::cout << "+tn_min_tc0 " << nextrtcptime.GetDouble()-tc.GetDouble() << std::endl;
//  std::cout << "-tn_min_tc0 " << -nextrtcptime.GetDouble()+tc.GetDouble() << std::endl;
//  std::cout << "tn_min_tc " << tn_min_tc.GetDouble() << std::endl;

    RTPTime tc_min_tp = tc;

    if (tc_min_tp > prevrtcptime)
        tc_min_tp -= prevrtcptime;
    else
        tc_min_tp = 0;

    if (pmembers == 0) // avoid division by zero
        pmembers++;

    diff1 = (((double) members) / ((double) pmembers)) * tn_min_tc.GetDouble();
    diff2 = (((double) members) / ((double) pmembers)) * tc_min_tp.GetDouble();

    nextrtcptime = tc;
    prevrtcptime = tc;
    nextrtcptime += RTPTime(diff1);
    prevrtcptime -= RTPTime(diff2);

    pmembers = members;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Reset()

void qrtplib::RTCPScheduler::Reset

(

)

Resets the scheduler.

Definition at line 104 of file rtcpscheduler.cpp.

References avgrtcppacksize, byescheduled, firstcall, hassentrtcp, headeroverhead, and sendbyenow.

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

{
    headeroverhead = 0; // user has to set this to an appropriate value
    hassentrtcp = false;
    firstcall = true;
    avgrtcppacksize = 1000; // TODO: what is a good value for this?
    byescheduled = false;
    sendbyenow = false;
}

Here is the caller graph for this function:

ScheduleBYEPacket()

void qrtplib::RTCPScheduler::ScheduleBYEPacket

(

std::size_t

packetsize

)

Asks the scheduler to schedule an RTCP compound packet containing a BYE packetl; the compound packet has size packetsize.

Definition at line 362 of file rtcpscheduler.cpp.

References avgbyepacketsize, byemembers, byescheduled, CalculateBYETransmissionInterval(), qrtplib::RTPTime::CurrentTime(), firstcall, qrtplib::RTPSources::GetActiveMemberCount(), qrtplib::RTCPSchedulerParams::GetRequestImmediateBYE(), headeroverhead, nextrtcptime, pbyemembers, pmembers, prevrtcptime, schedparams, sendbyenow, and sources.

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

{
    if (byescheduled)
        return;

    if (firstcall)
    {
        firstcall = false;
        pmembers = sources.GetActiveMemberCount();
    }

    byescheduled = true;
    avgbyepacketsize = packetsize + headeroverhead;

    // For now, we will always use the BYE backoff algorithm as described in rfc 3550 p 33

    byemembers = 1;
    pbyemembers = 1;

    if (schedparams.GetRequestImmediateBYE() && sources.GetActiveMemberCount() < 50) // p 34 (top)
        sendbyenow = true;
    else
        sendbyenow = false;

    prevrtcptime = RTPTime::CurrentTime();
    nextrtcptime = prevrtcptime;
    nextrtcptime += CalculateBYETransmissionInterval();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetHeaderOverhead()

void qrtplib::RTCPScheduler::SetHeaderOverhead ( std::size_t  numbytes )

inline

Sets the header overhead from underlying protocols (for example UDP and IP) to numbytes.

Definition at line 154 of file rtcpscheduler.h.

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

    {
        headeroverhead = numbytes;
    }

Here is the caller graph for this function:

SetParameters()

void qrtplib::RTCPScheduler::SetParameters ( const RTCPSchedulerParams &  params )

inline

Sets the scheduler parameters to be used to params.

Definition at line 142 of file rtcpscheduler.h.

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

    {
        schedparams = params;
    }

Here is the caller graph for this function:

Member Data Documentation

avgbyepacketsize

std::size_t qrtplib::RTCPScheduler::avgbyepacketsize

private

Definition at line 216 of file rtcpscheduler.h.

Referenced by AnalyseIncoming(), CalculateBYETransmissionInterval(), RTCPScheduler(), and ScheduleBYEPacket().

avgrtcppacksize

std::size_t qrtplib::RTCPScheduler::avgrtcppacksize

private

Definition at line 206 of file rtcpscheduler.h.

Referenced by AnalyseIncoming(), AnalyseOutgoing(), CalculateDeterministicInterval(), and Reset().

byemembers

int qrtplib::RTCPScheduler::byemembers

private

Definition at line 215 of file rtcpscheduler.h.

Referenced by AnalyseIncoming(), CalculateBYETransmissionInterval(), RTCPScheduler(), and ScheduleBYEPacket().

byescheduled

bool qrtplib::RTCPScheduler::byescheduled

private

Definition at line 214 of file rtcpscheduler.h.

Referenced by AnalyseIncoming(), CalculateBYETransmissionInterval(), IsTime(), Reset(), and ScheduleBYEPacket().

firstcall

bool qrtplib::RTCPScheduler::firstcall

private

Definition at line 208 of file rtcpscheduler.h.

Referenced by GetTransmissionDelay(), IsTime(), PerformReverseReconsideration(), Reset(), and ScheduleBYEPacket().

hassentrtcp

bool qrtplib::RTCPScheduler::hassentrtcp

private

Definition at line 207 of file rtcpscheduler.h.

Referenced by AnalyseOutgoing(), CalculateDeterministicInterval(), and Reset().

headeroverhead

std::size_t qrtplib::RTCPScheduler::headeroverhead

private

Definition at line 205 of file rtcpscheduler.h.

Referenced by AnalyseIncoming(), AnalyseOutgoing(), Reset(), and ScheduleBYEPacket().

nextrtcptime

RTPTime qrtplib::RTCPScheduler::nextrtcptime

private

Definition at line 209 of file rtcpscheduler.h.

Referenced by CalculateNextRTCPTime(), GetTransmissionDelay(), IsTime(), PerformReverseReconsideration(), and ScheduleBYEPacket().

pbyemembers

int qrtplib::RTCPScheduler::pbyemembers

private

Definition at line 215 of file rtcpscheduler.h.

Referenced by RTCPScheduler(), and ScheduleBYEPacket().

pmembers

int qrtplib::RTCPScheduler::pmembers

private

Definition at line 211 of file rtcpscheduler.h.

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

prevrtcptime

RTPTime qrtplib::RTCPScheduler::prevrtcptime

private

Definition at line 210 of file rtcpscheduler.h.

Referenced by GetTransmissionDelay(), IsTime(), PerformReverseReconsideration(), and ScheduleBYEPacket().

rtprand

RTPRandom& qrtplib::RTCPScheduler::rtprand

private

Definition at line 219 of file rtcpscheduler.h.

Referenced by CalculateBYETransmissionInterval(), and CalculateTransmissionInterval().

schedparams

RTCPSchedulerParams qrtplib::RTCPScheduler::schedparams

private

Definition at line 204 of file rtcpscheduler.h.

Referenced by CalculateBYETransmissionInterval(), CalculateDeterministicInterval(), and ScheduleBYEPacket().

sendbyenow

bool qrtplib::RTCPScheduler::sendbyenow

private

Definition at line 217 of file rtcpscheduler.h.

Referenced by CalculateBYETransmissionInterval(), Reset(), and ScheduleBYEPacket().

sources

RTPSources& qrtplib::RTCPScheduler::sources

private

Definition at line 203 of file rtcpscheduler.h.

Referenced by ActiveMemberDecrease(), CalculateDeterministicInterval(), CalculateNextRTCPTime(), GetTransmissionDelay(), IsTime(), PerformReverseReconsideration(), and ScheduleBYEPacket().

---

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

• qrtplib/rtcpscheduler.h
• qrtplib/rtcpscheduler.cpp