|
|
/*----------------------------------------------------------------------------
* File: RTCPTIME.C * Product: RTP/RTCP implementation * Description: Provides timers related functions for RTCP. * * INTEL Corporation Proprietary Information * This listing is supplied under the terms of a license agreement with * Intel Corporation and may not be copied nor disclosed except in * accordance with the terms of that agreement. * Copyright (c) 1995 Intel Corporation. *--------------------------------------------------------------------------*/
#include "rrcm.h"
/*---------------------------------------------------------------------------
/ Global Variables/--------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
/ External Variables/--------------------------------------------------------------------------*/ extern PRTCP_CONTEXT pRTCPContext;#ifdef _DEBUG
extern char debug_string[];#endif
/*----------------------------------------------------------------------------
* Function : RTCPxmitInterval * Description: Calculate the RTCP transmission interval * * Input : members: Estimated number of session members including * ourselves. On the initial call, should be 1. * * senders: Number of active senders since last report, known from * construction of receiver reports for this packet. * Includes ourselves if we sent. * * rtcpBw: The target RTCP bandwidth, ie, the total Bw that will * be used by RTCP by all members of this session, in * bytes per seconds. Should be 5% of the session Bw. * * weSent: True if we've sent data during the last two RTCP * intervals. If TRUE, the compound RTCP packet just * sent contained an SR packet. * * packetSize: Size of the RTCP packet just sent, in bytes, including * network encapsulation, eg 28 bytes for UDP over IP. * * *avgRtcpSize: Estimator to RTCP packet size, initialized and * updated by this function for the packet just sent. * * initial: Initial transmission flag. * * Return: Interval time before the next transmission in msec. ---------------------------------------------------------------------------*/DWORD RTCPxmitInterval (DWORD members, DWORD senders, DWORD rtcpBw, DWORD weSent, DWORD packetSize, int *avgRtcpSize, DWORD initial) {#ifdef ENABLE_FLOATING_POINT
// // Minimum time between RTCP packets from this site in seconds. This time
// // prevents the reports from clumping when sessions are small and the law
// // of large numbers isn't helping to smooth out the traffic. It also keeps
// // the report intervals from becoming ridiculously small during transient
// // outages like a network partition.
// double const RTCP_MinTime = 5.;
//
// // Fraction of the RTCP bandwidth to be shared among active senders. This
// // fraction was chosen so that in a typical session with one or two active
// // senders, the computed report time would be roughly equal to the minimum
// // report time so that we don't unnecessarily slow down receiver reports.
// // The receiver fraction must be 1 - the sender fraction.
// double const RTCP_SenderBwFraction = 0.25;
// double const RTCP_RcvrBwFraction = (1 - RTCP_SenderBwFraction);
//
// // Gain (smoothing constant) for the low-pass filter that estimates the
// // average RTCP packet size.
// double const RTCP_sizeGain = RTCP_SIZE_GAIN;
//
// // Interval
// double t = 0;
// double rtcp_min_time = RTCP_MinTime;
//
// // Number of member for computation
// unsigned int n;
// int tmpSize;
//
// // Random number
// double randNum;
//
// // Very first call at application start-up uses half the min delay for
// // quicker notification while still allowing some time before reporting
// // for randomization and to learn about other sources so the report
// // interval will converge to the correct interval more quickly. The
// // average RTCP size is initialized to 128 octects which is conservative.
// // It assumes everyone else is generating SRs instead of RRs:
// // 20 IP + 8 UDP + 52 SR + 48 SDES CNAME
// if (initial)
// {
// rtcp_min_time /= 2;
// *avgRtcpSize = 128;
// }
//
// // If there were active senders, give them at least a minimum share of the
// // RTCP bandwidth. Otherwise all participants share the RTCP Bw equally.
// n = members;
// if (senders > 0 && (senders < (members * RTCP_SenderBwFraction)))
// {
// if (weSent)
// {
// rtcpBw *= RTCP_SenderBwFraction;
// n = senders;
// }
// else
// {
// rtcpBw *= RTCP_RcvrBwFraction;
// n -= senders;
// }
// }
//
// // Update the average size estimate by the size of the report packet we
// // just sent out.
// tmpSize = packetSize - *avgRtcpSize;
// tmpSize = (int)(tmpSize * RTCP_sizeGain);
// *avgRtcpSize += tmpSize;
//
// // The effective number of sites times the average packet size is the
// // total number of octets sent when each site sends a report. Dividing
// // this by the effective bandwidth gives the time interval over which
// // those packets must be sent in order to meet the bandwidth target,
// // with a minimum enforced. In that time interval we send one report so
// // this time is also our average time between reports.
// t = (*avgRtcpSize) * n / rtcpBw;
//
// if (t < rtcp_min_time)
// t = rtcp_min_time;
//
// // To avoid traffic burst from unintended synchronization with other sites
// // we then pick our actual next report interval as a random number
// // uniformely distributed between 0.5*t and 1.5*t.
//
// // Get a random number between 0 and 1
// // rand() gives a number between 0-32767.
// randNum = RRCMrand() % 32767;
// randNum /= 32767.0;
//
// // return timeout in msec
// return (t * (randNum + 0.5) * 1000);
#else
// Minimum time between RTCP packets from this site in Msec. This time
// prevents the reports from clumping when sessions are small and the law
// of large numbers isn't helping to smooth out the traffic. It also keeps
// the report intervals from becoming ridiculously small during transient
// outages like a network partition.
int RTCP_MinTime = 5000;
// Interval
int t = 0; int rtcp_min_time = RTCP_MinTime;
// Number of member for computation
unsigned int n; int tmpSize;
// Random number
int randNum;
// Very first call at application start-up uses half the min delay for
// quicker notification while still allowing some time before reporting
// for randomization and to learn about other sources so the report
// interval will converge to the correct interval more quickly. The
// average RTCP size is initialized to 128 octects which is conservative.
// It assumes everyone else is generating SRs instead of RRs:
// 20 IP + 8 UDP + 52 SR + 48 SDES CNAME
if (initial) { rtcp_min_time /= 2; *avgRtcpSize = 128; }
// If there were active senders, give them at least a minimum share of the
// RTCP bandwidth. Otherwise all participants share the RTCP Bw equally.
n = members;
// Only a quart of the bandwidth (=> /4). Check above with floatting point
if (senders > 0 && (senders < (members / 4))) { if (weSent) { // Only a quart of the bandwidth for the sender
rtcpBw /= 4; n = senders; } else { // 3/4 of the bandwidth for the receiver
rtcpBw = (3*rtcpBw)/4; n -= senders; } }
// Update the average size estimate by the size of the report packet we
// just sent out.
tmpSize = packetSize - *avgRtcpSize; tmpSize = (tmpSize+8) / 16; *avgRtcpSize += tmpSize;
// The effective number of sites times the average packet size is the
// total number of octets sent when each site sends a report. Dividing
// this by the effective bandwidth gives the time interval over which
// those packets must be sent in order to meet the bandwidth target,
// with a minimum enforced. In that time interval we send one report so
// this time is also our average time between reports.
if (rtcpBw) t = (*avgRtcpSize) * n / rtcpBw;
if (t < rtcp_min_time) t = rtcp_min_time;
// To avoid traffic burst from unintended synchronization with other sites
// we then pick our actual next report interval as a random number
// uniformely distributed between 0.5*t and 1.5*t.
// Get a random number between 0 and 1
// In order to avoid floating point operation, get a number between
// 0 and 1000, i.e. converted in Msec already. Add 500 Msec instead of
// 0.5 to the random number
randNum = RRCMrand() % 1000;
return ((t * (randNum + 500))/1000);#endif
}
// [EOF]
|
