Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages   Examples  

RTPQueue Class Reference

RTP protocol queue handler. More...

#include <cc++/rtp.h>

Inheritance diagram for RTPQueue:

Thread MembershipControl Members QueueRTCPManager RTPDuplex List of all members.

Public Methods

const RTPSourcegetLocalInfo () const
bool isWaiting (const RTPSource &src=dummysource) const
bool isCookedWaiting (void) const
bool isSending (void) const
void putPacket (uint32 stamp, rtp_payload_t payload, unsigned char *data=NULL, size_t len=0, bool mark=false)
const RTPDatagetCookedPacket (const RTPSource &src=dummysource)
uint32 getFirstTimestamp (const RTPSource &src=dummysource)
uint16 getFirstSequence (const RTPSource &src=dummysource)
const RTPDatagetPacket (uint32 stamp, const RTPSource &src=dummysource)
size_t getPacket (uint32 stamp, unsigned char *data, size_t max, const RTPSource &src=dummysource)
rtp_payload_t getPayloadType (uint32 timestamp, const RTPSource &src=dummysource)
uint32 getCurrentTimestamp (rtp_payload_t pt) const
uint32 getTimestampIncrement (size_t packet_size) const
void setSessionBandwidth (uint32 bw)
uint32 getRate (rtp_payload_t pt=RTP_PAYLOAD_EMPTY) const
rtp_payload_t getPayloadType (const RTPSource &src) const
const RTPSourcegetSource (uint32 ssrc) const
void setTypeOfService (type_of_service_t tos)
size_t setPartial (uint32 timestamp, unsigned char *data, size_t offset, size_t max)
size_t getPartial (uint32 timestamp, unsigned char *data, size_t offset, size_t max)
bool isActive (void) const
void setTimeout (microtimeout_t t)
void setExpired (microtimeout_t t)
void setGlobalKitchenDuration (microtimeout_t t)
void setGlobalKitchenSize (uint32 s)
microtimeout_t getGlobalKitchenDuration () const
void setEndToEndDelay (microtimeout_t t)
void setSegmentSize (size_t size)
bool isComplete (void)
bool isMarked (void)
void setTimeclock (void)
timeout_t getTimeclock (void)
uint32 RTPSendCount () const
uint32 RTPOctetCount () const

Protected Methods

 RTPQueue (int pri, uint32 size=7)
 RTPQueue (uint32 ssrc, int pri, uint32 size=7)
virtual ~RTPQueue ()
virtual void RTCPService (microtimeout_t &wait)
virtual void Bye (const char *const reason)
virtual void timerTick (void)
microtimeout_t getTimeout (void)
virtual bool isPendingData (microtimeout_t timeout)=0
void Purge (rtp_purge_t flag)
size_t sendPacket (void)
virtual size_t writeData (const unsigned char *const packet, size_t len)=0
size_t recvPacket (void)
virtual size_t readData (unsigned char *buffer, size_t len)=0
virtual bool gotPacket (IncomingRTPPkt *packet)
virtual void expireSend (OutgoingRTPPkt *packet)
virtual void expireRecv (IncomingRTPPkt *packet)
IncomingRTPPktgetWaiting (uint32 timestamp, const RTPSource &src=dummysource)
void endQueue ()
void Final ()

Protected Attributes

volatile bool active
RTPSourcelocalsrc
struct timeval initial_time
uint32 current_rate
uint32 initial_timestamp

Private Methods

 RTPQueue (const RTPQueue &o)
RTPQueue& operator= (const RTPQueue &o)
void initQueue (uint32 localssrc)
void Run (void)
void RTPService (microtimeout_t &wait)
void insertRecvPacket (IncomingRTPPkt *packet)

Private Attributes

friend IncomingRTPPkt
type_of_service_t type_of_service
uint32 sessionbw
rtp_cast_t sessioncast
uint32 sendcount
uint32 octetcount
OutgoingRTPPktsendfirst
OutgoingRTPPktsendlast
IncomingRTPPktrecvfirst
IncomingRTPPktrecvlast
Mutex sendlock
Mutex recvlock
uint16 sendseq
uint32 sendsources [16]
unsigned sendcc
unsigned segment
bool marked
bool complete
TimerPort timeclock
struct timeval overflow_time
microtimeout_t timeout
microtimeout_t expired
microtimeout_t e2edelay
uint32 kitchensize

