TAO_AV_RTCP Class Reference

Encapsulate the header format for the Real Time Control Protocol (RTCP). More...

#include <RTCP.h>

List of all members.

Static Public Member Functions
static void	send_report (ACE_Message_Block *mb)
static ACE_UINT32	alloc_srcid (ACE_UINT32 addr)
static double	rtcp_interval (int members, int senders, double rtcp_bw, int we_sent, int packet_size, int *avg_rtcp_size, int initial)
Classes
struct	md5_string
struct	ntp64
struct	rtcphdr

---

Detailed Description

Encapsulate the header format for the Real Time Control Protocol (RTCP).

Definition at line 72 of file RTCP.h.

---

Member Function Documentation

ACE_UINT32 TAO_AV_RTCP::alloc_srcid

(

ACE_UINT32

addr

)

[static]

Definition at line 191 of file RTCP.cpp.

References ACE_OS::getgid(), ACE_OS::getpgid(), ACE_OS::getpid(), ACE_OS::getppid(), ACE_OS::gettimeofday(), ACE_OS::getuid(), TAO_AV_RTCP::md5_string::gid, MD5Final(), MD5Init(), MD5Update(), TAO_AV_RTCP::md5_string::pgid, TAO_AV_RTCP::md5_string::pid, TAO_AV_RTCP::md5_string::ppid, TAO_AV_RTCP::md5_string::tv, TAO_AV_RTCP::md5_string::type, and TAO_AV_RTCP::md5_string::uid.

Referenced by TAO_AV_RTP_Object::TAO_AV_RTP_Object(), and TAO_StreamCtrl::TAO_StreamCtrl().

{
  md5_string s;

  s.type = addr;
  s.tv = ACE_OS::gettimeofday ();
  s.pid = ACE_OS::getpid();
  s.pgid = ACE_OS::getpgid(s.pid);
  s.ppid = ACE_OS::getppid();
  s.uid = ACE_OS::getuid();
  s.gid = ACE_OS::getgid();

  unsigned char *string_val = (unsigned char *) &s;
  int length = sizeof(s);

  MD5_CTX context;
  union
    {
      char c[16];
      u_long x[4];
    } digest;
  ACE_UINT32 r;
  int i;

  MD5Init (&context);
  MD5Update (&context, string_val, length);
  MD5Final ((unsigned char*)&digest, &context);
  r=0;
  for (i=0; i<3; i++)
    r ^= digest.x[i];

  return r;

/* used to be this
  ACE_Time_Value tv = ACE_OS::gettimeofday ();
  ACE_UINT32 srcid = ACE_UINT32 (tv.sec () + tv.usec ());
  srcid += (ACE_UINT32)ACE_OS::getuid();
  srcid += (ACE_UINT32)ACE_OS::getpid();
  srcid += addr;
  return (srcid);
*/
}

double TAO_AV_RTCP::rtcp_interval	(	int	members,
		int	senders,
		double	rtcp_bw,
		int	we_sent,
		int	packet_size,
		int *	avg_rtcp_size,
		int	initial
	)			[static]

Definition at line 236 of file RTCP.cpp.

References ACE_OS::rand(), RTCP_MIN_RPT_TIME, RTCP_RECEIVER_BW_FRACTION, RTCP_SENDER_BW_FRACTION, RTCP_SIZE_GAIN, ACE_OS::srand(), and ACE_OS::time().

Referenced by TAO_AV_RTCP_Callback::get_timeout().

{
  // Minimum time between RTCP packets from this site (in sec.).
  // 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 interval from
  // becoming ridiculously small during transient outages like a
  // network partition.
//  double const RTCP_MIN_TIME = 5.0;   (from RTP.h)

  // 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_SENDER_BW_FRACTION = 0.25;   (from RTP.h)
//  double const RTCP_RCVR_BW_FRACTION = (1-RTCP_SENDER_BW_FRACTION); (from RTP.h)

  // Gain (smoothing constant) for the low-pass filter that
  // estimates the average RTCP packet size
//  double const RTCP_SIZE_GAIN = (1.0/16.0);   (from RTP.h)

  double t;
  double rtcp_min_time = RTCP_MIN_RPT_TIME;
  int n;   // number of members for computation

  // 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 octets which is conservative (it assumes everyone else
  // is generating SRs instead of RRs: 20 IP + 8 UDP + 52 SR + 48
  // SDES CNAME).
  if (initial)
    {
      // initialize the random number generator
      ACE_OS::srand(ACE_OS::time(0L));

      rtcp_min_time /= 2;
      *avg_rtcp_size = 128;
    }

  // If there were active senders, give them at least a minimum
  // share of the RTCP bandwidth.  Otherwise all participants share
  // the RTCP bandwidth equally.
  n = members;
  if ((senders > 0) && (senders < members*RTCP_SENDER_BW_FRACTION))
    {
      if (we_sent)
        {
          rtcp_bw *= RTCP_SENDER_BW_FRACTION;
          n = senders;
        }
      else
        {
          rtcp_bw *= RTCP_RECEIVER_BW_FRACTION;
          n -= senders;
        }
    }

  // Update the average size estimate by the size of the report
  // packet we just sent.
  *avg_rtcp_size += (int)((packet_size - *avg_rtcp_size)*RTCP_SIZE_GAIN);

  // 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 = (*avg_rtcp_size) * n / rtcp_bw;
  if (t < rtcp_min_time)
    t = rtcp_min_time;

  // To avoid traffic bursts from unintended synchronization with
  // other sites, we then pick our actual next report interval as a
  // random number uniformly distributed between 0.5*t and 1.5*t.

  // TODO: this may not be right.  need a random number between 0 and 1
  int max_rand = 32768;

  return t * ((double)ACE_OS::rand()/max_rand + 0.5);
//  return t * (drand48() + 0.5);
}

static void TAO_AV_RTCP::send_report

(

ACE_Message_Block *

mb

)

[static]

---

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

• RTCP.h
• RTCP.cpp

---