Static Private Attributes

const size_t RECVBUFFER_SIZE = 8192
uint32 payload_rate [96]

Detailed Description

RTP protocol queue handler.

A thread serviced packet queue handler for building different kinds of RTP protocol systems. The queue manages both incoming and outgoing RTP packets, as well as synchronization and transmission/reception timers. By making the queue handler a seperate base class it becomes possible to define RTP classes for RTP profiles and sessions of different types.

Outgoing packets are sent via the RTPQueue::putPacket method.

Incoming packets can be retrieved via:

Author(s):
David Sugar <dyfet@ostel.com>

Definition at line 805 of file rtp.h.


Constructor & Destructor Documentation

RTPQueue::RTPQueue ( int pri,
uint32 size = 7 ) [protected]
 

Constructor. This will generate a random application SSRC identifier.

Parameters:
pri   service thread base priority relative to its parent
size   an estimation of the number of participants in the session

RTPQueue::RTPQueue ( uint32 ssrc,
int pri,
uint32 size = 7 ) [protected]
 

Using this constructor you can start a session with the given ssrc, instead of the usual randomly generated one. This is necessary when you need to initiate several sessions having the same SSRC identifier, for instance, to implement layered encoding, in which case each layer is managed through a different session but all sessions share the same SSRC identifier.

Warning:
This doesn't seem to be a good solution
Parameters:
ssrc   Synchronization SouRCe identifier for this session
pri   service thread base priority relative to it's parent
size   an estimation of the number of participants in the session

RTPQueue::~RTPQueue ( ) [protected, virtual]
 

The queue destructor flush the queue and stop all services.

RTPQueue::RTPQueue ( const RTPQueue & o ) [private]
 


Member Function Documentation

void RTPQueue::Bye ( const char *const reason ) [inline, protected, virtual]
 

A plugin point for posting of BYE messages.

Reimplemented in QueueRTCPManager.

Definition at line 1350 of file rtp.h.

void RTPQueue::Final ( ) [inline, protected]
 

The queue removes itself when the service thread is detached

Definition at line 1481 of file rtp.h.

void RTPQueue::Purge ( rtp_purge_t flag ) [protected]
 

This function is used to purge the queue(s). Depending on the flag value, it purges the packets waiting to be sent, waiting to be picked up from the reception queue, or both.

void RTPQueue::RTCPService ( microtimeout_t & wait ) [inline, protected, virtual]
 

A plugin point for a scheduler of RTCP packets. The default implementation in RTPQueue is to do nothing.

Parameters:
wait   queue scheduling timeout

Reimplemented in QueueRTCPManager.

Definition at line 1343 of file rtp.h.

uint32 RTPQueue::RTPOctetCount ( ) const [inline]
 

Get the total number of octets (payload only) sent so far.

Returns:
total number of octets sent as payload in RTP packets.

Definition at line 1298 of file rtp.h.

uint32 RTPQueue::RTPSendCount ( ) const [inline]
 

Get the total number of packets sent so far

Returns:
total number of packets sent

Definition at line 1288 of file rtp.h.

void RTPQueue::RTPService ( microtimeout_t & wait ) [private]
 

Transmission and reception of RTP packets.

Parameters:
wait   scheduling timeout

void RTPQueue::Run ( void ) [private]
 

Runnable method for the service thread.

void RTPQueue::endQueue ( ) [protected]
 

This method ends the queue and service threads.

void RTPQueue::expireRecv ( IncomingRTPPkt * packet ) [inline, protected, virtual]
 

A hook to filter packets in the receive queue that are being expired.

Parameters:
packet   expired from the recv queue.

Definition at line 1457 of file rtp.h.

void RTPQueue::expireSend ( OutgoingRTPPkt * packet ) [inline, protected, virtual]
 

A hook to filter packets being sent that have been expired.

Parameters:
packet   expired from the send queue.

Definition at line 1448 of file rtp.h.

const RTPData & RTPQueue::getCookedPacket ( const RTPSource & src = dummysource )
 

Attempt to get a cooked packet. If available, thid method will retrieve the first cooked packet. A packet is said to be cooked if:

  1. There is no disorder or lost between the last retrieved packet an the current packet.
  2. There is disorder or lost, but the queue has reached its maximun size.

Therefore, cooking means recomposing a corrupted stream -waiting for the disordered packet, regenerating it (if FEC is enabled) or asking for retransmission- whenever it is possible.

If the queue has not yet reached its maximun size (that can be set with RTPQueue::setKitchenSize), ccRTP will try to cook the packets before allowing the application to pick them up. Note that if there are more packets than the maximun, they will not be thrown away.

In order to accomplish this task, at the beginning no packet will be released until the queue reaches the kitchen size (this will provide a buffer to ccRTP where to cook the packets). Then, provided that there is no disorder, ccRTP will release every packet when asked (note that usual applications will try to retrieve packets, broadly speaking, at the same rate they are received, so the kitchen will remain the same (maximun) size if there is no lost).

If the newest packet (the one with the minor timestamp) in the queue is disordered, ccRTP will not release it until the kitchen reaches at least it maximun size. When the maximun size is reached, if disorder could not be fixed, ccRTP will then release the packet. Thus, unrepairable disorder implies the queue will stop providing packets for a while and then provide a disordered packet.

If a lost packet arrives after newer packets have been retrieved, it will be silently discarded.

Summary:

If the next packet is ordered, it will be released wheter or not the kitchen is full.

If the next packet is disordered, it will be released only when the kitchen has at least its maximun size.

Parameters:
src   optional source selector.
Returns:
the block of data contained in the first "cooked" packet.
See also:
RTPQueue::setKitchenSize , RTPQueue::isCookedWaiting

uint32 RTPQueue::getCurrentTimestamp ( rtp_payload_t pt ) const
 

Get the timestamp for a packet whose payload sampling instant corresponds to the current system time.

The timestamp applications should provide for each packet represents the sampling instant of its payload and should not be a reading of the system clock. Nevertheless, the internal operation of the RTP stack relies on the accuracy of the provided timestamp, since several computations assume that there is a certain degree of correspondence between the timestamp and the system clock.

It is recommended that applications use this method in order to periodically adjust the RTP timestamp.

In particular, it is advisable getting the timestamp corresponding to the first sampling instant or any instant after a period of inactivity through a call to this method.

Applications should use the nominal sampling or any other value provided by the coder in order to compute the next timestamps with minimum computational requirement.

For instance, an application using an RTP profile that specifies a fixed sampling rate of 8 Khz with eight bits per sample, continuously transmitting audio blocks 80 octets long, would transmit 100 packets every second. Every packet would carry a timestamp 80 units greater than the previous one. So, the first timestamp would be obtained from this method, whereas the following ones would be computed adding 80 every time. Also the timestamp should be increased for every block whether it is put in the queue or dropped.

The aforementioned increment can be obtained from the RTPQueue::getTimestampIncrement() method rather than computing it by hand in the application.

Note:
Frame based applications must follow a specific timestamping method, probably specified in a profile.

Note:
You should take into account that by default ccRTP assumes that the application begins sampling at the queue creation time. Moreover, the first sampling instant is assigned a "user visible" timestamp of 0, although the RTP stack will then add internally a ramdom offset unknown to the application. That is to say, the application may count samples from 0 in order to get the timestamp for the next packet, provided that the first sampling instant is the same as the queue creation time. Nevertheless, this simpler way of starting will not be as accurate as it would be if the application got at least the first timestamp through getCurrentTimestamp. We provide this option since ccRTP interface is evolving, but we admit that it is ugly, we could remove this option or even replace uint32 timestamps with a restrictively regulated object; suggestions are gladly welcomed
Parameters:
pt   payload type of the packets sent. Determines the timestamp increasing rate.

uint16 RTPQueue::getFirstSequence ( const RTPSource & src = dummysource )
 

Get the sequence id of the first packet waiting.

Returns:
sequence id of first packet.
Parameters:
src   optional source selector.

uint32 RTPQueue::getFirstTimestamp ( const RTPSource & src = dummysource )
 

Get timestamp of first packet waiting in the queue.

Parameters:
src   optional source selector.
Returns:
timestamp of first arrival packet.
Examples:
rtpduphello.cpp.

microtimeout_t RTPQueue::getGlobalKitchenDuration ( ) const [inline]
 

Get the current global kitchen size. Note that the kitchen size can be modified individually for every source, so it is not guaranteed that this is the current kitchen for all sources.

Returns:
global kitchen size, in microseconds

Definition at line 1210 of file rtp.h.

const RTPSource & RTPQueue::getLocalInfo ( ) const [inline]
 

Get the application description.

Returns:
The RTPSource object describing the local application

Definition at line 814 of file rtp.h.

size_t RTPQueue::getPacket ( uint32 stamp,
unsigned char * data,
size_t max,
const RTPSource & src = dummysource )
 

Retreive data from a specific timestamped packet if such a packet is currently available in the receive buffer.

Parameters:
timestamp   of packet desired.
data   buffer to copy into.
maximum   data size.
src   optional source selector
Returns:
number of packet data bytes retrieved.
Return values:
0   if there is no such packet.

const RTPData & RTPQueue::getPacket ( uint32 stamp,
const RTPSource & src = dummysource )
 

Retreive data from a specific timestamped packet if such a packet is currently available in the receive buffer.

Parameters:
src   optional source selector.
Returns:
data retrieved from the reception buffer.
Examples:
rtpduphello.cpp.

size_t RTPQueue::getPartial ( uint32 timestamp,
unsigned char * data,
size_t offset,
size_t max )
 

Get partial data from a packet. This is often used to support oddball hardware that has unusual or non-standard codec buffering intervals.

Returns:
number of packet data bytes retrieved.
Parameters:
timestamp   of packet desired.
data   buffer to copy into.
offset   to copy from.
maximum   data size.

rtp_payload_t RTPQueue::getPayloadType ( const RTPSource & src ) const
 

Get the payload type of the first available packet

Parameters:
optional   source selector
Returns:
payload type of the first available packet

rtp_payload_t RTPQueue::getPayloadType ( uint32 timestamp,
const RTPSource & src = dummysource )
 

Get the payload type of a specific packet by timestamp.

Parameters:
timestamp   to find.
src   optional source selector
Returns:
payload of specified packet if found.

uint32 RTPQueue::getRate ( rtp_payload_t pt = RTP_PAYLOAD_EMPTY ) const
 

Get the transmission rate for a payload type. Note that for some payload types, the transmission rate corresponds to the timestamp rate, but this is not true for all payload types.

Returns:
transmission rate corresponding to the specified payload type. If no payload type is specified, returns the timestamp rate corresponding to the first available packet.
Todo:
complete implementation

Referenced by getGlobalKitchenDuration().

const RTPSource & RTPQueue::getSource ( uint32 ssrc ) const [inline]
 

Get the representation of a session participant by its Synchronization SouRCe identifier.

Parameters:
ssrc   an SSRC identifier

Returns:
a description of the source identified by ssrc

Reimplemented from MembershipControl.

Definition at line 1095 of file rtp.h.

timeout_t RTPQueue::getTimeclock ( void ) [inline]
 

Get the packet timeclock for synchronizing timestamps.

Returns:
runtime in milliseconds since last set.

Definition at line 1279 of file rtp.h.

microtimeout_t RTPQueue::getTimeout ( void ) [protected]
 

This computes the timeout period for scheduling transmission of the next packet at the "head" of the send buffer. If no packets are waiting, a default timeout is used. This actually forms the "isPending()" timeout of the rtp receiver in the service thread.

Returns:
timeout until next packet is scheduled to send.

uint32 RTPQueue::getTimestampIncrement ( size_t packet_size ) const
 

If your application uses a fixed sampling rate and a fixed payload format, given the size of the next packet to be sent, this method provides the timestamp increment for the next packet.

Parameters:
packet_size   the size of the next packet to be sent
Returns:
the timestamp increment for the next packet

IncomingRTPPkt * RTPQueue::getWaiting ( uint32 timestamp,
const RTPSource & src = dummysource ) [protected]
 

This is used to fetch a packet in the receive queue and to expire packets older than the current timestamp.

Returns:
packet buffer object for current timestamp if found.
Parameters:
timestamp   timestamp requested.
src   optional source selector
Note:
if found, the packet is removed from the reception queue

bool RTPQueue::gotPacket ( IncomingRTPPkt * packet ) [inline, protected, virtual]
 

A virtual function to support parsing of arriving packets to determine if they should be kept in the queue and to dispatch events.

Returns:
true if packet is kept.
Parameters:
packet   returned.

Definition at line 1440 of file rtp.h.

void RTPQueue::initQueue ( uint32 localssrc ) [private]
 

Global queue initialization.

Parameters:
localssrc   local 32-bit SSRC identifier

void RTPQueue::insertRecvPacket ( IncomingRTPPkt * packet ) [private]
 

Insert a just received packet in the queue (both general and source specific queues). If the packet was already in the queue (same SSRC and sequence number), it is not inserted but deleted.

Parameters:
pkt   a packet just received and validated

bool RTPQueue::isActive ( void ) const [inline]
 

Get active connection state flag.

Returns:
true if connection "active".
Examples:
audiorx.cpp, audiotx.cpp, rtpduphello.cpp, and rtphello.cpp.

Definition at line 1147 of file rtp.h.

bool RTPQueue::isComplete ( void ) [inline]
 

Is last packet processed "complete" or are sequences missing?

Returns:
true if complete.

Todo:
maybe, with the new RTPData, this is unnecessary. Could be useful for an application that is trying to figure out wheter to start processing data or wait for misordered packets.

Definition at line 1251 of file rtp.h.

bool RTPQueue::isCookedWaiting ( void ) const
 

Determine if cooked packets are waiting in the reception queue. Note that isCookedWaiting() == true implies isWaiting() == true.

Returns:
true if there are cooked packets waiting.
Todo:
implement it

bool RTPQueue::isMarked ( void ) [inline]
 

Is last packet processed "marked" (used to signal end on multi-sequence sends).

Returns:
true if marked.

Todo:
maybe, with the new RTPData, this is unnecessary.

Definition at line 1263 of file rtp.h.

bool RTPQueue::isPendingData ( microtimeout_t timeout ) [protected, pure virtual]
 

This function is used to check for and schedule against arriving packets based on the derived connection type.

Returns:
true if packet waiting for processing.
Parameters:
number   of microseconds to wait.

Reimplemented in RTPDuplex.

bool RTPQueue::isSending ( void ) const
 

Determine if outgoing packets are waiting to send.

Returns:
true if there are packets waiting to be send.

bool RTPQueue::isWaiting ( const RTPSource & src = dummysource ) const
 

Determine if packets are waiting in the reception queue.

Parameters:
src   optional source selector.
Returns:
true if packets are waiting.

RTPQueue& RTPQueue::operator= ( const RTPQueue & o ) [private]
 

void RTPQueue::putPacket ( uint32 stamp,
rtp_payload_t payload,
unsigned char * data = NULL,
size_t len = 0,
bool mark = false )
 

This is used to create a data packet in the send queue. Sometimes a "NULL" or empty packet will be used instead, and these are known as "silent" packets. "Silent" packets are used simply to "push" the scheduler along more accurately by giving the appearence that a next packet is waiting to be sent and to provide a valid timestamp for that packet.

Parameters:
stamp   timestamp for expected send time of packet.
payload   format of this packet.
data   value or NULL if special "silent" packet.
length   may be 0 to indicate a default by payload type.
mark   mark field in the RTP header
Examples:
rtpduphello.cpp.

size_t RTPQueue::readData ( unsigned char * buffer,
size_t len ) [protected, pure virtual]
 

This function performs the physical I/O for reading a packet from the source. It is a virtual that is overriden in the derived class.

Returns:
number of bytes read.
Parameters:
packet   read buffer.
length   of data to read.

Reimplemented in RTPDuplex.

size_t RTPQueue::recvPacket ( void ) [protected]
 

This function is used by the service thread to process the next incoming packet and place it in the receive list.

Returns:
number of payload bytes received. <0 if error.

size_t RTPQueue::sendPacket ( void ) [protected]
 

This function is used by the service thread to process the next outgoing packet pending in the sending queue.

Returns:
number of bytes sent. 0 if silent, <0 if error.

void RTPQueue::setEndToEndDelay ( microtimeout_t t ) [inline]
 

This method sets the maximun end to end delay allowed. If the processing delay plus the trip time for a packet is greater than the end to end delay, the packet is discarded, and the application cannot get it.

This is a way of setting an upper bound to the end to end delay, computed as the elapsed time between the packet timestamping at the sender side, and the picking of the packet at the receiver side.

Parameters:
t   maximum end to end delay allowed. A value of 0 implies there is no limit and is the default

Definition at line 1228 of file rtp.h.

void RTPQueue::setExpired ( microtimeout_t t ) [inline]
 

Set the "expired" timer for expiring packets pending in the send queue which have gone unsent and are already "too late" to be sent now.

Parameters:
timeout   to expire unsent packets in milliseconds.
Examples:
rtpduphello.cpp.

Definition at line 1169 of file rtp.h.

void RTPQueue::setGlobalKitchenDuration ( microtimeout_t t )
 

Specify how much time the incoming packets will be buffered for each and every source. Note that the size is specified in temporal units, thus the internal queue will usually hold as many packets as necessary to fill the specified amount of time. The default size is 0 us.

If using only the "high level" method for retrieving packets, RTPQueue::getCookedPacket(), before providing disordered packets to the application, ccRTP will try to cook them. The bigger the specified time, the higher the probability of reordering and recomposing the stream in case of corruption is.

Parameters:
t   amount of time the reception buffer fills. 0 means there is no buffer/kitchen and RTPQueue::getCookedPacket behaves as RTPQueue::getPacket does.

See also:
RTPSource::setKitchenSize() , RTPQueue::getCookedPacket() , RTPQueue::isCookedWaiting()

void RTPQueue::setGlobalKitchenSize ( uint32 s )
 

size_t RTPQueue::setPartial ( uint32 timestamp,
unsigned char * data,
size_t offset,
size_t max )
 

Set partial data for an already queued packet. This is often used for multichannel data.

Returns:
number of packet data bytes set.
Parameters:
timestamp   of packet desired.
data   buffer to copy from.
offset   to copy from.
maximum   data size.

void RTPQueue::setSegmentSize ( size_t size ) [inline]
 

Set maximum packet segment size before fragmenting sends.

Parameters:
maximum   packet size.

Definition at line 1237 of file rtp.h.

void RTPQueue::setSessionBandwidth ( uint32 bw ) [inline]
 

Specify the bandwidth of the current session.

Parameters:
bw   bandwidth of the current session, in bits/s.

See also:
QueueRTCPManager::setControlBandwidth

Definition at line 1059 of file rtp.h.

void RTPQueue::setTimeclock ( void ) [inline]
 

Set the packet timeclock for synchronizing timestamps.

Definition at line 1270 of file rtp.h.

void RTPQueue::setTimeout ( microtimeout_t t ) [inline]
 

Set the default scheduling timeout to use when no data packets are waiting to be sent.

Parameters:
timeout   in milliseconds.
Examples:
rtpduphello.cpp.

Definition at line 1157 of file rtp.h.

void RTPQueue::setTypeOfService ( type_of_service_t tos ) [inline]
 

Specify the kind of service the application expects to use.

Parameters:
tos   type of service the application expects to use

Note:
If enhanced service is specified but packet loss is high (the requested service does not appear to actually be delivered) ccRTP defaults to best-effort suitable behaviour: guarantee fair competition with TCP.

Todo:
Implement fair competition with tcp

Definition at line 1111 of file rtp.h.

void RTPQueue::timerTick ( void ) [inline, protected, virtual]
 

A plugin point for timer tick driven events.

Definition at line 1356 of file rtp.h.

size_t RTPQueue::writeData ( const unsigned char *const buffer,
size_t len ) [protected, pure virtual]
 

This function performs the physical I/O for writing a packet to the destination. It is a virtual that is overriden in the derived class.

Returns:
number of bytes sent.
Parameters:
packet   to write.
length   of data to write.

Reimplemented in RTPDuplex.


Member Data Documentation

IncomingRTPPkt [private]
 

Definition at line 1495 of file rtp.h.

const size_t RTPQueue::RECVBUFFER_SIZE = 8192 [static, private]
 

Definition at line 1541 of file rtp.h.

volatile bool RTPQueue::active [protected]
 

Definition at line 1485 of file rtp.h.

bool RTPQueue::complete [private]
 

Definition at line 1562 of file rtp.h.

uint32 RTPQueue::current_rate [protected]
 

Definition at line 1490 of file rtp.h.

microtimeout_t RTPQueue::e2edelay [private]
 

Definition at line 1577 of file rtp.h.

microtimeout_t RTPQueue::expired [private]
 

Definition at line 1573 of file rtp.h.

struct timeval RTPQueue::initial_time [protected]
 

Definition at line 1489 of file rtp.h.

uint32 RTPQueue::initial_timestamp [protected]
 

Definition at line 1492 of file rtp.h.

uint32 RTPQueue::kitchensize [private]
 

Definition at line 1580 of file rtp.h.

RTPSource * RTPQueue::localsrc [protected]
 

Definition at line 1487 of file rtp.h.

bool RTPQueue::marked [private]
 

Definition at line 1560 of file rtp.h.

uint32 RTPQueue::octetcount [private]
 

Definition at line 1545 of file rtp.h.

struct timeval RTPQueue::overflow_time [private]
 

Definition at line 1568 of file rtp.h.

uint32 RTPQueue::payload_rate[96] [static, private]
 

Definition at line 1585 of file rtp.h.

IncomingRTPPkt * RTPQueue::recvfirst [private]
 

Definition at line 1549 of file rtp.h.

IncomingRTPPkt * RTPQueue::recvlast [private]
 

Definition at line 1549 of file rtp.h.

Mutex RTPQueue::recvlock [mutable, private]
 

Definition at line 1550 of file rtp.h.

unsigned RTPQueue::segment [private]
 

Definition at line 1558 of file rtp.h.

unsigned RTPQueue::sendcc [private]
 

Definition at line 1556 of file rtp.h.

uint32 RTPQueue::sendcount [private]
 

Definition at line 1543 of file rtp.h.

OutgoingRTPPkt * RTPQueue::sendfirst [private]
 

Definition at line 1548 of file rtp.h.

OutgoingRTPPkt * RTPQueue::sendlast [private]
 

Definition at line 1548 of file rtp.h.

Mutex RTPQueue::sendlock [mutable, private]
 

Definition at line 1550 of file rtp.h.

uint16 RTPQueue::sendseq [private]
 

Definition at line 1552 of file rtp.h.

uint32 RTPQueue::sendsources[16] [private]
 

Definition at line 1554 of file rtp.h.

uint32 RTPQueue::sessionbw [private]
 

Definition at line 1537 of file rtp.h.

rtp_cast_t RTPQueue::sessioncast [private]
 

Definition at line 1538 of file rtp.h.

TimerPort RTPQueue::timeclock [private]
 

Definition at line 1564 of file rtp.h.

microtimeout_t RTPQueue::timeout [private]
 

Definition at line 1571 of file rtp.h.

type_of_service_t RTPQueue::type_of_service [private]
 

Definition at line 1536 of file rtp.h.


The documentation for this class was generated from the following file:
Generated at Fri Oct 5 10:28:27 2001 for ccRTP by doxygen1.2.5 written by Dimitri van Heesch, © 1997-2001